json-p3 1.3.5 → 2.1.0

package/dist/json-p3.esm.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
@@ -651,6 +651,30 @@ var index$3 = /*#__PURE__*/Object.freeze({
   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");
 
 /**
@@ -658,7 +682,7 @@ const Nothing = Symbol.for("jsonpath.nothing");
  */
 
 /**
- * Object passed to FilterExpression.evaluate().
+ * Object passed to `FilterExpression.evaluate()`.
  */
 
 /**
@@ -669,6 +693,14 @@ function hasStringKey(value, key) {
 }
 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.
  */
@@ -683,10 +715,31 @@ class JSONPathNode {
     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("")
     );
   }
 
@@ -699,8 +752,16 @@ class JSONPathNode {
     }
     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}`;
   }
 }
 
@@ -761,8 +822,8 @@ class JSONPathNodeList {
    * 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));
   }
 
   /**
@@ -834,7 +895,7 @@ class StringLiteral extends FilterExpressionLiteral {
     return this.value;
   }
   toString() {
-    return JSON.stringify(this.value);
+    return toCanonical(this.value);
   }
 }
 class NumberLiteral extends FilterExpressionLiteral {
@@ -865,10 +926,13 @@ class PrefixExpression extends FilterExpression {
     }
     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);
@@ -891,11 +955,12 @@ class InfixExpression extends FilterExpression {
     }
     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 {
@@ -909,35 +974,65 @@ class LogicalExpression extends FilterExpression {
     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 {
@@ -955,8 +1050,8 @@ class FunctionExtension extends FilterExpression {
     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) {
@@ -1026,9 +1121,9 @@ var expression = /*#__PURE__*/Object.freeze({
   BooleanLiteral: BooleanLiteral,
   FilterExpression: FilterExpression,
   FilterExpressionLiteral: FilterExpressionLiteral,
+  FilterQuery: FilterQuery,
   FunctionExtension: FunctionExtension,
   InfixExpression: InfixExpression,
-  JSONPathQuery: JSONPathQuery,
   LogicalExpression: LogicalExpression,
   NullLiteral: NullLiteral,
   NumberLiteral: NumberLiteral,
@@ -3129,11 +3224,11 @@ class JSONPathSelector {
   }
 
   /**
-   * @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.
    */
 
   /**
@@ -3145,31 +3240,35 @@ class JSONPathSelector {
  * 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);
   }
 }
 
@@ -3186,25 +3285,21 @@ class IndexSelector extends JSONPathSelector {
       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);
       }
     }
   }
@@ -3226,19 +3321,16 @@ class SliceSelector extends JSONPathSelector {
     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);
       }
@@ -3344,281 +3436,185 @@ class SliceSelector extends JSONPathSelector {
 }
 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));
         }
       }
     }
@@ -3626,13 +3622,75 @@ class BracketedSelection extends JSONPathSelector {
   }
   *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);
+      }
+    }
   }
 }
 
@@ -3671,54 +3729,37 @@ function shuffle(entries) {
   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;
   }
@@ -3739,15 +3780,21 @@ class JSONPath {
   }
 
   /**
-   *
+   * 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;
@@ -3765,33 +3812,33 @@ class CurrentKey extends FilterExpression {
 
 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)}`;
   }
 }
 
@@ -3800,36 +3847,29 @@ class KeySelector extends JSONPathSelector {
  */
 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 {
@@ -3839,47 +3879,43 @@ class KeysFilterSelector extends JSONPathSelector {
     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)}`;
   }
 }
 
@@ -3902,52 +3938,59 @@ class Parser {
   }
   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) {
@@ -4004,38 +4047,38 @@ class Parser {
   }
   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);
@@ -4049,10 +4092,10 @@ class Parser {
       }
       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;
@@ -4132,11 +4175,11 @@ class Parser {
   }
   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);
@@ -4438,10 +4481,10 @@ class JSONPathEnvironment {
 
   /**
    * @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))));
   }
 
   /**
@@ -4496,7 +4539,7 @@ class JSONPathEnvironment {
   /**
    * 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.
    *
@@ -4523,17 +4566,17 @@ class JSONPathEnvironment {
     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);
           }
       }
@@ -4649,14 +4692,16 @@ var index$1 = /*#__PURE__*/Object.freeze({
   __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,
@@ -5160,6 +5205,6 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "1.3.5";
+const version = "2.1.0";
 
-export { DEFAULT_ENVIRONMENT, FunctionExpressionType, JSONPatch, JSONPatchError, JSONPatchTestFailure, JSONPath, JSONPathEnvironment, JSONPathError, JSONPathIndexError, JSONPathLexerError, JSONPathNode, JSONPathNodeList, JSONPathRecursionLimitError, JSONPathSyntaxError, JSONPathTypeError, JSONPointer, Nothing, RelativeJSONPointer, Token, TokenKind, UNDEFINED, apply, compile, index as jsonpatch, index$1 as jsonpath, index$3 as jsonpointer, lazyQuery, query, resolve, version };
+export { DEFAULT_ENVIRONMENT, FunctionExpressionType, JSONPatch, JSONPatchError, JSONPatchTestFailure, JSONPathEnvironment, JSONPathError, JSONPathIndexError, JSONPathLexerError, JSONPathNode, JSONPathNodeList, JSONPathQuery, JSONPathRecursionLimitError, JSONPathSyntaxError, JSONPathTypeError, JSONPointer, Nothing, RelativeJSONPointer, Token, TokenKind, UNDEFINED, apply, compile, index as jsonpatch, index$1 as jsonpath, index$3 as jsonpointer, lazyQuery, query, resolve, version };