json-p3 1.3.5 → 2.0.0

package/dist/json-p3.iife.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
@@ -920,14 +920,14 @@ var json_p3 = (function (exports) {
   /**
    * 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);
     }
@@ -935,7 +935,7 @@ var json_p3 = (function (exports) {
       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);
     }
@@ -1029,9 +1029,9 @@ var json_p3 = (function (exports) {
     BooleanLiteral: BooleanLiteral,
     FilterExpression: FilterExpression,
     FilterExpressionLiteral: FilterExpressionLiteral,
+    FilterQuery: FilterQuery,
     FunctionExtension: FunctionExtension,
     InfixExpression: InfixExpression,
-    JSONPathQuery: JSONPathQuery,
     LogicalExpression: LogicalExpression,
     NullLiteral: NullLiteral,
     NumberLiteral: NumberLiteral,
@@ -3132,11 +3132,11 @@ var json_p3 = (function (exports) {
     }
 
     /**
-     * @param nodes - Nodes matched by preceding selectors.
+     * @param node - Nodes matched by preceding selectors.
      */
 
     /**
-     * @param nodes - Nodes matched by preceding selectors.
+     * @param node - Nodes matched by preceding selectors.
      */
 
     /**
@@ -3148,31 +3148,26 @@ var json_p3 = (function (exports) {
    * Shorthand and quoted name selector.
    */
   class NameSelector extends JSONPathSelector {
-    constructor(environment, token, name, shorthand) {
+    constructor(environment, token, name) {
       super(environment, token);
       this.environment = environment;
       this.token = token;
       this.name = name;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
-          rv.push(new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root));
-        }
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
+        rv.push(new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root));
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
-          yield new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root);
-        }
+    *lazyResolve(node) {
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
+        yield new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root);
       }
     }
     toString() {
-      return this.shorthand ? `['${this.name}']` : `'${this.name}'`;
+      return `'${this.name}'`;
     }
   }
 
@@ -3189,25 +3184,21 @@ var json_p3 = (function (exports) {
         throw new JSONPathIndexError("index out of range", this.token);
       }
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (isArray(node.value)) {
-          const normIndex = this.normalizedIndex(node.value.length);
-          if (normIndex in node.value) {
-            rv.push(new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root));
-          }
+      if (isArray(node.value)) {
+        const normIndex = this.normalizedIndex(node.value.length);
+        if (normIndex in node.value) {
+          rv.push(new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root));
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (isArray(node.value)) {
-          const normIndex = this.normalizedIndex(node.value.length);
-          if (normIndex in node.value) {
-            yield new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root);
-          }
+    *lazyResolve(node) {
+      if (isArray(node.value)) {
+        const normIndex = this.normalizedIndex(node.value.length);
+        if (normIndex in node.value) {
+          yield new JSONPathNode(node.value[normIndex], node.location.concat(normIndex), node.root);
         }
       }
     }
@@ -3229,19 +3220,16 @@ var json_p3 = (function (exports) {
       this.step = step;
       this.checkRange(start, stop, step);
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (!isArray(node.value)) continue;
-        for (const [i, value] of this.slice(node.value, this.start, this.stop, this.step)) {
-          rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
-        }
+      if (!isArray(node.value)) return rv;
+      for (const [i, value] of this.slice(node.value, this.start, this.stop, this.step)) {
+        rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (!isArray(node.value)) continue;
+    *lazyResolve(node) {
+      if (isArray(node.value)) {
         for (const [i, value] of this.lazySlice(node.value, this.start, this.stop, this.step)) {
           yield new JSONPathNode(value, node.location.concat(i), node.root);
         }
@@ -3347,281 +3335,175 @@ var json_p3 = (function (exports) {
   }
   class WildcardSelector extends JSONPathSelector {
     constructor(environment, token) {
-      let shorthand = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       super(environment, token);
       this.environment = environment;
       this.token = token;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String) continue;
-        if (isArray(node.value)) {
-          for (let i = 0; i < node.value.length; i++) {
-            rv.push(new JSONPathNode(node.value[i], node.location.concat(i), node.root));
-          }
-        } else if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
-          }
+      if (node.value instanceof String) return rv;
+      if (isArray(node.value)) {
+        for (let i = 0; i < node.value.length; i++) {
+          rv.push(new JSONPathNode(node.value[i], node.location.concat(i), node.root));
+        }
+      } else if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String) continue;
-        if (isArray(node.value)) {
-          for (let i = 0; i < node.value.length; i++) {
-            yield new JSONPathNode(node.value[i], node.location.concat(i), node.root);
-          }
-        } else if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            yield new JSONPathNode(value, node.location.concat(key), node.root);
-          }
+    *lazyResolve(node) {
+      if (isArray(node.value)) {
+        for (let i = 0; i < node.value.length; i++) {
+          yield new JSONPathNode(node.value[i], node.location.concat(i), node.root);
+        }
+      } else if (isObject(node.value) && !isString(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          yield new JSONPathNode(value, node.location.concat(key), node.root);
         }
       }
     }
     toString() {
-      return this.shorthand ? "[*]" : "*";
+      return "*";
     }
   }
-  class RecursiveDescentSegment extends JSONPathSelector {
-    constructor(environment, token, selector) {
+  class FilterSelector extends JSONPathSelector {
+    constructor(environment, token, expression) {
       super(environment, token);
       this.environment = environment;
       this.token = token;
-      this.selector = selector;
-    }
-    resolve(nodes) {
-      const rv = [];
-      if (this.environment.nondeterministic) {
-        for (const root of nodes) {
-          for (const node of this.nondeterministicVisitor(root)) {
-            rv.push(node);
-          }
-        }
-      } else {
-        for (const node of nodes) {
-          rv.push(node);
-          for (const _node of this.visitor(node)) {
-            rv.push(_node);
-          }
-        }
-      }
-      return this.selector.resolve(rv);
-    }
-    *lazyResolve(nodes) {
-      yield* this.selector.lazyResolve(this._lazyResolve(nodes));
-    }
-
-    // eslint-disable-next-line sonarjs/cognitive-complexity
-    *_lazyResolve(nodes) {
-      for (const _node of nodes) {
-        const stack = [{
-          node: _node,
-          depth: 0
-        }];
-        yield _node;
-        while (stack.length) {
-          const {
-            node: currentNode,
-            depth
-          } = stack.pop();
-          if (depth >= this.environment.maxRecursionDepth) {
-            throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
-          }
-          if (currentNode.value instanceof String) continue;
-          if (isArray(currentNode.value)) {
-            for (let i = 0; i < currentNode.value.length; i++) {
-              const __node = new JSONPathNode(currentNode.value[i], currentNode.location.concat(i), currentNode.root);
-              yield __node;
-              if (isObject(__node.value)) {
-                stack.push({
-                  node: __node,
-                  depth: depth + 1
-                });
-              }
-            }
-          } else if (isObject(currentNode.value)) {
-            for (const [key, value] of this.environment.entries(currentNode.value)) {
-              const __node = new JSONPathNode(value, currentNode.location.concat(key), currentNode.root);
-              yield __node;
-              if (isObject(__node.value)) {
-                stack.push({
-                  node: __node,
-                  depth: depth + 1
-                });
-              }
-            }
-          }
-        }
-      }
-    }
-    toString() {
-      return `..${this.selector.toString()}`;
+      this.expression = expression;
     }
-    visitor(node) {
-      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      if (depth >= this.environment.maxRecursionDepth) {
-        throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
-      }
+    resolve(node) {
       const rv = [];
       if (node.value instanceof String) return rv;
       if (isArray(node.value)) {
         for (let i = 0; i < node.value.length; i++) {
-          const _node = new JSONPathNode(node.value[i], node.location.concat(i), node.root);
-          rv.push(_node);
-          for (const __node of this.visitor(_node, depth + 1)) {
-            rv.push(__node);
+          const value = node.value[i];
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            currentKey: i
+          };
+          if (this.expression.evaluate(filterContext)) {
+            rv.push(new JSONPathNode(value, node.location.concat(i), node.root));
           }
         }
       } else if (isObject(node.value)) {
         for (const [key, value] of this.environment.entries(node.value)) {
-          const _node = new JSONPathNode(value, node.location.concat(key), node.root);
-          rv.push(_node);
-          for (const __node of this.visitor(_node, depth + 1)) {
-            rv.push(__node);
-          }
-        }
-      }
-      return rv;
-    }
-    nondeterministicVisitor(root) {
-      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      const rv = [root];
-      let queue = this.nondeterministicChildren(root).map(node => [node, depth]);
-      while (queue.length) {
-        const [node, _depth] = queue.shift();
-        rv.push(node);
-        if (_depth >= this.environment.maxRecursionDepth) {
-          throw new JSONPathRecursionLimitError("recursion limit reached", this.token);
-        }
-
-        // Visit child nodes now or queue them for later?
-        const visitChildren = Math.random() < 0.5;
-        for (const child of this.nondeterministicChildren(node)) {
-          if (visitChildren) {
-            rv.push(child);
-            const grandchildren = this.nondeterministicChildren(child).map(n => [n, _depth + 2]);
-            queue = interleave(queue, grandchildren);
-          } else {
-            queue.push([child, _depth + 1]);
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
           }
         }
       }
       return rv;
     }
-    nondeterministicChildren(node) {
-      const _rv = [];
-      if (node.value instanceof String) return _rv;
+    *lazyResolve(node) {
       if (isArray(node.value)) {
         for (let i = 0; i < node.value.length; i++) {
-          _rv.push(new JSONPathNode(node.value[i], node.location.concat(i), node.root));
+          const value = node.value[i];
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            lazy: true,
+            currentKey: i
+          };
+          if (this.expression.evaluate(filterContext)) {
+            yield new JSONPathNode(value, node.location.concat(i), node.root);
+          }
         }
-      } else if (isObject(node.value)) {
+      } else if (isObject(node.value) && !isString(node.value)) {
         for (const [key, value] of this.environment.entries(node.value)) {
-          _rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            lazy: true,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            yield new JSONPathNode(value, node.location.concat(key), node.root);
+          }
         }
       }
-      return _rv;
+    }
+    toString() {
+      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));
           }
         }
       }
@@ -3629,13 +3511,75 @@ var json_p3 = (function (exports) {
     }
     *lazyResolve(nodes) {
       for (const node of nodes) {
-        for (const item of this.items) {
-          yield* item.lazyResolve([node]);
+        for (const _node of this.visit(node)) {
+          for (const selector of this.selectors) {
+            yield* selector.resolve(_node);
+          }
         }
       }
     }
     toString() {
-      return `[${this.items.map(itm => itm.toString()).join(", ")}]`;
+      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);
+        }
+      }
     }
   }
 
@@ -3674,30 +3618,18 @@ var json_p3 = (function (exports) {
     return entries;
   }
 
-  var selectors = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    BracketedSelection: BracketedSelection,
-    FilterSelector: FilterSelector,
-    IndexSelector: IndexSelector,
-    JSONPathSelector: JSONPathSelector,
-    NameSelector: NameSelector,
-    RecursiveDescentSegment: RecursiveDescentSegment,
-    SliceSelector: SliceSelector,
-    WildcardSelector: WildcardSelector
-  });
-
   /**
    *
    */
-  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;
     }
 
     /**
@@ -3707,8 +3639,8 @@ var json_p3 = (function (exports) {
      */
     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);
     }
@@ -3720,8 +3652,8 @@ var json_p3 = (function (exports) {
      */
     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;
     }
@@ -3745,12 +3677,14 @@ var json_p3 = (function (exports) {
      *
      */
     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;
@@ -3768,33 +3702,26 @@ var json_p3 = (function (exports) {
 
   class KeySelector extends JSONPathSelector {
     constructor(environment, token, key) {
-      let shorthand = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
       super(environment, token);
       this.environment = environment;
       this.token = token;
       this.key = key;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value) && hasStringKey(node.value, this.key)) {
-          rv.push(new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root));
-        }
+      if (node.value instanceof String || isArray(node.value)) return rv;
+      if (isObject(node.value) && hasStringKey(node.value, this.key)) {
+        rv.push(new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root));
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value) && hasStringKey(node.value, this.key)) {
-          yield new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root);
-        }
+    *lazyResolve(node) {
+      if (!isString(node.value) && isObject(node.value) && hasStringKey(node.value, this.key)) {
+        yield new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root);
       }
     }
     toString() {
-      return this.shorthand ? `[~'${this.key.replaceAll("'", "\\'")}']` : `~'${this.key.replaceAll("'", "\\'")}'`;
+      return `~'${this.key.replaceAll("'", "\\'")}'`;
     }
   }
 
@@ -3803,36 +3730,29 @@ var json_p3 = (function (exports) {
    */
   class KeysSelector extends JSONPathSelector {
     constructor(environment, token) {
-      let shorthand = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       super(environment, token);
       this.environment = environment;
       this.token = token;
-      this.shorthand = shorthand;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, _] of this.environment.entries(node.value)) {
-            rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
-          }
+      if (node.value instanceof String || isArray(node.value)) return rv;
+      if (isObject(node.value)) {
+        for (const [key, _] of this.environment.entries(node.value)) {
+          rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, _] of this.environment.entries(node.value)) {
-            yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
-          }
+    *lazyResolve(node) {
+      if (isObject(node.value) && !isString(node.value) && !isArray(node.value)) {
+        for (const [key, _] of this.environment.entries(node.value)) {
+          yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
         }
       }
     }
     toString() {
-      return this.shorthand ? "[~]" : "~";
+      return "~";
     }
   }
   class KeysFilterSelector extends JSONPathSelector {
@@ -3842,41 +3762,37 @@ var json_p3 = (function (exports) {
       this.token = token;
       this.expression = expression;
     }
-    resolve(nodes) {
+    resolve(node) {
       const rv = [];
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              currentKey: key
-            };
-            if (this.expression.evaluate(filterContext)) {
-              rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
-            }
+      if (node.value instanceof String || isArray(node.value)) return rv;
+      if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
           }
         }
       }
       return rv;
     }
-    *lazyResolve(nodes) {
-      for (const node of nodes) {
-        if (node.value instanceof String || isArray(node.value)) continue;
-        if (isObject(node.value)) {
-          for (const [key, value] of this.environment.entries(node.value)) {
-            const filterContext = {
-              environment: this.environment,
-              currentValue: value,
-              rootValue: node.root,
-              lazy: true,
-              currentKey: key
-            };
-            if (this.expression.evaluate(filterContext)) {
-              yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
-            }
+    *lazyResolve(node) {
+      if (node.value instanceof String || isArray(node.value)) return;
+      if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            lazy: true,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
           }
         }
       }
@@ -3905,52 +3821,59 @@ var json_p3 = (function (exports) {
     }
     parse(stream) {
       if (stream.current.kind === TokenKind.ROOT) stream.next();
-      const selectors = this.parsePath(stream);
+      const segments = this.parseQuery(stream);
       if (stream.current.kind !== TokenKind.EOF) {
         throw new JSONPathSyntaxError(`unexpected token '${stream.current.kind}'`, stream.current);
       }
-      return selectors;
+      return segments;
     }
-    parsePath(stream) {
+    parseQuery(stream) {
       let inFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      const selectors = [];
-      for (;;) {
-        const selector = this.parseSegment(stream);
-        if (!selector) {
-          if (inFilter) {
-            stream.backup();
-          }
-          break;
+      const segments = [];
+      loop: for (;;) {
+        switch (stream.current.kind) {
+          case TokenKind.DDOT:
+            {
+              const token = stream.next();
+              const selectors = this.parseSelectors(stream);
+              segments.push(new DescendantSegment(this.environment, token, selectors));
+              break;
+            }
+          case TokenKind.LBRACKET:
+          case TokenKind.KEY:
+          case TokenKind.KEYS:
+          case TokenKind.NAME:
+          case TokenKind.WILD:
+            {
+              const token = stream.current;
+              const selectors = this.parseSelectors(stream);
+              segments.push(new ChildSegment(this.environment, token, selectors));
+              break;
+            }
+          default:
+            {
+              if (inFilter) stream.backup();
+              break loop;
+            }
         }
-        selectors.push(selector);
         stream.next();
       }
-      return selectors;
+      return segments;
     }
-    parseSegment(stream) {
+    parseSelectors(stream) {
       switch (stream.current.kind) {
         case TokenKind.NAME:
-          return new NameSelector(this.environment, stream.current, stream.current.value, true);
+          return [new NameSelector(this.environment, stream.current, stream.current.value)];
         case TokenKind.WILD:
-          return new WildcardSelector(this.environment, stream.current, true);
+          return [new WildcardSelector(this.environment, stream.current)];
         case TokenKind.KEY:
-          return new KeySelector(this.environment, stream.current, stream.current.value, true);
+          return [new KeySelector(this.environment, stream.current, stream.current.value)];
         case TokenKind.KEYS:
-          return new KeysSelector(this.environment, stream.current, true);
-        case TokenKind.DDOT:
-          {
-            const segmentToken = stream.current;
-            stream.next();
-            const selector = this.parseSegment(stream);
-            if (!selector) {
-              throw new JSONPathSyntaxError("bald descendant segment", stream.current);
-            }
-            return new RecursiveDescentSegment(this.environment, segmentToken, selector);
-          }
+          return [new KeysSelector(this.environment, stream.current)];
         case TokenKind.LBRACKET:
           return this.parseBracketedSelection(stream);
         default:
-          return null;
+          return [];
       }
     }
     parseIndex(stream) {
@@ -4007,38 +3930,38 @@ var json_p3 = (function (exports) {
     }
     parseBracketedSelection(stream) {
       const token = stream.next();
-      const items = [];
+      const selectors = [];
       while (stream.current.kind !== TokenKind.RBRACKET) {
         switch (stream.current.kind) {
           case TokenKind.SINGLE_QUOTE_STRING:
           case TokenKind.DOUBLE_QUOTE_STRING:
-            items.push(new NameSelector(this.environment, stream.current, this.decodeString(stream.current), false));
+            selectors.push(new NameSelector(this.environment, stream.current, this.decodeString(stream.current)));
             break;
           case TokenKind.FILTER:
-            items.push(this.parseFilter(stream));
+            selectors.push(this.parseFilter(stream));
             break;
           case TokenKind.INDEX:
             if (stream.peek.kind === TokenKind.COLON) {
-              items.push(this.parseSlice(stream));
+              selectors.push(this.parseSlice(stream));
             } else {
-              items.push(this.parseIndex(stream));
+              selectors.push(this.parseIndex(stream));
             }
             break;
           case TokenKind.COLON:
-            items.push(this.parseSlice(stream));
+            selectors.push(this.parseSlice(stream));
             break;
           case TokenKind.WILD:
-            items.push(new WildcardSelector(this.environment, stream.current));
+            selectors.push(new WildcardSelector(this.environment, stream.current));
             break;
           case TokenKind.KEY_SINGLE_QUOTE_STRING:
           case TokenKind.KEY_DOUBLE_QUOTE_STRING:
-            items.push(new KeySelector(this.environment, stream.current, this.decodeString(stream.current), false));
+            selectors.push(new KeySelector(this.environment, stream.current, this.decodeString(stream.current)));
             break;
           case TokenKind.KEYS_FILTER:
-            items.push(this.parseFilter(stream, true));
+            selectors.push(this.parseFilter(stream, true));
             break;
           case TokenKind.KEYS:
-            items.push(new KeysSelector(this.environment, stream.current));
+            selectors.push(new KeysSelector(this.environment, stream.current));
             break;
           case TokenKind.EOF:
             throw new JSONPathSyntaxError("unexpected end of query", stream.current);
@@ -4052,10 +3975,10 @@ var json_p3 = (function (exports) {
         }
         stream.next();
       }
-      if (!items.length) {
+      if (!selectors.length) {
         throw new JSONPathSyntaxError("empty bracketed segment", token);
       }
-      return new BracketedSelection(this.environment, token, items);
+      return selectors;
     }
     parseFilter(stream) {
       let keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -4135,11 +4058,11 @@ var json_p3 = (function (exports) {
     }
     parseRootQuery(stream) {
       const tok = stream.next();
-      return new RootQuery(tok, new JSONPath(this.environment, this.parsePath(stream, true)));
+      return new RootQuery(tok, new JSONPathQuery(this.environment, this.parseQuery(stream, true)));
     }
     parseRelativeQuery(stream) {
       const tok = stream.next();
-      return new RelativeQuery(tok, new JSONPath(this.environment, this.parsePath(stream, true)));
+      return new RelativeQuery(tok, new JSONPathQuery(this.environment, this.parseQuery(stream, true)));
     }
     parseCurrentKey(stream) {
       return new CurrentKey(stream.current);
@@ -4441,10 +4364,10 @@ var json_p3 = (function (exports) {
 
     /**
      * @param path - A JSONPath query to parse.
-     * @returns A new {@link JSONPath} object, bound to this environment.
+     * @returns A new {@link JSONPathQuery} object, bound to this environment.
      */
     compile(path) {
-      return new JSONPath(this, this.parser.parse(new TokenStream(tokenize(this, path))));
+      return new JSONPathQuery(this, this.parser.parse(new TokenStream(tokenize(this, path))));
     }
 
     /**
@@ -4499,7 +4422,7 @@ var json_p3 = (function (exports) {
     /**
      * Check the well-typedness of a function's arguments at compile-time.
      *
-     * This method is called by the {@link Parser} when parsing function calls.
+     * This method is called by the parser when parsing function calls.
      * It is expected to throw a {@link JSONPathTypeError} if the function's
      * parameters are not well-typed.
      *
@@ -4526,17 +4449,17 @@ var json_p3 = (function (exports) {
       for (const [typ, arg, idx] of func.argTypes.map((t, i) => [t, args[i], i])) {
         switch (typ) {
           case FunctionExpressionType.ValueType:
-            if (!(arg instanceof FilterExpressionLiteral || arg instanceof CurrentKey || arg instanceof JSONPathQuery && arg.path.singularQuery() || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.ValueType)) {
+            if (!(arg instanceof FilterExpressionLiteral || arg instanceof CurrentKey || arg instanceof FilterQuery && arg.path.singularQuery() || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.ValueType)) {
               throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of ValueType`, arg.token);
             }
             break;
           case FunctionExpressionType.LogicalType:
-            if (!(arg instanceof JSONPathQuery || arg instanceof InfixExpression)) {
+            if (!(arg instanceof FilterQuery || arg instanceof InfixExpression)) {
               throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of LogicalType`, arg.token);
             }
             break;
           case FunctionExpressionType.NodesType:
-            if (!(arg instanceof JSONPathQuery || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.NodesType)) {
+            if (!(arg instanceof FilterQuery || arg instanceof FunctionExtension && this.functionRegister.get(arg.name)?.returnType === FunctionExpressionType.NodesType)) {
               throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of NodesType`, arg.token);
             }
         }
@@ -4652,14 +4575,16 @@ var json_p3 = (function (exports) {
     __proto__: null,
     DEFAULT_ENVIRONMENT: DEFAULT_ENVIRONMENT,
     FunctionExpressionType: FunctionExpressionType,
-    JSONPath: JSONPath,
     JSONPathEnvironment: JSONPathEnvironment,
     JSONPathError: JSONPathError,
     JSONPathIndexError: JSONPathIndexError,
     JSONPathLexerError: JSONPathLexerError,
     JSONPathNode: JSONPathNode,
     JSONPathNodeList: JSONPathNodeList,
+    JSONPathQuery: JSONPathQuery,
     JSONPathRecursionLimitError: JSONPathRecursionLimitError,
+    JSONPathSegment: JSONPathSegment,
+    JSONPathSelector: JSONPathSelector,
     JSONPathSyntaxError: JSONPathSyntaxError,
     JSONPathTypeError: JSONPathTypeError,
     KEY_MARK: KEY_MARK,
@@ -5163,20 +5088,20 @@ var json_p3 = (function (exports) {
     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;