@loancrate/json-selector 2.0.0 → 2.1.0

package/dist/json-selector.esm.js

@@ -0,0 +1,3450 @@
+import deepEqual from 'fast-deep-equal';
+
+function isArray(value) {
+    return Array.isArray(value);
+}
+function asArray(value) {
+    return value == null ? [] : isArray(value) ? value : [value];
+}
+function isObject(value) {
+    return typeof value === "object" && value != null;
+}
+function isFalseOrEmpty(value) {
+    return (value == null ||
+        value === false ||
+        value === "" ||
+        (isArray(value) && value.length === 0) ||
+        (isObject(value) && !hasOwnProperties(value)));
+}
+function hasOwnProperties(value) {
+    for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getField(obj, name) {
+    return isObject(obj) ? obj[name] ?? null : null;
+}
+function getIndex(obj, index) {
+    return isArray(obj)
+        ? obj[index < 0 ? obj.length + index : index] ?? null
+        : null;
+}
+function findId(obj, id) {
+    return isArray(obj)
+        ? obj.find((e) => isObject(e) && e.id === id) ?? null
+        : null;
+}
+function findIdIndex(arr, id) {
+    return arr.findIndex((e) => isObject(e) && e.id === id);
+}
+function formatLiteral(value) {
+    return "`" + JSON.stringify(value).replace(/`/g, "\\`") + "`";
+}
+function isValidIdentifier(s) {
+    return /^[a-z_][0-9a-z_]*$/i.test(s);
+}
+function formatIdentifier(s) {
+    return isValidIdentifier(s) ? s : JSON.stringify(s);
+}
+function formatRawString(s) {
+    // https://jmespath.org/specification.html#raw-string-literals
+    // eslint-disable-next-line no-control-regex
+    return `'${s.replace(/[\0-\x1F]/g, "").replace(/['\\]/g, (c) => `\\${c}`)}'`;
+}
+
+function visitJsonSelector(selector, visitor, context) {
+    switch (selector.type) {
+        case "current":
+            return visitor.current(selector, context);
+        case "literal":
+            return visitor.literal(selector, context);
+        case "identifier":
+            return visitor.identifier(selector, context);
+        case "fieldAccess":
+            return visitor.fieldAccess(selector, context);
+        case "indexAccess":
+            return visitor.indexAccess(selector, context);
+        case "idAccess":
+            return visitor.idAccess(selector, context);
+        case "project":
+            return visitor.project(selector, context);
+        case "filter":
+            return visitor.filter(selector, context);
+        case "slice":
+            return visitor.slice(selector, context);
+        case "flatten":
+            return visitor.flatten(selector, context);
+        case "not":
+            return visitor.not(selector, context);
+        case "compare":
+            return visitor.compare(selector, context);
+        case "and":
+            return visitor.and(selector, context);
+        case "or":
+            return visitor.or(selector, context);
+        case "pipe":
+            return visitor.pipe(selector, context);
+    }
+}
+
+function evaluateJsonSelector(selector, context) {
+    return visitJsonSelector(selector, {
+        current() {
+            return context;
+        },
+        literal({ value }) {
+            return value;
+        },
+        identifier({ id }) {
+            return getField(context, id);
+        },
+        fieldAccess({ expression, field }) {
+            return getField(evaluateJsonSelector(expression, context), field);
+        },
+        indexAccess({ expression, index }) {
+            return getIndex(evaluateJsonSelector(expression, context), index);
+        },
+        idAccess({ expression, id }) {
+            return findId(evaluateJsonSelector(expression, context), id);
+        },
+        project({ expression, projection }) {
+            return project(evaluateJsonSelector(expression, context), projection);
+        },
+        filter({ expression, condition }) {
+            return filter(evaluateJsonSelector(expression, context), condition);
+        },
+        slice({ expression, start, end, step }) {
+            return slice(evaluateJsonSelector(expression, context), start, end, step);
+        },
+        flatten({ expression }) {
+            return flatten(evaluateJsonSelector(expression, context));
+        },
+        not({ expression }) {
+            return isFalseOrEmpty(evaluateJsonSelector(expression, context));
+        },
+        compare({ lhs, rhs, operator }) {
+            const lv = evaluateJsonSelector(lhs, context);
+            const rv = evaluateJsonSelector(rhs, context);
+            return compare(lv, rv, operator);
+        },
+        and({ lhs, rhs }) {
+            const lv = evaluateJsonSelector(lhs, context);
+            return isFalseOrEmpty(lv) ? lv : evaluateJsonSelector(rhs, context);
+        },
+        or({ lhs, rhs }) {
+            const lv = evaluateJsonSelector(lhs, context);
+            return !isFalseOrEmpty(lv) ? lv : evaluateJsonSelector(rhs, context);
+        },
+        pipe({ lhs, rhs }) {
+            return evaluateJsonSelector(rhs, evaluateJsonSelector(lhs, context));
+        },
+    }, context);
+}
+function project(value, projection) {
+    if (!isArray(value)) {
+        return null;
+    }
+    if (!projection) {
+        return value;
+    }
+    const result = value
+        .map((e) => evaluateJsonSelector(projection, e))
+        .filter((e) => e != null);
+    return result;
+}
+function filter(value, condition) {
+    if (!isArray(value)) {
+        return null;
+    }
+    const result = value.filter((e) => !isFalseOrEmpty(evaluateJsonSelector(condition, e)));
+    return result;
+}
+function slice(value, start, end, step) {
+    if (!isArray(value)) {
+        return null;
+    }
+    ({ start, end, step } = normalizeSlice(value.length, start, end, step));
+    const collected = [];
+    if (step > 0) {
+        for (let i = start; i < end; i += step) {
+            collected.push(value[i]);
+        }
+    }
+    else {
+        for (let i = start; i > end; i += step) {
+            collected.push(value[i]);
+        }
+    }
+    return collected;
+}
+function normalizeSlice(length, start, end, step) {
+    if (step == null) {
+        step = 1;
+    }
+    else if (step === 0) {
+        throw new Error("Invalid slice: step cannot be 0");
+    }
+    if (start == null) {
+        start = step < 0 ? length - 1 : 0;
+    }
+    else {
+        start = limitSlice(start, step, length);
+    }
+    if (end == null) {
+        end = step < 0 ? -1 : length;
+    }
+    else {
+        end = limitSlice(end, step, length);
+    }
+    return { start, end, step };
+}
+function limitSlice(value, step, length) {
+    if (value < 0) {
+        value += length;
+        if (value < 0) {
+            value = step < 0 ? -1 : 0;
+        }
+    }
+    else if (value >= length) {
+        value = step < 0 ? length - 1 : length;
+    }
+    return value;
+}
+function flatten(value) {
+    return isArray(value) ? value.flat() : null;
+}
+function compare(lv, rv, operator) {
+    switch (operator) {
+        case "==":
+            return deepEqual(lv, rv);
+        case "!=":
+            return !deepEqual(lv, rv);
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+            if (typeof lv === "number" && typeof rv === "number") {
+                switch (operator) {
+                    case "<":
+                        return lv < rv;
+                    case "<=":
+                        return lv <= rv;
+                    case ">":
+                        return lv > rv;
+                    case ">=":
+                        return lv >= rv;
+                }
+            }
+    }
+    return null;
+}
+
+const PRECEDENCE_ACCESS = 1;
+const PRECEDENCE_NOT = 2;
+const PRECEDENCE_COMPARE = 3;
+const PRECEDENCE_AND = 4;
+const PRECEDENCE_OR = 5;
+const PRECEDENCE_PIPE = 6;
+const PRECEDENCE_MAX = 7;
+const operatorPrecedence = {
+    fieldAccess: PRECEDENCE_ACCESS,
+    idAccess: PRECEDENCE_ACCESS,
+    indexAccess: PRECEDENCE_ACCESS,
+    project: PRECEDENCE_ACCESS,
+    filter: PRECEDENCE_ACCESS,
+    slice: PRECEDENCE_ACCESS,
+    flatten: PRECEDENCE_ACCESS,
+    not: PRECEDENCE_NOT,
+    compare: PRECEDENCE_COMPARE,
+    and: PRECEDENCE_AND,
+    or: PRECEDENCE_OR,
+    pipe: PRECEDENCE_PIPE,
+};
+function formatSubexpression(expr, options, precedence) {
+    // Ensure @ is only used as a bare expression
+    if (!options.currentImplied) {
+        options = { ...options, currentImplied: true };
+    }
+    let result = formatJsonSelector(expr, options);
+    const subPrecedence = operatorPrecedence[expr.type];
+    if (subPrecedence != null && subPrecedence > precedence) {
+        result = `(${result})`;
+    }
+    return result;
+}
+const projectionNodeTypes = new Set([
+    "project",
+    "filter",
+    "slice",
+    "flatten",
+]);
+function formatJsonSelector(selector, options = {}) {
+    return visitJsonSelector(selector, {
+        current() {
+            return !options.currentImplied ? "@" : "";
+        },
+        literal({ value }) {
+            return formatLiteral(value);
+        },
+        identifier({ id }) {
+            return formatIdentifier(id);
+        },
+        fieldAccess({ expression, field }) {
+            const lv = formatSubexpression(expression, options, PRECEDENCE_ACCESS);
+            return `${lv}.${formatIdentifier(field)}`;
+        },
+        indexAccess({ expression, index }) {
+            const lv = formatSubexpression(expression, options, PRECEDENCE_ACCESS);
+            return `${lv}[${index}]`;
+        },
+        idAccess({ expression, id }) {
+            const lv = formatSubexpression(expression, options, PRECEDENCE_ACCESS);
+            return `${lv}[${formatRawString(id)}]`;
+        },
+        project({ expression, projection }) {
+            let result = formatSubexpression(expression, options, PRECEDENCE_ACCESS);
+            // Wildcard operator is only needed if expression is not already a projection
+            if (!projectionNodeTypes.has(expression.type)) {
+                result += "[*]";
+            }
+            if (projection) {
+                result += formatSubexpression(projection, options, PRECEDENCE_MAX);
+            }
+            return result;
+        },
+        filter({ expression, condition }) {
+            const lv = formatSubexpression(expression, options, PRECEDENCE_ACCESS);
+            const rv = formatSubexpression(condition, options, PRECEDENCE_MAX);
+            return `${lv}[?${rv}]`;
+        },
+        slice({ expression, start, end, step }) {
+            const lv = formatSubexpression(expression, options, PRECEDENCE_ACCESS);
+            const rv = `${start ?? ""}:${end ?? ""}${step != null ? `:${step}` : ""}`;
+            return `${lv}[${rv}]`;
+        },
+        flatten({ expression }) {
+            const lv = formatSubexpression(expression, options, PRECEDENCE_ACCESS);
+            return `${lv}[]`;
+        },
+        not({ expression }) {
+            return `!${formatSubexpression(expression, options, PRECEDENCE_NOT)}`;
+        },
+        compare({ lhs, operator, rhs }) {
+            const lv = formatSubexpression(lhs, options, PRECEDENCE_COMPARE);
+            const rv = formatSubexpression(rhs, options, PRECEDENCE_COMPARE - 1);
+            return `${lv} ${operator} ${rv}`;
+        },
+        and({ lhs, rhs }) {
+            const lv = formatSubexpression(lhs, options, PRECEDENCE_AND);
+            const rv = formatSubexpression(rhs, options, PRECEDENCE_AND - 1);
+            return `${lv} && ${rv}`;
+        },
+        or({ lhs, rhs }) {
+            const lv = formatSubexpression(lhs, options, PRECEDENCE_OR);
+            const rv = formatSubexpression(rhs, options, PRECEDENCE_OR - 1);
+            return `${lv} || ${rv}`;
+        },
+        pipe({ lhs, rhs }) {
+            const lv = formatSubexpression(lhs, options, PRECEDENCE_PIPE);
+            const rv = formatSubexpression(rhs, options, PRECEDENCE_PIPE - 1);
+            return `${lv} | ${rv}`;
+        },
+    }, undefined);
+}
+
+class BaseAccessor {
+    constructor(selector) {
+        this.selector = selector;
+    }
+}
+class ReadOnlyAccessor extends BaseAccessor {
+    constructor(selector) {
+        super(selector);
+    }
+    isValidContext() {
+        return true;
+    }
+    set() {
+        // ignored
+    }
+    delete() {
+        // ignored
+    }
+}
+class ConstantAccessor extends ReadOnlyAccessor {
+    constructor(selector, value) {
+        super(selector);
+        this.value = value;
+    }
+    get() {
+        return this.value;
+    }
+}
+class ContextAccessor extends ReadOnlyAccessor {
+    constructor() {
+        super({ type: "current" });
+    }
+    get(context) {
+        return context;
+    }
+}
+function makeJsonSelectorAccessor(selector) {
+    return visitJsonSelector(selector, {
+        current() {
+            return new ContextAccessor();
+        },
+        literal(selector) {
+            return new ConstantAccessor(selector, selector.value);
+        },
+        identifier(selector) {
+            const { id } = selector;
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isObject(context);
+                }
+                get(context) {
+                    return getField(context, id);
+                }
+                set(context, value) {
+                    if (isObject(context)) {
+                        context[id] = value;
+                    }
+                }
+                delete(context) {
+                    if (isObject(context)) {
+                        delete context[id];
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        fieldAccess(selector) {
+            const { expression, field } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isObject(base.get(context));
+                }
+                get(context) {
+                    return getField(base.get(context), field);
+                }
+                set(context, value) {
+                    const obj = base.get(context);
+                    if (isObject(obj)) {
+                        obj[field] = value;
+                    }
+                }
+                delete(context) {
+                    const obj = base.get(context);
+                    if (isObject(obj)) {
+                        delete obj[field];
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        indexAccess(selector) {
+            const { expression, index } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isArray(base.get(context));
+                }
+                get(context) {
+                    return getIndex(base.get(context), index);
+                }
+                set(context, value) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        arr[index] = value;
+                    }
+                }
+                delete(context) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        arr.splice(index, 1);
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        idAccess(selector) {
+            const { expression, id } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isArray(base.get(context));
+                }
+                get(context) {
+                    return findId(base.get(context), id);
+                }
+                set(context, value) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        const index = findIdIndex(arr, id);
+                        if (index >= 0) {
+                            arr[index] = value;
+                        }
+                    }
+                }
+                delete(context) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        const index = findIdIndex(arr, id);
+                        if (index >= 0) {
+                            arr.splice(index, 1);
+                        }
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        project(selector) {
+            const { expression, projection } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const proj = projection && makeJsonSelectorAccessor(projection);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isArray(base.get(context));
+                }
+                get(context) {
+                    return project(base.get(context), projection);
+                }
+                set(context, value) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        if (proj) {
+                            for (const element of arr) {
+                                proj.set(element, value);
+                            }
+                        }
+                        else {
+                            replaceArray(arr, asArray(value));
+                        }
+                    }
+                }
+                delete(context) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        if (proj) {
+                            for (const element of arr) {
+                                proj.delete(element);
+                            }
+                        }
+                        else {
+                            arr.length = 0;
+                        }
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        filter(selector) {
+            const { expression, condition } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isArray(base.get(context));
+                }
+                get(context) {
+                    return filter(base.get(context), condition);
+                }
+                set(context, value) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedFilter(arr, condition).concat(asArray(value)));
+                    }
+                }
+                delete(context) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedFilter(arr, condition));
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        slice(selector) {
+            const { expression, start, end, step } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isArray(base.get(context));
+                }
+                get(context) {
+                    return slice(base.get(context), start, end, step);
+                }
+                set(context, value) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedSlice(arr, start, end, step).concat(asArray(value)));
+                    }
+                }
+                delete(context) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedSlice(arr, start, end, step));
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        flatten(selector) {
+            const { expression } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isArray(base.get(context));
+                }
+                get(context) {
+                    return flatten(base.get(context));
+                }
+                set(context, value) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        replaceArray(arr, asArray(value));
+                    }
+                }
+                delete(context) {
+                    const arr = base.get(context);
+                    if (isArray(arr)) {
+                        arr.length = 0;
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        not(selector) {
+            const { expression } = selector;
+            const base = makeJsonSelectorAccessor(expression);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context) {
+                    return isFalseOrEmpty(base.get(context));
+                }
+            };
+            return new Accessor();
+        },
+        compare(selector) {
+            const { lhs, rhs, operator } = selector;
+            const la = makeJsonSelectorAccessor(lhs);
+            const ra = makeJsonSelectorAccessor(rhs);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context) {
+                    const lv = la.get(context);
+                    const rv = ra.get(context);
+                    return compare(lv, rv, operator);
+                }
+            };
+            return new Accessor();
+        },
+        and(selector) {
+            const { lhs, rhs } = selector;
+            const la = makeJsonSelectorAccessor(lhs);
+            const ra = makeJsonSelectorAccessor(rhs);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context) {
+                    const lv = la.get(context);
+                    return isFalseOrEmpty(lv) ? lv : ra.get(context);
+                }
+            };
+            return new Accessor();
+        },
+        or(selector) {
+            const { lhs, rhs } = selector;
+            const la = makeJsonSelectorAccessor(lhs);
+            const ra = makeJsonSelectorAccessor(rhs);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context) {
+                    const lv = la.get(context);
+                    return !isFalseOrEmpty(lv) ? lv : ra.get(context);
+                }
+            };
+            return new Accessor();
+        },
+        pipe(selector) {
+            const { lhs, rhs } = selector;
+            const la = makeJsonSelectorAccessor(lhs);
+            const ra = makeJsonSelectorAccessor(rhs);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return ra.isValidContext(la.get(context));
+                }
+                get(context) {
+                    return ra.get(la.get(context));
+                }
+                set(context, value) {
+                    ra.set(la.get(context), value);
+                }
+                delete(context) {
+                    ra.delete(la.get(context));
+                }
+            };
+            return new Accessor();
+        },
+    }, undefined);
+}
+function bindJsonSelectorAccessor(unbound, context) {
+    const { selector } = unbound;
+    const valid = unbound.isValidContext(context);
+    return {
+        selector,
+        valid,
+        path: formatJsonSelector(selector),
+        get() {
+            return unbound.get(context);
+        },
+        set(v) {
+            unbound.set(context, v);
+        },
+        delete() {
+            unbound.delete(context);
+        },
+    };
+}
+function accessWithJsonSelector(selector, context) {
+    return bindJsonSelectorAccessor(makeJsonSelectorAccessor(selector), context);
+}
+function replaceArray(target, source) {
+    target.length = 0;
+    target.push(...source);
+    return target;
+}
+function invertedFilter(value, condition) {
+    return value.filter((e) => isFalseOrEmpty(evaluateJsonSelector(condition, e)));
+}
+function invertedSlice(value, start, end, step) {
+    ({ start, end, step } = normalizeSlice(value.length, start, end, step));
+    const collected = [];
+    if (step > 0) {
+        if (start >= end) {
+            return value;
+        }
+        let skip = start;
+        for (let i = 0; i < value.length; ++i) {
+            if (i < skip || i >= end) {
+                collected.push(value[i]);
+            }
+            else {
+                skip += step;
+            }
+        }
+    }
+    else {
+        if (start <= end) {
+            return value;
+        }
+        let skip = start;
+        for (let i = value.length - 1; i >= 0; --i) {
+            if (i > skip || i <= end) {
+                collected.push(value[i]);
+            }
+            else {
+                skip += step;
+            }
+        }
+    }
+    return collected;
+}
+
+function getWithJsonSelector(selector, context) {
+    return accessWithJsonSelector(selector, context).get();
+}
+
+function peg$subclass(child, parent) {
+  function C() { this.constructor = child; }
+  C.prototype = parent.prototype;
+  child.prototype = new C();
+}
+
+function peg$SyntaxError(message, expected, found, location) {
+  var self = Error.call(this, message);
+  // istanbul ignore next Check is a necessary evil to support older environments
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(self, peg$SyntaxError.prototype);
+  }
+  self.expected = expected;
+  self.found = found;
+  self.location = location;
+  self.name = "SyntaxError";
+  return self;
+}
+
+peg$subclass(peg$SyntaxError, Error);
+
+function peg$padEnd(str, targetLength, padString) {
+  padString = padString || " ";
+  if (str.length > targetLength) { return str; }
+  targetLength -= str.length;
+  padString += padString.repeat(targetLength);
+  return str + padString.slice(0, targetLength);
+}
+
+peg$SyntaxError.prototype.format = function(sources) {
+  var str = "Error: " + this.message;
+  if (this.location) {
+    var src = null;
+    var k;
+    for (k = 0; k < sources.length; k++) {
+      if (sources[k].source === this.location.source) {
+        src = sources[k].text.split(/\r\n|\n|\r/g);
+        break;
+      }
+    }
+    var s = this.location.start;
+    var loc = this.location.source + ":" + s.line + ":" + s.column;
+    if (src) {
+      var e = this.location.end;
+      var filler = peg$padEnd("", s.line.toString().length, ' ');
+      var line = src[s.line - 1];
+      var last = s.line === e.line ? e.column : line.length + 1;
+      var hatLen = (last - s.column) || 1;
+      str += "\n --> " + loc + "\n"
+          + filler + " |\n"
+          + s.line + " | " + line + "\n"
+          + filler + " | " + peg$padEnd("", s.column - 1, ' ')
+          + peg$padEnd("", hatLen, "^");
+    } else {
+      str += "\n at " + loc;
+    }
+  }
+  return str;
+};
+
+peg$SyntaxError.buildMessage = function(expected, found) {
+  var DESCRIBE_EXPECTATION_FNS = {
+    literal: function(expectation) {
+      return "\"" + literalEscape(expectation.text) + "\"";
+    },
+
+    class: function(expectation) {
+      var escapedParts = expectation.parts.map(function(part) {
+        return Array.isArray(part)
+          ? classEscape(part[0]) + "-" + classEscape(part[1])
+          : classEscape(part);
+      });
+
+      return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
+    },
+
+    any: function() {
+      return "any character";
+    },
+
+    end: function() {
+      return "end of input";
+    },
+
+    other: function(expectation) {
+      return expectation.description;
+    }
+  };
+
+  function hex(ch) {
+    return ch.charCodeAt(0).toString(16).toUpperCase();
+  }
+
+  function literalEscape(s) {
+    return s
+      .replace(/\\/g, "\\\\")
+      .replace(/"/g,  "\\\"")
+      .replace(/\0/g, "\\0")
+      .replace(/\t/g, "\\t")
+      .replace(/\n/g, "\\n")
+      .replace(/\r/g, "\\r")
+      .replace(/[\x00-\x0F]/g,          function(ch) { return "\\x0" + hex(ch); })
+      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x"  + hex(ch); });
+  }
+
+  function classEscape(s) {
+    return s
+      .replace(/\\/g, "\\\\")
+      .replace(/\]/g, "\\]")
+      .replace(/\^/g, "\\^")
+      .replace(/-/g,  "\\-")
+      .replace(/\0/g, "\\0")
+      .replace(/\t/g, "\\t")
+      .replace(/\n/g, "\\n")
+      .replace(/\r/g, "\\r")
+      .replace(/[\x00-\x0F]/g,          function(ch) { return "\\x0" + hex(ch); })
+      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x"  + hex(ch); });
+  }
+
+  function describeExpectation(expectation) {
+    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+  }
+
+  function describeExpected(expected) {
+    var descriptions = expected.map(describeExpectation);
+    var i, j;
+
+    descriptions.sort();
+
+    if (descriptions.length > 0) {
+      for (i = 1, j = 1; i < descriptions.length; i++) {
+        if (descriptions[i - 1] !== descriptions[i]) {
+          descriptions[j] = descriptions[i];
+          j++;
+        }
+      }
+      descriptions.length = j;
+    }
+
+    switch (descriptions.length) {
+      case 1:
+        return descriptions[0];
+
+      case 2:
+        return descriptions[0] + " or " + descriptions[1];
+
+      default:
+        return descriptions.slice(0, -1).join(", ")
+          + ", or "
+          + descriptions[descriptions.length - 1];
+    }
+  }
+
+  function describeFound(found) {
+    return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+  }
+
+  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+};
+
+function peg$parse(input, options) {
+  options = options !== undefined ? options : {};
+
+  var peg$FAILED = {};
+  var peg$source = options.grammarSource;
+
+  var peg$startRuleFunctions = { selector: peg$parseselector };
+  var peg$startRuleFunction = peg$parseselector;
+
+  var peg$c0 = "|";
+  var peg$c1 = "||";
+  var peg$c2 = "&&";
+  var peg$c3 = "<=";
+  var peg$c4 = ">=";
+  var peg$c5 = "<";
+  var peg$c6 = ">";
+  var peg$c7 = "==";
+  var peg$c8 = "!=";
+  var peg$c9 = "!";
+  var peg$c10 = "[]";
+  var peg$c11 = "[?";
+  var peg$c12 = "]";
+  var peg$c13 = "[";
+  var peg$c14 = "*";
+  var peg$c15 = ":";
+  var peg$c16 = ".";
+  var peg$c17 = "@";
+  var peg$c18 = "(";
+  var peg$c19 = ")";
+  var peg$c20 = "`";
+  var peg$c21 = "\"";
+  var peg$c22 = "\\";
+  var peg$c23 = "/";
+  var peg$c24 = "b";
+  var peg$c25 = "f";
+  var peg$c26 = "n";
+  var peg$c27 = "r";
+  var peg$c28 = "t";
+  var peg$c29 = "u";
+  var peg$c30 = "'";
+  var peg$c31 = "-";
+  var peg$c32 = "0";
+  var peg$c33 = "null";
+  var peg$c34 = "false";
+  var peg$c35 = "true";
+  var peg$c36 = "{";
+  var peg$c37 = ",";
+  var peg$c38 = "}";
+
+  var peg$r0 = /^[a-z_]/i;
+  var peg$r1 = /^[0-9a-z_]/i;
+  var peg$r2 = /^[^\0-\x1F"\\]/;
+  var peg$r3 = /^[0-9a-f]/i;
+  var peg$r4 = /^[^'\\]/;
+  var peg$r5 = /^[^']/;
+  var peg$r6 = /^[1-9]/;
+  var peg$r7 = /^[0-9]/;
+  var peg$r8 = /^[eE]/;
+  var peg$r9 = /^[+\-]/;
+  var peg$r10 = /^[^\0-\x1F"\\`]/;
+  var peg$r11 = /^[ \t\n\r]/;
+
+  var peg$e0 = peg$literalExpectation("|", false);
+  var peg$e1 = peg$literalExpectation("||", false);
+  var peg$e2 = peg$literalExpectation("&&", false);
+  var peg$e3 = peg$literalExpectation("<=", false);
+  var peg$e4 = peg$literalExpectation(">=", false);
+  var peg$e5 = peg$literalExpectation("<", false);
+  var peg$e6 = peg$literalExpectation(">", false);
+  var peg$e7 = peg$literalExpectation("==", false);
+  var peg$e8 = peg$literalExpectation("!=", false);
+  var peg$e9 = peg$literalExpectation("!", false);
+  var peg$e10 = peg$literalExpectation("[]", false);
+  var peg$e11 = peg$literalExpectation("[?", false);
+  var peg$e12 = peg$literalExpectation("]", false);
+  var peg$e13 = peg$literalExpectation("[", false);
+  var peg$e14 = peg$literalExpectation("*", false);
+  var peg$e15 = peg$literalExpectation(":", false);
+  var peg$e16 = peg$literalExpectation(".", false);
+  var peg$e17 = peg$literalExpectation("@", false);
+  var peg$e18 = peg$literalExpectation("(", false);
+  var peg$e19 = peg$literalExpectation(")", false);
+  var peg$e20 = peg$literalExpectation("`", false);
+  var peg$e21 = peg$classExpectation([["a", "z"], "_"], false, true);
+  var peg$e22 = peg$classExpectation([["0", "9"], ["a", "z"], "_"], false, true);
+  var peg$e23 = peg$literalExpectation("\"", false);
+  var peg$e24 = peg$classExpectation([["\0", "\x1F"], "\"", "\\"], true, false);
+  var peg$e25 = peg$literalExpectation("\\", false);
+  var peg$e26 = peg$literalExpectation("/", false);
+  var peg$e27 = peg$literalExpectation("b", false);
+  var peg$e28 = peg$literalExpectation("f", false);
+  var peg$e29 = peg$literalExpectation("n", false);
+  var peg$e30 = peg$literalExpectation("r", false);
+  var peg$e31 = peg$literalExpectation("t", false);
+  var peg$e32 = peg$literalExpectation("u", false);
+  var peg$e33 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true);
+  var peg$e34 = peg$literalExpectation("'", false);
+  var peg$e35 = peg$classExpectation(["'", "\\"], true, false);
+  var peg$e36 = peg$classExpectation(["'"], true, false);
+  var peg$e37 = peg$literalExpectation("-", false);
+  var peg$e38 = peg$literalExpectation("0", false);
+  var peg$e39 = peg$classExpectation([["1", "9"]], false, false);
+  var peg$e40 = peg$classExpectation([["0", "9"]], false, false);
+  var peg$e41 = peg$literalExpectation("null", false);
+  var peg$e42 = peg$literalExpectation("false", false);
+  var peg$e43 = peg$literalExpectation("true", false);
+  var peg$e44 = peg$classExpectation(["e", "E"], false, false);
+  var peg$e45 = peg$classExpectation(["+", "-"], false, false);
+  var peg$e46 = peg$classExpectation([["\0", "\x1F"], "\"", "\\", "`"], true, false);
+  var peg$e47 = peg$literalExpectation("{", false);
+  var peg$e48 = peg$literalExpectation(",", false);
+  var peg$e49 = peg$literalExpectation("}", false);
+  var peg$e50 = peg$otherExpectation("whitespace");
+  var peg$e51 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false);
+
+  var peg$f0 = function(head, tail) { return binaryExpression("pipe", head, tail); };
+  var peg$f1 = function(head, tail) { return binaryExpression("or", head, tail); };
+  var peg$f2 = function(head, tail) { return binaryExpression("and", head, tail); };
+  var peg$f3 = function(head, tail) {
+  return tail.reduce((result, [operator, rhs]) => (
+    {
+      type: "compare",
+      operator,
+      lhs: result,
+      rhs
+    }
+  ), head);
+};
+  var peg$f4 = function(expression) { return { type: "not", expression }; };
+  var peg$f5 = function(lhs, rhs) { return reduceProjection(lhs, rhs); };
+  var peg$f6 = function(flatten) { return flatten({ type: "current" }); };
+  var peg$f7 = function(flatten, pfns) { return (expression) => maybeProject(flatten(expression), pfns); };
+  var peg$f8 = function() { return (expression) => ({ type: "flatten", expression }); };
+  var peg$f9 = function(lhs, rhs) { return reduceProjection(lhs, rhs); };
+  var peg$f10 = function(filter) { return filter({ type: "current" }); };
+  var peg$f11 = function(filter, pfns) { return (expression) => maybeProject(filter(expression), pfns); };
+  var peg$f12 = function(condition) { return (expression) => ({ type: "filter", expression, condition }); };
+  var peg$f13 = function(lhs, rhs) { return reduceProjection(lhs, rhs); };
+  var peg$f14 = function(projection) { return projection({ type: "current" }); };
+  var peg$f15 = function(projection, pfns) { return (expression) => maybeProject(projection(expression), pfns); };
+  var peg$f16 = function() { return (expression) => ({ type: "project", expression, projection: { type: "current" } }); };
+  var peg$f17 = function(start, end, step) { return (expression) => ({ type: "slice", expression, start, end, step }); };
+  var peg$f18 = function(lhs, rhs) { return reduceProjection(lhs, rhs); };
+  var peg$f19 = function(index) { return index({ type: "current" }); };
+  var peg$f20 = function(index) { return (expression) => ({ type: "indexAccess", expression, index }); };
+  var peg$f21 = function(id) { return (expression) => ({ type: "idAccess", expression, id }); };
+  var peg$f22 = function(field) { return (expression) => ({ type: "fieldAccess", expression, field }); };
+  var peg$f23 = function(lhs, rhs) { return reduceProjection(lhs, rhs); };
+  var peg$f24 = function(id) { return { type: "identifier", id }; };
+  var peg$f25 = function() { return { type: "current" }; };
+  var peg$f26 = function(value) { return { type: "literal", value }; };
+  var peg$f27 = function(value) { return { type: "literal", value }; };
+  var peg$f28 = function(head, tail) { return head + tail.join(""); };
+  var peg$f29 = function(chars) { return chars.join(""); };
+  var peg$f30 = function() { return "\b"; };
+  var peg$f31 = function() { return "\f"; };
+  var peg$f32 = function() { return "\n"; };
+  var peg$f33 = function() { return "\r"; };
+  var peg$f34 = function() { return "\t"; };
+  var peg$f35 = function(digits) {
+        return String.fromCharCode(parseInt(digits, 16));
+      };
+  var peg$f36 = function(chars) { return chars.join(""); };
+  var peg$f37 = function() { return text(); };
+  var peg$f38 = function() { return parseInt(text()); };
+  var peg$f39 = function() { return null; };
+  var peg$f40 = function() { return false; };
+  var peg$f41 = function() { return true; };
+  var peg$f42 = function() { return parseFloat(text()); };
+  var peg$f43 = function(chars) { return chars.join(""); };
+  var peg$f44 = function(head, tail) { return [head].concat(tail); };
+  var peg$f45 = function(members) { return Object.fromEntries(members ?? []); };
+  var peg$f46 = function(name, value) { return [name, value]; };
+  var peg$f47 = function(head, tail) { return [head].concat(tail); };
+  var peg$f48 = function(values) { return values ?? []; };
+  var peg$currPos = 0;
+  var peg$savedPos = 0;
+  var peg$posDetailsCache = [{ line: 1, column: 1 }];
+  var peg$maxFailPos = 0;
+  var peg$maxFailExpected = [];
+  var peg$silentFails = 0;
+
+  var peg$result;
+
+  if ("startRule" in options) {
+    if (!(options.startRule in peg$startRuleFunctions)) {
+      throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+    }
+
+    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+  }
+
+  function text() {
+    return input.substring(peg$savedPos, peg$currPos);
+  }
+
+  function peg$literalExpectation(text, ignoreCase) {
+    return { type: "literal", text: text, ignoreCase: ignoreCase };
+  }
+
+  function peg$classExpectation(parts, inverted, ignoreCase) {
+    return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
+  }
+
+  function peg$endExpectation() {
+    return { type: "end" };
+  }
+
+  function peg$otherExpectation(description) {
+    return { type: "other", description: description };
+  }
+
+  function peg$computePosDetails(pos) {
+    var details = peg$posDetailsCache[pos];
+    var p;
+
+    if (details) {
+      return details;
+    } else {
+      p = pos - 1;
+      while (!peg$posDetailsCache[p]) {
+        p--;
+      }
+
+      details = peg$posDetailsCache[p];
+      details = {
+        line: details.line,
+        column: details.column
+      };
+
+      while (p < pos) {
+        if (input.charCodeAt(p) === 10) {
+          details.line++;
+          details.column = 1;
+        } else {
+          details.column++;
+        }
+
+        p++;
+      }
+
+      peg$posDetailsCache[pos] = details;
+
+      return details;
+    }
+  }
+
+  function peg$computeLocation(startPos, endPos) {
+    var startPosDetails = peg$computePosDetails(startPos);
+    var endPosDetails = peg$computePosDetails(endPos);
+
+    return {
+      source: peg$source,
+      start: {
+        offset: startPos,
+        line: startPosDetails.line,
+        column: startPosDetails.column
+      },
+      end: {
+        offset: endPos,
+        line: endPosDetails.line,
+        column: endPosDetails.column
+      }
+    };
+  }
+
+  function peg$fail(expected) {
+    if (peg$currPos < peg$maxFailPos) { return; }
+
+    if (peg$currPos > peg$maxFailPos) {
+      peg$maxFailPos = peg$currPos;
+      peg$maxFailExpected = [];
+    }
+
+    peg$maxFailExpected.push(expected);
+  }
+
+  function peg$buildStructuredError(expected, found, location) {
+    return new peg$SyntaxError(
+      peg$SyntaxError.buildMessage(expected, found),
+      expected,
+      found,
+      location
+    );
+  }
+
+  function peg$parseselector() {
+    var s0, s2;
+
+    s0 = peg$currPos;
+    peg$parsews();
+    s2 = peg$parsepipe_expression();
+    if (s2 !== peg$FAILED) {
+      peg$parsews();
+      s0 = s2;
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsepipe_expression() {
+    var s0, s1, s2, s3, s5, s7;
+
+    s0 = peg$currPos;
+    s1 = peg$parseor_expression();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 124) {
+        s5 = peg$c0;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e0); }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$parsews();
+        s7 = peg$parseor_expression();
+        if (s7 !== peg$FAILED) {
+          s3 = s7;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        peg$parsews();
+        if (input.charCodeAt(peg$currPos) === 124) {
+          s5 = peg$c0;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e0); }
+        }
+        if (s5 !== peg$FAILED) {
+          peg$parsews();
+          s7 = peg$parseor_expression();
+          if (s7 !== peg$FAILED) {
+            s3 = s7;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f0(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseor_expression() {
+    var s0, s1, s2, s3, s5, s7;
+
+    s0 = peg$currPos;
+    s1 = peg$parseand_expression();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      peg$parsews();
+      if (input.substr(peg$currPos, 2) === peg$c1) {
+        s5 = peg$c1;
+        peg$currPos += 2;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e1); }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$parsews();
+        s7 = peg$parseand_expression();
+        if (s7 !== peg$FAILED) {
+          s3 = s7;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        peg$parsews();
+        if (input.substr(peg$currPos, 2) === peg$c1) {
+          s5 = peg$c1;
+          peg$currPos += 2;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e1); }
+        }
+        if (s5 !== peg$FAILED) {
+          peg$parsews();
+          s7 = peg$parseand_expression();
+          if (s7 !== peg$FAILED) {
+            s3 = s7;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f1(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseand_expression() {
+    var s0, s1, s2, s3, s5, s7;
+
+    s0 = peg$currPos;
+    s1 = peg$parsecompare_expression();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      peg$parsews();
+      if (input.substr(peg$currPos, 2) === peg$c2) {
+        s5 = peg$c2;
+        peg$currPos += 2;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e2); }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$parsews();
+        s7 = peg$parsecompare_expression();
+        if (s7 !== peg$FAILED) {
+          s3 = s7;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        peg$parsews();
+        if (input.substr(peg$currPos, 2) === peg$c2) {
+          s5 = peg$c2;
+          peg$currPos += 2;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+        if (s5 !== peg$FAILED) {
+          peg$parsews();
+          s7 = peg$parsecompare_expression();
+          if (s7 !== peg$FAILED) {
+            s3 = s7;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f2(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsecompare_expression() {
+    var s0, s1, s2, s3, s5, s7;
+
+    s0 = peg$currPos;
+    s1 = peg$parsenot_expression();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$currPos;
+      peg$parsews();
+      if (input.substr(peg$currPos, 2) === peg$c3) {
+        s5 = peg$c3;
+        peg$currPos += 2;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e3); }
+      }
+      if (s5 === peg$FAILED) {
+        if (input.substr(peg$currPos, 2) === peg$c4) {
+          s5 = peg$c4;
+          peg$currPos += 2;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e4); }
+        }
+        if (s5 === peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 60) {
+            s5 = peg$c5;
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e5); }
+          }
+          if (s5 === peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 62) {
+              s5 = peg$c6;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e6); }
+            }
+            if (s5 === peg$FAILED) {
+              if (input.substr(peg$currPos, 2) === peg$c7) {
+                s5 = peg$c7;
+                peg$currPos += 2;
+              } else {
+                s5 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e7); }
+              }
+              if (s5 === peg$FAILED) {
+                if (input.substr(peg$currPos, 2) === peg$c8) {
+                  s5 = peg$c8;
+                  peg$currPos += 2;
+                } else {
+                  s5 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e8); }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$parsews();
+        s7 = peg$parsenot_expression();
+        if (s7 !== peg$FAILED) {
+          s3 = [ s5, s7 ];
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        peg$parsews();
+        if (input.substr(peg$currPos, 2) === peg$c3) {
+          s5 = peg$c3;
+          peg$currPos += 2;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e3); }
+        }
+        if (s5 === peg$FAILED) {
+          if (input.substr(peg$currPos, 2) === peg$c4) {
+            s5 = peg$c4;
+            peg$currPos += 2;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e4); }
+          }
+          if (s5 === peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 60) {
+              s5 = peg$c5;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e5); }
+            }
+            if (s5 === peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 62) {
+                s5 = peg$c6;
+                peg$currPos++;
+              } else {
+                s5 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e6); }
+              }
+              if (s5 === peg$FAILED) {
+                if (input.substr(peg$currPos, 2) === peg$c7) {
+                  s5 = peg$c7;
+                  peg$currPos += 2;
+                } else {
+                  s5 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e7); }
+                }
+                if (s5 === peg$FAILED) {
+                  if (input.substr(peg$currPos, 2) === peg$c8) {
+                    s5 = peg$c8;
+                    peg$currPos += 2;
+                  } else {
+                    s5 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e8); }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (s5 !== peg$FAILED) {
+          peg$parsews();
+          s7 = peg$parsenot_expression();
+          if (s7 !== peg$FAILED) {
+            s3 = [ s5, s7 ];
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f3(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsenot_expression() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 33) {
+      s1 = peg$c9;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e9); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parsenot_expression();
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f4(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseflatten_expression();
+    }
+
+    return s0;
+  }
+
+  function peg$parseflatten_expression() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseflatten_lhs();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseflatten_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseflatten_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f5(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseflatten_lhs() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    s1 = peg$parseflatten();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f6(s1);
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsefilter_expression();
+    }
+
+    return s0;
+  }
+
+  function peg$parseflatten_rhs() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseflatten();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parsefilter_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parsefilter_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f7(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsefilter_rhs();
+    }
+
+    return s0;
+  }
+
+  function peg$parseflatten() {
+    var s0, s2;
+
+    s0 = peg$currPos;
+    peg$parsews();
+    if (input.substr(peg$currPos, 2) === peg$c10) {
+      s2 = peg$c10;
+      peg$currPos += 2;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e10); }
+    }
+    if (s2 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s0 = peg$f8();
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsefilter_expression() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parsefilter_lhs();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parsefilter_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parsefilter_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f9(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsefilter_lhs() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    s1 = peg$parsefilter();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f10(s1);
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseprojection_expression();
+    }
+
+    return s0;
+  }
+
+  function peg$parsefilter_rhs() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parsefilter();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parsefilter_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parsefilter_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f11(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseprojection_rhs();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsedot_rhs();
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parsefilter() {
+    var s0, s2, s3, s4;
+
+    s0 = peg$currPos;
+    peg$parsews();
+    if (input.substr(peg$currPos, 2) === peg$c11) {
+      s2 = peg$c11;
+      peg$currPos += 2;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e11); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$parseselector();
+      if (s3 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 93) {
+          s4 = peg$c12;
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e12); }
+        }
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f12(s3);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseprojection_expression() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseprojection_lhs();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseprojection_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseprojection_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f13(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseprojection_lhs() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    s1 = peg$parseprojection();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f14(s1);
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseindex_expression();
+    }
+
+    return s0;
+  }
+
+  function peg$parseprojection_rhs() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseprojection();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parsefilter_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parsefilter_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f15(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseindex_rhs();
+    }
+
+    return s0;
+  }
+
+  function peg$parseprojection() {
+    var s0, s2, s4, s6;
+
+    s0 = peg$currPos;
+    peg$parsews();
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s2 = peg$c13;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e13); }
+    }
+    if (s2 !== peg$FAILED) {
+      peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 42) {
+        s4 = peg$c14;
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e14); }
+      }
+      if (s4 !== peg$FAILED) {
+        peg$parsews();
+        if (input.charCodeAt(peg$currPos) === 93) {
+          s6 = peg$c12;
+          peg$currPos++;
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e12); }
+        }
+        if (s6 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f16();
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s2 = peg$c13;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e13); }
+      }
+      if (s2 !== peg$FAILED) {
+        peg$parsews();
+        s4 = peg$parseslice();
+        if (s4 !== peg$FAILED) {
+          peg$parsews();
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s6 = peg$c12;
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e12); }
+          }
+          if (s6 !== peg$FAILED) {
+            s0 = s4;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseslice() {
+    var s0, s1, s3, s5, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parsenumber();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    peg$parsews();
+    if (input.charCodeAt(peg$currPos) === 58) {
+      s3 = peg$c15;
+      peg$currPos++;
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e15); }
+    }
+    if (s3 !== peg$FAILED) {
+      peg$parsews();
+      s5 = peg$parsenumber();
+      if (s5 === peg$FAILED) {
+        s5 = null;
+      }
+      peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 58) {
+        peg$currPos++;
+      } else {
+        if (peg$silentFails === 0) { peg$fail(peg$e15); }
+      }
+      peg$parsews();
+      s9 = peg$parsenumber();
+      if (s9 === peg$FAILED) {
+        s9 = null;
+      }
+      peg$savedPos = s0;
+      s0 = peg$f17(s1, s5, s9);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseindex_expression() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseindex_lhs();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseindex_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseindex_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f18(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseindex_lhs() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    s1 = peg$parseindex_rhs();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f19(s1);
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsemember_expression();
+    }
+
+    return s0;
+  }
+
+  function peg$parseindex_rhs() {
+    var s0, s2, s4, s6;
+
+    s0 = peg$currPos;
+    peg$parsews();
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s2 = peg$c13;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e13); }
+    }
+    if (s2 !== peg$FAILED) {
+      peg$parsews();
+      s4 = peg$parsenumber();
+      if (s4 !== peg$FAILED) {
+        peg$parsews();
+        if (input.charCodeAt(peg$currPos) === 93) {
+          s6 = peg$c12;
+          peg$currPos++;
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e12); }
+        }
+        if (s6 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f20(s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s2 = peg$c13;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e13); }
+      }
+      if (s2 !== peg$FAILED) {
+        peg$parsews();
+        s4 = peg$parseraw_string();
+        if (s4 !== peg$FAILED) {
+          peg$parsews();
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s6 = peg$c12;
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e12); }
+          }
+          if (s6 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f21(s4);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parsedot_rhs() {
+    var s0, s2, s4;
+
+    s0 = peg$currPos;
+    peg$parsews();
+    if (input.charCodeAt(peg$currPos) === 46) {
+      s2 = peg$c16;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e16); }
+    }
+    if (s2 !== peg$FAILED) {
+      peg$parsews();
+      s4 = peg$parseidentifier();
+      if (s4 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f22(s4);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsemember_expression() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseprimary_expression();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parsedot_rhs();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parsedot_rhs();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f23(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseprimary_expression() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseidentifier();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f24(s1);
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 64) {
+        s1 = peg$c17;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e17); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f25();
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseliteral();
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = peg$parseraw_string();
+          if (s1 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$f26(s1);
+          }
+          s0 = s1;
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 40) {
+              s1 = peg$c18;
+              peg$currPos++;
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e18); }
+            }
+            if (s1 !== peg$FAILED) {
+              s2 = peg$parseselector();
+              if (s2 !== peg$FAILED) {
+                if (input.charCodeAt(peg$currPos) === 41) {
+                  s3 = peg$c19;
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e19); }
+                }
+                if (s3 !== peg$FAILED) {
+                  s0 = s2;
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseliteral() {
+    var s0, s1, s3, s5;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 96) {
+      s1 = peg$c20;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e20); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$parsews();
+      s3 = peg$parsejson_value();
+      if (s3 === peg$FAILED) {
+        s3 = peg$parseunquoted_json_string();
+      }
+      if (s3 !== peg$FAILED) {
+        peg$parsews();
+        if (input.charCodeAt(peg$currPos) === 96) {
+          s5 = peg$c20;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e20); }
+        }
+        if (s5 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f27(s3);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseidentifier() {
+    var s0;
+
+    s0 = peg$parseunquoted_string();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsequoted_string();
+    }
+
+    return s0;
+  }
+
+  function peg$parseunquoted_string() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    if (peg$r0.test(input.charAt(peg$currPos))) {
+      s1 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e21); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      if (peg$r1.test(input.charAt(peg$currPos))) {
+        s3 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e22); }
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        if (peg$r1.test(input.charAt(peg$currPos))) {
+          s3 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e22); }
+        }
+      }
+      peg$savedPos = s0;
+      s0 = peg$f28(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsequoted_string() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 34) {
+      s1 = peg$c21;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e23); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parsechar();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parsechar();
+      }
+      if (input.charCodeAt(peg$currPos) === 34) {
+        s3 = peg$c21;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e23); }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f29(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsechar() {
+    var s0;
+
+    s0 = peg$parseunescaped_char();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseescaped_char();
+    }
+
+    return s0;
+  }
+
+  function peg$parseunescaped_char() {
+    var s0;
+
+    if (peg$r2.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseescaped_char() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 92) {
+      s1 = peg$c22;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 34) {
+        s2 = peg$c21;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e23); }
+      }
+      if (s2 === peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 92) {
+          s2 = peg$c22;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e25); }
+        }
+        if (s2 === peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 47) {
+            s2 = peg$c23;
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          }
+          if (s2 === peg$FAILED) {
+            s2 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 98) {
+              s3 = peg$c24;
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e27); }
+            }
+            if (s3 !== peg$FAILED) {
+              peg$savedPos = s2;
+              s3 = peg$f30();
+            }
+            s2 = s3;
+            if (s2 === peg$FAILED) {
+              s2 = peg$currPos;
+              if (input.charCodeAt(peg$currPos) === 102) {
+                s3 = peg$c25;
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e28); }
+              }
+              if (s3 !== peg$FAILED) {
+                peg$savedPos = s2;
+                s3 = peg$f31();
+              }
+              s2 = s3;
+              if (s2 === peg$FAILED) {
+                s2 = peg$currPos;
+                if (input.charCodeAt(peg$currPos) === 110) {
+                  s3 = peg$c26;
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e29); }
+                }
+                if (s3 !== peg$FAILED) {
+                  peg$savedPos = s2;
+                  s3 = peg$f32();
+                }
+                s2 = s3;
+                if (s2 === peg$FAILED) {
+                  s2 = peg$currPos;
+                  if (input.charCodeAt(peg$currPos) === 114) {
+                    s3 = peg$c27;
+                    peg$currPos++;
+                  } else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e30); }
+                  }
+                  if (s3 !== peg$FAILED) {
+                    peg$savedPos = s2;
+                    s3 = peg$f33();
+                  }
+                  s2 = s3;
+                  if (s2 === peg$FAILED) {
+                    s2 = peg$currPos;
+                    if (input.charCodeAt(peg$currPos) === 116) {
+                      s3 = peg$c28;
+                      peg$currPos++;
+                    } else {
+                      s3 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$e31); }
+                    }
+                    if (s3 !== peg$FAILED) {
+                      peg$savedPos = s2;
+                      s3 = peg$f34();
+                    }
+                    s2 = s3;
+                    if (s2 === peg$FAILED) {
+                      s2 = peg$currPos;
+                      if (input.charCodeAt(peg$currPos) === 117) {
+                        s3 = peg$c29;
+                        peg$currPos++;
+                      } else {
+                        s3 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$e32); }
+                      }
+                      if (s3 !== peg$FAILED) {
+                        s4 = peg$currPos;
+                        s5 = peg$currPos;
+                        s6 = peg$parseHEXDIG();
+                        if (s6 !== peg$FAILED) {
+                          s7 = peg$parseHEXDIG();
+                          if (s7 !== peg$FAILED) {
+                            s8 = peg$parseHEXDIG();
+                            if (s8 !== peg$FAILED) {
+                              s9 = peg$parseHEXDIG();
+                              if (s9 !== peg$FAILED) {
+                                s6 = [s6, s7, s8, s9];
+                                s5 = s6;
+                              } else {
+                                peg$currPos = s5;
+                                s5 = peg$FAILED;
+                              }
+                            } else {
+                              peg$currPos = s5;
+                              s5 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s5;
+                            s5 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s5;
+                          s5 = peg$FAILED;
+                        }
+                        if (s5 !== peg$FAILED) {
+                          s4 = input.substring(s4, peg$currPos);
+                        } else {
+                          s4 = s5;
+                        }
+                        if (s4 !== peg$FAILED) {
+                          peg$savedPos = s2;
+                          s2 = peg$f35(s4);
+                        } else {
+                          peg$currPos = s2;
+                          s2 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s2;
+                        s2 = peg$FAILED;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (s2 !== peg$FAILED) {
+        s0 = s2;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseHEXDIG() {
+    var s0;
+
+    if (peg$r3.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e33); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseraw_string() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 39) {
+      s1 = peg$c30;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e34); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseraw_string_char();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseraw_string_char();
+      }
+      if (input.charCodeAt(peg$currPos) === 39) {
+        s3 = peg$c30;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f36(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseraw_string_char() {
+    var s0;
+
+    s0 = peg$parseunescaped_raw_string_char();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsepreserved_escape();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseraw_string_escape();
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseunescaped_raw_string_char() {
+    var s0;
+
+    if (peg$r4.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e35); }
+    }
+
+    return s0;
+  }
+
+  function peg$parsepreserved_escape() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 92) {
+      s1 = peg$c22;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      if (peg$r5.test(input.charAt(peg$currPos))) {
+        s2 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e36); }
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f37();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseraw_string_escape() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 92) {
+      s1 = peg$c22;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e25); }
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 39) {
+        s2 = peg$c30;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e34); }
+      }
+      if (s2 !== peg$FAILED) {
+        s0 = s2;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsenumber() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    s1 = peg$parseint();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f38();
+    }
+    s0 = s1;
+
+    return s0;
+  }
+
+  function peg$parseint() {
+    var s0, s1, s2, s3, s4, s5;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 45) {
+      s1 = peg$c31;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e37); }
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (input.charCodeAt(peg$currPos) === 48) {
+      s2 = peg$c32;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e38); }
+    }
+    if (s2 === peg$FAILED) {
+      s2 = peg$currPos;
+      if (peg$r6.test(input.charAt(peg$currPos))) {
+        s3 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e39); }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = [];
+        if (peg$r7.test(input.charAt(peg$currPos))) {
+          s5 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e40); }
+        }
+        while (s5 !== peg$FAILED) {
+          s4.push(s5);
+          if (peg$r7.test(input.charAt(peg$currPos))) {
+            s5 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e40); }
+          }
+        }
+        s3 = [s3, s4];
+        s2 = s3;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s1 = [s1, s2];
+      s0 = s1;
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsejson_value() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 4) === peg$c33) {
+      s1 = peg$c33;
+      peg$currPos += 4;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e41); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f39();
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 5) === peg$c34) {
+        s1 = peg$c34;
+        peg$currPos += 5;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e42); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f40();
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 4) === peg$c35) {
+          s1 = peg$c35;
+          peg$currPos += 4;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$f41();
+        }
+        s0 = s1;
+        if (s0 === peg$FAILED) {
+          s0 = peg$parsejson_number();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parsejson_string();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parsejson_object();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parsejson_array();
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parsejson_number() {
+    var s0, s1, s2, s3, s4, s5, s6, s7;
+
+    s0 = peg$currPos;
+    s1 = peg$parseint();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s3 = peg$c16;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e16); }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = [];
+        if (peg$r7.test(input.charAt(peg$currPos))) {
+          s5 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e40); }
+        }
+        if (s5 !== peg$FAILED) {
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            if (peg$r7.test(input.charAt(peg$currPos))) {
+              s5 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e40); }
+            }
+          }
+        } else {
+          s4 = peg$FAILED;
+        }
+        if (s4 !== peg$FAILED) {
+          s3 = [s3, s4];
+          s2 = s3;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      s3 = peg$currPos;
+      if (peg$r8.test(input.charAt(peg$currPos))) {
+        s4 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e44); }
+      }
+      if (s4 !== peg$FAILED) {
+        if (peg$r9.test(input.charAt(peg$currPos))) {
+          s5 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e45); }
+        }
+        if (s5 === peg$FAILED) {
+          s5 = null;
+        }
+        s6 = [];
+        if (peg$r7.test(input.charAt(peg$currPos))) {
+          s7 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s7 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e40); }
+        }
+        if (s7 !== peg$FAILED) {
+          while (s7 !== peg$FAILED) {
+            s6.push(s7);
+            if (peg$r7.test(input.charAt(peg$currPos))) {
+              s7 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e40); }
+            }
+          }
+        } else {
+          s6 = peg$FAILED;
+        }
+        if (s6 !== peg$FAILED) {
+          s4 = [s4, s5, s6];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      peg$savedPos = s0;
+      s0 = peg$f42();
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsejson_string() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 34) {
+      s1 = peg$c21;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e23); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseunquoted_json_string();
+      if (input.charCodeAt(peg$currPos) === 34) {
+        s3 = peg$c21;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e23); }
+      }
+      if (s3 !== peg$FAILED) {
+        s0 = s2;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseunquoted_json_string() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = peg$parseunescaped_literal();
+    if (s2 === peg$FAILED) {
+      s2 = peg$parseescaped_literal();
+    }
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = peg$parseunescaped_literal();
+      if (s2 === peg$FAILED) {
+        s2 = peg$parseescaped_literal();
+      }
+    }
+    peg$savedPos = s0;
+    s1 = peg$f43(s1);
+    s0 = s1;
+
+    return s0;
+  }
+
+  function peg$parseunescaped_literal() {
+    var s0;
+
+    if (peg$r10.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e46); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseescaped_literal() {
+    var s0, s1, s2;
+
+    s0 = peg$parseescaped_char();
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 92) {
+        s1 = peg$c22;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e25); }
+      }
+      if (s1 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 96) {
+          s2 = peg$c20;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e20); }
+        }
+        if (s2 !== peg$FAILED) {
+          s0 = s2;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parsejson_object() {
+    var s0, s1, s3, s4, s5, s6, s8, s10;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 123) {
+      s1 = peg$c36;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e47); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$parsews();
+      s3 = peg$currPos;
+      s4 = peg$parsejson_member();
+      if (s4 !== peg$FAILED) {
+        s5 = [];
+        s6 = peg$currPos;
+        peg$parsews();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s8 = peg$c37;
+          peg$currPos++;
+        } else {
+          s8 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+        }
+        if (s8 !== peg$FAILED) {
+          peg$parsews();
+          s10 = peg$parsejson_member();
+          if (s10 !== peg$FAILED) {
+            s6 = s10;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s6;
+          s6 = peg$FAILED;
+        }
+        while (s6 !== peg$FAILED) {
+          s5.push(s6);
+          s6 = peg$currPos;
+          peg$parsews();
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s8 = peg$c37;
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e48); }
+          }
+          if (s8 !== peg$FAILED) {
+            peg$parsews();
+            s10 = peg$parsejson_member();
+            if (s10 !== peg$FAILED) {
+              s6 = s10;
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+        }
+        peg$savedPos = s3;
+        s3 = peg$f44(s4, s5);
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      s4 = peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 125) {
+        s5 = peg$c38;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e49); }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f45(s3);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsejson_member() {
+    var s0, s1, s3, s5;
+
+    s0 = peg$currPos;
+    s1 = peg$parsejson_string();
+    if (s1 !== peg$FAILED) {
+      peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 58) {
+        s3 = peg$c15;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e15); }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$parsews();
+        s5 = peg$parsejson_value();
+        if (s5 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f46(s1, s5);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsejson_array() {
+    var s0, s1, s3, s4, s5, s6, s8, s10;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s1 = peg$c13;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e13); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$parsews();
+      s3 = peg$currPos;
+      s4 = peg$parsejson_value();
+      if (s4 !== peg$FAILED) {
+        s5 = [];
+        s6 = peg$currPos;
+        peg$parsews();
+        if (input.charCodeAt(peg$currPos) === 44) {
+          s8 = peg$c37;
+          peg$currPos++;
+        } else {
+          s8 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+        }
+        if (s8 !== peg$FAILED) {
+          peg$parsews();
+          s10 = peg$parsejson_value();
+          if (s10 !== peg$FAILED) {
+            s6 = s10;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s6;
+          s6 = peg$FAILED;
+        }
+        while (s6 !== peg$FAILED) {
+          s5.push(s6);
+          s6 = peg$currPos;
+          peg$parsews();
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s8 = peg$c37;
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e48); }
+          }
+          if (s8 !== peg$FAILED) {
+            peg$parsews();
+            s10 = peg$parsejson_value();
+            if (s10 !== peg$FAILED) {
+              s6 = s10;
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+        }
+        peg$savedPos = s3;
+        s3 = peg$f47(s4, s5);
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      s4 = peg$parsews();
+      if (input.charCodeAt(peg$currPos) === 93) {
+        s5 = peg$c12;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e12); }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f48(s3);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsews() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = [];
+    if (peg$r11.test(input.charAt(peg$currPos))) {
+      s1 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e51); }
+    }
+    while (s1 !== peg$FAILED) {
+      s0.push(s1);
+      if (peg$r11.test(input.charAt(peg$currPos))) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e51); }
+      }
+    }
+    peg$silentFails--;
+    s1 = peg$FAILED;
+    if (peg$silentFails === 0) { peg$fail(peg$e50); }
+
+    return s0;
+  }
+
+
+  function binaryExpression(type, head, tail) {
+    return tail.reduce((lhs, rhs) => (
+      {
+        type,
+        lhs,
+        rhs
+      }
+    ), head);
+  }
+
+  function reduceProjection(lhs, rhs) {
+    return rhs.reduce((result, fn) => fn(result), lhs);
+  }
+
+  function maybeProject(expression, pfns) {
+    return !pfns.length ? expression : (
+      {
+        type: "project",
+        expression: unwrapTrivialProjection(expression),
+        projection: pfns.reduce((result, pfn) => pfn(result), { type: "current" })
+      });
+  }
+
+  function unwrapTrivialProjection(expression) {
+    const { type, projection } = expression;
+    return type === "project" && (!projection || projection.type === "current") ? expression.expression : expression;
+  }
+
+  peg$result = peg$startRuleFunction();
+
+  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+    return peg$result;
+  } else {
+    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+      peg$fail(peg$endExpectation());
+    }
+
+    throw peg$buildStructuredError(
+      peg$maxFailExpected,
+      peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
+      peg$maxFailPos < input.length
+        ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
+        : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
+    );
+  }
+}
+
+var parser = {
+  SyntaxError: peg$SyntaxError,
+  parse: peg$parse
+};
+
+function parseJsonSelector(selectorExpression) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return parser.parse(selectorExpression);
+}
+
+function setWithJsonSelector(selector, context, value) {
+    const accessor = accessWithJsonSelector(selector, context);
+    const oldValue = accessor.get();
+    accessor.set(value);
+    return oldValue;
+}
+
+export { accessWithJsonSelector, bindJsonSelectorAccessor, evaluateJsonSelector, formatJsonSelector, getWithJsonSelector, invertedSlice, makeJsonSelectorAccessor, parseJsonSelector, setWithJsonSelector };
+//# sourceMappingURL=json-selector.esm.js.map