json-p3 1.3.5 → 2.1.0

package/dist/json-p3.iife.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 1.3.5
+ * json-p3 version 2.1.0
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -654,6 +654,30 @@ var json_p3 = (function (exports) {
     resolve: resolve
   });
 
+  /**
+   * An identifier that is allowed in both JS and JSONPath.
+   * JSONPath identifiers are generally much more permissive than JS ones, but
+   * they don't allow the character "$", so we take the intersection of the two
+   * when deciding whether to use dot shorthand for canonical serialization of
+   * simple names.
+   */
+  const SHORTHAND_COMPATIBLE_IDENTIFIER = /^[\p{ID_Start}_]\p{ID_Continue}*$/u;
+
+  /** Usable in a quoted path. */
+  function toQuoted(name) {
+    return name.includes("'") && !name.includes('"') ? JSON.stringify(name) : toCanonical(name);
+  }
+
+  /** Usable in a normalized path. */
+  function toCanonical(name) {
+    return `'${JSON.stringify(name).slice(1, -1).replaceAll('\\"', '"').replaceAll("'", "\\'")}'`;
+  }
+
+  /** Usable in a shorthand path. */
+  function toShorthand(name) {
+    return SHORTHAND_COMPATIBLE_IDENTIFIER.test(name) ? name : null;
+  }
+
   const Nothing = Symbol.for("jsonpath.nothing");
 
   /**
@@ -661,7 +685,7 @@ var json_p3 = (function (exports) {
    */
 
   /**
-   * Object passed to FilterExpression.evaluate().
+   * Object passed to `FilterExpression.evaluate()`.
    */
 
   /**
@@ -672,6 +696,14 @@ var json_p3 = (function (exports) {
   }
   const KEY_MARK = "\x02";
 
+  /**
+   * Options for serializing paths.
+   */
+
+  const defaultSerializationOptions = {
+    form: "pretty"
+  };
+
   /**
    * The pair of a JSON value and its location found in the target JSON value.
    */
@@ -686,10 +718,31 @@ var json_p3 = (function (exports) {
       this.location = location;
       this.root = root;
     }
+
+    /**
+     * @deprecated Use {@link getPath} with `options.form` set to `canonical` instead.
+     */
     get path() {
+      return this.getPath({
+        form: "canonical"
+      });
+    }
+
+    /**
+     * Get the path to this node in the target JSON value.
+     *
+     * Given that the path refers to the singular current node, the returned path
+     * will always be a normalized path if `options.form` is set to `canonical`,
+     * following section 2.7 of RFC 9535.
+     */
+    getPath(options) {
+      const opts = {
+        ...defaultSerializationOptions,
+        ...options
+      };
       return (
         // eslint-disable-next-line prefer-template
-        "$" + this.location.map(s => isString(s) ? this.decode_name_location(s) : `[${s}]`).join("")
+        "$" + this.location.map(s => isString(s) ? this.decodeNameLocation(s, opts) : `[${s}]`).join("")
       );
     }
 
@@ -702,8 +755,16 @@ var json_p3 = (function (exports) {
       }
       return new JSONPointer(JSONPointer.encode(this.location.map(String)));
     }
-    decode_name_location(name) {
-      return name.startsWith(KEY_MARK) ? `[~'${name.slice(1).replaceAll("'", "\\'")}']` : `['${name.replaceAll("'", "\\'")}']`;
+    decodeNameLocation(name, options) {
+      const normalized = options.form === "canonical";
+      const serialize = normalized ? toCanonical : toQuoted;
+      const hasKeyMark = name.startsWith(KEY_MARK);
+      if (hasKeyMark) name = name.slice(1);
+      const shorthand = toShorthand(name);
+      if (hasKeyMark) {
+        return normalized || shorthand == null ? `[~${serialize(name)}]` : `.~${shorthand}`;
+      }
+      return normalized || shorthand == null ? `[${serialize(name)}]` : `.${shorthand}`;
     }
   }
 
@@ -764,8 +825,8 @@ var json_p3 = (function (exports) {
      * A normalized path contains only property name and index selectors, and
      * always uses bracketed segments, never shorthand selectors.
      */
-    paths() {
-      return this.nodes.map(node => node.path);
+    paths(options) {
+      return this.nodes.map(node => node.getPath(options));
     }
 
     /**
@@ -837,7 +898,7 @@ var json_p3 = (function (exports) {
       return this.value;
     }
     toString() {
-      return JSON.stringify(this.value);
+      return toCanonical(this.value);
     }
   }
   class NumberLiteral extends FilterExpressionLiteral {
@@ -868,10 +929,13 @@ var json_p3 = (function (exports) {
       }
       throw new JSONPathTypeError(`unknown operator '${this.operator}'`, this.token);
     }
-    toString() {
-      return `${this.operator}${this.right.toString()}`;
+    toString(options) {
+      return `${this.operator}${this.right.toString(options)}`;
     }
   }
+  const PRECEDENCE_LOGICAL_OR$1 = 4;
+  const PRECEDENCE_LOGICAL_AND$1 = 5;
+  const PRECEDENCE_PREFIX$1 = 7;
   class InfixExpression extends FilterExpression {
     constructor(token, left, operator, right) {
       super(token);
@@ -894,11 +958,12 @@ var json_p3 = (function (exports) {
       }
       return compare(left, this.operator, right);
     }
-    toString() {
+    toString(options) {
+      // Note that `LogicalExpression.toString()` does not call this.
       if (this.logical) {
-        return `(${this.left.toString()} ${this.operator} ${this.right.toString()})`;
+        return `(${this.left.toString(options)} ${this.operator} ${this.right.toString(options)})`;
       }
-      return `${this.left.toString()} ${this.operator} ${this.right.toString()}`;
+      return `${this.left.toString(options)} ${this.operator} ${this.right.toString(options)}`;
     }
   }
   class LogicalExpression extends FilterExpression {
@@ -912,35 +977,65 @@ var json_p3 = (function (exports) {
       if (value instanceof JSONPathNodeList) return value.nodes.length > 0; // existence
       return isTruthy(value);
     }
-    toString() {
-      return this.expression.toString();
+    toString(options) {
+      // Minimize parentheses in logical expressions.
+      function _toString(expression, parentPrecedence) {
+        if (expression instanceof InfixExpression) {
+          let precedence;
+          let op;
+          let left;
+          let right;
+          if (expression.operator === "&&") {
+            precedence = PRECEDENCE_LOGICAL_AND$1;
+            op = "&&";
+            left = _toString(expression.left, precedence);
+            right = _toString(expression.right, precedence);
+          } else if (expression.operator === "||") {
+            precedence = PRECEDENCE_LOGICAL_OR$1;
+            op = "||";
+            left = _toString(expression.left, precedence);
+            right = _toString(expression.right, precedence);
+          } else {
+            return expression.toString(options);
+          }
+          const expr = `${left} ${op} ${right}`;
+          return precedence < parentPrecedence ? `(${expr})` : expr;
+        }
+        if (expression instanceof PrefixExpression) {
+          const operand = _toString(expression.right, PRECEDENCE_PREFIX$1);
+          const expr = `!${operand}`;
+          return parentPrecedence > PRECEDENCE_PREFIX$1 ? `(${expr})` : expr;
+        }
+        return expression.toString(options);
+      }
+      return _toString(this.expression, 0);
     }
   }
 
   /**
    * Base class for relative and absolute JSONPath query expressions.
    */
-  class JSONPathQuery extends FilterExpression {
+  class FilterQuery extends FilterExpression {
     constructor(token, path) {
       super(token);
       this.token = token;
       this.path = path;
     }
   }
-  class RelativeQuery extends JSONPathQuery {
+  class RelativeQuery extends FilterQuery {
     evaluate(context) {
       return context.lazy ? new JSONPathNodeList(Array.from(this.path.lazyQuery(context.currentValue))) : this.path.query(context.currentValue);
     }
-    toString() {
-      return `@${this.path.toString().slice(1)}`;
+    toString(options) {
+      return `@${this.path.toString(options).slice(1)}`;
     }
   }
-  class RootQuery extends JSONPathQuery {
+  class RootQuery extends FilterQuery {
     evaluate(context) {
       return context.lazy ? new JSONPathNodeList(Array.from(this.path.lazyQuery(context.rootValue))) : this.path.query(context.rootValue);
     }
-    toString() {
-      return this.path.toString();
+    toString(options) {
+      return this.path.toString(options);
     }
   }
   class FunctionExtension extends FilterExpression {
@@ -958,8 +1053,8 @@ var json_p3 = (function (exports) {
       const args = this.args.map(arg => arg.evaluate(context)).map((arg, idx) => func.argTypes[idx] !== FunctionExpressionType.NodesType && arg instanceof JSONPathNodeList ? this.unpack_node_list(arg) : arg);
       return func.call(...args);
     }
-    toString() {
-      return `${this.name}(${this.args.map(e => e.toString()).join(", ")})`;
+    toString(options) {
+      return `${this.name}(${this.args.map(e => e.toString(options)).join(", ")})`;
     }
     unpack_node_list(arg) {
       switch (arg.length) {
@@ -1029,9 +1124,9 @@ var json_p3 = (function (exports) {
     BooleanLiteral: BooleanLiteral,
     FilterExpression: FilterExpression,
     FilterExpressionLiteral: FilterExpressionLiteral,
+    FilterQuery: FilterQuery,
     FunctionExtension: FunctionExtension,
     InfixExpression: InfixExpression,
-    JSONPathQuery: JSONPathQuery,
     LogicalExpression: LogicalExpression,
     NullLiteral: NullLiteral,
     NumberLiteral: NumberLiteral,
@@ -3132,11 +3227,11 @@ var json_p3 = (function (exports) {
     }
 
     /**
-     * @param nodes - Nodes matched by preceding selectors.
+     * @param node - Nodes matched by preceding selectors.
      */
 
     /**
-     * @param nodes - Nodes matched by preceding selectors.
+     * @param node - Nodes matched by preceding selectors.
      */
 
     /**
@@ -3148,31 +3243,35 @@ var json_p3 = (function (exports) {
    * Shorthand and quoted name selector.
    */
   class NameSelector extends JSONPathSelector {
-    constructor(environment, token, name, shorthand) {
+    constructor(environment, token, name) {
       super(environment, token);
       this.environment = environment;
       this.token = token;
       this.name = name;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
-          rv.push(new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root));
-        }
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
+        rv.push(new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root));
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
-          yield new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root);
-        }
+    *lazyResolve(node) {
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
+        yield new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root);
       }
     }
-    toString() {
-      return this.shorthand ? `['${this.name}']` : `'${this.name}'`;
+    toString(options) {
+      const {
+        form
+      } = {
+        ...defaultSerializationOptions,
+        ...options
+      };
+      return form === "canonical" ? toCanonical(this.name) : toQuoted(this.name);
+    }
+    shorthand() {
+      return toShorthand(this.name);
     }
   }
 
@@ -3189,25 +3288,21 @@ var json_p3 = (function (exports) {
         throw new JSONPathIndexError("index out of range", this.token);
       }
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (isArray(node.value)) {
-          const normIndex = this.normalizedIndex(node.value.length);
-          if (normIndex in node.value) {
-            rv.push(new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root));
-          }
+      if (isArray(node.value)) {
+        const normIndex = this.normalizedIndex(node.value.length);
+        if (normIndex in node.value) {
+          rv.push(new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root));
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (isArray(node.value)) {
-          const normIndex = this.normalizedIndex(node.value.length);
-          if (normIndex in node.value) {
-            yield new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root);
-          }
+    *lazyResolve(node) {
+      if (isArray(node.value)) {
+        const normIndex = this.normalizedIndex(node.value.length);
+        if (normIndex in node.value) {
+          yield new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root);
         }
       }
     }
@@ -3229,19 +3324,16 @@ var json_p3 = (function (exports) {
       this.step = step;
       this.checkRange(start, stop, step);
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (!isArray(node.value)) continue;
-        for (const [i, value] of this.slice(node.value, this.start, this.stop, this.step)) {
-          rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
-        }
+      if (!isArray(node.value)) return rv;
+      for (const [i, value] of this.slice(node.value, this.start, this.stop, this.step)) {
+        rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (!isArray(node.value)) continue;
+    *lazyResolve(node) {
+      if (isArray(node.value)) {
         for (const [i, value] of this.lazySlice(node.value, this.start, this.stop, this.step)) {
           yield new JSONPathNode(value, node.location.concat(i), node.root);
         }
@@ -3347,281 +3439,185 @@ var json_p3 = (function (exports) {
   }
   class WildcardSelector extends JSONPathSelector {
     constructor(environment, token) {
-      let shorthand = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       super(environment, token);
       this.environment = environment;
       this.token = token;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String) continue;
-        if (isArray(node.value)) {
-          for (let i = 0; i < node.value.length; i++) {
-            rv.push(new JSONPathNode(node.value[i], node.location.concat(i), node.root));
-          }
-        } else if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
-          }
+      if (node.value instanceof String) return rv;
+      if (isArray(node.value)) {
+        for (let i = 0; i < node.value.length; i++) {
+          rv.push(new JSONPathNode(node.value[i], node.location.concat(i), node.root));
+        }
+      } else if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String) continue;
-        if (isArray(node.value)) {
-          for (let i = 0; i < node.value.length; i++) {
-            yield new JSONPathNode(node.value[i], node.location.concat(i), node.root);
-          }
-        } else if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            yield new JSONPathNode(value, node.location.concat(key), node.root);
-          }
+    *lazyResolve(node) {
+      if (isArray(node.value)) {
+        for (let i = 0; i < node.value.length; i++) {
+          yield new JSONPathNode(node.value[i], node.location.concat(i), node.root);
+        }
+      } else if (isObject(node.value) && !isString(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          yield new JSONPathNode(value, node.location.concat(key), node.root);
         }
       }
     }
     toString() {
-      return this.shorthand ? "[*]" : "*";
+      return "*";
     }
   }
-  class RecursiveDescentSegment extends JSONPathSelector {
-    constructor(environment, token, selector) {
+  class FilterSelector extends JSONPathSelector {
+    constructor(environment, token, expression) {
       super(environment, token);
       this.environment = environment;
       this.token = token;
-      this.selector = selector;
-    }
-    resolve(nodes) {
-      const rv = [];
-      if (this.environment.nondeterministic) {
-        for (const root of nodes) {
-          for (const node of this.nondeterministicVisitor(root)) {
-            rv.push(node);
-          }
-        }
-      } else {
-        for (const node of nodes) {
-          rv.push(node);
-          for (const _node of this.visitor(node)) {
-            rv.push(_node);
-          }
-        }
-      }
-      return this.selector.resolve(rv);
-    }
-    *lazyResolve(nodes) {
-      yield* this.selector.lazyResolve(this._lazyResolve(nodes));
-    }
-
-    // eslint-disable-next-line sonarjs/cognitive-complexity
-    *_lazyResolve(nodes) {
-      for (const _node of nodes) {
-        const stack = [{
-          node: _node,
-          depth: 0
-        }];
-        yield _node;
-        while (stack.length) {
-          const {
-            node: currentNode,
-            depth
-          } = stack.pop();
-          if (depth >= this.environment.maxRecursionDepth) {
-            throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
-          }
-          if (currentNode.value instanceof String) continue;
-          if (isArray(currentNode.value)) {
-            for (let i = 0; i < currentNode.value.length; i++) {
-              const __node = new JSONPathNode(currentNode.value[i], currentNode.location.concat(i), currentNode.root);
-              yield __node;
-              if (isObject(__node.value)) {
-                stack.push({
-                  node: __node,
-                  depth: depth + 1
-                });
-              }
-            }
-          } else if (isObject(currentNode.value)) {
-            for (const [key, value] of this.environment.entries(currentNode.value)) {
-              const __node = new JSONPathNode(value, currentNode.location.concat(key), currentNode.root);
-              yield __node;
-              if (isObject(__node.value)) {
-                stack.push({
-                  node: __node,
-                  depth: depth + 1
-                });
-              }
-            }
-          }
-        }
-      }
-    }
-    toString() {
-      return `..${this.selector.toString()}`;
+      this.expression = expression;
     }
-    visitor(node) {
-      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      if (depth >= this.environment.maxRecursionDepth) {
-        throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
-      }
+    resolve(node) {
       const rv = [];
       if (node.value instanceof String) return rv;
       if (isArray(node.value)) {
         for (let i = 0; i < node.value.length; i++) {
-          const _node = new JSONPathNode(node.value[i], node.location.concat(i), node.root);
-          rv.push(_node);
-          for (const __node of this.visitor(_node, depth + 1)) {
-            rv.push(__node);
+          const value = node.value[i];
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            currentKey: i
+          };
+          if (this.expression.evaluate(filterContext)) {
+            rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
           }
         }
       } else if (isObject(node.value)) {
         for (const [key, value] of this.environment.entries(node.value)) {
-          const _node = new JSONPathNode(value, node.location.concat(key), node.root);
-          rv.push(_node);
-          for (const __node of this.visitor(_node, depth + 1)) {
-            rv.push(__node);
-          }
-        }
-      }
-      return rv;
-    }
-    nondeterministicVisitor(root) {
-      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      const rv = [root];
-      let queue = this.nondeterministicChildren(root).map(node => [node, depth]);
-      while (queue.length) {
-        const [node, _depth] = queue.shift();
-        rv.push(node);
-        if (_depth >= this.environment.maxRecursionDepth) {
-          throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
-        }
-
-        // Visit child nodes now or queue them for later?
-        const visitChildren = Math.random() < 0.5;
-        for (const child of this.nondeterministicChildren(node)) {
-          if (visitChildren) {
-            rv.push(child);
-            const grandchildren = this.nondeterministicChildren(child).map(n => [n, _depth + 2]);
-            queue = interleave(queue, grandchildren);
-          } else {
-            queue.push([child, _depth + 1]);
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
           }
         }
       }
       return rv;
     }
-    nondeterministicChildren(node) {
-      const _rv = [];
-      if (node.value instanceof String) return _rv;
+    *lazyResolve(node) {
       if (isArray(node.value)) {
         for (let i = 0; i < node.value.length; i++) {
-          _rv.push(new JSONPathNode(node.value[i], node.location.concat(i), node.root));
+          const value = node.value[i];
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            lazy: true,
+            currentKey: i
+          };
+          if (this.expression.evaluate(filterContext)) {
+            yield new JSONPathNode(value, node.location.concat(i), node.root);
+          }
         }
-      } else if (isObject(node.value)) {
+      } else if (isObject(node.value) && !isString(node.value)) {
         for (const [key, value] of this.environment.entries(node.value)) {
-          _rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            lazy: true,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            yield new JSONPathNode(value, node.location.concat(key), node.root);
+          }
         }
       }
-      return _rv;
+    }
+    toString(options) {
+      return `?${this.expression.toString(options)}`;
     }
   }
-  class FilterSelector extends JSONPathSelector {
-    constructor(environment, token, expression) {
-      super(environment, token);
+
+  var selectors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FilterSelector: FilterSelector,
+    IndexSelector: IndexSelector,
+    JSONPathSelector: JSONPathSelector,
+    NameSelector: NameSelector,
+    SliceSelector: SliceSelector,
+    WildcardSelector: WildcardSelector
+  });
+
+  /** Base class for all JSONPath segments. Both shorthand and bracketed. */
+  class JSONPathSegment {
+    constructor(environment, token, selectors) {
       this.environment = environment;
       this.token = token;
-      this.expression = expression;
+      this.selectors = selectors;
     }
 
-    // eslint-disable-next-line sonarjs/cognitive-complexity
+    /**
+     * @param nodes - Nodes matched by preceding segments.
+     */
+
+    /**
+     * @param nodes - Nodes matched by preceding segments.
+     */
+
+    /**
+     * Return a string representation of this segment.
+     */
+  }
+
+  /** The child selection segment. */
+  class ChildSegment extends JSONPathSegment {
     resolve(nodes) {
       const rv = [];
       for (const node of nodes) {
-        if (node.value instanceof String) continue;
-        if (isArray(node.value)) {
-          for (let i = 0; i < node.value.length; i++) {
-            const value = node.value[i];
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              currentKey: i
-            };
-            if (this.expression.evaluate(filterContext)) {
-              rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
-            }
-          }
-        } else if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              currentKey: key
-            };
-            if (this.expression.evaluate(filterContext)) {
-              rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
-            }
-          }
+        for (const selector of this.selectors) {
+          rv.push(...selector.resolve(node));
         }
       }
       return rv;
     }
-
-    // eslint-disable-next-line sonarjs/cognitive-complexity
     *lazyResolve(nodes) {
       for (const node of nodes) {
-        if (node.value instanceof String) continue;
-        if (isArray(node.value)) {
-          for (let i = 0; i < node.value.length; i++) {
-            const value = node.value[i];
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              lazy: true,
-              currentKey: i
-            };
-            if (this.expression.evaluate(filterContext)) {
-              yield new JSONPathNode(value, node.location.concat(i), node.root);
-            }
-          }
-        } else if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              lazy: true,
-              currentKey: key
-            };
-            if (this.expression.evaluate(filterContext)) {
-              yield new JSONPathNode(value, node.location.concat(key), node.root);
-            }
-          }
+        for (const selector of this.selectors) {
+          yield* selector.resolve(node);
         }
       }
     }
-    toString() {
-      return `?${this.expression.toString()}`;
+    toString(options) {
+      const {
+        form
+      } = {
+        ...defaultSerializationOptions,
+        ...options
+      };
+      if (form === "pretty" && this.selectors.length === 1 && this.selectors[0] instanceof NameSelector) {
+        const shorthand = this.selectors[0].shorthand();
+        if (shorthand != null) return `.${shorthand}`;
+      }
+      return `[${this.selectors.map(s => s.toString(options)).join(", ")}]`;
     }
   }
-  class BracketedSelection extends JSONPathSelector {
-    constructor(environment, token, items) {
-      super(environment, token);
-      this.environment = environment;
-      this.token = token;
-      this.items = items;
-    }
+
+  /** The recursive descent segment. */
+  class DescendantSegment extends JSONPathSegment {
     resolve(nodes) {
       const rv = [];
+      const visitor = (this.environment.nondeterministic ? this.nondeterministicVisit : this.visit).bind(this);
       for (const node of nodes) {
-        for (const item of this.items) {
-          for (const _node of item.resolve([node])) {
-            rv.push(_node);
+        for (const _node of visitor(node)) {
+          for (const selector of this.selectors) {
+            rv.push(...selector.resolve(_node));
           }
         }
       }
@@ -3629,13 +3625,75 @@ var json_p3 = (function (exports) {
     }
     *lazyResolve(nodes) {
       for (const node of nodes) {
-        for (const item of this.items) {
-          yield* item.lazyResolve([node]);
+        for (const _node of this.visit(node)) {
+          for (const selector of this.selectors) {
+            yield* selector.resolve(_node);
+          }
         }
       }
     }
-    toString() {
-      return `[${this.items.map(itm => itm.toString()).join(", ")}]`;
+    toString(options) {
+      return `..[${this.selectors.map(s => s.toString(options)).join(", ")}]`;
+    }
+    visit(node) {
+      var _this = this;
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      return function* () {
+        if (depth >= _this.environment.maxRecursionDepth) {
+          throw new JSONPathRecursionLimitError("recursion limit reached", _this.token);
+        }
+        yield node;
+        if (isArray(node.value)) {
+          for (let i = 0; i < node.value.length; i++) {
+            const _node = new JSONPathNode(node.value[i], node.location.concat(i), node.root);
+            yield* _this.visit(_node, depth + 1);
+          }
+        } else if (isObject(node.value)) {
+          for (const [key, value] of _this.environment.entries(node.value)) {
+            const _node = new JSONPathNode(value, node.location.concat(key), node.root);
+            yield* _this.visit(_node, depth + 1);
+          }
+        }
+      }();
+    }
+    nondeterministicVisit(root) {
+      var _this2 = this;
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      return function* () {
+        let queue = Array.from(_this2.nondeterministicChildren(root)).map(node => [node, depth]);
+        yield root;
+        while (queue.length) {
+          const [node, _depth] = queue.shift();
+          yield node;
+          if (_depth >= _this2.environment.maxRecursionDepth) {
+            throw new JSONPathRecursionLimitError("recursion limit reached", _this2.token);
+          }
+
+          // Visit child nodes now or queue them for later?
+          const visitChildren = Math.random() < 0.5;
+          for (const child of _this2.nondeterministicChildren(node)) {
+            if (visitChildren) {
+              yield child;
+              const grandchildren = Array.from(_this2.nondeterministicChildren(child)).map(n => [n, _depth + 2]);
+              queue = interleave(queue, grandchildren);
+            } else {
+              queue.push([child, _depth + 1]);
+            }
+          }
+        }
+      }();
+    }
+    *nondeterministicChildren(node) {
+      if (isString(node.value)) return;
+      if (isArray(node.value)) {
+        for (let i = 0; i < node.value.length; i++) {
+          yield new JSONPathNode(node.value[i], node.location.concat(i), node.root);
+        }
+      } else if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          yield new JSONPathNode(value, node.location.concat(key), node.root);
+        }
+      }
     }
   }
 
@@ -3674,54 +3732,37 @@ var json_p3 = (function (exports) {
     return entries;
   }
 
-  var selectors = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    BracketedSelection: BracketedSelection,
-    FilterSelector: FilterSelector,
-    IndexSelector: IndexSelector,
-    JSONPathSelector: JSONPathSelector,
-    NameSelector: NameSelector,
-    RecursiveDescentSegment: RecursiveDescentSegment,
-    SliceSelector: SliceSelector,
-    WildcardSelector: WildcardSelector
-  });
-
   /**
-   *
+   * A compiled JSONPath query ready to be applied to different data repeatedly.
    */
-  class JSONPath {
-    /**
-     *
-     * @param environment -
-     * @param selectors -
-     */
-    constructor(environment, selectors) {
+  class JSONPathQuery {
+    constructor(environment, segments) {
       this.environment = environment;
-      this.selectors = selectors;
+      this.segments = segments;
     }
 
     /**
-     *
-     * @param value -
-     * @returns
+     * Apply this JSONPath query to _value_.
+     * @param value - A JSON-like object to apply this query to.
+     * @returns Nodes matched by applying this query to _value_.
      */
     query(value) {
       let nodes = [new JSONPathNode(value, [], value)];
-      for (const selector of this.selectors) {
-        nodes = selector.resolve(nodes);
+      for (const segment of this.segments) {
+        nodes = segment.resolve(nodes);
       }
       return new JSONPathNodeList(nodes);
     }
 
     /**
-     *
-     * @param value -
-     * @returns
+     * Apply this JSONPath query to _value_.
+     * @param value - A JSON-like object to apply this query to.
+     * @returns An iterator over nodes matched by applying this query to _value_.
      */
     lazyQuery(value) {
       let nodes = [new JSONPathNode(value, [], value)][Symbol.iterator]();
-      for (const selector of this.selectors) {
-        nodes = selector.lazyResolve(nodes);
+      for (const segment of this.segments) {
+        nodes = segment.lazyResolve(nodes);
       }
       return nodes;
     }
@@ -3742,15 +3783,21 @@ var json_p3 = (function (exports) {
     }
 
     /**
-     *
+     * Return a string representation of this query.
      */
-    toString() {
-      return `$${this.selectors.map(s => s.toString()).join("")}`;
+    toString(options) {
+      return `$${this.segments.map(s => s.toString(options)).join("")}`;
     }
+
+    /**
+     * Return `true` if this query is a _singular query_, or `false` otherwise.
+     */
     singularQuery() {
-      for (const selector of this.selectors) {
-        if (selector instanceof NameSelector) continue;
-        if (selector instanceof BracketedSelection && selector.items.length === 1 && (selector.items[0] instanceof NameSelector || selector.items[0] instanceof IndexSelector)) continue;
+      for (const segment of this.segments) {
+        if (segment instanceof DescendantSegment) return false;
+        if (segment.selectors.length === 1 && (segment.selectors[0] instanceof NameSelector || segment.selectors[0] instanceof IndexSelector)) {
+          continue;
+        }
         return false;
       }
       return true;
@@ -3768,33 +3815,33 @@ var json_p3 = (function (exports) {
 
   class KeySelector extends JSONPathSelector {
     constructor(environment, token, key) {
-      let shorthand = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
       super(environment, token);
       this.environment = environment;
       this.token = token;
       this.key = key;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value) && hasStringKey(node.value, this.key)) {
-          rv.push(new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root));
-        }
+      if (node.value instanceof String || isArray(node.value)) return rv;
+      if (isObject(node.value) && hasStringKey(node.value, this.key)) {
+        rv.push(new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root));
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value) && hasStringKey(node.value, this.key)) {
-          yield new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root);
-        }
+    *lazyResolve(node) {
+      if (!isString(node.value) && isObject(node.value) && hasStringKey(node.value, this.key)) {
+        yield new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root);
       }
     }
-    toString() {
-      return this.shorthand ? `[~'${this.key.replaceAll("'", "\\'")}']` : `~'${this.key.replaceAll("'", "\\'")}'`;
+    toString(options) {
+      const {
+        form
+      } = {
+        ...defaultSerializationOptions,
+        ...options
+      };
+      const serialize = form === "canonical" ? toCanonical : toQuoted;
+      return `~${serialize(this.key)}`;
     }
   }
 
@@ -3803,36 +3850,29 @@ var json_p3 = (function (exports) {
    */
   class KeysSelector extends JSONPathSelector {
     constructor(environment, token) {
-      let shorthand = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       super(environment, token);
       this.environment = environment;
       this.token = token;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, _] of this.environment.entries(node.value)) {
-            rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
-          }
+      if (node.value instanceof String || isArray(node.value)) return rv;
+      if (isObject(node.value)) {
+        for (const [key, _] of this.environment.entries(node.value)) {
+          rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, _] of this.environment.entries(node.value)) {
-            yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
-          }
+    *lazyResolve(node) {
+      if (isObject(node.value) && !isString(node.value) && !isArray(node.value)) {
+        for (const [key, _] of this.environment.entries(node.value)) {
+          yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
         }
       }
     }
     toString() {
-      return this.shorthand ? "[~]" : "~";
+      return "~";
     }
   }
   class KeysFilterSelector extends JSONPathSelector {
@@ -3842,47 +3882,43 @@ var json_p3 = (function (exports) {
       this.token = token;
       this.expression = expression;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              currentKey: key
-            };
-            if (this.expression.evaluate(filterContext)) {
-              rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
-            }
+      if (node.value instanceof String || isArray(node.value)) return rv;
+      if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
           }
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              lazy: true,
-              currentKey: key
-            };
-            if (this.expression.evaluate(filterContext)) {
-              yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
-            }
+    *lazyResolve(node) {
+      if (node.value instanceof String || isArray(node.value)) return;
+      if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            lazy: true,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
           }
         }
       }
     }
-    toString() {
-      return `~?${this.expression.toString()}`;
+    toString(options) {
+      return `~?${this.expression.toString(options)}`;
     }
   }
 
@@ -3905,52 +3941,59 @@ var json_p3 = (function (exports) {
     }
     parse(stream) {
       if (stream.current.kind === TokenKind.ROOT) stream.next();
-      const selectors = this.parsePath(stream);
+      const segments = this.parseQuery(stream);
       if (stream.current.kind !== TokenKind.EOF) {
         throw new JSONPathSyntaxError(`unexpected token '${stream.current.kind}'`, stream.current);
       }
-      return selectors;
+      return segments;
     }
-    parsePath(stream) {
+    parseQuery(stream) {
       let inFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      const selectors = [];
-      for (;;) {
-        const selector = this.parseSegment(stream);
-        if (!selector) {
-          if (inFilter) {
-            stream.backup();
-          }
-          break;
+      const segments = [];
+      loop: for (;;) {
+        switch (stream.current.kind) {
+          case TokenKind.DDOT:
+            {
+              const token = stream.next();
+              const selectors = this.parseSelectors(stream);
+              segments.push(new DescendantSegment(this.environment, token, selectors));
+              break;
+            }
+          case TokenKind.LBRACKET:
+          case TokenKind.KEY:
+          case TokenKind.KEYS:
+          case TokenKind.NAME:
+          case TokenKind.WILD:
+            {
+              const token = stream.current;
+              const selectors = this.parseSelectors(stream);
+              segments.push(new ChildSegment(this.environment, token, selectors));
+              break;
+            }
+          default:
+            {
+              if (inFilter) stream.backup();
+              break loop;
+            }
         }
-        selectors.push(selector);
         stream.next();
       }
-      return selectors;
+      return segments;
     }
-    parseSegment(stream) {
+    parseSelectors(stream) {
       switch (stream.current.kind) {
         case TokenKind.NAME:
-          return new NameSelector(this.environment, stream.current, stream.current.value, true);
+          return [new NameSelector(this.environment, stream.current, stream.current.value)];
         case TokenKind.WILD:
-          return new WildcardSelector(this.environment, stream.current, true);
+          return [new WildcardSelector(this.environment, stream.current)];
         case TokenKind.KEY:
-          return new KeySelector(this.environment, stream.current, stream.current.value, true);
+          return [new KeySelector(this.environment, stream.current, stream.current.value)];
         case TokenKind.KEYS:
-          return new KeysSelector(this.environment, stream.current, true);
-        case TokenKind.DDOT:
-          {
-            const segmentToken = stream.current;
-            stream.next();
-            const selector = this.parseSegment(stream);
-            if (!selector) {
-              throw new JSONPathSyntaxError("bald descendant segment", stream.current);
-            }
-            return new RecursiveDescentSegment(this.environment, segmentToken, selector);
-          }
+          return [new KeysSelector(this.environment, stream.current)];
         case TokenKind.LBRACKET:
           return this.parseBracketedSelection(stream);
         default:
-          return null;
+          return [];
       }
     }
     parseIndex(stream) {
@@ -4007,38 +4050,38 @@ var json_p3 = (function (exports) {
     }
     parseBracketedSelection(stream) {
       const token = stream.next();
-      const items = [];
+      const selectors = [];
       while (stream.current.kind !== TokenKind.RBRACKET) {
         switch (stream.current.kind) {
           case TokenKind.SINGLE_QUOTE_STRING:
           case TokenKind.DOUBLE_QUOTE_STRING:
-            items.push(new NameSelector(this.environment, stream.current, this.decodeString(stream.current), false));
+            selectors.push(new NameSelector(this.environment, stream.current, this.decodeString(stream.current)));
             break;
           case TokenKind.FILTER:
-            items.push(this.parseFilter(stream));
+            selectors.push(this.parseFilter(stream));
             break;
           case TokenKind.INDEX:
             if (stream.peek.kind === TokenKind.COLON) {
-              items.push(this.parseSlice(stream));
+              selectors.push(this.parseSlice(stream));
             } else {
-              items.push(this.parseIndex(stream));
+              selectors.push(this.parseIndex(stream));
             }
             break;
           case TokenKind.COLON:
-            items.push(this.parseSlice(stream));
+            selectors.push(this.parseSlice(stream));
             break;
           case TokenKind.WILD:
-            items.push(new WildcardSelector(this.environment, stream.current));
+            selectors.push(new WildcardSelector(this.environment, stream.current));
             break;
           case TokenKind.KEY_SINGLE_QUOTE_STRING:
           case TokenKind.KEY_DOUBLE_QUOTE_STRING:
-            items.push(new KeySelector(this.environment, stream.current, this.decodeString(stream.current), false));
+            selectors.push(new KeySelector(this.environment, stream.current, this.decodeString(stream.current)));
             break;
           case TokenKind.KEYS_FILTER:
-            items.push(this.parseFilter(stream, true));
+            selectors.push(this.parseFilter(stream, true));
             break;
           case TokenKind.KEYS:
-            items.push(new KeysSelector(this.environment, stream.current));
+            selectors.push(new KeysSelector(this.environment, stream.current));
             break;
           case TokenKind.EOF:
             throw new JSONPathSyntaxError("unexpected end of query", stream.current);
@@ -4052,10 +4095,10 @@ var json_p3 = (function (exports) {
         }
         stream.next();
       }
-      if (!items.length) {
+      if (!selectors.length) {
         throw new JSONPathSyntaxError("empty bracketed segment", token);
       }
-      return new BracketedSelection(this.environment, token, items);
+      return selectors;
     }
     parseFilter(stream) {
       let keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -4135,11 +4178,11 @@ var json_p3 = (function (exports) {
     }
     parseRootQuery(stream) {
       const tok = stream.next();
-      return new RootQuery(tok, new JSONPath(this.environment, this.parsePath(stream, true)));
+      return new RootQuery(tok, new JSONPathQuery(this.environment, this.parseQuery(stream, true)));
     }
     parseRelativeQuery(stream) {
       const tok = stream.next();
-      return new RelativeQuery(tok, new JSONPath(this.environment, this.parsePath(stream, true)));
+      return new RelativeQuery(tok, new JSONPathQuery(this.environment, this.parseQuery(stream, true)));
     }
     parseCurrentKey(stream) {
       return new CurrentKey(stream.current);
@@ -4441,10 +4484,10 @@ var json_p3 = (function (exports) {
 
     /**
      * @param path - A JSONPath query to parse.
-     * @returns A new {@link JSONPath} object, bound to this environment.
+     * @returns A new {@link JSONPathQuery} object, bound to this environment.
      */
     compile(path) {
-      return new JSONPath(this, this.parser.parse(new TokenStream(tokenize(this, path))));
+      return new JSONPathQuery(this, this.parser.parse(new TokenStream(tokenize(this, path))));
     }
 
     /**
@@ -4499,7 +4542,7 @@ var json_p3 = (function (exports) {
     /**
      * Check the well-typedness of a function's arguments at compile-time.
      *
-     * This method is called by the {@link Parser} when parsing function calls.
+     * This method is called by the parser when parsing function calls.
      * It is expected to throw a {@link JSONPathTypeError} if the function's
      * parameters are not well-typed.
      *
@@ -4526,17 +4569,17 @@ var json_p3 = (function (exports) {
       for (const [typ, arg, idx] of func.argTypes.map((t, i) => [t, args[i], i])) {
         switch (typ) {
           case FunctionExpressionType.ValueType:
-            if (!(arg instanceof FilterExpressionLiteral || arg instanceof CurrentKey || arg instanceof JSONPathQuery && arg.path.singularQuery() || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.ValueType)) {
+            if (!(arg instanceof FilterExpressionLiteral || arg instanceof CurrentKey || arg instanceof FilterQuery && arg.path.singularQuery() || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.ValueType)) {
               throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of ValueType`, arg.token);
             }
             break;
           case FunctionExpressionType.LogicalType:
-            if (!(arg instanceof JSONPathQuery || arg instanceof InfixExpression)) {
+            if (!(arg instanceof FilterQuery || arg instanceof InfixExpression)) {
               throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of LogicalType`, arg.token);
             }
             break;
           case FunctionExpressionType.NodesType:
-            if (!(arg instanceof JSONPathQuery || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.NodesType)) {
+            if (!(arg instanceof FilterQuery || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.NodesType)) {
               throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of NodesType`, arg.token);
             }
         }
@@ -4652,14 +4695,16 @@ var json_p3 = (function (exports) {
     __proto__: null,
     DEFAULT_ENVIRONMENT: DEFAULT_ENVIRONMENT,
     FunctionExpressionType: FunctionExpressionType,
-    JSONPath: JSONPath,
     JSONPathEnvironment: JSONPathEnvironment,
     JSONPathError: JSONPathError,
     JSONPathIndexError: JSONPathIndexError,
     JSONPathLexerError: JSONPathLexerError,
     JSONPathNode: JSONPathNode,
     JSONPathNodeList: JSONPathNodeList,
+    JSONPathQuery: JSONPathQuery,
     JSONPathRecursionLimitError: JSONPathRecursionLimitError,
+    JSONPathSegment: JSONPathSegment,
+    JSONPathSelector: JSONPathSelector,
     JSONPathSyntaxError: JSONPathSyntaxError,
     JSONPathTypeError: JSONPathTypeError,
     KEY_MARK: KEY_MARK,
@@ -5163,20 +5208,20 @@ var json_p3 = (function (exports) {
     apply: apply
   });
 
-  const version = "1.3.5";
+  const version = "2.1.0";
 
   exports.DEFAULT_ENVIRONMENT = DEFAULT_ENVIRONMENT;
   exports.FunctionExpressionType = FunctionExpressionType;
   exports.JSONPatch = JSONPatch;
   exports.JSONPatchError = JSONPatchError;
   exports.JSONPatchTestFailure = JSONPatchTestFailure;
-  exports.JSONPath = JSONPath;
   exports.JSONPathEnvironment = JSONPathEnvironment;
   exports.JSONPathError = JSONPathError;
   exports.JSONPathIndexError = JSONPathIndexError;
   exports.JSONPathLexerError = JSONPathLexerError;
   exports.JSONPathNode = JSONPathNode;
   exports.JSONPathNodeList = JSONPathNodeList;
+  exports.JSONPathQuery = JSONPathQuery;
   exports.JSONPathRecursionLimitError = JSONPathRecursionLimitError;
   exports.JSONPathSyntaxError = JSONPathSyntaxError;
   exports.JSONPathTypeError = JSONPathTypeError;