@nocobase/plugin-flow-engine 2.2.27 → 2.2.28

package/dist/node_modules/liquidjs/dist/tags/for.d.ts

@@ -0,0 +1,15 @@
+import { Hash, ValueToken, Liquid, Tag, Emitter, TagToken, TopLevelToken, Context, Template } from '..';
+import { Parser } from '../parser';
+import { Arguments } from '../template';
+export default class extends Tag {
+    variable: string;
+    collection: ValueToken;
+    hash: Hash;
+    templates: Template[];
+    elseTemplates: Template[];
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, void | string, Template[]>;
+    children(): Generator<unknown, Template[]>;
+    arguments(): Arguments;
+    blockScope(): Iterable<string>;
+}

package/dist/node_modules/liquidjs/dist/tags/if.d.ts

@@ -0,0 +1,14 @@
+import { Liquid, Tag, Value, Emitter, TagToken, TopLevelToken, Context, Template } from '..';
+import { Parser } from '../parser';
+import { Arguments } from '../template';
+export default class extends Tag {
+    branches: {
+        value: Value;
+        templates: Template[];
+    }[];
+    elseTemplates: Template[] | undefined;
+    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, void, string>;
+    children(): Generator<unknown, Template[]>;
+    arguments(): Arguments;
+}

package/dist/node_modules/liquidjs/dist/tags/include.d.ts

@@ -0,0 +1,12 @@
+import { Template, TopLevelToken, Liquid, Tag, Emitter, TagToken, Context } from '..';
+import { Parser } from '../parser';
+import { Arguments, PartialScope } from '../template';
+export default class extends Tag {
+    private withVar?;
+    private hash;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, void, unknown>;
+    children(partials: boolean, sync: boolean): Generator<unknown, Template[]>;
+    partialScope(): PartialScope | undefined;
+    arguments(): Arguments;
+}

package/dist/node_modules/liquidjs/dist/tags/increment.d.ts

@@ -0,0 +1,9 @@
+import { Tag, Liquid, TopLevelToken, Emitter, TagToken, Context } from '..';
+import { IdentifierToken } from '../tokens';
+export default class extends Tag {
+    private identifier;
+    private variable;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(context: Context, emitter: Emitter): void;
+    localScope(): Iterable<string | IdentifierToken>;
+}

package/dist/node_modules/liquidjs/dist/tags/index.d.ts

@@ -0,0 +1,24 @@
+import AssignTag from './assign';
+import ForTag from './for';
+import CaptureTag from './capture';
+import CaseTag from './case';
+import CommentTag from './comment';
+import IncludeTag from './include';
+import RenderTag from './render';
+import DecrementTag from './decrement';
+import CycleTag from './cycle';
+import IfTag from './if';
+import IncrementTag from './increment';
+import LayoutTag from './layout';
+import BlockTag from './block';
+import RawTag from './raw';
+import TablerowTag from './tablerow';
+import UnlessTag from './unless';
+import BreakTag from './break';
+import ContinueTag from './continue';
+import EchoTag from './echo';
+import LiquidTag from './liquid';
+import InlineCommentTag from './inline-comment';
+import type { TagClass } from '../template/tag';
+export declare const tags: Record<string, TagClass>;
+export { AssignTag, ForTag, CaptureTag, CaseTag, CommentTag, IncludeTag, RenderTag, DecrementTag, IncrementTag, CycleTag, IfTag, LayoutTag, BlockTag, RawTag, TablerowTag, UnlessTag, BreakTag, ContinueTag, EchoTag, LiquidTag, InlineCommentTag };

package/dist/node_modules/liquidjs/dist/tags/inline-comment.d.ts

@@ -0,0 +1,5 @@
+import { TagToken, Liquid, TopLevelToken, Tag } from '..';
+export default class extends Tag {
+    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(): void;
+}

package/dist/node_modules/liquidjs/dist/tags/layout.d.ts

@@ -0,0 +1,14 @@
+import { Template, Liquid, Tag, Emitter, Hash, TagToken, TopLevelToken, Context } from '..';
+import { ParsedFileName } from './render';
+import { Parser } from '../parser';
+import { Arguments, PartialScope } from '../template';
+export default class extends Tag {
+    args: Hash;
+    templates: Template[];
+    file?: ParsedFileName;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, unknown, unknown>;
+    children(partials: boolean): Generator<unknown, Template[]>;
+    arguments(): Arguments;
+    partialScope(): PartialScope | undefined;
+}

package/dist/node_modules/liquidjs/dist/tags/liquid.d.ts

@@ -0,0 +1,8 @@
+import { Template, Emitter, Liquid, TopLevelToken, TagToken, Context, Tag } from '..';
+import { Parser } from '../parser';
+export default class extends Tag {
+    templates: Template[];
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, void, unknown>;
+    children(): Generator<unknown, Template[]>;
+}

package/dist/node_modules/liquidjs/dist/tags/raw.d.ts

@@ -0,0 +1,6 @@
+import { Liquid, TagToken, TopLevelToken, Tag } from '..';
+export default class extends Tag {
+    private tokens;
+    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(): string;
+}

package/dist/node_modules/liquidjs/dist/tags/render.d.ts

@@ -0,0 +1,22 @@
+import { TopLevelToken, Liquid, Token, Template, Tokenizer, Emitter, TagToken, Context, Tag } from '..';
+import { Parser } from '../parser';
+import { Arguments, PartialScope } from '../template';
+export type ParsedFileName = Template[] | Token | string | undefined;
+export default class extends Tag {
+    private file;
+    private currentFile?;
+    private hash;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, void, unknown>;
+    children(partials: boolean, sync: boolean): Generator<unknown, Template[]>;
+    partialScope(): PartialScope | undefined;
+    arguments(): Arguments;
+}
+/**
+ * @return null for "none",
+ * @return Template[] for quoted with tags and/or filters
+ * @return Token for expression (not quoted)
+ * @throws TypeError if cannot read next token
+ */
+export declare function parseFilePath(tokenizer: Tokenizer, liquid: Liquid, parser: Parser): ParsedFileName;
+export declare function renderFilePath(file: ParsedFileName, ctx: Context, liquid: Liquid): IterableIterator<unknown>;

package/dist/node_modules/liquidjs/dist/tags/tablerow.d.ts

@@ -0,0 +1,14 @@
+import { ValueToken, Liquid, Tag, Emitter, Hash, TagToken, TopLevelToken, Context, Template } from '..';
+import { Parser } from '../parser';
+import { Arguments } from '../template';
+export default class extends Tag {
+    variable: string;
+    args: Hash;
+    templates: Template[];
+    collection: ValueToken;
+    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, void, unknown>;
+    children(): Generator<unknown, Template[]>;
+    arguments(): Arguments;
+    blockScope(): string[];
+}

package/dist/node_modules/liquidjs/dist/tags/unless.d.ts

@@ -0,0 +1,15 @@
+import { Liquid, Tag, Value, TopLevelToken, Template, Emitter, Context, TagToken } from '..';
+import { Parser } from '../parser';
+import { Arguments } from '../template';
+export default class extends Tag {
+    branches: {
+        value: Value;
+        test: (val: any, ctx: Context) => boolean;
+        templates: Template[];
+    }[];
+    elseTemplates: Template[];
+    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, unknown, unknown>;
+    children(): Generator<unknown, Template[]>;
+    arguments(): Arguments;
+}

package/dist/node_modules/liquidjs/dist/template/analysis.d.ts

@@ -0,0 +1,85 @@
+import { Template } from '.';
+/**
+ * Row, column and file name where a variable was found.
+ */
+export interface VariableLocation {
+    row: number;
+    col: number;
+    file?: string;
+}
+/**
+ * A variable's segments as an array, possibly with nested arrays of segments.
+ */
+export type SegmentArray = Array<string | number | SegmentArray>;
+/**
+ * A variable's segments and location, which can be coerced to a string.
+ */
+export declare class Variable {
+    readonly segments: Array<string | number | Variable>;
+    readonly location: VariableLocation;
+    constructor(segments: Array<string | number | Variable>, location: VariableLocation);
+    toString(): string;
+    /** Return this variable's segments as an array, possibly with nested arrays for nested paths. */
+    toArray(): SegmentArray;
+}
+/**
+ * Property names and array indexes that make up a path to a variable.
+ */
+export type VariableSegments = Array<string | number | Variable>;
+/**
+ * A mapping of variable names to an array of locations at which the variable was found.
+ */
+export type Variables = {
+    [key: string]: Variable[];
+};
+/**
+ * Group variables by the string representation of their root segment.
+ */
+export declare class VariableMap {
+    private map;
+    constructor();
+    get(key: Variable): Variable[];
+    has(key: Variable): boolean;
+    push(variable: Variable): void;
+    asObject(): Variables;
+}
+/**
+ * The result of calling `analyze()` or `analyzeSync()`.
+ */
+export interface StaticAnalysis {
+    /**
+     * All variables, whether they are in scope or not. Including references to names
+     * such as `forloop` from the `for` tag.
+     */
+    variables: Variables;
+    /**
+     * Variables that are not in scope. These could be a "global" variables that are
+     * expected to be provided by the application developer, or possible mistakes
+     * from the template author.
+     *
+     * If a variable is referenced before and after assignment, you should expect
+     * that variable to be included in `globals`, `variables` and `locals`, each with
+     * a different location.
+     */
+    globals: Variables;
+    /**
+     * Template variables that are added to the template local scope using tags like
+     * `assign`, `capture` or `increment`.
+     */
+    locals: Variables;
+}
+export interface StaticAnalysisOptions {
+    /**
+     * When `true` (the default), try to load partial templates and analyze them too.
+     */
+    partials?: boolean;
+}
+export declare const defaultStaticAnalysisOptions: StaticAnalysisOptions;
+/**
+ * Statically analyze a template and report variable usage.
+ */
+export declare function analyze(template: Template[], options?: StaticAnalysisOptions): Promise<StaticAnalysis>;
+/**
+ * Statically analyze a template and report variable usage.
+ */
+export declare function analyzeSync(template: Template[], options?: StaticAnalysisOptions): StaticAnalysis;

package/dist/node_modules/liquidjs/dist/template/analysis.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/liquidjs/dist/template/filter-impl-options.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from '../context';
+import type { Liquid } from '../liquid';
+import type { FilterToken } from '../tokens';
+export interface FilterImpl {
+    context: Context;
+    token: FilterToken;
+    liquid: Liquid;
+}
+export type FilterHandler = (this: FilterImpl, value: any, ...args: any[]) => any;
+export interface FilterOptions {
+    handler: FilterHandler;
+    raw: boolean;
+}
+export type FilterImplOptions = FilterHandler | FilterOptions;

package/dist/node_modules/liquidjs/dist/template/filter.d.ts

@@ -0,0 +1,15 @@
+import { Context } from '../context';
+import { FilterImplOptions } from './filter-impl-options';
+import { FilterArg } from '../parser/filter-arg';
+import { Liquid } from '../liquid';
+import { FilterToken } from '../tokens';
+export declare class Filter {
+    name: string;
+    args: FilterArg[];
+    readonly raw: boolean;
+    private handler;
+    private liquid;
+    private token;
+    constructor(token: FilterToken, options: FilterImplOptions | undefined, liquid: Liquid);
+    render(value: any, context: Context): IterableIterator<unknown>;
+}

package/dist/node_modules/liquidjs/dist/template/filter.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/liquidjs/dist/template/hash.d.ts

@@ -0,0 +1,18 @@
+import { Context } from '../context/context';
+import { Tokenizer } from '../parser/tokenizer';
+import { Token } from '../tokens/token';
+type HashValueTokens = Record<string, Token | undefined>;
+/**
+ * Key-Value Pairs Representing Tag Arguments
+ * Example:
+ *    For the markup `, foo:'bar', coo:2 reversed %}`,
+ *    hash['foo'] === 'bar'
+ *    hash['coo'] === 2
+ *    hash['reversed'] === undefined
+ */
+export declare class Hash {
+    hash: HashValueTokens;
+    constructor(input: string | Tokenizer, jekyllStyle?: boolean | string);
+    render(ctx: Context): Generator<unknown, Record<string, any>, unknown>;
+}
+export {};

package/dist/node_modules/liquidjs/dist/template/hash.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/liquidjs/dist/template/html.d.ts

@@ -0,0 +1,9 @@
+import { TemplateImpl, Template } from '../template';
+import { HTMLToken } from '../tokens';
+import { Context } from '../context';
+import { Emitter } from '../emitters';
+export declare class HTML extends TemplateImpl<HTMLToken> implements Template {
+    private str;
+    constructor(token: HTMLToken);
+    render(ctx: Context, emitter: Emitter): IterableIterator<void>;
+}

package/dist/node_modules/liquidjs/dist/template/index.d.ts

@@ -0,0 +1,11 @@
+export * from './template';
+export * from './template-impl';
+export * from './tag';
+export * from './tag-options-adapter';
+export * from './filter';
+export * from './filter-impl-options';
+export * from './hash';
+export * from './value';
+export * from './output';
+export * from './html';
+export * from './analysis';

package/dist/node_modules/liquidjs/dist/template/output.d.ts

@@ -0,0 +1,12 @@
+import { Value } from './value';
+import { Arguments, Template, TemplateImpl } from '../template';
+import { Context } from '../context/context';
+import { Emitter } from '../emitters/emitter';
+import { OutputToken } from '../tokens/output-token';
+import { Liquid } from '../liquid';
+export declare class Output extends TemplateImpl<OutputToken> implements Template {
+    value: Value;
+    constructor(token: OutputToken, liquid: Liquid);
+    render(ctx: Context, emitter: Emitter): IterableIterator<unknown>;
+    arguments(): Arguments;
+}

package/dist/node_modules/liquidjs/dist/template/output.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/liquidjs/dist/template/tag-options-adapter.d.ts

@@ -0,0 +1,10 @@
+import { Tag, TagClass, TagRenderReturn } from './tag';
+import { TagToken, TopLevelToken } from '../tokens';
+import { Emitter } from '../emitters';
+import { Context } from '../context';
+export interface TagImplOptions {
+    [key: string]: any;
+    parse?: (this: Tag & TagImplOptions, token: TagToken, remainingTokens: TopLevelToken[]) => void;
+    render: (this: Tag & TagImplOptions, ctx: Context, emitter: Emitter, hash: Record<string, any>) => TagRenderReturn;
+}
+export declare function createTagClass(options: TagImplOptions): TagClass;

package/dist/node_modules/liquidjs/dist/template/tag.d.ts

@@ -0,0 +1,18 @@
+import { TemplateImpl } from './template-impl';
+import type { Emitter } from '../emitters/emitter';
+import type { Parser, Tokenizer } from '../parser';
+import type { Context } from '../context/context';
+import type { TopLevelToken, TagToken } from '../tokens';
+import type { Template } from './template';
+import type { Liquid } from '../liquid';
+export type TagRenderReturn = Generator<unknown, unknown, unknown> | Promise<unknown> | unknown;
+export declare abstract class Tag extends TemplateImpl<TagToken> implements Template {
+    name: string;
+    liquid: Liquid;
+    protected tokenizer: Tokenizer;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    abstract render(ctx: Context, emitter: Emitter): TagRenderReturn;
+}
+export interface TagClass {
+    new (token: TagToken, tokens: TopLevelToken[], liquid: Liquid, parser: Parser): Tag;
+}

package/dist/node_modules/liquidjs/dist/template/template-impl.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class TemplateImpl<T> {
+    token: T;
+    constructor(token: T);
+}

package/dist/node_modules/liquidjs/dist/template/template.d.ts

@@ -0,0 +1,36 @@
+import { Context } from '../context/context';
+import { Token } from '../tokens/token';
+import { Emitter } from '../emitters/emitter';
+import { IdentifierToken, QuotedToken, ValueToken } from '../tokens';
+import { Value } from './value';
+export type Argument = Value | ValueToken;
+export type Arguments = Iterable<Argument>;
+/** Scope information used when analyzing partial templates. */
+export interface PartialScope {
+    /**
+     * The name of the partial template. We need this to make sure we only analyze
+     * each template once.
+     * */
+    name: string;
+    /**
+     * If `true`, names in `scope` will be added to a new, isolated scope before
+     * analyzing any child templates, without access to the parent template's scope.
+     */
+    isolated: boolean;
+    /**
+     * A list of names that will be in scope for the child template.
+     *
+     * If an item is a [string, Argument] tuple, the string is considered an alias
+     * for the argument.
+     */
+    scope: Iterable<string | [string, Argument]>;
+}
+export interface Template {
+    token: Token;
+    render(ctx: Context, emitter: Emitter): any;
+    children?(partials: boolean, sync: boolean): Generator<unknown, Template[]>;
+    arguments?(): Arguments;
+    blockScope?(): Iterable<string>;
+    localScope?(): Iterable<IdentifierToken | QuotedToken>;
+    partialScope?(): PartialScope | undefined;
+}

package/dist/node_modules/liquidjs/dist/template/value.d.ts

@@ -0,0 +1,15 @@
+import { Filter } from './filter';
+import { Expression } from '../render';
+import type { FilteredValueToken } from '../tokens';
+import type { Liquid } from '../liquid';
+import type { Context } from '../context';
+export declare class Value {
+    readonly filters: Filter[];
+    readonly initial: Expression;
+    /**
+     * @param str the value to be valuated, eg.: "foobar" | truncate: 3
+     */
+    constructor(input: string | FilteredValueToken, liquid: Liquid);
+    value(ctx: Context, lenient?: boolean): Generator<unknown, unknown, unknown>;
+    private getFilter;
+}

package/dist/node_modules/liquidjs/dist/template/value.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/liquidjs/dist/tokens/delimited-token.d.ts

@@ -0,0 +1,9 @@
+import { Token } from './token';
+import { TokenKind } from '../parser';
+export declare abstract class DelimitedToken extends Token {
+    trimLeft: boolean;
+    trimRight: boolean;
+    contentRange: [number, number];
+    constructor(kind: TokenKind, [contentBegin, contentEnd]: [number, number], input: string, begin: number, end: number, trimLeft: boolean, trimRight: boolean, file?: string);
+    get content(): string;
+}

package/dist/node_modules/liquidjs/dist/tokens/filter-token.d.ts

@@ -0,0 +1,7 @@
+import { Token } from './token';
+import { FilterArg } from '../parser/filter-arg';
+export declare class FilterToken extends Token {
+    name: string;
+    args: FilterArg[];
+    constructor(name: string, args: FilterArg[], input: string, begin: number, end: number, file?: string);
+}

package/dist/node_modules/liquidjs/dist/tokens/filtered-value-token.d.ts

@@ -0,0 +1,17 @@
+import { Token } from './token';
+import { FilterToken } from './filter-token';
+import { Expression } from '../render';
+/**
+ * value expression with optional filters
+ * e.g.
+ * {% assign foo="bar" | append: "coo" %}
+ */
+export declare class FilteredValueToken extends Token {
+    initial: Expression;
+    filters: FilterToken[];
+    input: string;
+    begin: number;
+    end: number;
+    file?: string | undefined;
+    constructor(initial: Expression, filters: FilterToken[], input: string, begin: number, end: number, file?: string | undefined);
+}

package/dist/node_modules/liquidjs/dist/tokens/hash-token.d.ts

@@ -0,0 +1,12 @@
+import { Token } from './token';
+import { ValueToken } from './value-token';
+import { IdentifierToken } from './identifier-token';
+export declare class HashToken extends Token {
+    input: string;
+    begin: number;
+    end: number;
+    name: IdentifierToken;
+    value?: ValueToken | undefined;
+    file?: string | undefined;
+    constructor(input: string, begin: number, end: number, name: IdentifierToken, value?: ValueToken | undefined, file?: string | undefined);
+}

package/dist/node_modules/liquidjs/dist/tokens/html-token.d.ts

@@ -0,0 +1,11 @@
+import { Token } from './token';
+export declare class HTMLToken extends Token {
+    input: string;
+    begin: number;
+    end: number;
+    file?: string | undefined;
+    trimLeft: number;
+    trimRight: number;
+    constructor(input: string, begin: number, end: number, file?: string | undefined);
+    getContent(): string;
+}

package/dist/node_modules/liquidjs/dist/tokens/identifier-token.d.ts

@@ -0,0 +1,9 @@
+import { Token } from './token';
+export declare class IdentifierToken extends Token {
+    input: string;
+    begin: number;
+    end: number;
+    file?: string | undefined;
+    content: string;
+    constructor(input: string, begin: number, end: number, file?: string | undefined);
+}

package/dist/node_modules/liquidjs/dist/tokens/index.d.ts

@@ -0,0 +1,18 @@
+export * from './top-level-token';
+export * from './tag-token';
+export * from './output-token';
+export * from './html-token';
+export * from './number-token';
+export * from './identifier-token';
+export * from './literal-token';
+export * from './operator-token';
+export * from './property-access-token';
+export * from './filter-token';
+export * from './hash-token';
+export * from './quoted-token';
+export * from './token';
+export * from './range-token';
+export * from './value-token';
+export * from './liquid-tag-token';
+export * from './delimited-token';
+export * from './filtered-value-token';

package/dist/node_modules/liquidjs/dist/tokens/liquid-tag-token.d.ts

@@ -0,0 +1,12 @@
+import { DelimitedToken } from './delimited-token';
+import { NormalizedFullOptions } from '../liquid-options';
+import { Tokenizer } from '../parser';
+/**
+ * LiquidTagToken is different from TagToken by not having delimiters `{%` or `%}`
+ */
+export declare class LiquidTagToken extends DelimitedToken {
+    name: string;
+    tokenizer: Tokenizer;
+    constructor(input: string, begin: number, end: number, options: NormalizedFullOptions, file?: string);
+    get args(): string;
+}

package/dist/node_modules/liquidjs/dist/tokens/literal-token.d.ts

@@ -0,0 +1,11 @@
+import { Token } from './token';
+import { LiteralValue } from '../util';
+export declare class LiteralToken extends Token {
+    input: string;
+    begin: number;
+    end: number;
+    file?: string | undefined;
+    content: LiteralValue;
+    literal: string;
+    constructor(input: string, begin: number, end: number, file?: string | undefined);
+}

package/dist/node_modules/liquidjs/dist/tokens/number-token.d.ts

@@ -0,0 +1,9 @@
+import { Token } from './token';
+export declare class NumberToken extends Token {
+    input: string;
+    begin: number;
+    end: number;
+    file?: string | undefined;
+    content: number;
+    constructor(input: string, begin: number, end: number, file?: string | undefined);
+}

package/dist/node_modules/liquidjs/dist/tokens/operator-token.d.ts

@@ -0,0 +1,38 @@
+import { Token } from './token';
+export declare const enum OperatorType {
+    Binary = 0,
+    Unary = 1
+}
+export declare const operatorPrecedences: {
+    '==': number;
+    '!=': number;
+    '>': number;
+    '<': number;
+    '>=': number;
+    '<=': number;
+    contains: number;
+    not: number;
+    and: number;
+    or: number;
+};
+export declare const operatorTypes: {
+    '==': OperatorType;
+    '!=': OperatorType;
+    '>': OperatorType;
+    '<': OperatorType;
+    '>=': OperatorType;
+    '<=': OperatorType;
+    contains: OperatorType;
+    not: OperatorType;
+    and: OperatorType;
+    or: OperatorType;
+};
+export declare class OperatorToken extends Token {
+    input: string;
+    begin: number;
+    end: number;
+    file?: string | undefined;
+    operator: string;
+    constructor(input: string, begin: number, end: number, file?: string | undefined);
+    getPrecedence(): any;
+}

package/dist/node_modules/liquidjs/dist/tokens/output-token.d.ts

@@ -0,0 +1,5 @@
+import { DelimitedToken } from './delimited-token';
+import { NormalizedFullOptions } from '../liquid-options';
+export declare class OutputToken extends DelimitedToken {
+    constructor(input: string, begin: number, end: number, options: NormalizedFullOptions, file?: string);
+}