json-p3 2.2.2 → 2.3.0

package/dist/path/functions/match.d.ts

@@ -1,33 +0,0 @@
-import { FilterFunction, FunctionExpressionType } from "./function";
-export type MatchFilterFunctionOptions = {
-    /**
-     * The maximum number of regular expressions to cache.
-     */
-    cacheSize?: number;
-    /**
-     * If _true_, throw errors from regex checking, construction and matching.
-     * The standard and default behavior is to ignore these errors and return
-     * _false_.
-     */
-    throwErrors?: boolean;
-    /**
-     * If _true_, check that regexp patterns are valid according to I-Regexp.
-     * The standard and default behavior is to silently return _false_ if a
-     * pattern is invalid.
-     *
-     * If `iRegexpCheck` is _true_ and `throwErrors` is _true_, an `IRegexpError`
-     * will be thrown.
-     */
-    iRegexpCheck?: boolean;
-};
-export declare class Match implements FilterFunction {
-    #private;
-    readonly options: MatchFilterFunctionOptions;
-    readonly argTypes: FunctionExpressionType[];
-    readonly returnType = FunctionExpressionType.LogicalType;
-    readonly cacheSize: number;
-    readonly throwErrors: boolean;
-    readonly iRegexpCheck: boolean;
-    constructor(options?: MatchFilterFunctionOptions);
-    call(s: string, pattern: string): boolean;
-}

package/dist/path/functions/pattern.d.ts

@@ -1,2 +0,0 @@
-export declare function mapRegexp(pattern: string): string;
-export declare function fullMatch(pattern: string): string;

package/dist/path/functions/search.d.ts

@@ -1,34 +0,0 @@
-import { FilterFunction, FunctionExpressionType } from "./function";
-export type SearchFilterFunctionOptions = {
-    /**
-     * The maximum number of regular expressions to cache. Defaults
-     * to 10.
-     */
-    cacheSize?: number;
-    /**
-     * If _true_, throw errors from regex construction and matching.
-     * The standard and default behavior is to ignore these errors
-     * and return _false_.
-     */
-    throwErrors?: boolean;
-    /**
-     * If _true_, check that regexp patterns are valid according to I-Regexp.
-     * The standard and default behavior is to silently return _false_ if a
-     * pattern is invalid.
-     *
-     * If `iRegexpCheck` is _true_ and `throwErrors` is _true_, an `IRegexpError`
-     * will be thrown.
-     */
-    iRegexpCheck?: boolean;
-};
-export declare class Search implements FilterFunction {
-    #private;
-    readonly options: SearchFilterFunctionOptions;
-    readonly argTypes: FunctionExpressionType[];
-    readonly returnType = FunctionExpressionType.LogicalType;
-    readonly cacheSize: number;
-    readonly throwErrors: boolean;
-    readonly iRegexpCheck: boolean;
-    constructor(options?: SearchFilterFunctionOptions);
-    call(s: string, pattern: string): boolean;
-}

package/dist/path/functions/value.d.ts

@@ -1,7 +0,0 @@
-import { JSONPathNodeList } from "../node";
-import { FilterFunction, FunctionExpressionType } from "./function";
-export declare class Value implements FilterFunction {
-    readonly argTypes: FunctionExpressionType[];
-    readonly returnType = FunctionExpressionType.ValueType;
-    call(nodes: JSONPathNodeList): unknown;
-}

package/dist/path/index.d.ts

@@ -1,76 +0,0 @@
-import { JSONValue } from "../types";
-import { JSONPathEnvironment } from "./environment";
-import { JSONPathNode, JSONPathNodeList } from "./node";
-import { JSONPathQuery } from "./path";
-export { JSONPathEnvironment } from "./environment";
-export type { JSONPathEnvironmentOptions } from "./environment";
-export { JSONPathSegment } from "./segments";
-export { JSONPathSelector } from "./selectors";
-export { JSONPathQuery } from "./path";
-export { JSONPathNodeList, JSONPathNode } from "./node";
-export { Token, TokenKind } from "./token";
-export * as selectors from "./selectors";
-export * as expressions from "./expression";
-export * as functions from "./functions";
-export { FunctionExpressionType } from "./functions";
-export type { FilterFunction } from "./functions";
-export { JSONPathError, JSONPathIndexError, JSONPathLexerError, JSONPathSyntaxError, JSONPathTypeError, JSONPathRecursionLimitError, } from "./errors";
-export { Nothing, KEY_MARK } from "./types";
-export type { JSONPathValue, FilterContext, SerializationOptions, } from "./types";
-export declare const DEFAULT_ENVIRONMENT: 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.
- */
-export declare function query(path: string, value: JSONValue): JSONPathNodeList;
-/**
- * Lazily query JSON value _value_ with JSONPath expression _path_.
- * Lazy queries can be faster and more memory efficient when querying
- * large datasets, especially when using recursive decent selectors.
- *
- * @param path - A JSONPath expression/query.
- * @param value - The JSON-like value the JSONPath query is applied to.
- * @returns A sequence of {@link JSONPathNode} objects resulting from
- * applying _path_ to _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.
- */
-export declare function lazyQuery(path: string, value: JSONValue): IterableIterator<JSONPathNode>;
-/**
- * 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.
- */
-export declare function compile(path: string): JSONPathQuery;
-/**
- * Return a {@link JSONPathNode} instance for the first object found in
- * _value_ matching _path_.
- *
- * @param path - A JSONPath query.
- * @param value - JSON-like data to which the query _path_ will be applied.
- * @returns The first node in _value_ matching  _path_, or `undefined` if
- * there are no matches.
- */
-export declare function match(path: string, value: JSONValue): JSONPathNode | undefined;

package/dist/path/lex.d.ts

@@ -1,74 +0,0 @@
-/** A lexer that accepts additional, non-standard tokens. */
-import { JSONPathEnvironment } from "./environment";
-import { Token, TokenKind } from "./token";
-/**
- * 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.
- */
-declare class Lexer {
-    #private;
-    readonly environment: JSONPathEnvironment;
-    readonly path: string;
-    /**
-     * Filter nesting level.
-     */
-    filterLevel: number;
-    /**
-     * 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.
-     */
-    funcCallStack: number[];
-    /**
-     * A stack of parentheses and square brackets used to check for balanced
-     * brackets.
-     */
-    bracketStack: Array<[string, number]>;
-    /** Tokens resulting from tokenizing a JSONPath query. */
-    tokens: Token[];
-    /**
-     * @param path - A JSONPath query.
-     */
-    constructor(environment: JSONPathEnvironment, path: string);
-    get pos(): number;
-    get start(): number;
-    run(): void;
-    emit(t: TokenKind): void;
-    next(): string;
-    ignore(): void;
-    backup(): void;
-    peek(): string;
-    peekMatch(pattern: RegExp): boolean;
-    accept(valid: Set<string>): boolean;
-    acceptMatch(pattern: RegExp): boolean;
-    acceptRun(valid: Set<string>): boolean;
-    acceptMatchRun(pattern: RegExp): boolean;
-    ignoreWhitespace(): boolean;
-    error(msg: string): void;
-}
-/**
- * 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.
- */
-export declare function lex(environment: JSONPathEnvironment, path: string): [Lexer, Token[]];
-/**
- * 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.
- */
-export declare function tokenize(environment: JSONPathEnvironment, path: string): Token[];
-export {};

package/dist/path/lru_cache.d.ts

@@ -1,10 +0,0 @@
-/**
- * A Least Recently Used cache, implemented as an extended Map.
- */
-export declare class LRUCache<K, V> extends Map<K, V> {
-    readonly maxSize: number;
-    constructor(maxSize?: number, entries?: Iterable<[K, V]>);
-    get(key: K): V | undefined;
-    set(key: K, value: V): this;
-    first(): K | undefined;
-}

package/dist/path/node.d.ts

@@ -1,84 +0,0 @@
-import { JSONPointer } from "../pointer";
-import { JSONValue } from "../types";
-import { type SerializationOptions } from "./types";
-/**
- * The pair of a JSON value and its location found in the target JSON value.
- */
-export declare class JSONPathNode {
-    readonly value: JSONValue;
-    readonly location: Array<string | number>;
-    readonly root: JSONValue;
-    /**
-     * @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: JSONValue, location: Array<string | number>, root: JSONValue);
-    /**
-     * @deprecated Use {@link getPath} with `options.form` set to `canonical` instead.
-     */
-    get path(): string;
-    /**
-     * Get the path to this node in the target JSON value.
-     *
-     * Given that the path refers to the singular current node, the returned path
-     * will always be a normalized path if `options.form` is set to `canonical`,
-     * following section 2.7 of RFC 9535.
-     */
-    getPath(options?: SerializationOptions): string;
-    /**
-     * Return this node's location as a {@link JSONPointer}.
-     */
-    toPointer(): JSONPointer;
-    private decodeNameLocation;
-}
-/**
- *
- */
-export declare class JSONPathNodeList {
-    readonly nodes: JSONPathNode[];
-    constructor(nodes: JSONPathNode[]);
-    /**
-     * @returns an iterator over nodes in the list.
-     */
-    [Symbol.iterator](): Iterator<JSONPathNode>;
-    /**
-     * @returns `true` if the node list is empty.
-     */
-    empty(): boolean;
-    /**
-     * @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(): JSONValue[];
-    /**
-     * Like {@link values}, but returns the node's value is there is only one
-     * node in the list.
-     */
-    valuesOrSingular(): JSONValue;
-    /**
-     * @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(): Array<Array<string | number>>;
-    /**
-     * @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(options?: SerializationOptions): string[];
-    /**
-     * @returns An array of {@link JSONPointer} instances, one for each node
-     * in the list.
-     */
-    pointers(): JSONPointer[];
-    /**
-     * @returns The number of nodes in the node list.
-     */
-    get length(): number;
-}

package/dist/path/parse.d.ts

@@ -1,61 +0,0 @@
-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;

package/dist/path/path.d.ts

@@ -1,42 +0,0 @@
-import { JSONPathEnvironment } from "./environment";
-import { JSONPathNode, JSONPathNodeList } from "./node";
-import { JSONValue } from "../types";
-import { JSONPathSegment } from "./segments";
-import { SerializationOptions } from "./types";
-/**
- * A compiled JSONPath query ready to be applied to different data repeatedly.
- */
-export declare class JSONPathQuery {
-    readonly environment: JSONPathEnvironment;
-    readonly segments: JSONPathSegment[];
-    constructor(environment: JSONPathEnvironment, segments: JSONPathSegment[]);
-    /**
-     * Apply this JSONPath query to _value_.
-     * @param value - A JSON-like object to apply this query to.
-     * @returns Nodes matched by applying this query to _value_.
-     */
-    query(value: JSONValue): JSONPathNodeList;
-    /**
-     * Apply this JSONPath query to _value_.
-     * @param value - A JSON-like object to apply this query to.
-     * @returns An iterator over nodes matched by applying this query to _value_.
-     */
-    lazyQuery(value: JSONValue): IterableIterator<JSONPathNode>;
-    /**
-     * Return a {@link JSONPathNode} instance for the first object found in
-     * _value_ matching this query.
-     *
-     * @param value - JSON-like data to which this query will be applied.
-     * @returns The first node in _value_ matching this query, or `undefined` if
-     * there are no matches.
-     */
-    match(value: JSONValue): JSONPathNode | undefined;
-    /**
-     * Return a string representation of this query.
-     */
-    toString(options?: SerializationOptions): string;
-    /**
-     * Return `true` if this query is a _singular query_, or `false` otherwise.
-     */
-    singularQuery(): boolean;
-}

package/dist/path/segments.d.ts

@@ -1,39 +0,0 @@
-import { JSONPathEnvironment } from "./environment";
-import { JSONPathNode } from "./node";
-import { JSONPathSelector } from "./selectors";
-import { Token } from "./token";
-import { type SerializationOptions } from "./types";
-/** Base class for all JSONPath segments. Both shorthand and bracketed. */
-export declare abstract class JSONPathSegment {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    readonly selectors: JSONPathSelector[];
-    constructor(environment: JSONPathEnvironment, token: Token, selectors: JSONPathSelector[]);
-    /**
-     * @param nodes - Nodes matched by preceding segments.
-     */
-    abstract resolve(nodes: JSONPathNode[]): JSONPathNode[];
-    /**
-     * @param nodes - Nodes matched by preceding segments.
-     */
-    abstract lazyResolve(nodes: Iterable<JSONPathNode>): Generator<JSONPathNode>;
-    /**
-     * Return a string representation of this segment.
-     */
-    abstract toString(options?: SerializationOptions): string;
-}
-/** The child selection segment. */
-export declare class ChildSegment extends JSONPathSegment {
-    resolve(nodes: JSONPathNode[]): JSONPathNode[];
-    lazyResolve(nodes: Iterable<JSONPathNode>): Generator<JSONPathNode>;
-    toString(options?: SerializationOptions): string;
-}
-/** The recursive descent segment. */
-export declare class DescendantSegment extends JSONPathSegment {
-    resolve(nodes: JSONPathNode[]): JSONPathNode[];
-    lazyResolve(nodes: Iterable<JSONPathNode>): Generator<JSONPathNode>;
-    toString(options?: SerializationOptions): string;
-    private visit;
-    private nondeterministicVisit;
-    private nondeterministicChildren;
-}

package/dist/path/selectors.d.ts

@@ -1,85 +0,0 @@
-import { JSONPathEnvironment } from "./environment";
-import { LogicalExpression } from "./expression";
-import { JSONPathNode } from "./node";
-import { Token } from "./token";
-import { type SerializationOptions } from "./types";
-/**
- * Base class for all JSONPath segments and selectors.
- */
-export declare abstract class JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    /**
-     * @param token - The token at the start of this selector.
-     */
-    constructor(environment: JSONPathEnvironment, token: Token);
-    /**
-     * @param node - Nodes matched by preceding selectors.
-     */
-    abstract resolve(node: JSONPathNode): JSONPathNode[];
-    /**
-     * @param node - Nodes matched by preceding selectors.
-     */
-    abstract lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    /**
-     * Return a canonical string representation of this selector.
-     */
-    abstract toString(options?: SerializationOptions): string;
-}
-/**
- * Shorthand and quoted name selector.
- */
-export declare class NameSelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    readonly name: string;
-    constructor(environment: JSONPathEnvironment, token: Token, name: string);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(options?: SerializationOptions): string;
-    shorthand(): string | null;
-}
-/**
- * Array index selector.
- */
-export declare class IndexSelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    readonly index: number;
-    constructor(environment: JSONPathEnvironment, token: Token, index: number);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(): string;
-    private normalizedIndex;
-}
-export declare class SliceSelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    readonly start?: number | undefined;
-    readonly stop?: number | undefined;
-    readonly step?: number | undefined;
-    constructor(environment: JSONPathEnvironment, token: Token, start?: number | undefined, stop?: number | undefined, step?: number | undefined);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(): string;
-    private checkRange;
-    private slice;
-    private lazySlice;
-}
-export declare class WildcardSelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    constructor(environment: JSONPathEnvironment, token: Token);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(): string;
-}
-export declare class FilterSelector extends JSONPathSelector {
-    readonly environment: JSONPathEnvironment;
-    readonly token: Token;
-    readonly expression: LogicalExpression;
-    constructor(environment: JSONPathEnvironment, token: Token, expression: LogicalExpression);
-    resolve(node: JSONPathNode): JSONPathNode[];
-    lazyResolve(node: JSONPathNode): Generator<JSONPathNode>;
-    toString(options?: SerializationOptions): string;
-}

package/dist/path/serialize.d.ts

@@ -1,6 +0,0 @@
-/** Usable in a quoted path. */
-export declare function toQuoted(name: string): string;
-/** Usable in a normalized path. */
-export declare function toCanonical(name: string): string;
-/** Usable in a shorthand path. */
-export declare function toShorthand(name: string): string | null;

package/dist/path/token.d.ts

@@ -1,70 +0,0 @@
-/**
- *
- */
-export declare enum TokenKind {
-    AND = "TOKEN_AND",
-    COLON = "TOKEN_COLON",
-    COMMA = "TOKEN_COMMA",
-    CURRENT = "TOKEN_CURRENT_VALUE",
-    CURRENT_KEY = "TOKEN_CURRENT_KEY",// non-standard, default `#`
-    DDOT = "TOKEN_DDOT",
-    DOT = "TOKEN_DOT",
-    DOUBLE_QUOTE_STRING = "TOKEN_DOUBLE_QUOTE_STRING",
-    EOF = "TOKEN_EOF",
-    EQ = "TOKEN_EQ",
-    ERROR = "TOKEN_ERROR",
-    FALSE = "TOKEN_FALSE",
-    FILTER = "TOKEN_FILTER_START",
-    FUNCTION = "TOKEN_FUNCTION",
-    GE = "TOKEN_GE",
-    GT = "TOKEN_GT",
-    INDEX = "TOKEN_INDEX",
-    KEY = "TOKEN_KEY",// non-standard, default `~<name>`
-    KEY_DOUBLE_QUOTE_STRING = "TOKEN_KEY_DOUBLE_QUOTE_STRING",// non-standard, `~"<name>"`
-    KEY_SINGLE_QUOTE_STRING = "TOKEN_KEY_SINGLE_QUOTE_STRING",// non-standard, `~'<name>'`
-    KEYS = "TOKEN_KEYS",// non-standard, default `~`
-    KEYS_FILTER = "TOKEN_KEYS_FILTER",// non-standard, `~?<expression>`
-    LBRACKET = "TOKEN_LBRACKET",
-    LE = "TOKEN_LE",
-    LG = "TOKEN_LG",
-    LPAREN = "TOKEN_LPAREN",
-    LT = "TOKEN_LT",
-    NAME = "TOKEN_NAME",
-    NE = "TOKEN_NE",
-    NOT = "TOKEN_NOT",
-    NULL = "TOKEN_NULL",
-    NUMBER = "NUMBER",
-    OR = "TOKEN_OR",
-    RBRACKET = "TOKEN_RBRACKET",
-    ROOT = "TOKEN_ROOT",
-    RPAREN = "TOKEN_RPAREN",
-    SINGLE_QUOTE_STRING = "TOKEN_SINGLE_QUOTE_STRING",
-    TRUE = "TOKEN_TRUE",
-    WILD = "TOKEN_WILD"
-}
-/**
- *
- */
-export declare class Token {
-    readonly kind: TokenKind;
-    readonly value: string;
-    readonly index: number;
-    readonly input: string;
-    constructor(kind: TokenKind, value: string, index: number, input: string);
-}
-export declare const EOF: Token;
-/**
- *
- */
-export declare class TokenStream {
-    #private;
-    private tokens;
-    constructor(tokens: Token[]);
-    get current(): Token;
-    get peek(): Token;
-    next(): Token;
-    backup(): void;
-    expect(kind: TokenKind): void;
-    expectPeek(kind: TokenKind): void;
-    expectPeekNot(kind: TokenKind, message: string): void;
-}