liquidjs

constructor(message: string);

constructor(
    env?: {},
    opts?: NormalizedFullOptions,
    renderOptions?: RenderOptions
);

environments: Scope;

globals: Scope;

opts: NormalizedFullOptions;

strictVariables: boolean;

sync: boolean;

bottom: () => Scope;

get: (paths: string[]) => object;

getAll: () => Scope;

getFromScope: (scope: object, paths: string[] | string) => object;

getRegister: (key: string) => any;

pop: () => Scope | undefined;

push: (ctx: object) => number;

restoreRegister: (keyValues: [string, any][]) => void;

saveRegister: (...keys: string[]) => [string, any][];

setRegister: (key: string, value: any) => any;

liquidMethodMissing: (
    key: string
) => Promise<string | undefined> | string | undefined;

valueOf: () => any;

constructor(tokens: IterableIterator<Token>);

evaluate: (
    ctx: Context,
    lenient: boolean
) => Generator<unknown, unknown, unknown>;

constructor(markup: string, jekyllStyle?: boolean);

hash: HashValue;

render: (ctx: Context) => Generator<unknown, HashValue, unknown>;

constructor(variableName: string);

variableName: string;

constructor(opts?: LiquidOptions);

readonly filters: FilterMap;

readonly options: NormalizedFullOptions;

readonly parser: Parser;

readonly renderer: Render;

readonly tags: TagMap;

evalValue: (str: string, ctx: Context) => Promise<any>;

evalValueSync: (str: string, ctx: Context) => any;

express: () => (
    this: any,
    filePath: string,
    ctx: object,
    callback: (err: Error | null, rendered: string) => void
) => void;

parse: (html: string, filepath?: string) => Template[];

parseAndRender: (
    html: string,
    scope?: object,
    renderOptions?: RenderOptions
) => Promise<any>;

parseAndRenderSync: (
    html: string,
    scope?: object,
    renderOptions?: RenderOptions
) => any;

parseFile: (file: string) => Promise<Template[]>;

parseFileSync: (file: string) => Template[];

plugin: (plugin: (this: Liquid, L: typeof Liquid) => void) => void;

registerFilter: (name: string, filter: FilterImplOptions) => void;

registerTag: (name: string, tag: TagImplOptions) => void;

render: (
    tpl: Template[],
    scope?: object,
    renderOptions?: RenderOptions
) => Promise<any>;

renderFile: (
    file: string,
    ctx?: object,
    renderOptions?: RenderOptions
) => Promise<any>;

renderFileSync: (
    file: string,
    ctx?: object,
    renderOptions?: RenderOptions
) => any;

renderFileToNodeStream: (
    file: string,
    scope?: object,
    renderOptions?: RenderOptions
) => Promise<NodeJS.ReadableStream>;

renderSync: (
    tpl: Template[],
    scope?: object,
    renderOptions?: RenderOptions
) => any;

renderToNodeStream: (
    tpl: Template[],
    scope?: object,
    renderOptions?: RenderOptions
) => NodeJS.ReadableStream;

constructor(err: Error, token: Token);

context: string;

protected update: () => void;

constructor(err: Error, token: Token);

constructor(tokens: T[], parseToken: ParseToken<T>);

on: <T2 extends Template | T>(
    name: string,
    cb: (this: ParseStream, arg: T2) => void
) => ParseStream<T>;

start: () => this;

stop: () => this;

constructor(err: Error, tpl: Template);

static is: (obj: any) => obj is RenderError;

constructor(
    input: string,
    begin: number,
    end: number,
    options: NormalizedFullOptions,
    file?: string
);

args: string;

name: string;

constructor(
    kind: TokenKind,
    input: string,
    begin: number,
    end: number,
    file?: string
);

begin: number;

end: number;

file?: string;

input: string;

kind: TokenKind;

getPosition: () => number[];

getText: () => string;

size: () => number;

constructor(message: string, token: Token);

constructor(input: string, trie: Trie, file?: string);

file: string;

input: string;

N: number;

p: number;

advance: (i?: number) => void;

end: () => boolean;

match: (word: string) => boolean;

mkError: (msg: string, begin: number) => TokenizationError;

peek: (n?: number) => string;

peekType: (n?: number) => number;

readEndrawOrRawContent: (options: NormalizedFullOptions) => HTMLToken | TagToken;

readExpression: () => Expression;

readExpressionTokens: () => IterableIterator<Token>;

readFileNameTemplate: (
    options: NormalizedFullOptions
) => IterableIterator<TopLevelToken>;

readFilter: () => FilterToken | null;

readFilterArg: () => FilterArg | undefined;

readFilters: () => FilterToken[];

readHash: (jekyllStyle?: boolean) => HashToken | undefined;

readHashes: (jekyllStyle?: boolean) => HashToken[];

readHTMLToken: (stopStrings: string[]) => HTMLToken;

readIdentifier: () => IdentifierToken;

readLiquidTagToken: (options: NormalizedFullOptions) => LiquidTagToken;

readLiquidTagTokens: (options?: NormalizedFullOptions) => LiquidTagToken[];

readOperator: () => OperatorToken | undefined;

readOutputToken: (options?: NormalizedFullOptions) => OutputToken;

readQuoted: () => QuotedToken | undefined;

readRange: () => RangeToken | undefined;

readTagToken: (options?: NormalizedFullOptions) => TagToken;

readTo: (end: string) => number;

readToDelimiter: (delimiter: string) => number;

readTopLevelToken: (options: NormalizedFullOptions) => TopLevelToken;

readTopLevelTokens: (options?: NormalizedFullOptions) => TopLevelToken[];

readValue: () => ValueToken | undefined;

readValueOrThrow: () => ValueToken;

readWord: () => IdentifierToken;

remaining: () => string;

rmatch: (pattern: string) => boolean;

skipBlank: () => void;

snapshot: (begin?: number) => string;

constructor(err: Error, token: Token);

constructor(str: string, liquid: Liquid);

readonly filters: Filter[];

readonly initial: Expression;

value: (ctx: Context, lenient: boolean) => Generator<unknown, unknown, unknown>;

buffer: string;

write: (html: any) => void;

(this: FilterImpl, value: any, ...args: any[]): any;

[key: string]: (lhs: any, rhs: any, ctx: Context) => boolean;

liquid: Liquid;

[key: string]: any;

parse?: (
    this: TagImpl,
    token: TagToken,
    remainingTokens: TopLevelToken[]
) => void;

render: (
    this: TagImpl,
    ctx: Context,
    emitter: Emitter,
    hash: HashValue
) =>
    | void
    | string
    | Promise<void | string>
    | Generator<unknown, void | string, unknown>;

token: Token;

render: (ctx: Context, emitter: Emitter) => any;

[key: string]: any;

Delimited = 12

Filter = 32

Hash = 64

HTML = 16

Literal = 2

Number = 1

Operator = 2048

Output = 8

PropertyAccess = 128

Quoted = 1024

Range = 512

Tag = 4

Word = 256

isDelimitedToken: (val: any) => val is DelimitedToken;

isHTMLToken: (val: any) => val is HTMLToken;

isLiteralToken: (val: any) => val is LiteralToken;

isNumberToken: (val: any) => val is NumberToken;

isOperatorToken: (val: any) => val is OperatorToken;

isOutputToken: (val: any) => val is OutputToken;

isPropertyAccessToken: (val: any) => val is PropertyAccessToken;

isQuotedToken: (val: any) => val is QuotedToken;

isRangeToken: (val: any) => val is RangeToken;

isTagToken: (val: any) => val is TagToken;

isWordToken: (val: any) => val is IdentifierToken;