@loancrate/json-selector 2.0.0 → 2.1.0

package/dist/json-selector.umd.js

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