@skeptools/skep-organization-project 0.0.0

package/node_modules/liquidjs/dist/parser/filter-arg.d.ts

@@ -0,0 +1,5 @@
+import { ValueToken } from '../tokens/value-token';
+declare type KeyValuePair = [string?, ValueToken?];
+export declare type FilterArg = ValueToken | KeyValuePair;
+export declare function isKeyValuePair(arr: FilterArg): arr is KeyValuePair;
+export {};

package/node_modules/liquidjs/dist/parser/match-operator.d.ts

@@ -0,0 +1,2 @@
+import { Trie } from '../util/operator-trie';
+export declare function matchOperator(str: string, begin: number, trie: Trie, end?: number): number;

package/node_modules/liquidjs/dist/parser/parse-stream.d.ts

@@ -0,0 +1,16 @@
+import { Token } from '../tokens/token';
+import { Template } from '../template/template';
+import { TopLevelToken } from '../tokens/toplevel-token';
+declare type ParseToken<T extends Token> = ((token: T, remainTokens: T[]) => Template);
+export declare class ParseStream<T extends Token = TopLevelToken> {
+    private tokens;
+    private handlers;
+    private stopRequested;
+    private parseToken;
+    constructor(tokens: T[], parseToken: ParseToken<T>);
+    on<T2 extends Template | T | undefined>(name: string, cb: (this: ParseStream, arg: T2) => void): ParseStream<T>;
+    private trigger;
+    start(): this;
+    stop(): this;
+}
+export {};

package/node_modules/liquidjs/dist/parser/parse-string-literal.d.ts

@@ -0,0 +1 @@
+export declare function parseStringLiteral(str: string): string;

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

@@ -0,0 +1,22 @@
+import { Liquid } from '../liquid';
+import { ParseStream } from './parse-stream';
+import { Tag } from '../template/tag/tag';
+import { Output } from '../template/output';
+import { HTML } from '../template/html';
+import { Template } from '../template/template';
+import { TopLevelToken } from '../tokens/toplevel-token';
+import { LookupType } from '../fs/loader';
+export default class Parser {
+    parseFile: (file: string, sync?: boolean, type?: LookupType, currentFile?: string) => Generator<unknown, Template[], Template[] | string>;
+    private liquid;
+    private fs;
+    private cache?;
+    private loader;
+    constructor(liquid: Liquid);
+    parse(html: string, filepath?: string): Template[];
+    parseTokens(tokens: TopLevelToken[]): Template[];
+    parseToken(token: TopLevelToken, remainTokens: TopLevelToken[]): Tag | Output | HTML;
+    parseStream(tokens: TopLevelToken[]): ParseStream<TopLevelToken>;
+    private _parseFileCached;
+    private _parseFile;
+}

package/node_modules/liquidjs/dist/parser/token-kind.d.ts

@@ -0,0 +1,15 @@
+export declare enum TokenKind {
+    Number = 1,
+    Literal = 2,
+    Tag = 4,
+    Output = 8,
+    HTML = 16,
+    Filter = 32,
+    Hash = 64,
+    PropertyAccess = 128,
+    Word = 256,
+    Range = 512,
+    Quoted = 1024,
+    Operator = 2048,
+    Delimited = 12
+}

package/node_modules/liquidjs/dist/parser/tokenizer.d.ts

@@ -0,0 +1,66 @@
+import { IdentifierToken } from '../tokens/identifier-token';
+import { OperatorToken } from '../tokens/operator-token';
+import { TopLevelToken } from '../tokens/toplevel-token';
+import { FilterArg } from './filter-arg';
+import { FilterToken } from '../tokens/filter-token';
+import { HashToken } from '../tokens/hash-token';
+import { QuotedToken } from '../tokens/quoted-token';
+import { HTMLToken } from '../tokens/html-token';
+import { TagToken } from '../tokens/tag-token';
+import { Token } from '../tokens/token';
+import { RangeToken } from '../tokens/range-token';
+import { ValueToken } from '../tokens/value-token';
+import { OutputToken } from '../tokens/output-token';
+import { TokenizationError } from '../util/error';
+import { NormalizedFullOptions } from '../liquid-options';
+import { Trie } from '../util/operator-trie';
+import { Expression } from '../render/expression';
+import { LiquidTagToken } from '../tokens/liquid-tag-token';
+export declare class Tokenizer {
+    input: string;
+    private trie;
+    file: string;
+    p: number;
+    N: number;
+    private rawBeginAt;
+    constructor(input: string, trie?: Trie, file?: string);
+    readExpression(): Expression;
+    readExpressionTokens(): IterableIterator<Token>;
+    readOperator(): OperatorToken | undefined;
+    readFilters(): FilterToken[];
+    readFilter(): FilterToken | null;
+    readFilterArg(): FilterArg | undefined;
+    readTopLevelTokens(options?: NormalizedFullOptions): TopLevelToken[];
+    readTopLevelToken(options: NormalizedFullOptions): TopLevelToken;
+    readHTMLToken(stopStrings: string[]): HTMLToken;
+    readTagToken(options?: NormalizedFullOptions): TagToken;
+    readToDelimiter(delimiter: string): number;
+    readOutputToken(options?: NormalizedFullOptions): OutputToken;
+    readEndrawOrRawContent(options: NormalizedFullOptions): HTMLToken | TagToken;
+    readLiquidTagTokens(options?: NormalizedFullOptions): LiquidTagToken[];
+    readLiquidTagToken(options: NormalizedFullOptions): LiquidTagToken;
+    mkError(msg: string, begin: number): TokenizationError;
+    snapshot(begin?: number): string;
+    /**
+     * @deprecated
+     */
+    readWord(): IdentifierToken;
+    readIdentifier(): IdentifierToken;
+    readTagName(): string;
+    readHashes(jekyllStyle?: boolean): HashToken[];
+    readHash(jekyllStyle?: boolean): HashToken | undefined;
+    remaining(): string;
+    advance(i?: number): void;
+    end(): boolean;
+    readTo(end: string): number;
+    readValue(): ValueToken | undefined;
+    readRange(): RangeToken | undefined;
+    readValueOrThrow(): ValueToken;
+    readQuoted(): QuotedToken | undefined;
+    readFileNameTemplate(options: NormalizedFullOptions): IterableIterator<TopLevelToken>;
+    match(word: string): boolean;
+    rmatch(pattern: string): boolean;
+    peekType(n?: number): number;
+    peek(n?: number): string;
+    skipBlank(): void;
+}

package/node_modules/liquidjs/dist/parser/whitespace-ctrl.d.ts

@@ -0,0 +1,3 @@
+import { Token } from '../tokens/token';
+import { NormalizedFullOptions } from '../liquid-options';
+export declare function whiteSpaceCtrl(tokens: Token[], options: NormalizedFullOptions): void;

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

@@ -0,0 +1,3 @@
+import { Context } from '../context/context';
+export declare function isTruthy(val: any, ctx: Context): boolean;
+export declare function isFalsy(val: any, ctx: Context): boolean;

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

@@ -0,0 +1,14 @@
+import { QuotedToken } from '../tokens/quoted-token';
+import { Token } from '../tokens/token';
+import { Context } from '../context/context';
+export declare class Expression {
+    private postfix;
+    constructor(tokens: IterableIterator<Token>);
+    evaluate(ctx: Context, lenient?: boolean): Generator<unknown, unknown, unknown>;
+}
+/**
+ * @deprecated use `_evalToken` instead
+ */
+export declare function evalToken(token: Token | undefined, ctx: Context, lenient?: boolean): Generator<never, any, unknown>;
+export declare function _evalToken(token: Token | undefined, ctx: Context, lenient?: boolean): IterableIterator<unknown>;
+export declare function evalQuotedToken(token: QuotedToken): string;

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

@@ -0,0 +1,5 @@
+import { Context } from '../context/context';
+export interface Operators {
+    [key: string]: (lhs: any, rhs: any, ctx: Context) => boolean;
+}
+export declare const defaultOperators: Operators;

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Context } from '../context/context';
+import { Template } from '../template/template';
+import { Emitter } from '../emitters/emitter';
+export declare class Render {
+    renderTemplatesToNodeStream(templates: Template[], ctx: Context): NodeJS.ReadableStream;
+    renderTemplates(templates: Template[], ctx: Context, emitter?: Emitter): IterableIterator<any>;
+}

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

@@ -0,0 +1,4 @@
+import { FilterImpl } from './filter-impl';
+export interface FilterImplOptions {
+    (this: FilterImpl, value: any, ...args: any[]): any;
+}

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

@@ -0,0 +1,6 @@
+import { Context } from '../../context/context';
+import { Liquid } from '../../liquid';
+export interface FilterImpl {
+    context: Context;
+    liquid: Liquid;
+}

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

@@ -0,0 +1,13 @@
+import { FilterImplOptions } from './filter-impl-options';
+import { Filter } from './filter';
+import { FilterArg } from '../../parser/filter-arg';
+import { Liquid } from '../../liquid';
+export declare class FilterMap {
+    private readonly strictFilters;
+    private readonly liquid;
+    private impls;
+    constructor(strictFilters: boolean, liquid: Liquid);
+    get(name: string): FilterImplOptions;
+    set(name: string, impl: FilterImplOptions): void;
+    create(name: string, args: FilterArg[]): Filter;
+}

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { TemplateImpl } from '../template/template-impl';
+import { Template } from '../template/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 {
+    private value;
+    constructor(token: OutputToken, liquid: Liquid);
+    render(ctx: Context, emitter: Emitter): IterableIterator<unknown>;
+}

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

@@ -0,0 +1,17 @@
+import { Context } from '../../context/context';
+export interface HashValue {
+    [key: string]: any;
+}
+/**
+ * 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: HashValue;
+    constructor(markup: string, jekyllStyle?: boolean);
+    render(ctx: Context): Generator<unknown, HashValue, unknown>;
+}

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

@@ -0,0 +1,10 @@
+import { Context } from '../../context/context';
+import { TagToken } from '../../tokens/tag-token';
+import { TopLevelToken } from '../../tokens/toplevel-token';
+import { TagImpl } from './tag-impl';
+import { HashValue } from '../../template/tag/hash';
+import { Emitter } from '../../emitters/emitter';
+export interface TagImplOptions {
+    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>;
+}

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

@@ -0,0 +1,6 @@
+import { Liquid } from '../../liquid';
+import { TagImplOptions } from './tag-impl-options';
+export interface TagImpl extends TagImplOptions {
+    liquid: Liquid;
+    [key: string]: any;
+}

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

@@ -0,0 +1,6 @@
+import { TagImplOptions } from './tag-impl-options';
+export declare class TagMap {
+    private impls;
+    get(name: string): TagImplOptions;
+    set(name: string, impl: TagImplOptions): void;
+}

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

@@ -0,0 +1,10 @@
+import { Liquid } from '../../liquid';
+import { TemplateImpl } from '../../template/template-impl';
+import { Emitter, Context, TagToken, Template, TopLevelToken } from '../../types';
+import { HashValue } from './hash';
+export declare class Tag extends TemplateImpl<TagToken> implements Template {
+    name: string;
+    private impl;
+    constructor(token: TagToken, tokens: TopLevelToken[], liquid: Liquid);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, unknown, HashValue | unknown>;
+}

package/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/node_modules/liquidjs/dist/template/template.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '../context/context';
+import { Token } from '../tokens/token';
+import { Emitter } from '../emitters/emitter';
+export interface Template {
+    token: Token;
+    render(ctx: Context, emitter: Emitter): any;
+}

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

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

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

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

package/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/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/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/node_modules/liquidjs/dist/tokens/identifier-token.d.ts

@@ -0,0 +1,10 @@
+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);
+    isNumber(allowSign?: boolean): boolean;
+}

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { Token } from './token';
+import { IdentifierToken } from './identifier-token';
+export declare class NumberToken extends Token {
+    whole: IdentifierToken;
+    decimal?: IdentifierToken | undefined;
+    constructor(whole: IdentifierToken, decimal?: IdentifierToken | undefined);
+}

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

@@ -0,0 +1,21 @@
+import { Token } from './token';
+export declare const precedence: {
+    '==': number;
+    '!=': number;
+    '>': number;
+    '<': number;
+    '>=': number;
+    '<=': number;
+    contains: number;
+    and: number;
+    or: number;
+};
+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/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);
+}

package/node_modules/liquidjs/dist/tokens/property-access-token.d.ts

@@ -0,0 +1,9 @@
+import { Token } from './token';
+import { IdentifierToken } from './identifier-token';
+import { QuotedToken } from './quoted-token';
+export declare class PropertyAccessToken extends Token {
+    variable: IdentifierToken | QuotedToken;
+    props: (IdentifierToken | QuotedToken | PropertyAccessToken)[];
+    propertyName: string;
+    constructor(variable: IdentifierToken | QuotedToken, props: (IdentifierToken | QuotedToken | PropertyAccessToken)[], end: number);
+}

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

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

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

@@ -0,0 +1,11 @@
+import { Token } from './token';
+import { ValueToken } from './value-token';
+export declare class RangeToken extends Token {
+    input: string;
+    begin: number;
+    end: number;
+    lhs: ValueToken;
+    rhs: ValueToken;
+    file?: string | undefined;
+    constructor(input: string, begin: number, end: number, lhs: ValueToken, rhs: ValueToken, file?: string | undefined);
+}

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

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

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

@@ -0,0 +1,12 @@
+import { TokenKind } from '../parser/token-kind';
+export declare abstract class Token {
+    kind: TokenKind;
+    input: string;
+    begin: number;
+    end: number;
+    file?: string | undefined;
+    constructor(kind: TokenKind, input: string, begin: number, end: number, file?: string | undefined);
+    getText(): string;
+    getPosition(): number[];
+    size(): number;
+}

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

@@ -0,0 +1,4 @@
+import { TagToken } from './tag-token';
+import { HTMLToken } from './html-token';
+import { OutputToken } from './output-token';
+export declare type TopLevelToken = TagToken | OutputToken | HTMLToken;

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

@@ -0,0 +1,5 @@
+import { RangeToken } from './range-token';
+import { LiteralToken } from './literal-token';
+import { QuotedToken } from './quoted-token';
+import { PropertyAccessToken } from './property-access-token';
+export declare type ValueToken = RangeToken | LiteralToken | QuotedToken | PropertyAccessToken;

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

@@ -0,0 +1,30 @@
+import * as TypeGuards from './util/type-guards';
+export { TypeGuards };
+export { ParseError, TokenizationError, AssertionError } from './util/error';
+export { assert } from './util/assert';
+export { Drop } from './drop/drop';
+export { Emitter } from './emitters/emitter';
+export { Expression } from './render/expression';
+export { isFalsy, isTruthy } from './render/boolean';
+export { TagToken } from './tokens/tag-token';
+export { Context } from './context/context';
+export { Template } from './template/template';
+export { FilterImplOptions } from './template/filter/filter-impl-options';
+export { TagImplOptions } from './template/tag/tag-impl-options';
+export { TagImpl } from './template/tag/tag-impl';
+export { ParseStream } from './parser/parse-stream';
+export { Token } from './tokens/token';
+export { TokenKind } from './parser/token-kind';
+export { TopLevelToken } from './tokens/toplevel-token';
+export { Tokenizer } from './parser/tokenizer';
+export { Hash } from './template/tag/hash';
+export { Value } from './template/value';
+export { _evalToken, evalToken, evalQuotedToken } from './render/expression';
+export { toPromise, toThenable, toValueSync } from './util/async';
+export { defaultOperators, Operators } from './render/operator';
+export { createTrie, Trie } from './util/operator-trie';
+export { toValue } from './util/underscore';
+export { TimezoneDate } from './util/timezone-date';
+export * as filters from './builtin/filters';
+export * as tags from './builtin/tags';
+export { defaultOptions } from './liquid-options';

package/node_modules/liquidjs/dist/util/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert<T>(predicate: T | null | undefined, message?: string | (() => string)): void;

package/node_modules/liquidjs/dist/util/async.d.ts

@@ -0,0 +1,3 @@
+export declare function toPromise<T>(val: Generator<unknown, T, unknown> | Promise<T> | T): Promise<T>;
+export declare function toValueSync<T>(val: Generator<unknown, T, unknown> | T): T;
+export declare const toThenable: typeof toPromise;

package/node_modules/liquidjs/dist/util/character.d.ts

@@ -0,0 +1,8 @@
+export declare const TYPES: number[];
+export declare const IDENTIFIER = 1;
+export declare const OPERATOR = 2;
+export declare const BLANK = 4;
+export declare const QUOTE = 8;
+export declare const INLINE_BLANK = 16;
+export declare const NUMBER = 32;
+export declare const SIGN = 64;

package/node_modules/liquidjs/dist/util/collection.d.ts

@@ -0,0 +1,2 @@
+export declare function toEnumerable(val: any): any[];
+export declare function toArray(val: any): any[];

package/node_modules/liquidjs/dist/util/error.d.ts

@@ -0,0 +1,29 @@
+import { Token } from '../tokens/token';
+import { Template } from '../template/template';
+export declare abstract class LiquidError extends Error {
+    private token;
+    context: string;
+    private originalError;
+    constructor(err: Error, token: Token);
+    protected update(): void;
+}
+export declare class TokenizationError extends LiquidError {
+    constructor(message: string, token: Token);
+}
+export declare class ParseError extends LiquidError {
+    constructor(err: Error, token: Token);
+}
+export declare class RenderError extends LiquidError {
+    constructor(err: Error, tpl: Template);
+    static is(obj: any): obj is RenderError;
+}
+export declare class UndefinedVariableError extends LiquidError {
+    constructor(err: Error, token: Token);
+}
+export declare class InternalUndefinedVariableError extends Error {
+    variableName: string;
+    constructor(variableName: string);
+}
+export declare class AssertionError extends Error {
+    constructor(message: string);
+}

package/node_modules/liquidjs/dist/util/liquid-date.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The date interface LiquidJS uses.
+ * Basically a subset of JavaScript Date,
+ * it's defined abstractly here to allow different implementation
+ */
+export interface LiquidDate {
+    getTime(): number;
+    getMilliseconds(): number;
+    getSeconds(): number;
+    getMinutes(): number;
+    getHours(): number;
+    getDay(): number;
+    getDate(): number;
+    getMonth(): number;
+    getFullYear(): number;
+    getTimezoneOffset(): number;
+    toLocaleTimeString(): string;
+    toLocaleDateString(): string;
+}