@fastly/esi/build/EsiExpressions.d.ts

ESI implementation for JavaScript, using the modern fetch and streaming APIs.

import { IEsiVariables } from "./EsiVariables.js";
export declare class StringReader {
    text: string;
    length: number;
    offset: number;
    set(value: string): void;
    get(): string;
    addOffset(offset: number): void;
    isEOF(): boolean;
    reset(): void;
}
export type LexerTokenDef = RegExp | RegExp[];
export type LexerTokenDefs = {
    [type: string]: LexerTokenDef;
};
export type LexerOptions = {
    tokenDefs?: LexerTokenDefs;
};
export type LexerToken = {
    text: string;
    type: string;
};
type LexerTokenRule = {
    token: string;
    regex: RegExp[];
};
export declare class StringLexer {
    rules: LexerTokenRule[];
    constructor(options?: LexerOptions);
    tokenize(text: string): LexerToken[];
}
export type ParserOpDef = {
    precedence: number;
    associativity: 'left' | 'right';
};
export type ParserTable = {
    [operator: string]: ParserOpDef;
};
declare abstract class ExpressionEvaluatorBase<TToken> {
    table: ParserTable;
    constructor(table?: ParserTable);
    abstract isOpenParen(token: TToken): boolean;
    abstract isCloseParen(token: TToken): boolean;
    abstract getOperation(token: TToken): ParserOpDef | undefined;
    onPop(token: TToken, output: TToken[]): TToken;
    evaluateTokens(tokens: TToken[]): TToken[];
}
export declare class ExpressionEvaluator extends ExpressionEvaluatorBase<string> {
    isOpenParen(token: string): boolean;
    isCloseParen(token: string): boolean;
    getOperation(token: string): ParserOpDef | undefined;
}
export type EsiExpressionValueString = {
    type: 'string';
    value: string;
};
export type EsiExpressionValueNumber = {
    type: 'number';
    value: number;
};
export type EsiExpressionValueBoolean = {
    type: 'boolean';
    value: boolean;
};
export type EsiExpressionValueUndefined = {
    type: 'undefined';
};
export type EsiExpressionValueParen = {
    type: 'openParen' | 'closeParen';
};
export type EsiExpressionValueOperator = {
    type: 'openParen' | 'closeParen' | 'operator';
    value: string;
};
export type EsiExpressionValue = EsiExpressionValueString | EsiExpressionValueNumber | EsiExpressionValueBoolean | EsiExpressionValueUndefined | EsiExpressionValueParen | EsiExpressionValueOperator;
export declare class EsiExpressionEvaluator extends ExpressionEvaluatorBase<EsiExpressionValue> {
    static LEXER_TOKEN_DEFS: LexerTokenDefs;
    static PARSER_TABLE: ParserTable;
    static stringLexer: StringLexer;
    vars?: IEsiVariables;
    constructor(vars?: IEsiVariables);
    static COMPARISON_OPS: {
        [op: string]: <T>(a: T, b: T) => boolean;
    };
    static LOGICAL_OPS: {
        [op: string]: (a: boolean, b: boolean) => boolean;
    };
    onPop(token: EsiExpressionValue, output: EsiExpressionValue[]): EsiExpressionValue;
    tokenize(expression: string): EsiExpressionValue[];
    evaluate(expression: string): boolean;
    getOperation(token: EsiExpressionValue): ParserOpDef | undefined;
    isCloseParen(token: EsiExpressionValue): boolean;
    isOpenParen(token: EsiExpressionValue): boolean;
}
export {};
//# sourceMappingURL=EsiExpressions.d.ts.map