json-p3 0.1.0

package/dist/json-p3.iife.js

@@ -0,0 +1,2843 @@
+/*
+ * json-p3 version 0.1.0
+ * https://github.com/jg-rp/json-p3
+ * 
+ * MIT License
+ * 
+ * Copyright (c) 2023 James Prior
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+var json_p3 = (function (exports) {
+  'use strict';
+
+  /**
+   * Base class for all JSONPath errors.
+   */
+  class JSONPathError extends Error {
+    constructor(message, token) {
+      super(message);
+      this.message = message;
+      this.token = token;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPathError";
+      this.message = withErrorContext(message, token);
+    }
+  }
+  function withErrorContext(message, token) {
+    if (token.input.length <= 9) {
+      return `${message} ('${token.input}':${token.index})`;
+    }
+    if (token.index > token.input.length - 5) {
+      return `${message} ('${token.input.slice(token.input.length - 9)}':${token.index})`;
+    }
+    if (token.index - 4 < 0) {
+      return `${message} ('${token.input.slice(0, 9)}':${token.index})`;
+    }
+    return `${message} ('${token.input.slice(token.index - 4, token.index + 5)}':${token.index})`;
+  }
+
+  /**
+   * Error thrown due to unexpected, internal path tokenization problems.
+   */
+  class JSONPathLexerError extends JSONPathError {
+    constructor(message, token) {
+      super(message, token);
+      this.message = message;
+      this.token = token;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPathLexerError";
+      this.message = withErrorContext(message, token);
+    }
+  }
+
+  /**
+   * Error thrown due to type errors when evaluating filter expressions.
+   */
+  class JSONPathTypeError extends JSONPathError {
+    constructor(message, token) {
+      super(message, token);
+      this.message = message;
+      this.token = token;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPathTypeError";
+      this.message = withErrorContext(message, token);
+    }
+  }
+
+  /**
+   * Error thrown due to out of range indices.
+   */
+  class JSONPathIndexError extends JSONPathError {
+    constructor(message, token) {
+      super(message, token);
+      this.message = message;
+      this.token = token;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPathIndexError";
+      this.message = withErrorContext(message, token);
+    }
+  }
+
+  /**
+   * Error thrown when attempting to retrieve a filter function that has not
+   * been registered.
+   */
+  class UndefinedFilterFunctionError extends JSONPathError {
+    constructor(message, token) {
+      super(message, token);
+      this.message = message;
+      this.token = token;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "UndefinedFilterFunctionError";
+      this.message = withErrorContext(message, token);
+    }
+  }
+
+  /**
+   * Error thrown due to syntax errors found during parsing a JSONPath query.
+   */
+  class JSONPathSyntaxError extends JSONPathError {
+    constructor(message, token) {
+      super(message, token);
+      this.message = message;
+      this.token = token;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPathSyntaxError";
+      this.message = withErrorContext(message, token);
+    }
+  }
+
+  /**
+   * Common types and type predicates.
+   */
+
+  /**
+   * A JSON-like value.
+   */
+
+  /**
+   * A type predicate for the Array object.
+   */
+  function isArray(value) {
+    return Array.isArray(value);
+  }
+
+  /**
+   * A type predicate for object.
+   */
+  function isObject(value) {
+    const _type = typeof value;
+    return value !== null && _type === "object" || _type === "function" ? true : false;
+  }
+
+  /**
+   * A type predicate for a string primitive.
+   */
+  function isString(value) {
+    return typeof value === "string";
+  }
+
+  /**
+   * A type predicate for a number primitive.
+   */
+  function isNumber(value) {
+    return typeof value === "number";
+  }
+
+  /**
+   * Deep equality of JSON-like values.
+   *
+   * No attempt is made to handle function objects, recursive data
+   * structures, NaNs, sparse arrays, primitive wrapper objects....
+   *
+   * We're not using JSON.stringify because we want objects with the same
+   * entries in a different order to compare equal.
+   */
+
+
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  function deepEquals(a, b) {
+    if (a === b) {
+      return true;
+    }
+    if (Array.isArray(a)) {
+      if (Array.isArray(b)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+          if (!deepEquals(a[i], b[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return false;
+    } else if (isObject(a) && isObject(b)) {
+      const keysA = Object.keys(a);
+      const keysB = Object.keys(b);
+      if (keysA.length !== keysB.length) {
+        return false;
+      }
+      for (const key of keysA) {
+        if (!deepEquals(a[key], b[key])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * The type of a JSONPath filter function parameter or return value, as
+   * described in See section 2.4.1 of draft-ietf-jsonpath-base-20.
+   */
+  let FunctionExpressionType = /*#__PURE__*/function (FunctionExpressionType) {
+    FunctionExpressionType["ValueType"] = "ValueType";
+    FunctionExpressionType["LogicalType"] = "LogicalType";
+    FunctionExpressionType["NodesType"] = "NodesType";
+    return FunctionExpressionType;
+  }({});
+
+  /**
+   * A JSONPath filter function definition.
+   */
+
+  /**
+   * Base class for all JSON Pointer errors.
+   */
+  class JSONPointerError extends Error {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPointerError";
+    }
+  }
+  class JSONPointerResolutionError extends JSONPointerError {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPointerResolutionError";
+    }
+  }
+  class JSONPointerIndexError extends JSONPointerResolutionError {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPointerIndexError";
+    }
+  }
+  class JSONPointerKeyError extends JSONPointerResolutionError {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPointerKeyError";
+    }
+  }
+  class JSONPointerSyntaxError extends JSONPointerError {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPointerSyntaxError";
+    }
+  }
+  class JSONPointerTypeError extends JSONPointerResolutionError {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPointerTypeError";
+    }
+  }
+
+  /**
+   * The symbol indicating the absence of a JSON value.
+   */
+  const UNDEFINED = Symbol.for("jsonpointer.undefined");
+  /**
+   * Identify a single value in JSON-like data, as per RFC 6901.
+   */
+  class JSONPointer {
+    #pointer;
+    /**
+     * @param pointer - A string representation of a JSON Pointer.
+     */
+    constructor(pointer) {
+      this.tokens = this.parse(pointer);
+      this.#pointer = JSONPointer.encode(this.tokens);
+    }
+    static encode(tokens) {
+      if (!tokens.length) return "";
+      return (
+        // eslint-disable-next-line prefer-template
+        "/" + tokens.map(token => token.replaceAll("~", "~0").replaceAll("/", "~1")).join("/")
+      );
+    }
+
+    /**
+     * Resolve this pointer against JSON-like data _value_.
+     *
+     * @param value - The target JSON-like value, possibly loaded using
+     *  `JSON.parse()`.
+     * @param fallback - A default value to return if _value_ has no
+     *   path matching `pointer`.
+     * @returns The value identified by _pointer_ or, if given, the fallback
+     *   value in the even of a `JSONPointerResolutionError`.
+     *
+     * @throws {@link JSONPointerResolutionError}
+     * If the value pointed to by _pointer_ does not exist in _value_, and
+     * no fallback value is given.
+     */
+    resolve(value) {
+      let fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : UNDEFINED;
+      try {
+        return this.tokens.reduce(this.getItem.bind(this), value);
+      } catch (error) {
+        if (error instanceof JSONPointerResolutionError && fallback !== UNDEFINED) {
+          return fallback;
+        }
+        throw error;
+      }
+    }
+
+    // TODO: add `resolveWithFallback` to handle explicit `undefined`
+
+    /**
+     *
+     * @param value -
+     * @returns
+     */
+    resolveWithParent(value) {
+      if (!this.tokens.length) return [UNDEFINED, this.resolve(value)];
+      const parent = this.tokens.slice(0, this.tokens.length - 1).reduce(this.getItem.bind(this), value);
+      try {
+        return [parent, this.getItem(parent, this.tokens[this.tokens.length - 1], this.tokens.length - 1)];
+      } catch (error) {
+        if (error instanceof JSONPointerIndexError || error instanceof JSONPointerKeyError) {
+          return [parent, UNDEFINED];
+        }
+        throw error;
+      }
+    }
+
+    /**
+     *
+     * @returns
+     */
+    toString() {
+      return this.#pointer;
+    }
+
+    /**
+     * Return _true_ if this pointer points to a child of _pointer_.
+     */
+    isRelativeTo(pointer) {
+      return pointer.tokens.length < this.tokens.length && this.tokens.slice(0, pointer.tokens.length).every((t, i) => t === pointer.tokens[i]);
+    }
+    parse(pointer) {
+      if (pointer.length && !pointer.startsWith("/")) {
+        throw new JSONPointerSyntaxError(`"${pointer}" pointers must start with a slash or be the empty string`);
+      }
+      return pointer.split("/").map(token => token.replaceAll("~1", "/").replaceAll("~0", "~")).slice(1);
+    }
+    getItem(val, token, idx) {
+      // NOTE:
+      //   - string primitives "have own" indices and `length`.
+      //   - Arrays have a `length` property.
+      //   - A property might exist with the value `undefined` or `null`.
+      //   - obj[1] is equivalent to obj["1"].
+      if (isArray(val)) {
+        if (token !== "length" && Object.hasOwn(val, token)) {
+          return val[Number(token)];
+        } else {
+          throw new JSONPointerIndexError(`index out of range '${JSONPointer.encode(this.tokens.slice(0, idx + 1))}'`);
+        }
+      } else if (isObject(val)) {
+        if (Object.hasOwn(val, token)) {
+          return val[token];
+        } else {
+          throw new JSONPointerKeyError(`no such property '${JSONPointer.encode(this.tokens.slice(0, idx + 1))}'`);
+        }
+      }
+      throw new JSONPointerTypeError(`found primitive value, expected an object '${JSONPointer.encode(this.tokens.slice(0, idx + 1))}'`);
+    }
+    _join(pointer) {
+      if (!isString(pointer)) {
+        throw new JSONPointerTypeError(`join() requires string arguments, found ${typeof pointer}`);
+      }
+      if (pointer.startsWith("/")) {
+        return new JSONPointer(pointer);
+      }
+      const tokens = this.tokens.concat(pointer.split("/").map(token => token.replaceAll("~1", "/").replaceAll("~0", "~")));
+      return new JSONPointer(JSONPointer.encode(tokens));
+    }
+
+    /**
+     * Join this pointer with _tokens_.
+     * @param tokens - JSON Pointer strings, possibly without leading slashes.
+     * If a token or "part" does have a leading slash, the previous pointer is
+     * ignored and a new `JSONPointer` is created, then processing of the
+     * remaining tokens continues.
+     * @returns A new JSON Pointer that is the concatenation of all tokens or
+     * "parts".
+     */
+    join() {
+      for (var _len = arguments.length, tokens = new Array(_len), _key = 0; _key < _len; _key++) {
+        tokens[_key] = arguments[_key];
+      }
+      if (!tokens.length) {
+        return this;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      let pointer = this;
+      for (const tok of tokens) {
+        pointer = pointer._join(tok);
+      }
+      return pointer;
+    }
+
+    /**
+     * Return _true_ if this pointer can be resolved against _value_.
+     *
+     * Note that `JSONPointer.resolve()` can return legitimate falsy values
+     * that form part of the target JSON document. This method will return
+     * `true` if a falsy value is found.
+     */
+    exists(value) {
+      try {
+        this.resolve(value);
+      } catch (error) {
+        if (error instanceof JSONPointerResolutionError) {
+          return false;
+        }
+        throw error;
+      }
+      return true;
+    }
+
+    /**
+     * Return this pointer's parent as a new `JSONPointer`.
+     *
+     * If this pointer points to the document root, _this_ is returned.
+     */
+    parent() {
+      if (!this.tokens.length) {
+        return this;
+      }
+      return new JSONPointer(JSONPointer.encode(this.tokens.slice(0, this.tokens.length - 1)));
+    }
+
+    // TODO: to (relative pointer)
+  }
+
+  /**
+   * Resolve JSON Pointer _pointer_ against JSON-like data _value_.
+   *
+   * @param pointer - A string representation of a JSON pointer.
+   * @param value - The target JSON-like value, possibly loaded using
+   *  `JSON.parse()`.
+   * @param fallback - A default value to return if _value_ has no
+   *   path matching `pointer`.
+   * @returns The value identified by _pointer_ or, if given, the fallback
+   *   value in the even of a `JSONPointerResolutionError`.
+   *
+   * @throws {@link JSONPointerResolutionError}
+   * If the value pointed to by _pointer_ does not exist in _value_, and
+   * no fallback value is given.
+   *
+   * @throws {@link JSONPointerSyntaxError}
+   * If _pointer_ is malformed according to RFC 6901.
+   */
+  function resolve(pointer, value) {
+    let fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : UNDEFINED;
+    return new JSONPointer(pointer).resolve(value, fallback);
+  }
+
+  var index$3 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    JSONPointer: JSONPointer,
+    JSONPointerError: JSONPointerError,
+    JSONPointerIndexError: JSONPointerIndexError,
+    JSONPointerKeyError: JSONPointerKeyError,
+    JSONPointerResolutionError: JSONPointerResolutionError,
+    JSONPointerSyntaxError: JSONPointerSyntaxError,
+    JSONPointerTypeError: JSONPointerTypeError,
+    UNDEFINED: UNDEFINED,
+    resolve: resolve
+  });
+
+  /**
+   * The pair of a JSON value and its location found in the target JSON value.
+   */
+  class JSONPathNode {
+    /**
+     * The normalized path to this node in the target JSON value.
+     */
+
+    /**
+     * @param value - The JSON value found at _location_.
+     * @param location - The parts of a normalized path to _value_.
+     * @param root - The target value at the top of the JSON node tree.
+     */
+    constructor(value, location, root) {
+      this.value = value;
+      this.location = location;
+      this.root = root;
+      this.path =
+      // eslint-disable-next-line prefer-template
+      "$" + location.map(s => isString(s) ? `['${s}']` : `[${s}]`).join("");
+    }
+
+    /**
+     * Return this node's location as a {@link JSONPointer}.
+     */
+    toPointer() {
+      if (!this.location.length) {
+        return new JSONPointer("");
+      }
+      return new JSONPointer(JSONPointer.encode(this.location.map(String)));
+    }
+  }
+
+  /**
+   *
+   */
+  class JSONPathNodeList {
+    constructor(nodes) {
+      this.nodes = nodes;
+    }
+
+    /**
+     * @returns an iterator over nodes in the list.
+     */
+    [Symbol.iterator]() {
+      return this.nodes[Symbol.iterator]();
+    }
+
+    /**
+     * @returns `true` if the node list is empty.
+     */
+    empty() {
+      return this.nodes.length === 0;
+    }
+
+    /**
+     * @returns An array containing the values at each node in the list.
+     *
+     * @see {@link valuesOrSingular} to unpack the array if there is only
+     * one node in the list.
+     */
+    values() {
+      return this.nodes.map(node => node.value);
+    }
+
+    /**
+     * Like {@link values}, but returns the node's value is there is only one
+     * node in the list.
+     */
+    valuesOrSingular() {
+      if (this.nodes.length === 1) return this.nodes[0].value;
+      return this.nodes.map(node => node.value);
+    }
+
+    /**
+     * @returns An array of locations for each node in the node list.
+     *
+     * A location is an array of property names and array indices that were
+     * required to reach the node's value in the target JSON value.
+     */
+    locations() {
+      return this.nodes.map(node => node.location);
+    }
+
+    /**
+     * @returns An array of normalized path strings for each node in the list.
+     *
+     * 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);
+    }
+
+    /**
+     * @returns An array of {@link JSONPointer} instances, one for each node
+     * in the list.
+     */
+    pointers() {
+      return this.nodes.map(node => node.toPointer());
+    }
+
+    /**
+     * @returns The number of nodes in the node list.
+     */
+    get length() {
+      return this.nodes.length;
+    }
+  }
+
+  const Nothing = Symbol.for("jsonpath.nothing");
+
+  /**
+   * ValueType for JSONPath function expression tye system.
+   */
+
+  /**
+   * Object passed to FilterExpression.evaluate().
+   */
+
+  /**
+   * A type predicate for an object with a string property.
+   */
+  function hasStringKey(value, key) {
+    return isObject(value) && Object.hasOwn(value, key);
+  }
+
+  /**
+   * Base class for all filter expressions.
+   */
+  class FilterExpression {
+    constructor(token) {
+      this.token = token;
+    }
+
+    /**
+     * Evaluate the filter expression in the given context.
+     * @param context - Evaluation context.
+     */
+
+    /**
+     * Return a string representation of the expression.
+     */
+  }
+
+  /**
+   * Base class for JSONPath ValueType literals.
+   */
+  class FilterExpressionLiteral extends FilterExpression {}
+  class NullLiteral extends FilterExpressionLiteral {
+    evaluate() {
+      return null;
+    }
+    toString() {
+      return "null";
+    }
+  }
+  class BooleanLiteral extends FilterExpressionLiteral {
+    constructor(token, value) {
+      super(token);
+      this.token = token;
+      this.value = value;
+    }
+    evaluate() {
+      return this.value;
+    }
+    toString() {
+      return String(this.value);
+    }
+  }
+  class StringLiteral extends FilterExpressionLiteral {
+    constructor(token, value) {
+      super(token);
+      this.token = token;
+      this.value = value;
+    }
+    evaluate() {
+      return this.value;
+    }
+    toString() {
+      return JSON.stringify(this.value);
+    }
+  }
+  class NumberLiteral extends FilterExpressionLiteral {
+    constructor(token, value) {
+      super(token);
+      this.token = token;
+      this.value = value;
+    }
+    evaluate() {
+      return this.value;
+    }
+    toString() {
+      return String(this.value);
+    }
+  }
+  class PrefixExpression extends FilterExpression {
+    constructor(token, operator, right) {
+      super(token);
+      this.token = token;
+      this.operator = operator;
+      this.right = right;
+    }
+    evaluate(context) {
+      if (this.operator === "!") {
+        const value = this.right.evaluate(context);
+        if (value instanceof JSONPathNodeList) return value.nodes.length === 0; // negated existence
+        return !isTruthy(value);
+      }
+      throw new JSONPathTypeError(`unknown operator '${this.operator}'`, this.token);
+    }
+    toString() {
+      return `${this.operator}${this.right.toString()}`;
+    }
+  }
+  class InfixExpression extends FilterExpression {
+    constructor(token, left, operator, right) {
+      super(token);
+      this.token = token;
+      this.left = left;
+      this.operator = operator;
+      this.right = right;
+    }
+    evaluate(context) {
+      let left = this.left.evaluate(context);
+      if (left instanceof JSONPathNodeList && left.nodes.length === 1) left = left.nodes[0].value;
+      let right = this.right.evaluate(context);
+      if (right instanceof JSONPathNodeList && right.nodes.length === 1) right = right.nodes[0].value;
+      if (this.operator === "&&") {
+        return isTruthy(left) && isTruthy(right);
+      }
+      if (this.operator === "||") {
+        return isTruthy(left) || isTruthy(right);
+      }
+      return compare(left, this.operator, right);
+    }
+    toString() {
+      if (this.operator === "&&" || this.operator === "||") {
+        return `(${this.left.toString()} ${this.operator} ${this.right.toString()})`;
+      }
+      return `${this.left.toString()} ${this.operator} ${this.right.toString()}`;
+    }
+  }
+  class LogicalExpression extends FilterExpression {
+    constructor(token, expression) {
+      super(token);
+      this.token = token;
+      this.expression = expression;
+    }
+    evaluate(context) {
+      const value = this.expression.evaluate(context);
+      if (value instanceof JSONPathNodeList) return value.nodes.length > 0; // existence
+      return isTruthy(value);
+    }
+    toString() {
+      return this.expression.toString();
+    }
+  }
+
+  /**
+   * Base class for relative and absolute JSONPath query expressions.
+   */
+  class JSONPathQuery extends FilterExpression {
+    constructor(token, path) {
+      super(token);
+      this.token = token;
+      this.path = path;
+    }
+  }
+  class RelativeQuery extends JSONPathQuery {
+    evaluate(context) {
+      return this.path.query(context.currentValue);
+    }
+    toString() {
+      return `@${this.path.toString().slice(1)}`;
+    }
+  }
+  class RootQuery extends JSONPathQuery {
+    evaluate(context) {
+      return this.path.query(context.rootValue);
+    }
+    toString() {
+      return this.path.toString();
+    }
+  }
+  class FunctionExtension extends FilterExpression {
+    constructor(token, name, args) {
+      super(token);
+      this.token = token;
+      this.name = name;
+      this.args = args;
+    }
+    evaluate(context) {
+      const func = context.environment.filterRegister.get(this.name);
+      if (!func) {
+        throw new UndefinedFilterFunctionError(`filter function '${this.name}' is undefined`, this.token);
+      }
+      const args = this.args.map(arg => arg.evaluate(context)).map((arg, idx) => func.argTypes[idx] !== FunctionExpressionType.NodesType && arg instanceof JSONPathNodeList ? arg.valuesOrSingular() : arg);
+      return func.call(...args);
+    }
+    toString() {
+      return `${this.name}(${this.args.map(e => e.toString()).join(", ")})`;
+    }
+  }
+
+  /**
+   *
+   * @param value -
+   */
+  function isTruthy(value) {
+    if (value instanceof JSONPathNodeList && value.empty()) return false;
+    return !(typeof value === "boolean" && value === false);
+  }
+
+  /**
+   *
+   * @param left -
+   * @param operator -
+   * @param right -
+   */
+  function compare(left, operator, right) {
+    switch (operator) {
+      case "==":
+        return eq(left, right);
+      case "!=":
+        return !eq(left, right);
+      case "<":
+        return lt(left, right);
+      case ">":
+        return lt(right, left);
+      case ">=":
+        return lt(right, left) || eq(left, right);
+      case "<=":
+        return lt(left, right) || eq(left, right);
+      default:
+        return false;
+    }
+  }
+
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  function eq(left, right) {
+    if (right instanceof JSONPathNodeList) [left, right] = [right, left];
+    if (left instanceof JSONPathNodeList) {
+      if (right instanceof JSONPathNodeList) {
+        if (left.empty() && right.empty()) return true;
+        if (left.nodes.length === 1 && right.nodes.length === 1) return deepEquals(left.nodes[0].value, right.nodes[0].value);
+      }
+      if (left.empty()) return right === Nothing;
+      if (left.nodes.length === 1) return deepEquals(left.nodes[0].value, right);
+      return false;
+    }
+    if (left === Nothing && right === Nothing) return true;
+    return deepEquals(left, right);
+  }
+  function lt(left, right) {
+    if (isString(left) && isString(right) || isNumber(left) && isNumber(right)) return left < right;
+    return false;
+  }
+
+  var expression = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BooleanLiteral: BooleanLiteral,
+    FilterExpression: FilterExpression,
+    FilterExpressionLiteral: FilterExpressionLiteral,
+    FunctionExtension: FunctionExtension,
+    InfixExpression: InfixExpression,
+    JSONPathQuery: JSONPathQuery,
+    LogicalExpression: LogicalExpression,
+    NullLiteral: NullLiteral,
+    NumberLiteral: NumberLiteral,
+    PrefixExpression: PrefixExpression,
+    RelativeQuery: RelativeQuery,
+    RootQuery: RootQuery,
+    StringLiteral: StringLiteral
+  });
+
+  class Count {
+    argTypes = [FunctionExpressionType.NodesType];
+    returnType = FunctionExpressionType.ValueType;
+    call(nodes) {
+      return nodes.length;
+    }
+  }
+
+  class Length {
+    argTypes = [FunctionExpressionType.ValueType];
+    returnType = FunctionExpressionType.ValueType;
+    call(value) {
+      if (isArray(value) || isString(value)) return value.length;
+      if (isObject(value)) return Object.keys(value).length;
+      return Nothing;
+    }
+  }
+
+  /**
+   * A Least Recently Used cache, implemented as an extended Map.
+   */
+  class LRUCache extends Map {
+    constructor() {
+      let maxSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 128;
+      let entries = arguments.length > 1 ? arguments[1] : undefined;
+      if (entries !== undefined) {
+        super(entries);
+      } else {
+        super();
+      }
+      this.maxSize = maxSize;
+    }
+    get(key) {
+      const val = super.get(key);
+      if (this.has(key)) {
+        this.delete(key);
+        this.set(key, val);
+      }
+      return val;
+    }
+    set(key, value) {
+      if (this.has(key)) {
+        this.delete(key);
+      } else if (this.size >= this.maxSize) {
+        this.delete(this.first());
+      }
+      return super.set(key, value);
+    }
+    first() {
+      return this.keys().next().value;
+    }
+  }
+
+  class Match {
+    argTypes = [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType];
+    returnType = FunctionExpressionType.LogicalType;
+    #cache;
+    constructor() {
+      let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.options = options;
+      this.cacheSize = options.cacheSize ?? 10;
+      this.throwErrors = options.throwErrors ?? false;
+      this.#cache = new LRUCache(this.cacheSize);
+    }
+    call(s, pattern) {
+      if (this.cacheSize > 0) {
+        const re = this.#cache.get(pattern);
+        if (re) {
+          try {
+            return re.test(s);
+          } catch (error) {
+            if (this.throwErrors) throw error;
+            return false;
+          }
+        }
+      }
+      try {
+        const re = new RegExp(this.fullMatch(pattern), "u");
+        if (this.cacheSize > 0) this.#cache.set(pattern, re);
+        return re.test(s);
+      } catch (error) {
+        if (this.throwErrors) throw error;
+        return false;
+      }
+    }
+    fullMatch(pattern) {
+      const parts = [];
+      if (!pattern.startsWith("^")) parts.push("^");
+      parts.push(pattern);
+      if (!pattern.endsWith("$")) parts.push("$");
+      return parts.join("");
+    }
+  }
+
+  class Search {
+    argTypes = [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType];
+    returnType = FunctionExpressionType.LogicalType;
+    #cache;
+    constructor() {
+      let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.options = options;
+      this.cacheSize = options.cacheSize ?? 10;
+      this.throwErrors = options.throwErrors ?? false;
+      this.#cache = new LRUCache(this.cacheSize);
+    }
+    call(s, pattern) {
+      if (this.cacheSize > 0) {
+        const re = this.#cache.get(pattern);
+        if (re) {
+          try {
+            return !!s.match(re);
+          } catch (error) {
+            if (this.throwErrors) throw error;
+            return false;
+          }
+        }
+      }
+      try {
+        const re = new RegExp(pattern, "u");
+        if (this.cacheSize > 0) this.#cache.set(pattern, re);
+        return !!s.match(re);
+      } catch (error) {
+        if (this.throwErrors) throw error;
+        return false;
+      }
+    }
+  }
+
+  class Value {
+    argTypes = [FunctionExpressionType.NodesType];
+    returnType = FunctionExpressionType.ValueType;
+    call(nodes) {
+      if (nodes.length === 1) return nodes.nodes[0].value;
+      return Nothing;
+    }
+  }
+
+  /**
+   *
+   */
+  let TokenKind = /*#__PURE__*/function (TokenKind) {
+    TokenKind["AND"] = "TOKEN_AND";
+    TokenKind["COLON"] = "TOKEN_COLON";
+    TokenKind["COMMA"] = "TOKEN_COMMA";
+    TokenKind["CURRENT"] = "TOKEN_CURRENT_NODE";
+    TokenKind["DDOT"] = "TOKEN_DDOT";
+    TokenKind["DOT"] = "TOKEN_DOT";
+    TokenKind["DOUBLE_QUOTE_STRING"] = "TOKEN_DOUBLE_QUOTE_STRING";
+    TokenKind["EOF"] = "TOKEN_EOF";
+    TokenKind["EQ"] = "TOKEN_EQ";
+    TokenKind["ERROR"] = "TOKEN_ERROR";
+    TokenKind["FALSE"] = "TOKEN_FALSE";
+    TokenKind["FILTER"] = "TOKEN_FILTER_START";
+    TokenKind["FUNCTION"] = "TOKEN_FUNCTION";
+    TokenKind["GE"] = "TOKEN_GE";
+    TokenKind["GT"] = "TOKEN_GT";
+    TokenKind["INDEX"] = "TOKEN_INDEX";
+    TokenKind["LBRACKET"] = "TOKEN_LBRACKET";
+    TokenKind["LE"] = "TOKEN_LE";
+    TokenKind["LG"] = "TOKEN_LG";
+    TokenKind["LPAREN"] = "TOKEN_LPAREN";
+    TokenKind["LT"] = "TOKEN_LT";
+    TokenKind["NAME"] = "TOKEN_NAME";
+    TokenKind["NE"] = "TOKEN_NE";
+    TokenKind["NOT"] = "TOKEN_NOT";
+    TokenKind["NULL"] = "TOKEN_NULL";
+    TokenKind["NUMBER"] = "NUMBER";
+    TokenKind["OR"] = "TOKEN_OR";
+    TokenKind["RBRACKET"] = "TOKEN_RBRACKET";
+    TokenKind["ROOT"] = "TOKEN_ROOT";
+    TokenKind["RPAREN"] = "TOKEN_RPAREN";
+    TokenKind["SINGLE_QUOTE_STRING"] = "TOKEN_SINGLE_QUOTE_STRING";
+    TokenKind["TRUE"] = "TOKEN_TRUE";
+    TokenKind["WILD"] = "TOKEN_WILD";
+    return TokenKind;
+  }({});
+
+  /**
+   *
+   */
+  class Token {
+    constructor(kind, value, index, input) {
+      this.kind = kind;
+      this.value = value;
+      this.index = index;
+      this.input = input;
+    }
+  }
+  new Token(TokenKind.EOF, "", -1, "");
+
+  /**
+   *
+   */
+  class TokenStream {
+    #pos = 0;
+    constructor(tokens) {
+      this.tokens = tokens;
+    }
+    get current() {
+      return this.tokens[this.#pos];
+    }
+    get peek() {
+      if (this.#pos >= this.tokens.length - 1) return this.tokens[this.tokens.length - 1];
+      return this.tokens[this.#pos + 1];
+    }
+    next() {
+      const current = this.current;
+      this.#pos += 1;
+      return current;
+    }
+    backup() {
+      if (this.#pos > 0) this.#pos -= 1;
+    }
+    expect(kind) {
+      if (this.current.kind !== kind) {
+        throw new JSONPathSyntaxError(`expected token '${kind}', found '${this.current.kind}'`, this.current);
+      }
+    }
+    expectPeek(kind) {
+      const peeked = this.peek;
+      if (peeked.kind !== kind) {
+        throw new JSONPathSyntaxError(`expected token '${kind}', found '${peeked.kind}'`, peeked);
+      }
+    }
+  }
+
+  // These regular expressions are to be used with Lexer.acceptMatchRun(),
+  // which expects the sticky flag to be set.
+  const exponentPattern = /e[+-]\d+/y;
+  const functionNamePattern = /[a-z][a-z_0-9]*/y;
+  const indexPattern = /-?\d+/y;
+  const intPattern = /-?[0-9]+/y;
+  const namePattern = /[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*/y;
+  const whitespace = new Set([" ", "\n", "\t", "\r"]);
+
+  /**
+   * JSONPath lexical scanner.
+   *
+   * Lexer state is shared between this class and the current state function. A
+   * new _Lexer_ instance is automatically created every time a path is tokenized.
+   *
+   * Use {@link tokenize} to get an array of {@link Token}'s for a JSONPath query.
+   */
+  class Lexer {
+    /**
+     * Filter nesting level.
+     */
+    filterLevel = 0;
+
+    /**
+     * A running count of parentheses for each, possibly nested, function call.
+     *
+     * If the stack is empty, we are not in a function call. Remember that
+     * function arguments can use arbitrarily nested in parentheses.
+     */
+    parenStack = [];
+
+    /** Tokens resulting from tokenizing a JSONPath query. */
+    tokens = [];
+    #start = 0;
+    #pos = 0;
+
+    /**
+     * @param path - A JSONPath query.
+     */
+    constructor(path) {
+      this.path = path;
+    }
+    get pos() {
+      return this.#pos;
+    }
+    get start() {
+      return this.#start;
+    }
+    run() {
+      let state = lexRoot;
+      while (state) {
+        state = state(this);
+      }
+    }
+    emit(t) {
+      this.tokens.push(new Token(t, this.path.slice(this.#start, this.#pos), this.#start, this.path));
+      this.#start = this.#pos;
+    }
+    next() {
+      if (this.#pos >= this.path.length) return "";
+      const s = this.path[this.#pos];
+      this.#pos += 1;
+      return s;
+    }
+    ignore() {
+      this.#start = this.#pos;
+    }
+    backup() {
+      if (this.#pos <= this.#start) {
+        const msg = "can't backup beyond start";
+        throw new JSONPathLexerError(msg, new Token(TokenKind.ERROR, msg, this.#pos, this.path));
+      }
+      this.#pos -= 1;
+    }
+    peek() {
+      const ch = this.next();
+      if (ch) this.backup();
+      return ch;
+    }
+    accept(valid) {
+      const ch = this.next();
+      if (valid.has(ch)) return true;
+      if (ch) this.backup();
+      return false;
+    }
+    acceptMatch(pattern) {
+      const ch = this.next();
+      if (pattern.test(ch)) return true;
+      if (ch) this.backup();
+      return false;
+    }
+    acceptRun(valid) {
+      let found = false;
+      let ch = this.next();
+      while (valid.has(ch)) {
+        ch = this.next();
+        found = true;
+      }
+      if (ch) this.backup();
+      return found;
+    }
+    acceptMatchRun(pattern) {
+      pattern.lastIndex = this.#pos;
+      const match = pattern.exec(this.path);
+      pattern.lastIndex = 0;
+      if (match) {
+        this.#pos += match[0].length;
+        return true;
+      }
+      return false;
+    }
+    ignoreWhitespace() {
+      if (this.#pos !== this.#start) {
+        const msg = `must emit or ignore before consuming whitespace ('${this.path.slice(this.#start, this.#pos)}':${this.pos})`;
+        throw new JSONPathLexerError(msg, new Token(TokenKind.ERROR, msg, this.pos, this.path));
+      }
+      if (this.acceptRun(whitespace)) {
+        this.ignore();
+        return true;
+      }
+      return false;
+    }
+    error(msg) {
+      this.tokens.push(new Token(TokenKind.ERROR, msg, this.#pos, this.path));
+    }
+  }
+  /**
+   * Return a lexer for _path_ and an array to be populated with Tokens.
+   *
+   * `lexer.run()` must be called to populate the returned tokens array.
+   *
+   * You probably want to use {@link tokenize} instead of _lex_. This function
+   * is mostly for internal use, where we want to test the state of the returned
+   * _lexer_ after tokens have been populated.
+   *
+   * @param path - A JSONPath query.
+   * @returns A two-tuple containing a lexer for _path_ and an array to populate
+   * with tokens.
+   */
+  function lex(path) {
+    const lexer = new Lexer(path);
+    return [lexer, lexer.tokens];
+  }
+
+  /**
+   * Scan _path_ and return an array of tokens to be parsed by the parser.
+   * @param path - A JSONPath query.
+   * @returns Tokens to be parsed by the parser.
+   */
+  function tokenize(path) {
+    const [lexer, tokens] = lex(path);
+    lexer.run();
+    if (tokens.length && tokens[tokens.length - 1].kind === TokenKind.ERROR) {
+      throw new JSONPathSyntaxError(tokens[tokens.length - 1].value, tokens[tokens.length - 1]);
+    }
+    return tokens;
+  }
+  function lexRoot(l) {
+    const ch = l.next();
+    if (ch !== "$") {
+      l.backup();
+      l.error(`expected '$', found '${ch}'`);
+      return null;
+    }
+    l.emit(TokenKind.ROOT);
+    return lexSegment;
+  }
+  function lexSegment(l) {
+    if (l.ignoreWhitespace() && !l.peek()) {
+      l.error("trailing whitespace");
+    }
+    const ch = l.next();
+    switch (ch) {
+      case "":
+        l.emit(TokenKind.EOF);
+        return null;
+      case ".":
+        if (l.peek() === ".") {
+          l.next();
+          l.emit(TokenKind.DDOT);
+          return lexDescendantSelection;
+        }
+        return lexDotSelector;
+      case "[":
+        l.emit(TokenKind.LBRACKET);
+        return lexInsideBracketedSelection;
+      default:
+        l.backup();
+        if (l.filterLevel) return lexInsideFilter;
+        l.error(`expected '.', '..' or a bracketed selection, found '${ch}'`);
+        return null;
+    }
+  }
+
+  /**
+   * Similar to _lexSegment_, but ..
+   *   - no leading whitespace
+   *   - no extra dot before a property name
+   *   - there must be a selector, so EOF would be an error
+   * @param l -
+   * @returns -
+   */
+  function lexDescendantSelection(l) {
+    const ch = l.next();
+    switch (ch) {
+      case "":
+        l.error("bald descendant segment");
+        return null;
+      case "*":
+        l.emit(TokenKind.WILD);
+        return lexSegment;
+      case "[":
+        l.emit(TokenKind.LBRACKET);
+        return lexInsideBracketedSelection;
+      default:
+        l.backup();
+        if (l.acceptMatchRun(namePattern)) {
+          l.emit(TokenKind.NAME);
+          return lexSegment;
+        } else {
+          l.error(`unexpected descendent selection token '${ch}'`);
+          return null;
+        }
+    }
+  }
+  function lexDotSelector(l) {
+    l.ignore();
+    if (l.ignoreWhitespace()) {
+      l.error("unexpected whitespace after dot");
+      return null;
+    }
+    const ch = l.next();
+    if (ch === "*") {
+      l.emit(TokenKind.WILD);
+      return lexSegment;
+    }
+    l.backup();
+    if (l.acceptMatchRun(namePattern)) {
+      l.emit(TokenKind.NAME);
+      return lexSegment;
+    } else {
+      l.error(`unexpected shorthand selector '${ch}'`);
+      return null;
+    }
+  }
+  function lexInsideBracketedSelection(l) {
+    for (;;) {
+      l.ignoreWhitespace();
+      const ch = l.next();
+      switch (ch) {
+        case "]":
+          l.emit(TokenKind.RBRACKET);
+          if (l.filterLevel) return lexInsideFilter;
+          return lexSegment;
+        case "":
+          l.error("unclosed bracketed selection");
+          return null;
+        case "*":
+          l.emit(TokenKind.WILD);
+          continue;
+        case "?":
+          l.emit(TokenKind.FILTER);
+          l.filterLevel += 1;
+          return lexInsideFilter;
+        case ",":
+          l.emit(TokenKind.COMMA);
+          continue;
+        case ":":
+          l.emit(TokenKind.COLON);
+          continue;
+        case "'":
+          return lexSingleQuoteStringInsideBracketSelection;
+        case '"':
+          return lexDoubleQuoteStringInsideBracketSelection;
+        default:
+          l.backup();
+          if (l.acceptMatchRun(indexPattern)) {
+            l.emit(TokenKind.INDEX);
+            continue;
+          }
+          l.error(`unexpected token '${ch}' in bracketed selection`);
+          return null;
+      }
+    }
+  }
+
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  function lexInsideFilter(l) {
+    for (;;) {
+      l.ignoreWhitespace();
+      const ch = l.next();
+      switch (ch) {
+        case "":
+        case "]":
+          l.filterLevel -= 1;
+          l.backup();
+          return lexInsideBracketedSelection;
+        case ",":
+          l.emit(TokenKind.COMMA);
+          // If we have unbalanced parens, we are inside a function call and a
+          // comma separates arguments. Otherwise a comma separates selectors.
+          if (l.parenStack.length) continue;
+          l.filterLevel -= 1;
+          return lexInsideBracketedSelection;
+        case "'":
+          return lexSingleQuoteStringInsideFilterExpression;
+        case '"':
+          return lexDoubleQuoteStringInsideFilterExpression;
+        case "(":
+          l.emit(TokenKind.LPAREN);
+          // Are we in a function call? If so, a function argument contains parens.
+          if (l.parenStack.length) l.parenStack[l.parenStack.length - 1] += 1;
+          continue;
+        case ")":
+          l.emit(TokenKind.RPAREN);
+          // Are we closing a function call or a parenthesized expression?
+          if (l.parenStack.length) {
+            if (l.parenStack[l.parenStack.length - 1] === 1) {
+              l.parenStack.pop();
+            } else {
+              l.parenStack[l.parenStack.length - 1] -= 1;
+            }
+          }
+          continue;
+        case "$":
+          l.emit(TokenKind.ROOT);
+          return lexSegment;
+        case "@":
+          l.emit(TokenKind.CURRENT);
+          return lexSegment;
+        case ".":
+          l.backup();
+          return lexSegment;
+        case "!":
+          if (l.peek() === "=") {
+            l.next();
+            l.emit(TokenKind.NE);
+          } else {
+            l.emit(TokenKind.NOT);
+          }
+          continue;
+        case "=":
+          if (l.peek() === "=") {
+            l.next();
+            l.emit(TokenKind.EQ);
+            continue;
+          } else {
+            l.backup();
+            l.error(`unexpected filter selector token '${ch}'`);
+            return null;
+          }
+        case "<":
+          if (l.peek() === "=") {
+            l.next();
+            l.emit(TokenKind.LE);
+          } else {
+            l.emit(TokenKind.LT);
+          }
+          continue;
+        case ">":
+          if (l.peek() === "=") {
+            l.next();
+            l.emit(TokenKind.GE);
+          } else {
+            l.emit(TokenKind.GT);
+          }
+          continue;
+        default:
+          l.backup();
+
+          // numbers
+          if (l.acceptMatchRun(intPattern)) {
+            if (l.peek() === ".") {
+              // A float.
+              l.next();
+              if (!l.acceptMatchRun(intPattern)) {
+                // Need at least one digit after a decimal place.
+                l.error("a fractional digit is required after a decimal point");
+                return null;
+              }
+            }
+            l.acceptMatchRun(exponentPattern);
+            l.emit(TokenKind.NUMBER);
+            continue;
+          }
+          if (l.acceptMatchRun(/&&/y)) {
+            l.emit(TokenKind.AND);
+            continue;
+          }
+          if (l.acceptMatchRun(/\|\|/y)) {
+            l.emit(TokenKind.OR);
+            continue;
+          }
+          if (l.acceptMatchRun(/true/y)) {
+            l.emit(TokenKind.TRUE);
+            continue;
+          }
+          if (l.acceptMatchRun(/false/y)) {
+            l.emit(TokenKind.FALSE);
+            continue;
+          }
+          if (l.acceptMatchRun(/null/y)) {
+            l.emit(TokenKind.NULL);
+            continue;
+          }
+
+          // functions
+          if (l.acceptMatchRun(functionNamePattern) && l.peek() === "(") {
+            // Keep track of parentheses for this function call.
+            l.parenStack.push(1);
+            l.emit(TokenKind.FUNCTION);
+            l.next();
+            l.ignore();
+            continue;
+          }
+      }
+      l.error(`unexpected filter selector token '${ch}'`);
+      return null;
+    }
+  }
+
+  /**
+   * Return a state function tokenizing string literals using _quote_ and
+   * returning control to _state_.
+   * @param quote - One of `'` or `"`.
+   * @param state - The state function to return control to.
+   * @returns String tokenizing state function.
+   */
+  function makeLexString(quote, state) {
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    function _lexString(l) {
+      l.ignore();
+      if (l.peek() === quote) {
+        // empty string
+        l.emit(quote === "'" ? TokenKind.SINGLE_QUOTE_STRING : TokenKind.DOUBLE_QUOTE_STRING);
+        l.next();
+        l.ignore();
+        return state;
+      }
+      for (;;) {
+        const la = l.path.slice(l.pos, l.pos + 2);
+        const ch = l.next();
+        if (la === "\\\\" || la === `\\${quote}`) {
+          l.next();
+          continue;
+        } else if (ch === "\\" && !la.match(/\\[bfnrtu/]/)) {
+          l.error(`invalid escape`);
+          return null;
+        }
+        if (!ch) {
+          l.error(`unclosed string starting at index ${l.start}`);
+          return null;
+        }
+        if (ch === quote) {
+          l.backup();
+          l.emit(quote === "'" ? TokenKind.SINGLE_QUOTE_STRING : TokenKind.DOUBLE_QUOTE_STRING);
+          l.next();
+          l.ignore();
+          return state;
+        }
+      }
+    }
+    return _lexString;
+  }
+  const lexSingleQuoteStringInsideBracketSelection = makeLexString("'", lexInsideBracketedSelection);
+  const lexDoubleQuoteStringInsideBracketSelection = makeLexString('"', lexInsideBracketedSelection);
+  const lexSingleQuoteStringInsideFilterExpression = makeLexString("'", lexInsideFilter);
+  const lexDoubleQuoteStringInsideFilterExpression = makeLexString('"', lexInsideFilter);
+
+  /**
+   * Base class for all JSONPath segments and selectors.
+   */
+  class JSONPathSelector {
+    /**
+     * @param token - The token at the start of this selector.
+     */
+    constructor(environment, token) {
+      this.environment = environment;
+      this.token = token;
+    }
+
+    /**
+     * @param nodes - Nodes matched by preceding selectors.
+     */
+
+    /**
+     * Return a canonical string representation of this selector.
+     */
+  }
+
+  /**
+   * Shorthand and quoted name selector.
+   */
+  class NameSelector extends JSONPathSelector {
+    constructor(environment, token, name, shorthand) {
+      super(environment, token);
+      this.environment = environment;
+      this.token = token;
+      this.name = name;
+      this.shorthand = shorthand;
+    }
+    resolve(nodes) {
+      const rv = [];
+      for (const node of nodes) {
+        if (hasStringKey(node.value, this.name)) {
+          rv.push(new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root));
+        }
+      }
+      return new JSONPathNodeList(rv);
+    }
+    toString() {
+      return this.shorthand ? `['${this.name}']` : `'${this.name}'`;
+    }
+  }
+
+  /**
+   * Array index selector.
+   */
+  class IndexSelector extends JSONPathSelector {
+    constructor(environment, token, index) {
+      super(environment, token);
+      this.environment = environment;
+      this.token = token;
+      this.index = index;
+      if (index < this.environment.options.minIntIndex || index > this.environment.options.maxIntIndex) {
+        throw new JSONPathIndexError("index out of range", this.token);
+      }
+    }
+    resolve(nodes) {
+      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));
+          }
+        }
+      }
+      return new JSONPathNodeList(rv);
+    }
+    toString() {
+      return String(this.index);
+    }
+    normalizedIndex(length) {
+      if (this.index < 0 && length >= Math.abs(this.index)) return length + this.index;
+      return this.index;
+    }
+  }
+  class SliceSelector extends JSONPathSelector {
+    constructor(environment, token, start, stop, step) {
+      super(environment, token);
+      this.environment = environment;
+      this.token = token;
+      this.start = start;
+      this.stop = stop;
+      this.step = step;
+      this.checkRange(start, stop, step);
+    }
+    resolve(nodes) {
+      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));
+        }
+      }
+      return new JSONPathNodeList(rv);
+    }
+    toString() {
+      const start = this.start ? this.start : "";
+      const stop = this.stop ? this.stop : "";
+      const step = this.step ? this.step : "1";
+      return `${start}:${stop}:${step}`;
+    }
+    checkRange() {
+      for (var _len = arguments.length, indices = new Array(_len), _key = 0; _key < _len; _key++) {
+        indices[_key] = arguments[_key];
+      }
+      for (const index of indices) {
+        if (index !== undefined && (index < this.environment.options.minIntIndex || index > this.environment.options.maxIntIndex)) {
+          throw new JSONPathIndexError("index out of range", this.token);
+        }
+      }
+    }
+    normalizedIndex(length, index) {
+      if (index < 0 && length >= Math.abs(index)) return Math.min(length + index, length - 1);
+      return Math.min(index, length - 1);
+    }
+
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    slice(arr, start, stop, step) {
+      if (!arr.length) return [];
+
+      // Handle negative start and stop values
+      if (start === undefined || start === null) {
+        start = step && step < 0 ? arr.length - 1 : 0;
+      } else if (start < 0) {
+        start = Math.max(arr.length + start, 0);
+      } else {
+        start = Math.min(start, arr.length - 1);
+      }
+      if (stop === undefined || stop === null) {
+        stop = step && step < 0 ? -1 : arr.length;
+      } else if (stop < 0) {
+        stop = Math.max(arr.length + stop, -1);
+      } else {
+        stop = Math.min(stop, arr.length);
+      }
+
+      // Handle step value
+      if (step === 0) {
+        return [];
+      }
+      if (!step) {
+        step = 1;
+      }
+
+      // Perform the slice
+      const slicedArray = [];
+      if (step > 0) {
+        for (let i = start; i < stop; i += step) {
+          slicedArray.push([i, arr[i]]);
+        }
+      } else {
+        for (let i = start; i > stop; i += step) {
+          slicedArray.push([i, arr[i]]);
+        }
+      }
+      return slicedArray;
+    }
+  }
+  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) {
+      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 Object.entries(node.value)) {
+            rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
+          }
+        }
+      }
+      return new JSONPathNodeList(rv);
+    }
+    toString() {
+      return this.shorthand ? "[*]" : "*";
+    }
+  }
+  class RecursiveDescentSegment extends JSONPathSelector {
+    resolve(nodes) {
+      const rv = [];
+      for (const node of nodes) {
+        rv.push(node, ...this.visit(node));
+      }
+      return new JSONPathNodeList(rv);
+    }
+    toString() {
+      return "..";
+    }
+    visit(node) {
+      const rv = [];
+      if (node.value instanceof String) return new JSONPathNodeList(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, ...this.visit(_node));
+        }
+      } else if (isObject(node.value)) {
+        for (const [key, value] of Object.entries(node.value)) {
+          const _node = new JSONPathNode(value, node.location.concat(key), node.root);
+          rv.push(_node, ...this.visit(_node));
+        }
+      }
+      return new JSONPathNodeList(rv);
+    }
+  }
+  class FilterSelector extends JSONPathSelector {
+    constructor(environment, token, expression) {
+      super(environment, token);
+      this.environment = environment;
+      this.token = token;
+      this.expression = expression;
+    }
+
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    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
+            };
+            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 Object.entries(node.value)) {
+            const filterContext = {
+              environment: this.environment,
+              currentValue: value,
+              rootValue: node.root
+            };
+            if (this.expression.evaluate(filterContext)) {
+              rv.push(new JSONPathNode(value, node.location.concat(key), node.root));
+            }
+          }
+        }
+      }
+      return new JSONPathNodeList(rv);
+    }
+    toString() {
+      return `?${this.expression.toString()}`;
+    }
+  }
+  class BracketedSelection extends JSONPathSelector {
+    constructor(environment, token, items) {
+      super(environment, token);
+      this.environment = environment;
+      this.token = token;
+      this.items = items;
+    }
+    resolve(nodes) {
+      const rv = [];
+      for (const node of nodes) {
+        for (const item of this.items) {
+          rv.push(...item.resolve(new JSONPathNodeList([node])));
+        }
+      }
+      return new JSONPathNodeList(rv);
+    }
+    toString() {
+      return `[${this.items.map(itm => itm.toString()).join(", ")}]`;
+    }
+  }
+
+  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 {
+    /**
+     *
+     * @param environment -
+     * @param selectors -
+     */
+    constructor(environment, selectors) {
+      this.environment = environment;
+      this.selectors = selectors;
+    }
+
+    /**
+     *
+     * @param value -
+     * @returns
+     */
+    query(value) {
+      let nodes = new JSONPathNodeList([new JSONPathNode(value, [], value)]);
+      for (const selector of this.selectors) {
+        nodes = selector.resolve(nodes);
+      }
+      return nodes;
+    }
+
+    /**
+     *
+     */
+    toString() {
+      return `$${this.selectors.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;
+        return false;
+      }
+      return true;
+    }
+  }
+
+  const PRECEDENCE_LOWEST = 1;
+  const PRECEDENCE_LOGICALRIGHT = 3;
+  const PRECEDENCE_LOGICAL_AND = 4;
+  const PRECEDENCE_LOGICAL_OR = 5;
+  const PRECEDENCE_COMPARISON = 6;
+  const PRECEDENCES = new Map([[TokenKind.AND, PRECEDENCE_LOGICAL_AND], [TokenKind.EQ, PRECEDENCE_COMPARISON], [TokenKind.GE, PRECEDENCE_COMPARISON], [TokenKind.GT, PRECEDENCE_COMPARISON], [TokenKind.LE, PRECEDENCE_COMPARISON], [TokenKind.LT, PRECEDENCE_COMPARISON], [TokenKind.NE, PRECEDENCE_COMPARISON], [TokenKind.NOT, PRECEDENCE_LOGICALRIGHT], [TokenKind.OR, PRECEDENCE_LOGICAL_OR], [TokenKind.RPAREN, PRECEDENCE_LOWEST]]);
+  const BINARY_OPERATORS = new Map([[TokenKind.AND, "&&"], [TokenKind.EQ, "=="], [TokenKind.GE, ">="], [TokenKind.GT, ">"], [TokenKind.LE, "<="], [TokenKind.LT, "<"], [TokenKind.NE, "!="], [TokenKind.OR, "||"]]);
+  const COMPARISON_OPERATORS = new Set(["==", ">=", ">", "<=", "<", "!="]);
+  class Parser {
+    constructor(environment) {
+      this.environment = environment;
+      this.tokenMap = new Map([[TokenKind.FALSE, this.parseBoolean], [TokenKind.NUMBER, this.parseNumber], [TokenKind.LPAREN, this.parseGroupedExpression], [TokenKind.NOT, this.parsePrefixExpression], [TokenKind.NULL, this.parseNull], [TokenKind.ROOT, this.parseRootQuery], [TokenKind.CURRENT, this.parseRelativeQuery], [TokenKind.SINGLE_QUOTE_STRING, this.parseString], [TokenKind.DOUBLE_QUOTE_STRING, this.parseString], [TokenKind.TRUE, this.parseBoolean], [TokenKind.FUNCTION, this.parseFunction]]);
+    }
+    parse(stream) {
+      if (stream.current.kind === TokenKind.ROOT) stream.next();
+      const selectors = this.parsePath(stream);
+      if (stream.current.kind !== TokenKind.EOF) {
+        throw new JSONPathSyntaxError(`unexpected token '${stream.current.kind}'`, stream.current);
+      }
+      return selectors;
+    }
+    parsePath(stream) {
+      let inFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      const selectors = [];
+      loop: for (;;) {
+        switch (stream.current.kind) {
+          case TokenKind.NAME:
+            selectors.push(new NameSelector(this.environment, stream.current, stream.current.value, true));
+            break;
+          case TokenKind.WILD:
+            selectors.push(new WildcardSelector(this.environment, stream.current, true));
+            break;
+          case TokenKind.DDOT:
+            selectors.push(new RecursiveDescentSegment(this.environment, stream.current));
+            break;
+          case TokenKind.LBRACKET:
+            selectors.push(this.parseBracketedSelection(stream));
+            break;
+          default:
+            if (inFilter) {
+              stream.backup();
+            }
+            break loop;
+        }
+        stream.next();
+      }
+      return selectors;
+    }
+    parseIndex(stream) {
+      if (stream.current.value.length > 1 && stream.current.value.startsWith("0") || stream.current.value.startsWith("-0")) {
+        throw new JSONPathSyntaxError("leading zero in index selector", stream.current);
+      }
+      return new IndexSelector(this.environment, stream.current, Number(stream.current.value));
+    }
+    parseSlice(stream) {
+      const tok = stream.current;
+      const indices = [];
+      function maybeIndex(token) {
+        if (token.kind === TokenKind.INDEX) {
+          if (token.value.length > 1 && token.value.startsWith("0") || token.value.startsWith("-0")) {
+            throw new JSONPathSyntaxError("leading zero in index selector", token);
+          }
+          return true;
+        }
+        return false;
+      }
+
+      // 1: or :
+      if (maybeIndex(stream.current)) {
+        indices.push(Number(stream.current.value));
+        stream.next();
+        stream.expect(TokenKind.COLON);
+        stream.next();
+      } else {
+        indices.push(undefined);
+        stream.expect(TokenKind.COLON);
+        stream.next();
+      }
+
+      // 1 or 1: or : or ?
+      if (maybeIndex(stream.current)) {
+        indices.push(Number(stream.current.value));
+        stream.next();
+        if (stream.current.kind === TokenKind.COLON) {
+          stream.next();
+        }
+      } else if (stream.current.kind === TokenKind.COLON) {
+        indices.push(undefined);
+        stream.expect(TokenKind.COLON);
+        stream.next();
+      }
+
+      // 1 or ?
+      if (maybeIndex(stream.current)) {
+        indices.push(Number(stream.current.value));
+        stream.next();
+      }
+      stream.backup();
+      return new SliceSelector(this.environment, tok, ...indices);
+    }
+    parseBracketedSelection(stream) {
+      const token = stream.next();
+      const items = [];
+      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, true), false));
+            break;
+          case TokenKind.FILTER:
+            items.push(this.parseFilter(stream));
+            break;
+          case TokenKind.INDEX:
+            if (stream.peek.kind === TokenKind.COLON) {
+              items.push(this.parseSlice(stream));
+            } else {
+              items.push(this.parseIndex(stream));
+            }
+            break;
+          case TokenKind.COLON:
+            items.push(this.parseSlice(stream));
+            break;
+          case TokenKind.WILD:
+            items.push(new WildcardSelector(this.environment, stream.current));
+            break;
+          case TokenKind.EOF:
+            throw new JSONPathSyntaxError("unexpected end of query", stream.current);
+          default:
+            throw new JSONPathSyntaxError(`unexpected token in bracketed selection '${stream.current.kind}'`, stream.current);
+        }
+        if (stream.peek.kind !== TokenKind.RBRACKET) {
+          stream.expectPeek(TokenKind.COMMA);
+          stream.next();
+        }
+        stream.next();
+      }
+      if (!items.length) {
+        throw new JSONPathSyntaxError("empty bracketed segment", token);
+      }
+      return new BracketedSelection(this.environment, token, items);
+    }
+    parseFilter(stream) {
+      const tok = stream.next();
+      const expr = this.parseFilterExpression(stream);
+      if (expr instanceof FunctionExtension) {
+        const func = this.environment.filterRegister.get(expr.name);
+        if (func && func.returnType === FunctionExpressionType.ValueType) {
+          throw new JSONPathTypeError(`result of ${expr.name}()  must be compared`, expr.token);
+        }
+      }
+      return new FilterSelector(this.environment, tok, new LogicalExpression(tok, expr));
+    }
+    parseBoolean(stream) {
+      if (stream.current.kind === TokenKind.FALSE) return new BooleanLiteral(stream.current, false);
+      return new BooleanLiteral(stream.current, true);
+    }
+    parseNull(stream) {
+      return new NullLiteral(stream.current);
+    }
+    parseString(stream) {
+      return new StringLiteral(stream.current, this.decodeString(stream.current));
+    }
+    parseNumber(stream) {
+      return new NumberLiteral(stream.current, Number(stream.current.value));
+    }
+    parsePrefixExpression(stream) {
+      stream.expect(TokenKind.NOT);
+      stream.next();
+      return new PrefixExpression(stream.current, "!", this.parseFilterExpression(stream, PRECEDENCE_LOGICALRIGHT));
+    }
+    parseInfixExpression(stream, left) {
+      const tok = stream.next();
+      const precedence = PRECEDENCES.get(tok.kind) || PRECEDENCE_LOWEST;
+      const right = this.parseFilterExpression(stream, precedence);
+      const operator = BINARY_OPERATORS.get(tok.kind);
+      if (!operator) {
+        throw new JSONPathSyntaxError(`unknown operator '${tok.kind}'`, tok);
+      }
+      this.throwForNonSingularQuery(left);
+      this.throwForNonSingularQuery(right);
+      if (COMPARISON_OPERATORS.has(operator)) {
+        this.throwForNonComparableFunction(left);
+        this.throwForNonComparableFunction(right);
+      }
+      return new InfixExpression(tok, left, operator, right);
+    }
+    parseGroupedExpression(stream) {
+      stream.next();
+      let expr = this.parseFilterExpression(stream);
+      stream.next();
+      while (stream.current.kind !== TokenKind.RPAREN) {
+        if (stream.current.kind === TokenKind.EOF) {
+          throw new JSONPathSyntaxError("unbalanced parentheses", stream.current);
+        }
+        expr = this.parseInfixExpression(stream, expr);
+      }
+      stream.expect(TokenKind.RPAREN);
+      return expr;
+    }
+    parseRootQuery(stream) {
+      const tok = stream.next();
+      return new RootQuery(tok, new JSONPath(this.environment, this.parsePath(stream, true)));
+    }
+    parseRelativeQuery(stream) {
+      const tok = stream.next();
+      return new RelativeQuery(tok, new JSONPath(this.environment, this.parsePath(stream, true)));
+    }
+    parseFunction(stream) {
+      const args = [];
+      const tok = stream.next();
+      while (stream.current.kind !== TokenKind.RPAREN) {
+        const func = this.tokenMap.get(stream.current.kind);
+        if (!func) {
+          throw new JSONPathSyntaxError(`unexpected '${stream.current.value}'`, stream.current);
+        }
+        args.push(func.bind(this)(stream));
+        if (stream.peek.kind !== TokenKind.RPAREN) {
+          if (stream.peek.kind === TokenKind.RBRACKET) break;
+          stream.expectPeek(TokenKind.COMMA);
+          stream.next();
+        }
+        stream.next();
+      }
+      return new FunctionExtension(tok, tok.value, this.environment.checkWellTypedness(tok, args));
+    }
+    parseFilterExpression(stream) {
+      let precedence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : PRECEDENCE_LOWEST;
+      const func = this.tokenMap.get(stream.current.kind);
+      if (!func) {
+        let msg;
+        switch (stream.current.kind) {
+          case TokenKind.EOF:
+          case TokenKind.RBRACKET:
+            msg = "end of expression";
+            break;
+          default:
+            msg = `'${stream.current.value}`;
+        }
+        throw new JSONPathSyntaxError(`unexpected ${msg}`, stream.current);
+      }
+      let left = func.bind(this)(stream);
+      for (;;) {
+        const peekKind = stream.peek.kind;
+        if (peekKind === TokenKind.EOF || peekKind === TokenKind.RBRACKET || (PRECEDENCES.get(peekKind) || PRECEDENCE_LOWEST) < precedence) {
+          break;
+        }
+        if (!BINARY_OPERATORS.has(peekKind)) return left;
+        stream.next();
+        left = this.parseInfixExpression(stream, left);
+      }
+      return left;
+    }
+    decodeString(token) {
+      let isName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      try {
+        return JSON.parse(token.kind === TokenKind.SINGLE_QUOTE_STRING ? `"${token.value.replaceAll('"', '\\"').replaceAll("\\'", "'")}"` : `"${token.value}"`);
+      } catch {
+        throw new JSONPathSyntaxError(`invalid ${isName ? "name selector" : "string literal"} '${token.value}'`, token);
+      }
+    }
+    throwForNonSingularQuery(expr) {
+      if ((expr instanceof RootQuery || expr instanceof RelativeQuery) && !expr.path.singularQuery()) {
+        throw new JSONPathSyntaxError("non-singular query is not comparable", expr.token);
+      }
+    }
+    throwForNonComparableFunction(expr) {
+      if (!(expr instanceof FunctionExtension)) return;
+      const func = this.environment.filterRegister.get(expr.name);
+      if (func && func.returnType !== FunctionExpressionType.ValueType) {
+        throw new JSONPathTypeError(`result of ${expr.name}() is not comparable`, expr.token);
+      }
+    }
+  }
+
+  /**
+   *
+   */
+
+  const defaultOptions = {
+    strict: true,
+    maxIntIndex: Math.pow(2, 53) - 1,
+    minIntIndex: -Math.pow(2, 53) - 1
+  };
+
+  /**
+   *
+   */
+  class JSONPathEnvironment {
+    /**
+     *
+     */
+    filterRegister = new Map();
+    /**
+     *
+     * @param options -
+     */
+    constructor() {
+      let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultOptions;
+      this.options = options;
+      this.parser = new Parser(this);
+      this.setupFilterFunctions();
+    }
+
+    /**
+     *
+     * @param path -
+     * @returns
+     */
+    compile(path) {
+      return new JSONPath(this, this.parser.parse(new TokenStream(tokenize(path))));
+    }
+
+    /**
+     *
+     * @param path -
+     * @param value -
+     * @returns
+     */
+    query(path, value) {
+      return this.compile(path).query(value);
+    }
+    setupFilterFunctions() {
+      this.filterRegister.set("count", new Count());
+      this.filterRegister.set("length", new Length());
+      this.filterRegister.set("search", new Search());
+      this.filterRegister.set("match", new Match());
+      this.filterRegister.set("value", new Value());
+    }
+
+    /**
+     *
+     * @param token -
+     * @param args -
+     */
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    checkWellTypedness(token, args) {
+      const func = this.filterRegister.get(token.value);
+      if (!func) {
+        throw new UndefinedFilterFunctionError(`no such function '${token.value}'`, token);
+      }
+
+      // Correct number of arguments
+      if (args.length !== func.argTypes.length) {
+        throw new JSONPathTypeError(`${token.value}() takes ${func.argTypes.length} argument${func.argTypes.length === 1 ? "" : "s"}, ${args.length} given`, token);
+      }
+
+      // Argument types
+      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 JSONPathQuery && arg.path.singularQuery())) {
+              throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of ValueType`, arg.token);
+            }
+            break;
+          case FunctionExpressionType.LogicalType:
+            if (!(arg instanceof BooleanLiteral)) {
+              throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of LogicalType`, arg.token);
+            }
+            break;
+          case FunctionExpressionType.NodesType:
+            if (!(arg instanceof JSONPathQuery)) {
+              throw new JSONPathTypeError(`${token.value}() argument ${idx} must be of NodesType`, arg.token);
+            }
+        }
+      }
+      return args;
+    }
+  }
+
+  var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Count: Count,
+    FunctionExpressionType: FunctionExpressionType,
+    Length: Length,
+    Match: Match,
+    Search: Search,
+    Value: Value
+  });
+
+  const DEFAULT_ENVIRONMENT = new JSONPathEnvironment();
+
+  /**
+   * Query JSON value _value_ with JSONPath expression _path_.
+   * @param path - A JSONPath expression/query.
+   * @param value - The JSON-like value the JSONPath query is applied to.
+   * @returns A list of JSONPathNode objects, one for each value matched
+   *  by _path_ in _value_.
+   *
+   * @throws {@link JSONPathSyntaxError}
+   * If the path does not conform to standard syntax.
+   *
+   * @throws {@link JSONPathTypeError}
+   * If filter function arguments are invalid, or filter expression are
+   * used in an invalid way.
+   */
+  function query(path, value) {
+    return DEFAULT_ENVIRONMENT.query(path, value);
+  }
+
+  /**
+   * Compile JSONPath _path_ for later use.
+   * @param path - A JSONPath expression/query.
+   * @returns A path object with a `query()` method.
+   *
+   * @throws {@link JSONPathSyntaxError}
+   * If the path does not conform to standard syntax.
+   *
+   * @throws {@link JSONPathTypeError}
+   * If filter function arguments are invalid, or filter expression are
+   * used in an invalid way.
+   */
+  function compile(path) {
+    return DEFAULT_ENVIRONMENT.compile(path);
+  }
+
+  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,
+    JSONPathSyntaxError: JSONPathSyntaxError,
+    JSONPathTypeError: JSONPathTypeError,
+    Nothing: Nothing,
+    Token: Token,
+    TokenKind: TokenKind,
+    compile: compile,
+    expressions: expression,
+    functions: index$2,
+    query: query,
+    selectors: selectors
+  });
+
+  /**
+   * Base class for all JSON Patch errors.
+   */
+  class JSONPatchError extends Error {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPatchError";
+    }
+  }
+  class JSONPatchTestFailure extends JSONPatchError {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "JSONPatchTestFailure";
+    }
+  }
+
+  /**
+   * A JSON Patch operation.
+   */
+
+  /**
+   * The JSON Patch _add_ operation.
+   */
+  class OpAdd {
+    name = "add";
+    constructor(path, value) {
+      this.path = path;
+      this.value = value;
+    }
+    apply(value, index) {
+      const [parent, obj] = this.path.resolveWithParent(value);
+      if (parent === UNDEFINED) {
+        // Replace the root object.
+        return this.value;
+      }
+      const target = this.path.tokens.at(-1);
+      if (target === undefined) {
+        // this should not be possible
+        throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
+      } else if (isArray(parent)) {
+        if (obj === UNDEFINED) {
+          if (target === "-") {
+            parent.push(this.value);
+          } else {
+            throw new JSONPatchError(`index out of range (${this.name}:${index})`);
+          }
+        } else {
+          parent.splice(Number(target), 0, this.value);
+        }
+      } else if (isObject(parent)) {
+        parent[target] = this.value;
+      } else {
+        throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
+      }
+      return value;
+    }
+    toObject() {
+      return {
+        op: this.name,
+        path: this.path.toString(),
+        value: this.value
+      };
+    }
+  }
+
+  /**
+   * The JSON Patch _remove_ operation.
+   */
+  class OpRemove {
+    name = "remove";
+    constructor(path) {
+      this.path = path;
+    }
+    apply(value, index) {
+      const [parent, obj] = this.path.resolveWithParent(value);
+      if (parent === UNDEFINED) {
+        throw new JSONPatchError(`can't remove root (${this.name}:${index})`);
+      }
+      const target = this.path.tokens.at(-1);
+      if (target === undefined) {
+        // this should not be possible
+        throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
+      } else if (isArray(parent)) {
+        if (obj === UNDEFINED) {
+          throw new JSONPatchError(`can't remove nonexistent item (${this.name}:${index})`);
+        }
+        parent.splice(Number(target), 1);
+      } else if (isObject(parent)) {
+        if (obj === UNDEFINED) {
+          throw new JSONPatchError(`can't remove nonexistent property (${this.name}:${index})`);
+        }
+        delete parent[target];
+      } else {
+        throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
+      }
+      return value;
+    }
+    toObject() {
+      return {
+        op: this.name,
+        path: this.path.toString()
+      };
+    }
+  }
+
+  /**
+   * The JSON Patch _replace_ operation.
+   */
+  class OpReplace {
+    name = "replace";
+    constructor(path, value) {
+      this.path = path;
+      this.value = value;
+    }
+    apply(value, index) {
+      const [parent, obj] = this.path.resolveWithParent(value);
+      if (parent === UNDEFINED) {
+        // Replace the root object.
+        return this.value;
+      }
+      const target = this.path.tokens.at(-1);
+      if (target === undefined) {
+        // this should not be possible
+        throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
+      }
+      if (isArray(parent)) {
+        if (obj === UNDEFINED) {
+          throw new JSONPatchError(`can't replace nonexistent item (${this.name}:${index})`);
+        }
+        parent.splice(Number(target), 1, this.value);
+      } else if (isObject(parent)) {
+        if (obj === UNDEFINED) {
+          throw new JSONPatchError(`can't replace nonexistent property (${this.name}:${index})`);
+        }
+        parent[target] = this.value;
+      } else {
+        throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
+      }
+      return value;
+    }
+    toObject() {
+      return {
+        op: this.name,
+        path: this.path.toString(),
+        value: this.value
+      };
+    }
+  }
+
+  /**
+   * The JSON Patch _move_ operation.
+   */
+  class OpMove {
+    name = "move";
+    constructor(from, path) {
+      this.from = from;
+      this.path = path;
+    }
+    apply(value, index) {
+      if (this.path.isRelativeTo(this.from)) {
+        throw new JSONPatchError(`can't move object to one of its own children (${this.name}:${index})`);
+      }
+      const [sourceParent, sourceObj] = this.from.resolveWithParent(value);
+      if (sourceObj === UNDEFINED) {
+        throw new JSONPatchError(`source object does not exist (${this.name}:${index})`);
+      }
+      const sourceTarget = this.from.tokens.at(-1);
+      if (sourceTarget === undefined) {
+        // this should not be possible
+        throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
+      }
+      if (isArray(sourceParent)) {
+        sourceParent.splice(Number(sourceTarget), 1);
+      } else if (isObject(sourceParent)) {
+        delete sourceParent[sourceTarget];
+      }
+      const [destParent, _] = this.path.resolveWithParent(value);
+      if (destParent === UNDEFINED) {
+        // move source to root
+        return sourceObj;
+      }
+      const destTarget = this.path.tokens.at(-1);
+      if (destTarget === undefined) {
+        // this should not be possible
+        throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
+      }
+      if (isArray(destParent)) {
+        destParent.splice(Number(destTarget), 0, sourceObj);
+      } else if (isObject(destParent)) {
+        destParent[destTarget] = sourceObj;
+      } else {
+        throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
+      }
+      return value;
+    }
+    toObject() {
+      return {
+        op: this.name,
+        from: this.from.toString(),
+        path: this.path.toString()
+      };
+    }
+  }
+
+  /**
+   * The JSON Patch _copy_ operation.
+   */
+  class OpCopy {
+    name = "copy";
+    constructor(from, path) {
+      this.from = from;
+      this.path = path;
+    }
+    apply(value, index) {
+      const [_, sourceObj] = this.from.resolveWithParent(value);
+      if (sourceObj === UNDEFINED) {
+        throw new JSONPatchError(`source object does not exist (${this.name}:${index})`);
+      }
+      const [destParent] = this.path.resolveWithParent(value);
+      if (destParent === UNDEFINED) {
+        // copy source to root
+        return this.deepCopy(sourceObj);
+      }
+      const destTarget = this.path.tokens.at(-1);
+      if (destTarget === undefined) {
+        // this should not be possible
+        throw new JSONPatchError(`unexpected operation on 'undefined' (${this.name}:${index})`);
+      }
+      if (isArray(destParent)) {
+        destParent.splice(Number(destTarget), 0, this.deepCopy(sourceObj));
+      } else if (isObject(destParent)) {
+        destParent[destTarget] = this.deepCopy(sourceObj);
+      } else {
+        throw new JSONPatchError(`unexpected operation on '${typeof parent}' (${this.name}:${index})`);
+      }
+      return value;
+    }
+
+    // eslint-disable-next-line sonarjs/no-identical-functions
+    toObject() {
+      return {
+        op: this.name,
+        from: this.from.toString(),
+        path: this.path.toString()
+      };
+    }
+    deepCopy(value) {
+      return JSON.parse(JSON.stringify(value));
+    }
+  }
+
+  /**
+   * The JSON Patch _test_ operation.
+   */
+  class OpTest {
+    name = "test";
+    constructor(path, value) {
+      this.path = path;
+      this.value = value;
+    }
+    apply(value, index) {
+      const [_, obj] = this.path.resolveWithParent(value);
+      if (!deepEquals(obj, this.value)) {
+        throw new JSONPatchTestFailure(`test failed (${this.name}:${index})`);
+      }
+      return value;
+    }
+    toObject() {
+      return {
+        op: this.name,
+        path: this.path.toString(),
+        value: this.value
+      };
+    }
+  }
+
+  /**
+   *
+   */
+  class JSONPatch {
+    ops = [];
+
+    /**
+     *
+     * @param ops -
+     */
+    constructor(ops) {
+      if (ops) {
+        this.build(ops);
+      }
+    }
+
+    /**
+     *
+     * @param path -
+     * @param value -
+     * @returns
+     */
+    add(path, value) {
+      this.ops.push(new OpAdd(this.ensurePointer(path, "add", this.ops.length), value));
+      return this;
+    }
+
+    /**
+     *
+     * @param path -
+     */
+    remove(path) {
+      this.ops.push(new OpRemove(this.ensurePointer(path, "remove", this.ops.length)));
+      return this;
+    }
+
+    /**
+     *
+     * @param path -
+     * @param value -
+     * @returns
+     */
+    replace(path, value) {
+      this.ops.push(new OpReplace(this.ensurePointer(path, "replace", this.ops.length), value));
+      return this;
+    }
+
+    /**
+     *
+     * @param from -
+     * @param path -
+     * @returns
+     */
+    move(from, path) {
+      this.ops.push(new OpMove(this.ensurePointer(from, "move", this.ops.length), this.ensurePointer(path, "move", this.ops.length)));
+      return this;
+    }
+    /**
+     *
+     * @param from -
+     * @param path -
+     * @returns
+     */
+    copy(from, path) {
+      this.ops.push(new OpCopy(this.ensurePointer(from, "copy", this.ops.length), this.ensurePointer(path, "copy", this.ops.length)));
+      return this;
+    }
+
+    /**
+     *
+     * @param path -
+     * @param value -
+     * @returns
+     */
+    test(path, value) {
+      this.ops.push(new OpTest(this.ensurePointer(path, "test", this.ops.length), value));
+      return this;
+    }
+
+    /**
+     *
+     * @param value -
+     */
+    apply(value) {
+      let _value = value;
+      for (let i = 0; i < this.ops.length; i++) {
+        const op = this.ops[i];
+        try {
+          _value = op.apply(_value, i);
+        } catch (error) {
+          if (error instanceof JSONPointerResolutionError) {
+            throw new JSONPatchError(`${error.message} (${op.name}:${i})`);
+          }
+          throw error;
+        }
+      }
+      return _value;
+    }
+
+    /**
+     *
+     * @returns
+     */
+    toArray() {
+      return this.ops.map(op => op.toObject());
+    }
+    build(ops) {
+      for (let i = 0; i < ops.length; i++) {
+        const operation = ops[i];
+        switch (operation.op) {
+          case "add":
+            this.add(this.opPointer(operation, "path", "add", i), this.opValue(operation, "value", "add", i));
+            break;
+          case "remove":
+            this.remove(this.opPointer(operation, "path", "remove", i));
+            break;
+          case "replace":
+            this.replace(this.opPointer(operation, "path", "replace", i), this.opValue(operation, "value", "replace", i));
+            break;
+          case "move":
+            this.move(this.opPointer(operation, "from", "move", i), this.opPointer(operation, "path", "move", i));
+            break;
+          case "copy":
+            this.copy(this.opPointer(operation, "from", "copy", i), this.opPointer(operation, "path", "copy", i));
+            break;
+          case "test":
+            this.test(this.opPointer(operation, "path", "test", i), this.opValue(operation, "value", "test", i));
+            break;
+          default:
+            throw new JSONPatchError(`expected 'op' to be one of 'add', 'remove', 'replace', 'move', 'copy' or 'test' (${operation.op}:${i})`);
+        }
+      }
+    }
+    opPointer(opObj, key, op, index) {
+      if (!Object.hasOwn(opObj, key)) {
+        throw new JSONPatchError(`missing property '${key}' (${op}:${index})`);
+      }
+      const p = opObj[key];
+      if (!isString(p)) {
+        throw new JSONPatchError(`expected a JSON Pointer string for '${key}', found ${typeof p} (${op}:${index})`);
+      }
+      try {
+        return new JSONPointer(p);
+      } catch (error) {
+        if (error instanceof JSONPointerError) {
+          throw new JSONPatchError(`${error.message} (${op}:${index})`);
+        }
+        throw error;
+      }
+    }
+    opValue(opObj, key, op, index) {
+      if (!Object.hasOwn(opObj, key)) {
+        throw new JSONPatchError(`missing property '${key}' (${op}:${index})`);
+      }
+      return opObj[key];
+    }
+    ensurePointer(p, op, index) {
+      if (p instanceof JSONPointer) {
+        return p;
+      }
+      if (!isString(p)) {
+        throw new JSONPatchError(`expected a JSON Pointer string, found ${typeof p} (${op}:${index})`);
+      }
+      try {
+        return new JSONPointer(p);
+      } catch (error) {
+        if (error instanceof JSONPointerError) {
+          throw new JSONPatchError(`${error.message} (${op}:${index})`);
+        }
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Apply the JSON Patch _patch_ to JSON-like data _value_.
+   * @param ops - JSON Patch operations following RFC 6902.
+   * @param value - The target JSON-like document to patch.
+   */
+  function apply(ops, value) {
+    return new JSONPatch(ops).apply(value);
+  }
+
+  var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    JSONPatch: JSONPatch,
+    JSONPatchError: JSONPatchError,
+    JSONPatchTestFailure: JSONPatchTestFailure,
+    apply: apply
+  });
+
+  const version = "0.1.0";
+
+  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.JSONPathSyntaxError = JSONPathSyntaxError;
+  exports.JSONPathTypeError = JSONPathTypeError;
+  exports.JSONPointer = JSONPointer;
+  exports.Nothing = Nothing;
+  exports.Token = Token;
+  exports.TokenKind = TokenKind;
+  exports.UNDEFINED = UNDEFINED;
+  exports.apply = apply;
+  exports.compile = compile;
+  exports.jsonpatch = index;
+  exports.jsonpath = index$1;
+  exports.jsonpointer = index$3;
+  exports.query = query;
+  exports.resolve = resolve;
+  exports.version = version;
+
+  return exports;
+
+})({});