json-p3/dist/path/parse.d.ts

JSONPath, JSON Pointer and JSON Patch

import { JSONPathEnvironment } from "./environment";
import { BooleanLiteral, FilterExpression, FunctionExtension, InfixExpression, NullLiteral, NumberLiteral, PrefixExpression, RelativeQuery, RootQuery, StringLiteral } from "./expression";
import { FilterSelector, IndexSelector, JSONPathSelector, SliceSelector } from "./selectors";
import { JSONPathSegment } from "./segments";
import { Token, TokenStream } from "./token";
import { CurrentKey } from "./extra/expression";
/**
 * JSONPath token stream parser.
 */
export declare class Parser {
    readonly environment: JSONPathEnvironment;
    protected tokenMap: Map<string, (stream: TokenStream) => FilterExpression>;
    constructor(environment: JSONPathEnvironment);
    parse(stream: TokenStream): JSONPathSegment[];
    protected parseQuery(stream: TokenStream, inFilter?: boolean): JSONPathSegment[];
    protected parseSelectors(stream: TokenStream): JSONPathSelector[];
    protected parseIndex(stream: TokenStream): IndexSelector;
    protected parseSlice(stream: TokenStream): SliceSelector;
    protected parseBracketedSelection(stream: TokenStream): JSONPathSelector[];
    protected parseFilter(stream: TokenStream, keys?: boolean): FilterSelector;
    protected parseBoolean(stream: TokenStream): BooleanLiteral;
    protected parseNull(stream: TokenStream): NullLiteral;
    protected parseString(stream: TokenStream): StringLiteral;
    protected parseNumber(stream: TokenStream): NumberLiteral;
    protected parsePrefixExpression(stream: TokenStream): PrefixExpression;
    protected parseInfixExpression(stream: TokenStream, left: FilterExpression): InfixExpression;
    protected parseGroupedExpression(stream: TokenStream): FilterExpression;
    protected parseRootQuery(stream: TokenStream): RootQuery;
    protected parseRelativeQuery(stream: TokenStream): RelativeQuery;
    protected parseCurrentKey(stream: TokenStream): CurrentKey;
    protected parseFunction(stream: TokenStream): FunctionExtension;
    protected parseFilterExpression(stream: TokenStream, precedence?: number): FilterExpression;
    protected decodeString(token: Token): string;
    protected unescapeString(value: string, token: Token): string;
    /**
     * Decode a `\uXXXX` or `\uXXXX\uXXXX` escape sequence from _value_ at _index_.
     *
     * @param value - A string value containing the sequence to decode.
     * @param index - The start index of an escape sequence in _value_.
     * @param token - The token for the string value.
     * @returns - A codepoint, new index tuple.
     */
    protected decodeHexChar(value: string, index: number, token: Token): [number, number];
    /**
     * Parse a hexadecimal string as an integer.
     *
     * @param digits - Hexadecimal digit string.
     * @param token - The token for the string value.
     * @returns - The number representation of _digits_.
     *
     * Note that we're not using `parseInt(digits, 16)` because it accepts `+`
     * and `-` and things we don't allow.
     */
    protected parseHexDigits(digits: string, token: Token): number;
    /** Check the codepoint is valid and return its string representation. */
    protected stringFromCodePoint(codepoint: number | undefined, token: Token): string;
    protected throwForNonComparable(expr: FilterExpression): void;
    protected throwForLiteral(expr: FilterExpression): void;
}
export declare function isHighSurrogate(codepoint: number): boolean;
export declare function isLowSurrogate(codepoint: number): boolean;