@loancrate/json-selector 2.0.0 → 3.0.0

package/dist/json-selector.umd.js

@@ -0,0 +1,3575 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jsonSelector = {}));
+})(this, (function (exports) { 'use strict';
+
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
+	// do not edit .js files directly - edit src/index.jst
+
+
+
+	var fastDeepEqual = function equal(a, b) {
+	  if (a === b) return true;
+
+	  if (a && b && typeof a == 'object' && typeof b == 'object') {
+	    if (a.constructor !== b.constructor) return false;
+
+	    var length, i, keys;
+	    if (Array.isArray(a)) {
+	      length = a.length;
+	      if (length != b.length) return false;
+	      for (i = length; i-- !== 0;)
+	        if (!equal(a[i], b[i])) return false;
+	      return true;
+	    }
+
+
+
+	    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+	    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+	    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+
+	    keys = Object.keys(a);
+	    length = keys.length;
+	    if (length !== Object.keys(b).length) return false;
+
+	    for (i = length; i-- !== 0;)
+	      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+
+	    for (i = length; i-- !== 0;) {
+	      var key = keys[i];
+
+	      if (!equal(a[key], b[key])) return false;
+	    }
+
+	    return true;
+	  }
+
+	  // true if both NaN, false otherwise
+	  return a!==a && b!==b;
+	};
+
+	var deepEqual = /*@__PURE__*/getDefaultExportFromCjs(fastDeepEqual);
+
+	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) {
+	    var _a;
+	    return isObject(obj) ? (_a = obj[name]) !== null && _a !== void 0 ? _a : null : null;
+	}
+	function getIndex(obj, index) {
+	    var _a;
+	    return isArray(obj)
+	        ? (_a = obj[index < 0 ? obj.length + index : index]) !== null && _a !== void 0 ? _a : null
+	        : null;
+	}
+	function findId(obj, id) {
+	    var _a;
+	    return isArray(obj)
+	        ? (_a = obj.find((e) => isObject(e) && e.id === id)) !== null && _a !== void 0 ? _a : 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 "root":
+	            return visitor.root(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, rootContext = context) {
+	    return visitJsonSelector(selector, {
+	        current() {
+	            return context;
+	        },
+	        root() {
+	            return rootContext;
+	        },
+	        literal({ value }) {
+	            return value;
+	        },
+	        identifier({ id }) {
+	            return getField(context, id);
+	        },
+	        fieldAccess({ expression, field }) {
+	            return getField(evaluateJsonSelector(expression, context, rootContext), field);
+	        },
+	        indexAccess({ expression, index }) {
+	            return getIndex(evaluateJsonSelector(expression, context, rootContext), index);
+	        },
+	        idAccess({ expression, id }) {
+	            return findId(evaluateJsonSelector(expression, context, rootContext), id);
+	        },
+	        project({ expression, projection }) {
+	            return project(evaluateJsonSelector(expression, context, rootContext), projection, rootContext);
+	        },
+	        filter({ expression, condition }) {
+	            return filter(evaluateJsonSelector(expression, context, rootContext), condition, rootContext);
+	        },
+	        slice({ expression, start, end, step }) {
+	            return slice(evaluateJsonSelector(expression, context, rootContext), start, end, step);
+	        },
+	        flatten({ expression }) {
+	            return flatten(evaluateJsonSelector(expression, context, rootContext));
+	        },
+	        not({ expression }) {
+	            return isFalseOrEmpty(evaluateJsonSelector(expression, context, rootContext));
+	        },
+	        compare({ lhs, rhs, operator }) {
+	            const lv = evaluateJsonSelector(lhs, context, rootContext);
+	            const rv = evaluateJsonSelector(rhs, context, rootContext);
+	            return compare(lv, rv, operator);
+	        },
+	        and({ lhs, rhs }) {
+	            const lv = evaluateJsonSelector(lhs, context, rootContext);
+	            return isFalseOrEmpty(lv)
+	                ? lv
+	                : evaluateJsonSelector(rhs, context, rootContext);
+	        },
+	        or({ lhs, rhs }) {
+	            const lv = evaluateJsonSelector(lhs, context, rootContext);
+	            return !isFalseOrEmpty(lv)
+	                ? lv
+	                : evaluateJsonSelector(rhs, context, rootContext);
+	        },
+	        pipe({ lhs, rhs }) {
+	            return evaluateJsonSelector(rhs, evaluateJsonSelector(lhs, context, rootContext), rootContext);
+	        },
+	    }, context);
+	}
+	function project(value, projection, rootContext) {
+	    if (!isArray(value)) {
+	        return null;
+	    }
+	    if (!projection) {
+	        return value;
+	    }
+	    const result = value
+	        .map((e) => evaluateJsonSelector(projection, e, rootContext))
+	        .filter((e) => e != null);
+	    return result;
+	}
+	function filter(value, condition, rootContext) {
+	    if (!isArray(value)) {
+	        return null;
+	    }
+	    const result = value.filter((e) => !isFalseOrEmpty(evaluateJsonSelector(condition, e, rootContext)));
+	    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 = Object.assign(Object.assign({}, 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 ? "@" : "";
+	        },
+	        root() {
+	            return "$";
+	        },
+	        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 !== null && start !== void 0 ? start : ""}:${end !== null && end !== void 0 ? 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;
+	    }
+	}
+	class RootContextAccessor extends ReadOnlyAccessor {
+	    constructor() {
+	        super({ type: "root" });
+	    }
+	    get(context, rootContext = context) {
+	        return rootContext;
+	    }
+	}
+	function makeJsonSelectorAccessor(selector) {
+	    return visitJsonSelector(selector, {
+	        current() {
+	            return new ContextAccessor();
+	        },
+	        root() {
+	            return new RootContextAccessor();
+	        },
+	        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(value, context) {
+	                    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, rootContext = context) {
+	                    return isObject(base.get(context, rootContext));
+	                }
+	                get(context, rootContext = context) {
+	                    return getField(base.get(context, rootContext), field);
+	                }
+	                set(value, context, rootContext = context) {
+	                    const obj = base.get(context, rootContext);
+	                    if (isObject(obj)) {
+	                        obj[field] = value;
+	                    }
+	                }
+	                delete(context, rootContext = context) {
+	                    const obj = base.get(context, rootContext);
+	                    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, rootContext = context) {
+	                    return isArray(base.get(context, rootContext));
+	                }
+	                get(context, rootContext = context) {
+	                    return getIndex(base.get(context, rootContext), index);
+	                }
+	                set(value, context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        arr[index] = value;
+	                    }
+	                }
+	                delete(context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    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, rootContext = context) {
+	                    return isArray(base.get(context, rootContext));
+	                }
+	                get(context, rootContext = context) {
+	                    return findId(base.get(context, rootContext), id);
+	                }
+	                set(value, context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        const index = findIdIndex(arr, id);
+	                        if (index >= 0) {
+	                            arr[index] = value;
+	                        }
+	                    }
+	                }
+	                delete(context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    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, rootContext = context) {
+	                    return isArray(base.get(context, rootContext));
+	                }
+	                get(context, rootContext = context) {
+	                    return project(base.get(context, rootContext), projection, context);
+	                }
+	                set(value, context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        if (proj) {
+	                            for (const element of arr) {
+	                                proj.set(value, element, rootContext);
+	                            }
+	                        }
+	                        else {
+	                            replaceArray(arr, asArray(value));
+	                        }
+	                    }
+	                }
+	                delete(context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        if (proj) {
+	                            for (const element of arr) {
+	                                proj.delete(element, rootContext);
+	                            }
+	                        }
+	                        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, rootContext = context) {
+	                    return isArray(base.get(context, rootContext));
+	                }
+	                get(context, rootContext = context) {
+	                    return filter(base.get(context, rootContext), condition, context);
+	                }
+	                set(value, context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        replaceArray(arr, invertedFilter(arr, condition, rootContext).concat(asArray(value)));
+	                    }
+	                }
+	                delete(context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        replaceArray(arr, invertedFilter(arr, condition, rootContext));
+	                    }
+	                }
+	            };
+	            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, rootContext = context) {
+	                    return isArray(base.get(context, rootContext));
+	                }
+	                get(context, rootContext = context) {
+	                    return slice(base.get(context, rootContext), start, end, step);
+	                }
+	                set(value, context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        replaceArray(arr, invertedSlice(arr, start, end, step).concat(asArray(value)));
+	                    }
+	                }
+	                delete(context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    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, rootContext = context) {
+	                    return isArray(base.get(context, rootContext));
+	                }
+	                get(context, rootContext = context) {
+	                    return flatten(base.get(context, rootContext));
+	                }
+	                set(value, context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    if (isArray(arr)) {
+	                        replaceArray(arr, asArray(value));
+	                    }
+	                }
+	                delete(context, rootContext = context) {
+	                    const arr = base.get(context, rootContext);
+	                    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, rootContext = context) {
+	                    return isFalseOrEmpty(base.get(context, rootContext));
+	                }
+	            };
+	            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, rootContext = context) {
+	                    const lv = la.get(context, rootContext);
+	                    const rv = ra.get(context, rootContext);
+	                    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, rootContext = context) {
+	                    const lv = la.get(context, rootContext);
+	                    return isFalseOrEmpty(lv) ? lv : ra.get(context, rootContext);
+	                }
+	            };
+	            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, rootContext = context) {
+	                    const lv = la.get(context, rootContext);
+	                    return !isFalseOrEmpty(lv) ? lv : ra.get(context, rootContext);
+	                }
+	            };
+	            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, rootContext = context) {
+	                    return ra.isValidContext(la.get(context, rootContext), rootContext);
+	                }
+	                get(context, rootContext = context) {
+	                    return ra.get(la.get(context, rootContext), rootContext);
+	                }
+	                set(value, context, rootContext = context) {
+	                    ra.set(value, la.get(context, rootContext), rootContext);
+	                }
+	                delete(context, rootContext = context) {
+	                    ra.delete(la.get(context, rootContext), rootContext);
+	                }
+	            };
+	            return new Accessor();
+	        },
+	    }, undefined);
+	}
+	function bindJsonSelectorAccessor(unbound, context, rootContext = context) {
+	    const { selector } = unbound;
+	    const valid = unbound.isValidContext(context, rootContext);
+	    return {
+	        selector,
+	        valid,
+	        path: formatJsonSelector(selector),
+	        get() {
+	            return unbound.get(context, rootContext);
+	        },
+	        set(value) {
+	            unbound.set(value, context, rootContext);
+	        },
+	        delete() {
+	            unbound.delete(context, rootContext);
+	        },
+	    };
+	}
+	function accessWithJsonSelector(selector, context, rootContext = context) {
+	    return bindJsonSelectorAccessor(makeJsonSelectorAccessor(selector), context, rootContext);
+	}
+	function replaceArray(target, source) {
+	    target.length = 0;
+	    target.push(...source);
+	    return target;
+	}
+	function invertedFilter(value, condition, rootContext) {
+	    return value.filter((e) => isFalseOrEmpty(evaluateJsonSelector(condition, e, rootContext)));
+	}
+	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 offset_s = (this.location.source && (typeof this.location.source.offset === "function"))
+	      ? this.location.source.offset(s)
+	      : s;
+	    var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+	    if (src) {
+	      var e = this.location.end;
+	      var filler = peg$padEnd("", offset_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"
+	          + offset_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 = "/";
+	  var peg$c25 = "b";
+	  var peg$c26 = "f";
+	  var peg$c27 = "n";
+	  var peg$c28 = "r";
+	  var peg$c29 = "t";
+	  var peg$c30 = "u";
+	  var peg$c31 = "'";
+	  var peg$c32 = "-";
+	  var peg$c33 = "0";
+	  var peg$c34 = "null";
+	  var peg$c35 = "false";
+	  var peg$c36 = "true";
+	  var peg$c37 = "{";
+	  var peg$c38 = ",";
+	  var peg$c39 = "}";
+
+	  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$literalExpectation("`", false);
+	  var peg$e22 = peg$classExpectation([["a", "z"], "_"], false, true);
+	  var peg$e23 = peg$classExpectation([["0", "9"], ["a", "z"], "_"], false, true);
+	  var peg$e24 = peg$literalExpectation("\"", false);
+	  var peg$e25 = peg$classExpectation([["\0", "\x1F"], "\"", "\\"], true, false);
+	  var peg$e26 = peg$literalExpectation("\\", false);
+	  var peg$e27 = peg$literalExpectation("/", false);
+	  var peg$e28 = peg$literalExpectation("b", false);
+	  var peg$e29 = peg$literalExpectation("f", false);
+	  var peg$e30 = peg$literalExpectation("n", false);
+	  var peg$e31 = peg$literalExpectation("r", false);
+	  var peg$e32 = peg$literalExpectation("t", false);
+	  var peg$e33 = peg$literalExpectation("u", false);
+	  var peg$e34 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true);
+	  var peg$e35 = peg$literalExpectation("'", false);
+	  var peg$e36 = peg$classExpectation(["'", "\\"], true, false);
+	  var peg$e37 = peg$classExpectation(["'"], true, false);
+	  var peg$e38 = peg$literalExpectation("-", false);
+	  var peg$e39 = peg$literalExpectation("0", false);
+	  var peg$e40 = peg$classExpectation([["1", "9"]], false, false);
+	  var peg$e41 = peg$classExpectation([["0", "9"]], false, false);
+	  var peg$e42 = peg$literalExpectation("null", false);
+	  var peg$e43 = peg$literalExpectation("false", false);
+	  var peg$e44 = peg$literalExpectation("true", false);
+	  var peg$e45 = peg$classExpectation(["e", "E"], false, false);
+	  var peg$e46 = peg$classExpectation(["+", "-"], false, false);
+	  var peg$e47 = peg$classExpectation([["\0", "\x1F"], "\"", "\\", "`"], true, false);
+	  var peg$e48 = peg$literalExpectation("{", false);
+	  var peg$e49 = peg$literalExpectation(",", false);
+	  var peg$e50 = peg$literalExpectation("}", false);
+	  var peg$e51 = peg$otherExpectation("whitespace");
+	  var peg$e52 = 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: start ?? undefined,
+	    end: end ?? undefined,
+	    step: step ?? undefined,
+	  });
+	};
+	  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() { return { type: "root" }; };
+	  var peg$f27 = function(value) { return { type: "literal", value }; };
+	  var peg$f28 = function(value) { return { type: "literal", value }; };
+	  var peg$f29 = function(head, tail) { return head + tail.join(""); };
+	  var peg$f30 = function(chars) { return chars.join(""); };
+	  var peg$f31 = function() { return "\b"; };
+	  var peg$f32 = function() { return "\f"; };
+	  var peg$f33 = function() { return "\n"; };
+	  var peg$f34 = function() { return "\r"; };
+	  var peg$f35 = function() { return "\t"; };
+	  var peg$f36 = function(digits) {
+	        return String.fromCharCode(parseInt(digits, 16));
+	      };
+	  var peg$f37 = function(chars) { return chars.join(""); };
+	  var peg$f38 = function() { return text(); };
+	  var peg$f39 = function() { return parseInt(text()); };
+	  var peg$f40 = function() { return null; };
+	  var peg$f41 = function() { return false; };
+	  var peg$f42 = function() { return true; };
+	  var peg$f43 = function() { return parseFloat(text()); };
+	  var peg$f44 = function(chars) { return chars.join(""); };
+	  var peg$f45 = function(head, tail) { return [head].concat(tail); };
+	  var peg$f46 = function(members) { return Object.fromEntries(members ?? []); };
+	  var peg$f47 = function(name, value) { return [name, value]; };
+	  var peg$f48 = function(head, tail) { return [head].concat(tail); };
+	  var peg$f49 = 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, offset) {
+	    var startPosDetails = peg$computePosDetails(startPos);
+	    var endPosDetails = peg$computePosDetails(endPos);
+
+	    var res = {
+	      source: peg$source,
+	      start: {
+	        offset: startPos,
+	        line: startPosDetails.line,
+	        column: startPosDetails.column
+	      },
+	      end: {
+	        offset: endPos,
+	        line: endPosDetails.line,
+	        column: endPosDetails.column
+	      }
+	    };
+	    if (offset && peg$source && (typeof peg$source.offset === "function")) {
+	      res.start = peg$source.offset(res.start);
+	      res.end = peg$source.offset(res.end);
+	    }
+	    return res;
+	  }
+
+	  function peg$fail(expected) {
+	    if (peg$currPos < peg$maxFailPos) { return; }
+
+	    if (peg$currPos > peg$maxFailPos) {
+	      peg$maxFailPos = peg$currPos;
+	      peg$maxFailExpected = [];
+	    }
+
+	    peg$maxFailExpected.push(expected);
+	  }
+
+	  function peg$buildStructuredError(expected, found, location) {
+	    return new peg$SyntaxError(
+	      peg$SyntaxError.buildMessage(expected, found),
+	      expected,
+	      found,
+	      location
+	    );
+	  }
+
+	  function peg$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$currPos;
+	        if (input.charCodeAt(peg$currPos) === 36) {
+	          s1 = peg$c18;
+	          peg$currPos++;
+	        } else {
+	          s1 = peg$FAILED;
+	          if (peg$silentFails === 0) { peg$fail(peg$e18); }
+	        }
+	        if (s1 !== peg$FAILED) {
+	          peg$savedPos = s0;
+	          s1 = peg$f26();
+	        }
+	        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$f27(s1);
+	            }
+	            s0 = s1;
+	            if (s0 === peg$FAILED) {
+	              s0 = peg$currPos;
+	              if (input.charCodeAt(peg$currPos) === 40) {
+	                s1 = peg$c19;
+	                peg$currPos++;
+	              } else {
+	                s1 = peg$FAILED;
+	                if (peg$silentFails === 0) { peg$fail(peg$e19); }
+	              }
+	              if (s1 !== peg$FAILED) {
+	                s2 = peg$parseselector();
+	                if (s2 !== peg$FAILED) {
+	                  if (input.charCodeAt(peg$currPos) === 41) {
+	                    s3 = peg$c20;
+	                    peg$currPos++;
+	                  } else {
+	                    s3 = peg$FAILED;
+	                    if (peg$silentFails === 0) { peg$fail(peg$e20); }
+	                  }
+	                  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$c21;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e21); }
+	    }
+	    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$c21;
+	          peg$currPos++;
+	        } else {
+	          s5 = peg$FAILED;
+	          if (peg$silentFails === 0) { peg$fail(peg$e21); }
+	        }
+	        if (s5 !== peg$FAILED) {
+	          peg$savedPos = s0;
+	          s0 = peg$f28(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$e22); }
+	    }
+	    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$e23); }
+	      }
+	      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$e23); }
+	        }
+	      }
+	      peg$savedPos = s0;
+	      s0 = peg$f29(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$c22;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+	    }
+	    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$c22;
+	        peg$currPos++;
+	      } else {
+	        s3 = peg$FAILED;
+	        if (peg$silentFails === 0) { peg$fail(peg$e24); }
+	      }
+	      if (s3 !== peg$FAILED) {
+	        peg$savedPos = s0;
+	        s0 = peg$f30(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$e25); }
+	    }
+
+	    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$c23;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+	    }
+	    if (s1 !== peg$FAILED) {
+	      if (input.charCodeAt(peg$currPos) === 34) {
+	        s2 = peg$c22;
+	        peg$currPos++;
+	      } else {
+	        s2 = peg$FAILED;
+	        if (peg$silentFails === 0) { peg$fail(peg$e24); }
+	      }
+	      if (s2 === peg$FAILED) {
+	        if (input.charCodeAt(peg$currPos) === 92) {
+	          s2 = peg$c23;
+	          peg$currPos++;
+	        } else {
+	          s2 = peg$FAILED;
+	          if (peg$silentFails === 0) { peg$fail(peg$e26); }
+	        }
+	        if (s2 === peg$FAILED) {
+	          if (input.charCodeAt(peg$currPos) === 47) {
+	            s2 = peg$c24;
+	            peg$currPos++;
+	          } else {
+	            s2 = peg$FAILED;
+	            if (peg$silentFails === 0) { peg$fail(peg$e27); }
+	          }
+	          if (s2 === peg$FAILED) {
+	            s2 = peg$currPos;
+	            if (input.charCodeAt(peg$currPos) === 98) {
+	              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) === 102) {
+	                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) === 110) {
+	                  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) === 114) {
+	                    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) === 116) {
+	                      s3 = peg$c29;
+	                      peg$currPos++;
+	                    } else {
+	                      s3 = peg$FAILED;
+	                      if (peg$silentFails === 0) { peg$fail(peg$e32); }
+	                    }
+	                    if (s3 !== peg$FAILED) {
+	                      peg$savedPos = s2;
+	                      s3 = peg$f35();
+	                    }
+	                    s2 = s3;
+	                    if (s2 === peg$FAILED) {
+	                      s2 = peg$currPos;
+	                      if (input.charCodeAt(peg$currPos) === 117) {
+	                        s3 = peg$c30;
+	                        peg$currPos++;
+	                      } else {
+	                        s3 = peg$FAILED;
+	                        if (peg$silentFails === 0) { peg$fail(peg$e33); }
+	                      }
+	                      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$f36(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$e34); }
+	    }
+
+	    return s0;
+	  }
+
+	  function peg$parseraw_string() {
+	    var s0, s1, s2, s3;
+
+	    s0 = peg$currPos;
+	    if (input.charCodeAt(peg$currPos) === 39) {
+	      s1 = peg$c31;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e35); }
+	    }
+	    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$c31;
+	        peg$currPos++;
+	      } else {
+	        s3 = peg$FAILED;
+	        if (peg$silentFails === 0) { peg$fail(peg$e35); }
+	      }
+	      if (s3 !== peg$FAILED) {
+	        peg$savedPos = s0;
+	        s0 = peg$f37(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$e36); }
+	    }
+
+	    return s0;
+	  }
+
+	  function peg$parsepreserved_escape() {
+	    var s0, s1, s2;
+
+	    s0 = peg$currPos;
+	    if (input.charCodeAt(peg$currPos) === 92) {
+	      s1 = peg$c23;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+	    }
+	    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$e37); }
+	      }
+	      if (s2 !== peg$FAILED) {
+	        peg$savedPos = s0;
+	        s0 = peg$f38();
+	      } 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$c23;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e26); }
+	    }
+	    if (s1 !== peg$FAILED) {
+	      if (input.charCodeAt(peg$currPos) === 39) {
+	        s2 = peg$c31;
+	        peg$currPos++;
+	      } else {
+	        s2 = peg$FAILED;
+	        if (peg$silentFails === 0) { peg$fail(peg$e35); }
+	      }
+	      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$f39();
+	    }
+	    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$c32;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e38); }
+	    }
+	    if (s1 === peg$FAILED) {
+	      s1 = null;
+	    }
+	    if (input.charCodeAt(peg$currPos) === 48) {
+	      s2 = peg$c33;
+	      peg$currPos++;
+	    } else {
+	      s2 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e39); }
+	    }
+	    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$e40); }
+	      }
+	      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$e41); }
+	        }
+	        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$e41); }
+	          }
+	        }
+	        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$c34) {
+	      s1 = peg$c34;
+	      peg$currPos += 4;
+	    } 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, 5) === peg$c35) {
+	        s1 = peg$c35;
+	        peg$currPos += 5;
+	      } 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$currPos;
+	        if (input.substr(peg$currPos, 4) === peg$c36) {
+	          s1 = peg$c36;
+	          peg$currPos += 4;
+	        } else {
+	          s1 = peg$FAILED;
+	          if (peg$silentFails === 0) { peg$fail(peg$e44); }
+	        }
+	        if (s1 !== peg$FAILED) {
+	          peg$savedPos = s0;
+	          s1 = peg$f42();
+	        }
+	        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$e41); }
+	        }
+	        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$e41); }
+	            }
+	          }
+	        } 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$e45); }
+	      }
+	      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$e46); }
+	        }
+	        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$e41); }
+	        }
+	        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$e41); }
+	            }
+	          }
+	        } 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$f43();
+	    } 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$c22;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e24); }
+	    }
+	    if (s1 !== peg$FAILED) {
+	      s2 = peg$parseunquoted_json_string();
+	      if (input.charCodeAt(peg$currPos) === 34) {
+	        s3 = peg$c22;
+	        peg$currPos++;
+	      } else {
+	        s3 = peg$FAILED;
+	        if (peg$silentFails === 0) { peg$fail(peg$e24); }
+	      }
+	      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$f44(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$e47); }
+	    }
+
+	    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$c23;
+	        peg$currPos++;
+	      } else {
+	        s1 = peg$FAILED;
+	        if (peg$silentFails === 0) { peg$fail(peg$e26); }
+	      }
+	      if (s1 !== peg$FAILED) {
+	        if (input.charCodeAt(peg$currPos) === 96) {
+	          s2 = peg$c21;
+	          peg$currPos++;
+	        } else {
+	          s2 = peg$FAILED;
+	          if (peg$silentFails === 0) { peg$fail(peg$e21); }
+	        }
+	        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$c37;
+	      peg$currPos++;
+	    } else {
+	      s1 = peg$FAILED;
+	      if (peg$silentFails === 0) { peg$fail(peg$e48); }
+	    }
+	    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$c38;
+	          peg$currPos++;
+	        } else {
+	          s8 = peg$FAILED;
+	          if (peg$silentFails === 0) { peg$fail(peg$e49); }
+	        }
+	        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$c38;
+	            peg$currPos++;
+	          } else {
+	            s8 = peg$FAILED;
+	            if (peg$silentFails === 0) { peg$fail(peg$e49); }
+	          }
+	          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$f45(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$c39;
+	        peg$currPos++;
+	      } else {
+	        s5 = peg$FAILED;
+	        if (peg$silentFails === 0) { peg$fail(peg$e50); }
+	      }
+	      if (s5 !== peg$FAILED) {
+	        peg$savedPos = s0;
+	        s0 = peg$f46(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$f47(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$c38;
+	          peg$currPos++;
+	        } else {
+	          s8 = peg$FAILED;
+	          if (peg$silentFails === 0) { peg$fail(peg$e49); }
+	        }
+	        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$c38;
+	            peg$currPos++;
+	          } else {
+	            s8 = peg$FAILED;
+	            if (peg$silentFails === 0) { peg$fail(peg$e49); }
+	          }
+	          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$f48(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$f49(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$e52); }
+	    }
+	    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$e52); }
+	      }
+	    }
+	    peg$silentFails--;
+	    s1 = peg$FAILED;
+	    if (peg$silentFails === 0) { peg$fail(peg$e51); }
+
+	    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;
+	}
+
+	exports.accessWithJsonSelector = accessWithJsonSelector;
+	exports.bindJsonSelectorAccessor = bindJsonSelectorAccessor;
+	exports.evaluateJsonSelector = evaluateJsonSelector;
+	exports.formatJsonSelector = formatJsonSelector;
+	exports.getWithJsonSelector = getWithJsonSelector;
+	exports.invertedSlice = invertedSlice;
+	exports.makeJsonSelectorAccessor = makeJsonSelectorAccessor;
+	exports.parseJsonSelector = parseJsonSelector;
+	exports.setWithJsonSelector = setWithJsonSelector;
+
+}));
+//# sourceMappingURL=json-selector.umd.js.map