python-jsonpath 1.3.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

jsonpath/parse.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING
 from typing import Callable
 from typing import Dict
 from typing import Iterable
+from typing import Iterator
 from typing import List
 from typing import Optional
 from typing import Union
@@ -22,41 +23,45 @@ from .filter import FALSE
 from .filter import NIL
 from .filter import TRUE
 from .filter import UNDEFINED_LITERAL
-from .filter import BooleanExpression
+from .filter import BaseExpression
 from .filter import FilterContextPath
 from .filter import FilterExpression
+from .filter import FilterExpressionLiteral
+from .filter import FilterQuery
 from .filter import FloatLiteral
 from .filter import FunctionExtension
 from .filter import InfixExpression
 from .filter import IntegerLiteral
 from .filter import ListLiteral
-from .filter import Literal
 from .filter import Nil
-from .filter import Path
 from .filter import PrefixExpression
 from .filter import RegexLiteral
-from .filter import RootPath
-from .filter import SelfPath
+from .filter import RelativeFilterQuery
+from .filter import RootFilterQuery
 from .filter import StringLiteral
 from .path import JSONPath
+from .segments import JSONPathChildSegment
+from .segments import JSONPathRecursiveDescentSegment
+from .segments import JSONPathSegment
 from .selectors import Filter
 from .selectors import IndexSelector
 from .selectors import JSONPathSelector
+from .selectors import KeySelector
+from .selectors import KeysFilter
 from .selectors import KeysSelector
-from .selectors import ListSelector
-from .selectors import PropertySelector
-from .selectors import RecursiveDescentSelector
+from .selectors import NameSelector
+from .selectors import SingularQuerySelector
 from .selectors import SliceSelector
-from .selectors import WildSelector
+from .selectors import WildcardSelector
 from .token import TOKEN_AND
-from .token import TOKEN_BARE_PROPERTY
+from .token import TOKEN_COLON
 from .token import TOKEN_COMMA
 from .token import TOKEN_CONTAINS
 from .token import TOKEN_DDOT
+from .token import TOKEN_DOT
 from .token import TOKEN_DOUBLE_QUOTE_STRING
 from .token import TOKEN_EOF
 from .token import TOKEN_EQ
-from .token import TOKEN_FAKE_ROOT
 from .token import TOKEN_FALSE
 from .token import TOKEN_FILTER
 from .token import TOKEN_FILTER_CONTEXT
@@ -68,20 +73,23 @@ from .token import TOKEN_IN
 from .token import TOKEN_INT
 from .token import TOKEN_INTERSECTION
 from .token import TOKEN_KEY
+from .token import TOKEN_KEY_NAME
 from .token import TOKEN_KEYS
+from .token import TOKEN_KEYS_FILTER
+from .token import TOKEN_LBRACKET
 from .token import TOKEN_LE
 from .token import TOKEN_LG
-from .token import TOKEN_LIST_START
 from .token import TOKEN_LPAREN
 from .token import TOKEN_LT
 from .token import TOKEN_MISSING
+from .token import TOKEN_NAME
 from .token import TOKEN_NE
 from .token import TOKEN_NIL
 from .token import TOKEN_NONE
 from .token import TOKEN_NOT
 from .token import TOKEN_NULL
 from .token import TOKEN_OR
-from .token import TOKEN_PROPERTY
+from .token import TOKEN_PSEUDO_ROOT
 from .token import TOKEN_RBRACKET
 from .token import TOKEN_RE
 from .token import TOKEN_RE_FLAGS
@@ -90,14 +98,13 @@ from .token import TOKEN_ROOT
 from .token import TOKEN_RPAREN
 from .token import TOKEN_SELF
 from .token import TOKEN_SINGLE_QUOTE_STRING
-from .token import TOKEN_SLICE_START
-from .token import TOKEN_SLICE_STEP
-from .token import TOKEN_SLICE_STOP
 from .token import TOKEN_TRUE
 from .token import TOKEN_UNDEFINED
 from .token import TOKEN_UNION
+from .token import TOKEN_WHITESPACE
 from .token import TOKEN_WILD
 from .token import Token
+from .unescape import unescape_string
 
 if TYPE_CHECKING:
     from .env import JSONPathEnvironment
@@ -145,7 +152,6 @@ class Parser:
     """A JSONPath parser bound to a JSONPathEnvironment."""
 
     PRECEDENCE_LOWEST = 1
-    PRECEDENCE_LOGICALRIGHT = 2
     PRECEDENCE_LOGICAL_OR = 3
     PRECEDENCE_LOGICAL_AND = 4
     PRECEDENCE_RELATIONAL = 5
@@ -234,16 +240,16 @@ class Parser:
     def __init__(self, *, env: JSONPathEnvironment) -> None:
         self.env = env
 
-        self.token_map: Dict[str, Callable[[TokenStream], FilterExpression]] = {
+        self.token_map: Dict[str, Callable[[TokenStream], BaseExpression]] = {
             TOKEN_DOUBLE_QUOTE_STRING: self.parse_string_literal,
-            TOKEN_FAKE_ROOT: self.parse_root_path,
+            TOKEN_PSEUDO_ROOT: self.parse_absolute_query,
             TOKEN_FALSE: self.parse_boolean,
             TOKEN_FILTER_CONTEXT: self.parse_filter_context_path,
             TOKEN_FLOAT: self.parse_float_literal,
             TOKEN_FUNCTION: self.parse_function_extension,
             TOKEN_INT: self.parse_integer_literal,
             TOKEN_KEY: self.parse_current_key,
-            TOKEN_LIST_START: self.parse_list_literal,
+            TOKEN_LBRACKET: self.parse_list_literal,
             TOKEN_LPAREN: self.parse_grouped_expression,
             TOKEN_MISSING: self.parse_undefined,
             TOKEN_NIL: self.parse_nil,
@@ -251,14 +257,14 @@ class Parser:
             TOKEN_NOT: self.parse_prefix_expression,
             TOKEN_NULL: self.parse_nil,
             TOKEN_RE_PATTERN: self.parse_regex,
-            TOKEN_ROOT: self.parse_root_path,
-            TOKEN_SELF: self.parse_self_path,
+            TOKEN_ROOT: self.parse_absolute_query,
+            TOKEN_SELF: self.parse_relative_query,
             TOKEN_SINGLE_QUOTE_STRING: self.parse_string_literal,
             TOKEN_TRUE: self.parse_boolean,
             TOKEN_UNDEFINED: self.parse_undefined,
         }
 
-        self.list_item_map: Dict[str, Callable[[TokenStream], FilterExpression]] = {
+        self.list_item_map: Dict[str, Callable[[TokenStream], BaseExpression]] = {
             TOKEN_FALSE: self.parse_boolean,
             TOKEN_FLOAT: self.parse_float_literal,
             TOKEN_INT: self.parse_integer_literal,
@@ -271,10 +277,10 @@ class Parser:
         }
 
         self.function_argument_map: Dict[
-            str, Callable[[TokenStream], FilterExpression]
+            str, Callable[[TokenStream], BaseExpression]
         ] = {
             TOKEN_DOUBLE_QUOTE_STRING: self.parse_string_literal,
-            TOKEN_FAKE_ROOT: self.parse_root_path,
+            TOKEN_PSEUDO_ROOT: self.parse_absolute_query,
             TOKEN_FALSE: self.parse_boolean,
             TOKEN_FILTER_CONTEXT: self.parse_filter_context_path,
             TOKEN_FLOAT: self.parse_float_literal,
@@ -284,212 +290,291 @@ class Parser:
             TOKEN_NIL: self.parse_nil,
             TOKEN_NONE: self.parse_nil,
             TOKEN_NULL: self.parse_nil,
-            TOKEN_ROOT: self.parse_root_path,
-            TOKEN_SELF: self.parse_self_path,
+            TOKEN_ROOT: self.parse_absolute_query,
+            TOKEN_SELF: self.parse_relative_query,
             TOKEN_SINGLE_QUOTE_STRING: self.parse_string_literal,
             TOKEN_TRUE: self.parse_boolean,
         }
 
-    def parse(self, stream: TokenStream) -> Iterable[JSONPathSelector]:
-        """Parse a JSONPath from a stream of tokens."""
-        if stream.current.kind in {TOKEN_ROOT, TOKEN_FAKE_ROOT}:
-            stream.next_token()
-        yield from self.parse_path(stream, in_filter=False)
+    def parse(self, stream: TokenStream) -> Iterator[JSONPathSegment]:
+        """Parse a JSONPath query from a stream of tokens."""
+        # Leading whitespace is not allowed in strict mode.
+        if stream.skip_whitespace() and self.env.strict:
+            raise JSONPathSyntaxError(
+                "unexpected leading whitespace", token=stream.current()
+            )
+
+        # Trailing whitespace is not allowed in strict mode.
+        if (
+            self.env.strict
+            and stream.tokens
+            and stream.tokens[-1].kind == TOKEN_WHITESPACE
+        ):
+            raise JSONPathSyntaxError(
+                "unexpected trailing whitespace", token=stream.tokens[-1]
+            )
+
+        token = stream.current()
+
+        if token.kind == TOKEN_ROOT or (
+            token.kind == TOKEN_PSEUDO_ROOT and not self.env.strict
+        ):
+            stream.next()
+        elif self.env.strict:
+            # Raises a syntax error because the current token is not TOKEN_ROOT.
+            stream.expect(TOKEN_ROOT)
 
-        if stream.current.kind not in (TOKEN_EOF, TOKEN_INTERSECTION, TOKEN_UNION):
+        yield from self.parse_query(stream)
+
+        if stream.current().kind not in (TOKEN_EOF, TOKEN_INTERSECTION, TOKEN_UNION):
             raise JSONPathSyntaxError(
-                f"unexpected token {stream.current.value!r}",
-                token=stream.current,
+                f"unexpected token {stream.current().value!r}",
+                token=stream.current(),
             )
 
-    def parse_path(
-        self,
-        stream: TokenStream,
-        *,
-        in_filter: bool = False,
-    ) -> Iterable[JSONPathSelector]:
-        """Parse a top-level JSONPath, or one that is nested in a filter."""
+    def parse_query(self, stream: TokenStream) -> Iterable[JSONPathSegment]:
+        """Parse a JSONPath query string.
+
+        This method assumes the root, current or pseudo root identifier has
+        already been consumed.
+        """
+        if not self.env.strict and stream.current().kind in {
+            TOKEN_NAME,
+            TOKEN_WILD,
+            TOKEN_KEYS,
+            TOKEN_KEY_NAME,
+        }:
+            # A non-standard "bare" path. One that starts with a shorthand selector
+            # without a leading identifier (`$`, `@`, `^` or `_`).
+            #
+            # When no identifier is given, a root query (`$`) is assumed.
+            token = stream.current()
+            selector = self.parse_shorthand_selector(stream)
+            yield JSONPathChildSegment(env=self.env, token=token, selectors=(selector,))
+
         while True:
-            if stream.current.kind in (TOKEN_PROPERTY, TOKEN_BARE_PROPERTY):
-                yield PropertySelector(
-                    env=self.env,
-                    token=stream.current,
-                    name=stream.current.value,
-                    shorthand=True,
-                )
-            elif stream.current.kind == TOKEN_SLICE_START:
-                yield self.parse_slice(stream)
-            elif stream.current.kind == TOKEN_WILD:
-                yield WildSelector(
-                    env=self.env,
-                    token=stream.current,
-                    shorthand=True,
+            stream.skip_whitespace()
+            token = stream.next()
+
+            if token.kind == TOKEN_DOT:
+                selector = self.parse_shorthand_selector(stream)
+                yield JSONPathChildSegment(
+                    env=self.env, token=token, selectors=(selector,)
                 )
-            elif stream.current.kind == TOKEN_KEYS:
-                yield KeysSelector(
-                    env=self.env,
-                    token=stream.current,
-                    shorthand=True,
+            elif token.kind == TOKEN_DDOT:
+                if stream.current().kind == TOKEN_LBRACKET:
+                    selectors = tuple(self.parse_bracketed_selection(stream))
+                else:
+                    selectors = (self.parse_shorthand_selector(stream),)
+
+                yield JSONPathRecursiveDescentSegment(
+                    env=self.env, token=token, selectors=selectors
                 )
-            elif stream.current.kind == TOKEN_DDOT:
-                yield RecursiveDescentSelector(
+            elif token.kind == TOKEN_LBRACKET:
+                stream.pos -= 1
+                yield JSONPathChildSegment(
                     env=self.env,
-                    token=stream.current,
+                    token=token,
+                    selectors=tuple(self.parse_bracketed_selection(stream)),
                 )
-            elif stream.current.kind == TOKEN_LIST_START:
-                yield self.parse_selector_list(stream)
+            elif token.kind == TOKEN_EOF:
+                break
             else:
-                if in_filter:
-                    stream.push(stream.current)
+                # An embedded query. Put the token back on the stream.
+                stream.pos -= 1
                 break
 
-            stream.next_token()
+    def parse_shorthand_selector(self, stream: TokenStream) -> JSONPathSelector:
+        token = stream.next()
 
-    def parse_slice(self, stream: TokenStream) -> SliceSelector:
-        """Parse a slice JSONPath expression from a stream of tokens."""
-        start_token = stream.next_token()
-        stream.expect(TOKEN_SLICE_STOP)
-        stop_token = stream.next_token()
-        stream.expect(TOKEN_SLICE_STEP)
-        step_token = stream.current
-
-        if not start_token.value:
-            start: Optional[int] = None
-        else:
-            start = int(start_token.value)
-
-        if not stop_token.value:
-            stop: Optional[int] = None
-        else:
-            stop = int(stop_token.value)
-
-        if not step_token.value:
-            step: Optional[int] = None
-        else:
-            step = int(step_token.value)
+        if token.kind == TOKEN_NAME:
+            return NameSelector(
+                env=self.env,
+                token=token,
+                name=token.value,
+            )
 
-        return SliceSelector(
-            env=self.env,
-            token=start_token,
-            start=start,
-            stop=stop,
-            step=step,
-        )
+        if token.kind == TOKEN_KEY_NAME:
+            return KeySelector(
+                env=self.env,
+                token=token,
+                key=token.value,
+            )
 
-    def parse_selector_list(self, stream: TokenStream) -> ListSelector:  # noqa: PLR0912
-        """Parse a comma separated list JSONPath selectors from a stream of tokens."""
-        tok = stream.next_token()
-        list_items: List[
-            Union[
-                IndexSelector,
-                KeysSelector,
-                PropertySelector,
-                SliceSelector,
-                WildSelector,
-                Filter,
-            ]
-        ] = []
-
-        while stream.current.kind != TOKEN_RBRACKET:
-            if stream.current.kind == TOKEN_INT:
-                if (
-                    len(stream.current.value) > 1
-                    and stream.current.value.startswith("0")
-                ) or stream.current.value.startswith("-0"):
-                    raise JSONPathSyntaxError(
-                        "leading zero in index selector", token=stream.current
-                    )
-                list_items.append(
-                    IndexSelector(
-                        env=self.env,
-                        token=stream.current,
-                        index=int(stream.current.value),
-                    )
-                )
-            elif stream.current.kind == TOKEN_BARE_PROPERTY:
-                list_items.append(
-                    PropertySelector(
-                        env=self.env,
-                        token=stream.current,
-                        name=stream.current.value,
-                        shorthand=False,
-                    ),
+        if token.kind == TOKEN_WILD:
+            return WildcardSelector(
+                env=self.env,
+                token=token,
+            )
+
+        if token.kind == TOKEN_KEYS:
+            if stream.current().kind == TOKEN_NAME:
+                return KeySelector(
+                    env=self.env,
+                    token=token,
+                    key=self._decode_string_literal(stream.next()),
                 )
-            elif stream.current.kind == TOKEN_KEYS:
-                list_items.append(
-                    KeysSelector(
-                        env=self.env,
-                        token=stream.current,
-                        shorthand=False,
+
+            return KeysSelector(
+                env=self.env,
+                token=token,
+            )
+
+        raise JSONPathSyntaxError("expected a shorthand selector", token=token)
+
+    def parse_bracketed_selection(self, stream: TokenStream) -> List[JSONPathSelector]:  # noqa: PLR0912, PLR0915
+        segment_token = stream.eat(TOKEN_LBRACKET)
+        selectors: List[JSONPathSelector] = []
+
+        while True:
+            stream.skip_whitespace()
+            token = stream.current()
+
+            if token.kind == TOKEN_RBRACKET:
+                break
+
+            if token.kind == TOKEN_INT:
+                if (
+                    stream.peek().kind == TOKEN_COLON
+                    or stream.peek(2).kind == TOKEN_COLON
+                ):
+                    selectors.append(self.parse_slice(stream))
+                else:
+                    self._raise_for_leading_zero(token)
+                    selectors.append(
+                        IndexSelector(
+                            env=self.env,
+                            token=token,
+                            index=int(token.value),
+                        )
                     )
-                )
-            elif stream.current.kind in (
+                    stream.next()
+            elif token.kind in (
                 TOKEN_DOUBLE_QUOTE_STRING,
                 TOKEN_SINGLE_QUOTE_STRING,
             ):
-                if self.RE_INVALID_NAME_SELECTOR.search(stream.current.value):
-                    raise JSONPathSyntaxError(
-                        f"invalid name selector {stream.current.value!r}",
-                        token=stream.current,
-                    )
-
-                list_items.append(
-                    PropertySelector(
+                selectors.append(
+                    NameSelector(
                         env=self.env,
-                        token=stream.current,
-                        name=self._decode_string_literal(stream.current),
-                        shorthand=False,
+                        token=token,
+                        name=self._decode_string_literal(token),
                     ),
                 )
-            elif stream.current.kind == TOKEN_SLICE_START:
-                list_items.append(self.parse_slice(stream))
-            elif stream.current.kind == TOKEN_WILD:
-                list_items.append(
-                    WildSelector(
-                        env=self.env,
-                        token=stream.current,
-                        shorthand=False,
+                stream.next()
+            elif token.kind == TOKEN_COLON:
+                selectors.append(self.parse_slice(stream))
+            elif token.kind == TOKEN_WILD:
+                selectors.append(WildcardSelector(env=self.env, token=token))
+                stream.next()
+            elif token.kind == TOKEN_KEYS:
+                stream.eat(TOKEN_KEYS)
+                if stream.current().kind in (
+                    TOKEN_DOUBLE_QUOTE_STRING,
+                    TOKEN_SINGLE_QUOTE_STRING,
+                ):
+                    selectors.append(
+                        KeySelector(
+                            env=self.env,
+                            token=token,
+                            key=self._decode_string_literal(stream.next()),
+                        )
                     )
-                )
-            elif stream.current.kind == TOKEN_FILTER:
-                list_items.append(self.parse_filter(stream))
-            elif stream.current.kind == TOKEN_EOF:
-                raise JSONPathSyntaxError(
-                    "unexpected end of query", token=stream.current
-                )
+                else:
+                    selectors.append(KeysSelector(env=self.env, token=token))
+
+            elif token.kind == TOKEN_FILTER:
+                selectors.append(self.parse_filter_selector(stream))
+            elif token.kind == TOKEN_KEYS_FILTER:
+                selectors.append(self.parse_filter_selector(stream, keys=True))
+            elif token.kind in (TOKEN_ROOT, TOKEN_NAME):
+                selectors.append(self.parse_singular_query_selector(stream))
+            elif token.kind == TOKEN_EOF:
+                raise JSONPathSyntaxError("unexpected end of query", token=token)
             else:
                 raise JSONPathSyntaxError(
-                    f"unexpected token in bracketed selection {stream.current.kind!r}",
-                    token=stream.current,
+                    f"unexpected token in bracketed selection {token.kind!r}",
+                    token=token,
                 )
 
-            if stream.peek.kind == TOKEN_EOF:
+            stream.skip_whitespace()
+
+            if stream.current().kind == TOKEN_EOF:
                 raise JSONPathSyntaxError(
-                    "unexpected end of selector list",
-                    token=stream.current,
+                    "unexpected end of segment",
+                    token=stream.current(),
                 )
 
-            if stream.peek.kind != TOKEN_RBRACKET:
-                # TODO: error message .. expected a comma or logical operator
-                stream.expect_peek(TOKEN_COMMA)
-                stream.next_token()
-
-                if stream.peek.kind == TOKEN_RBRACKET:
+            if stream.current().kind != TOKEN_RBRACKET:
+                stream.eat(TOKEN_COMMA)
+                stream.skip_whitespace()
+                if stream.current().kind == TOKEN_RBRACKET:
                     raise JSONPathSyntaxError(
-                        "unexpected trailing comma",
-                        token=stream.peek,
+                        "unexpected trailing comma", token=stream.current()
                     )
 
-            stream.next_token()
+        stream.eat(TOKEN_RBRACKET)
+
+        if not selectors:
+            raise JSONPathSyntaxError("empty bracketed segment", token=segment_token)
+
+        return selectors
 
-        if not list_items:
-            raise JSONPathSyntaxError("empty bracketed segment", token=tok)
+    def parse_slice(self, stream: TokenStream) -> SliceSelector:
+        """Parse a slice JSONPath expression from a stream of tokens."""
+        token = stream.current()
+        start: Optional[int] = None
+        stop: Optional[int] = None
+        step: Optional[int] = None
+
+        def _maybe_index(token: Token) -> bool:
+            if token.kind == TOKEN_INT:
+                if len(token.value) > 1 and token.value.startswith(("0", "-0")):
+                    raise JSONPathSyntaxError(
+                        f"invalid index {token.value!r}", token=token
+                    )
+                return True
+            return False
+
+        # 1: or :
+        if _maybe_index(stream.current()):
+            start = int(stream.current().value)
+            stream.next()
+
+        stream.skip_whitespace()
+        stream.expect(TOKEN_COLON)
+        stream.next()
+        stream.skip_whitespace()
+
+        # 1 or 1: or : or ?
+        if _maybe_index(stream.current()):
+            stop = int(stream.current().value)
+            stream.next()
+            stream.skip_whitespace()
+            if stream.current().kind == TOKEN_COLON:
+                stream.next()
+        elif stream.current().kind == TOKEN_COLON:
+            stream.expect(TOKEN_COLON)
+            stream.next()
+
+        # 1 or ?
+        stream.skip_whitespace()
+        if _maybe_index(stream.current()):
+            step = int(stream.current().value)
+            stream.next()
 
-        return ListSelector(env=self.env, token=tok, items=list_items)
+        return SliceSelector(
+            env=self.env,
+            token=token,
+            start=start,
+            stop=stop,
+            step=step,
+        )
 
-    def parse_filter(self, stream: TokenStream) -> Filter:
-        tok = stream.next_token()
-        expr = self.parse_filter_selector(stream)
+    def parse_filter_selector(
+        self, stream: TokenStream, *, keys: bool = False
+    ) -> Union[Filter, KeysFilter]:
+        token = stream.next()
+        expr = self.parse_filter_expression(stream)
 
         if self.env.well_typed and isinstance(expr, FunctionExtension):
             func = self.env.function_extensions.get(expr.name)
@@ -499,236 +584,291 @@ class Parser:
                 and func.return_type == ExpressionType.VALUE
             ):
                 raise JSONPathTypeError(
-                    f"result of {expr.name}() must be compared", token=tok
+                    f"result of {expr.name}() must be compared", token=token
                 )
 
-        if isinstance(expr, (Literal, Nil)):
+        if isinstance(expr, (FilterExpressionLiteral, Nil)):
             raise JSONPathSyntaxError(
                 "filter expression literals outside of "
                 "function expressions must be compared",
-                token=tok,
+                token=token,
             )
 
-        return Filter(env=self.env, token=tok, expression=BooleanExpression(expr))
+        if keys:
+            return KeysFilter(
+                env=self.env, token=token, expression=FilterExpression(expr)
+            )
+
+        return Filter(env=self.env, token=token, expression=FilterExpression(expr))
 
-    def parse_boolean(self, stream: TokenStream) -> FilterExpression:
-        if stream.current.kind == TOKEN_TRUE:
+    def parse_boolean(self, stream: TokenStream) -> BaseExpression:
+        if stream.next().kind == TOKEN_TRUE:
             return TRUE
         return FALSE
 
-    def parse_nil(self, _: TokenStream) -> FilterExpression:
+    def parse_nil(self, stream: TokenStream) -> BaseExpression:
+        stream.next()
         return NIL
 
-    def parse_undefined(self, _: TokenStream) -> FilterExpression:
+    def parse_undefined(self, stream: TokenStream) -> BaseExpression:
+        stream.next()
         return UNDEFINED_LITERAL
 
-    def parse_string_literal(self, stream: TokenStream) -> FilterExpression:
-        return StringLiteral(value=self._decode_string_literal(stream.current))
+    def parse_string_literal(self, stream: TokenStream) -> BaseExpression:
+        return StringLiteral(value=self._decode_string_literal(stream.next()))
+
+    def parse_integer_literal(self, stream: TokenStream) -> BaseExpression:
+        token = stream.next()
+        value = token.value
+
+        if self.env.strict and value.startswith("0") and len(value) > 1:
+            raise JSONPathSyntaxError("invalid integer literal", token=token)
 
-    def parse_integer_literal(self, stream: TokenStream) -> FilterExpression:
         # Convert to float first to handle scientific notation.
-        return IntegerLiteral(value=int(float(stream.current.value)))
+        return IntegerLiteral(value=int(float(value)))
+
+    def parse_float_literal(self, stream: TokenStream) -> BaseExpression:
+        token = stream.next()
+        value = token.value
 
-    def parse_float_literal(self, stream: TokenStream) -> FilterExpression:
-        return FloatLiteral(value=float(stream.current.value))
+        if value.startswith("0") and len(value.split(".")[0]) > 1:
+            raise JSONPathSyntaxError("invalid float literal", token=token)
 
-    def parse_prefix_expression(self, stream: TokenStream) -> FilterExpression:
-        tok = stream.next_token()
-        assert tok.kind == TOKEN_NOT
+        return FloatLiteral(value=float(value))
+
+    def parse_prefix_expression(self, stream: TokenStream) -> BaseExpression:
+        token = stream.next()
+        assert token.kind == TOKEN_NOT
         return PrefixExpression(
             operator="!",
-            right=self.parse_filter_selector(stream, precedence=self.PRECEDENCE_PREFIX),
+            right=self.parse_filter_expression(
+                stream, precedence=self.PRECEDENCE_PREFIX
+            ),
         )
 
     def parse_infix_expression(
-        self, stream: TokenStream, left: FilterExpression
-    ) -> FilterExpression:
-        tok = stream.next_token()
-        precedence = self.PRECEDENCES.get(tok.kind, self.PRECEDENCE_LOWEST)
-        right = self.parse_filter_selector(stream, precedence)
-        operator = self.BINARY_OPERATORS[tok.kind]
+        self, stream: TokenStream, left: BaseExpression
+    ) -> BaseExpression:
+        token = stream.next()
+        precedence = self.PRECEDENCES.get(token.kind, self.PRECEDENCE_LOWEST)
+        right = self.parse_filter_expression(stream, precedence)
+        operator = self.BINARY_OPERATORS[token.kind]
 
         if self.env.well_typed and operator in self.COMPARISON_OPERATORS:
-            self._raise_for_non_comparable_function(left, tok)
-            self._raise_for_non_comparable_function(right, tok)
+            self._raise_for_non_comparable_function(left, token)
+            self._raise_for_non_comparable_function(right, token)
 
         if operator not in self.INFIX_LITERAL_OPERATORS:
-            if isinstance(left, (Literal, Nil)):
+            if isinstance(left, (FilterExpressionLiteral, Nil)):
                 raise JSONPathSyntaxError(
                     "filter expression literals outside of "
                     "function expressions must be compared",
-                    token=tok,
+                    token=token,
                 )
-            if isinstance(right, (Literal, Nil)):
+            if isinstance(right, (FilterExpressionLiteral, Nil)):
                 raise JSONPathSyntaxError(
                     "filter expression literals outside of "
                     "function expressions must be compared",
-                    token=tok,
+                    token=token,
                 )
 
         return InfixExpression(left, operator, right)
 
-    def parse_grouped_expression(self, stream: TokenStream) -> FilterExpression:
-        stream.next_token()
-        expr = self.parse_filter_selector(stream)
-        stream.next_token()
+    def parse_grouped_expression(self, stream: TokenStream) -> BaseExpression:
+        _token = stream.eat(TOKEN_LPAREN)
+        expr = self.parse_filter_expression(stream)
 
-        while stream.current.kind != TOKEN_RPAREN:
-            if stream.current.kind == TOKEN_EOF:
-                raise JSONPathSyntaxError(
-                    "unbalanced parentheses", token=stream.current
-                )
-
-            if stream.current.kind not in self.BINARY_OPERATORS:
-                raise JSONPathSyntaxError(
-                    f"expected an expression, found '{stream.current.value}'",
-                    token=stream.current,
-                )
+        while stream.current().kind != TOKEN_RPAREN:
+            token = stream.current()
+            if token.kind in (TOKEN_EOF, TOKEN_RBRACKET):
+                raise JSONPathSyntaxError("unbalanced parentheses", token=_token)
 
             expr = self.parse_infix_expression(stream, expr)
 
-        stream.expect(TOKEN_RPAREN)
+        stream.eat(TOKEN_RPAREN)
         return expr
 
-    def parse_root_path(self, stream: TokenStream) -> FilterExpression:
-        root = stream.next_token()
-        return RootPath(
+    def parse_absolute_query(self, stream: TokenStream) -> BaseExpression:
+        root = stream.next()  # Could be TOKEN_ROOT or TOKEN_PSEUDO_ROOT
+        return RootFilterQuery(
             JSONPath(
                 env=self.env,
-                selectors=self.parse_path(stream, in_filter=True),
-                fake_root=root.kind == TOKEN_FAKE_ROOT,
+                segments=self.parse_query(stream),
+                pseudo_root=root.kind == TOKEN_PSEUDO_ROOT,
             )
         )
 
-    def parse_self_path(self, stream: TokenStream) -> FilterExpression:
-        stream.next_token()
-        return SelfPath(
-            JSONPath(env=self.env, selectors=self.parse_path(stream, in_filter=True))
+    def parse_relative_query(self, stream: TokenStream) -> BaseExpression:
+        stream.eat(TOKEN_SELF)
+        return RelativeFilterQuery(
+            JSONPath(env=self.env, segments=self.parse_query(stream))
+        )
+
+    def parse_singular_query_selector(
+        self, stream: TokenStream
+    ) -> SingularQuerySelector:
+        token = (
+            stream.next() if stream.current().kind == TOKEN_ROOT else stream.current()
+        )
+
+        query = JSONPath(env=self.env, segments=self.parse_query(stream))
+
+        if not query.singular_query():
+            raise JSONPathSyntaxError(
+                "embedded query selectors must be singular queries", token=token
+            )
+
+        return SingularQuerySelector(
+            env=self.env,
+            token=token,
+            query=query,
         )
 
-    def parse_current_key(self, _: TokenStream) -> FilterExpression:
+    def parse_current_key(self, stream: TokenStream) -> BaseExpression:
+        stream.next()
         return CURRENT_KEY
 
-    def parse_filter_context_path(self, stream: TokenStream) -> FilterExpression:
-        stream.next_token()
+    def parse_filter_context_path(self, stream: TokenStream) -> BaseExpression:
+        stream.next()
         return FilterContextPath(
-            JSONPath(env=self.env, selectors=self.parse_path(stream, in_filter=True))
+            JSONPath(env=self.env, segments=self.parse_query(stream))
         )
 
-    def parse_regex(self, stream: TokenStream) -> FilterExpression:
-        pattern = stream.current.value
+    def parse_regex(self, stream: TokenStream) -> BaseExpression:
+        pattern = stream.current().value
         flags = 0
-        if stream.peek.kind == TOKEN_RE_FLAGS:
-            stream.next_token()
-            for flag in set(stream.current.value):
+        if stream.peek().kind == TOKEN_RE_FLAGS:
+            stream.next()
+            for flag in set(stream.next().value):
                 flags |= self.RE_FLAG_MAP[flag]
         return RegexLiteral(value=re.compile(pattern, flags))
 
-    def parse_list_literal(self, stream: TokenStream) -> FilterExpression:
-        stream.next_token()
-        list_items: List[FilterExpression] = []
+    def parse_list_literal(self, stream: TokenStream) -> BaseExpression:
+        stream.eat(TOKEN_LBRACKET)
+        list_items: List[BaseExpression] = []
+
+        while True:
+            stream.skip_whitespace()
+
+            if stream.current().kind == TOKEN_RBRACKET:
+                break
 
-        while stream.current.kind != TOKEN_RBRACKET:
             try:
-                list_items.append(self.list_item_map[stream.current.kind](stream))
+                list_items.append(self.list_item_map[stream.current().kind](stream))
             except KeyError as err:
                 raise JSONPathSyntaxError(
-                    f"unexpected {stream.current.value!r}",
-                    token=stream.current,
+                    f"unexpected {stream.current().value!r}",
+                    token=stream.current(),
                 ) from err
 
-            if stream.peek.kind != TOKEN_RBRACKET:
-                stream.expect_peek(TOKEN_COMMA)
-                stream.next_token()
-
-            stream.next_token()
+            stream.skip_whitespace()
+            if stream.current().kind != TOKEN_RBRACKET:
+                stream.eat(TOKEN_COMMA)
+                stream.skip_whitespace()
 
+        stream.eat(TOKEN_RBRACKET)
         return ListLiteral(list_items)
 
-    def parse_function_extension(self, stream: TokenStream) -> FilterExpression:
-        function_arguments: List[FilterExpression] = []
-        tok = stream.next_token()
+    def parse_function_extension(self, stream: TokenStream) -> BaseExpression:
+        function_arguments: List[BaseExpression] = []
+        function_token = stream.next()
+        stream.eat(TOKEN_LPAREN)
+
+        while True:
+            stream.skip_whitespace()
+            token = stream.current()
+
+            if token.kind == TOKEN_RPAREN:
+                break
 
-        while stream.current.kind != TOKEN_RPAREN:
             try:
-                func = self.function_argument_map[stream.current.kind]
+                func = self.function_argument_map[token.kind]
             except KeyError as err:
                 raise JSONPathSyntaxError(
-                    f"unexpected {stream.current.value!r}",
-                    token=stream.current,
+                    f"unexpected {token.value!r}", token=token
                 ) from err
 
             expr = func(stream)
+            stream.skip_whitespace()
 
-            # The argument could be a comparison or logical expression
-            peek_kind = stream.peek.kind
-            while peek_kind in self.BINARY_OPERATORS:
-                stream.next_token()
+            while stream.current().kind in self.BINARY_OPERATORS:
                 expr = self.parse_infix_expression(stream, expr)
-                peek_kind = stream.peek.kind
 
             function_arguments.append(expr)
+            stream.skip_whitespace()
 
-            if stream.peek.kind != TOKEN_RPAREN:
-                stream.expect_peek(TOKEN_COMMA)
-                stream.next_token()
+            if stream.current().kind != TOKEN_RPAREN:
+                stream.eat(TOKEN_COMMA)
 
-            stream.next_token()
+        stream.eat(TOKEN_RPAREN)
 
         return FunctionExtension(
-            tok.value,
-            self.env.validate_function_extension_signature(tok, function_arguments),
+            function_token.value,
+            self.env.validate_function_extension_signature(
+                function_token, function_arguments
+            ),
         )
 
-    def parse_filter_selector(
+    def parse_filter_expression(
         self, stream: TokenStream, precedence: int = PRECEDENCE_LOWEST
-    ) -> FilterExpression:
+    ) -> BaseExpression:
+        stream.skip_whitespace()
+        token = stream.current()
+
         try:
-            left = self.token_map[stream.current.kind](stream)
+            left = self.token_map[token.kind](stream)
         except KeyError as err:
-            if stream.current.kind in (TOKEN_EOF, TOKEN_RBRACKET):
+            if token.kind in (TOKEN_EOF, TOKEN_RBRACKET):
                 msg = "end of expression"
             else:
-                msg = repr(stream.current.value)
-            raise JSONPathSyntaxError(
-                f"unexpected {msg}", token=stream.current
-            ) from err
+                msg = repr(token.value)
+            raise JSONPathSyntaxError(f"unexpected {msg}", token=token) from err
 
         while True:
-            peek_kind = stream.peek.kind
+            stream.skip_whitespace()
+            kind = stream.current().kind
+
             if (
-                peek_kind in (TOKEN_EOF, TOKEN_RBRACKET)
-                or self.PRECEDENCES.get(peek_kind, self.PRECEDENCE_LOWEST) < precedence
+                kind not in self.BINARY_OPERATORS
+                or self.PRECEDENCES.get(kind, self.PRECEDENCE_LOWEST) < precedence
             ):
                 break
 
-            if peek_kind not in self.BINARY_OPERATORS:
-                return left
-
-            stream.next_token()
             left = self.parse_infix_expression(stream, left)
 
         return left
 
     def _decode_string_literal(self, token: Token) -> str:
+        if self.env.strict:
+            # For strict compliance with RC 9535, we must unescape string literals
+            # ourself. RFC 9535 is more strict than json.loads when it comes to
+            # parsing \uXXXX escape sequences.
+            return unescape_string(
+                token.value,
+                token,
+                "'" if token.kind == TOKEN_SINGLE_QUOTE_STRING else '"',
+            )
+
         if self.env.unicode_escape:
             if token.kind == TOKEN_SINGLE_QUOTE_STRING:
                 value = token.value.replace('"', '\\"').replace("\\'", "'")
             else:
                 value = token.value
+
             try:
                 rv = json.loads(f'"{value}"')
                 assert isinstance(rv, str)
                 return rv
             except json.JSONDecodeError as err:
-                raise JSONPathSyntaxError(str(err).split(":")[1], token=token) from None
+                message = f"decode error: {str(err).split(':')[1]}"
+                raise JSONPathSyntaxError(message, token=token) from None
 
         return token.value
 
     def _raise_for_non_comparable_function(
-        self, expr: FilterExpression, token: Token
+        self, expr: BaseExpression, token: Token
     ) -> None:
-        if isinstance(expr, Path) and not expr.path.singular_query():
+        if isinstance(expr, FilterQuery) and not expr.path.singular_query():
             raise JSONPathTypeError("non-singular query is not comparable", token=token)
 
         if isinstance(expr, FunctionExtension):
@@ -740,3 +880,9 @@ class Parser:
                 raise JSONPathTypeError(
                     f"result of {expr.name}() is not comparable", token
                 )
+
+    def _raise_for_leading_zero(self, token: Token) -> None:
+        if (
+            len(token.value) > 1 and token.value.startswith("0")
+        ) or token.value.startswith("-0"):
+            raise JSONPathSyntaxError("leading zero in index selector", token=token)