json-p3 1.3.5 → 2.0.0

package/dist/json-p3.cjs.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 1.3.5
+ * json-p3 version 2.0.0
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -919,14 +919,14 @@ class LogicalExpression extends FilterExpression {
 /**
  * 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);
   }
@@ -934,7 +934,7 @@ class RelativeQuery extends JSONPathQuery {
     return `@${this.path.toString().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);
   }
@@ -1028,9 +1028,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,
@@ -3131,11 +3131,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.
    */
 
   /**
@@ -3147,31 +3147,26 @@ 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}'`;
+    return `'${this.name}'`;
   }
 }
 
@@ -3188,25 +3183,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);
       }
     }
   }
@@ -3228,19 +3219,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);
       }
@@ -3346,281 +3334,175 @@ 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() {
+    return `?${this.expression.toString()}`;
   }
 }
-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 canonical 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()}`;
+    return `[${this.selectors.map(s => s.toString()).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));
         }
       }
     }
@@ -3628,13 +3510,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(", ")}]`;
+    return `..[${this.selectors.map(s => s.toString()).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);
+      }
+    }
   }
 }
 
@@ -3673,30 +3617,18 @@ 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
-});
-
 /**
  *
  */
-class JSONPath {
+class JSONPathQuery {
   /**
    *
    * @param environment -
-   * @param selectors -
+   * @param segments -
    */
-  constructor(environment, selectors) {
+  constructor(environment, segments) {
     this.environment = environment;
-    this.selectors = selectors;
+    this.segments = segments;
   }
 
   /**
@@ -3706,8 +3638,8 @@ class JSONPath {
    */
   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);
   }
@@ -3719,8 +3651,8 @@ class JSONPath {
    */
   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;
   }
@@ -3744,12 +3676,14 @@ class JSONPath {
    *
    */
   toString() {
-    return `$${this.selectors.map(s => s.toString()).join("")}`;
+    return `$${this.segments.map(s => s.toString()).join("")}`;
   }
   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;
@@ -3767,33 +3701,26 @@ 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("'", "\\'")}'`;
+    return `~'${this.key.replaceAll("'", "\\'")}'`;
   }
 }
 
@@ -3802,36 +3729,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 {
@@ -3841,41 +3761,37 @@ 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);
         }
       }
     }
@@ -3904,52 +3820,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) {
@@ -4006,38 +3929,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);
@@ -4051,10 +3974,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;
@@ -4134,11 +4057,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);
@@ -4440,10 +4363,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))));
   }
 
   /**
@@ -4498,7 +4421,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.
    *
@@ -4525,17 +4448,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);
           }
       }
@@ -4651,14 +4574,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,
@@ -5162,20 +5087,20 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "1.3.5";
+const version = "2.0.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;