Initial commit

node_modules/liquidjs/dist/build/fs-impl-browser.d.ts

@@ -0,0 +1,7 @@
+export declare function resolve(root: string, filepath: string, ext: string): string;
+export declare function readFile(url: string): Promise<string>;
+export declare function readFileSync(url: string): string;
+export declare function exists(filepath: string): Promise<boolean>;
+export declare function existsSync(filepath: string): boolean;
+export declare function dirname(filepath: string): string;
+export declare const sep = "/";

node_modules/liquidjs/dist/build/fs-impl-browser.spec.d.ts

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

node_modules/liquidjs/dist/build/streamed-emitter-browser.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Emitter } from '../emitters';
+export declare class StreamedEmitter implements Emitter {
+    buffer: string;
+    stream: NodeJS.ReadableStream;
+    constructor();
+    write: (html: any) => void;
+    error: (err: Error) => void;
+    end: () => void;
+}

node_modules/liquidjs/dist/build/streamed-emitter-browser.spec.d.ts

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

node_modules/liquidjs/dist/cache/cache.d.ts

@@ -0,0 +1,7 @@
+import type { Template } from '../template/template';
+export interface Cache<T> {
+    write(key: string, value: T): void | Promise<void>;
+    read(key: string): T | undefined | Promise<T | undefined>;
+    remove(key: string): void | Promise<void>;
+}
+export type LiquidCache = Cache<Template[] | Promise<Template[]>>;

node_modules/liquidjs/dist/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cache';
+export * from './lru';

node_modules/liquidjs/dist/cache/lru.d.ts

@@ -0,0 +1,14 @@
+import { Cache } from './cache';
+export declare class LRU<T> implements Cache<T> {
+    limit: number;
+    size: number;
+    private cache;
+    private head;
+    private tail;
+    constructor(limit: number, size?: number);
+    write(key: string, value: T): void;
+    read(key: string): T | undefined;
+    remove(key: string): void;
+    clear(): void;
+    private ensureLimit;
+}

node_modules/liquidjs/dist/cache/lru.spec.d.ts

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

node_modules/liquidjs/dist/context/block-mode.d.ts

@@ -0,0 +1,4 @@
+export declare enum BlockMode {
+    OUTPUT = 0,
+    STORE = 1
+}

node_modules/liquidjs/dist/context/context.d.ts

@@ -0,0 +1,61 @@
+import { NormalizedFullOptions, RenderOptions } from '../liquid-options';
+import { Scope } from './scope';
+import { Limiter } from '../util';
+type PropertyKey = string | number;
+export declare class Context {
+    /**
+     * insert a Context-level empty scope,
+     * for tags like `{% capture %}` `{% assign %}` to operate
+     */
+    private scopes;
+    private registers;
+    /**
+     * user passed in scope
+     * `{% increment %}`, `{% decrement %}` changes this scope,
+     * whereas `{% capture %}`, `{% assign %}` only hide this scope
+     */
+    environments: Scope;
+    /**
+     * global scope used as fallback for missing variables
+     */
+    globals: Scope;
+    sync: boolean;
+    /**
+     * The normalized liquid options object
+     */
+    opts: NormalizedFullOptions;
+    /**
+     * Throw when accessing undefined variable?
+     */
+    strictVariables: boolean;
+    ownPropertyOnly: boolean;
+    memoryLimit: Limiter;
+    renderLimit: Limiter;
+    constructor(env?: object, opts?: NormalizedFullOptions, renderOptions?: RenderOptions, { memoryLimit, renderLimit }?: {
+        [key: string]: Limiter;
+    });
+    getRegister(key: string): any;
+    setRegister(key: string, value: any): any;
+    saveRegister(...keys: string[]): [string, any][];
+    restoreRegister(keyValues: [string, any][]): void;
+    getAll(): Scope;
+    /**
+     * @deprecated use `_get()` or `getSync()` instead
+     */
+    get(paths: PropertyKey[]): unknown;
+    getSync(paths: PropertyKey[]): unknown;
+    _get(paths: PropertyKey[]): IterableIterator<unknown>;
+    /**
+     * @deprecated use `_get()` instead
+     */
+    getFromScope(scope: unknown, paths: PropertyKey[] | string): IterableIterator<unknown>;
+    _getFromScope(scope: unknown, paths: PropertyKey[] | string, strictVariables?: boolean): IterableIterator<unknown>;
+    push(ctx: object): number;
+    pop(): Scope | undefined;
+    bottom(): Scope;
+    spawn(scope?: {}): Context;
+    private findScope;
+}
+export declare function readProperty(obj: Scope, key: PropertyKey, ownPropertyOnly: boolean): any;
+export declare function readJSProperty(obj: Scope, key: PropertyKey, ownPropertyOnly: boolean): any;
+export {};

node_modules/liquidjs/dist/context/context.spec.d.ts

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

node_modules/liquidjs/dist/context/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context';
+export * from './scope';
+export * from './block-mode';

node_modules/liquidjs/dist/context/scope.d.ts

@@ -0,0 +1,6 @@
+import { Drop } from '../drop/drop';
+interface ScopeObject extends Record<string, any> {
+    toLiquid?: () => any;
+}
+export type Scope = ScopeObject | Drop;
+export {};

node_modules/liquidjs/dist/drop/blank-drop.d.ts

@@ -0,0 +1,4 @@
+import { EmptyDrop } from '../drop';
+export declare class BlankDrop extends EmptyDrop {
+    equals(value: any): boolean;
+}

node_modules/liquidjs/dist/drop/block-drop.d.ts

@@ -0,0 +1,10 @@
+import { Drop } from './drop';
+export declare class BlockDrop extends Drop {
+    private superBlockRender;
+    constructor(superBlockRender?: () => Iterable<any>);
+    /**
+     * Provide parent access in child block by
+     * {{ block.super }}
+     */
+    super(): Iterable<any>;
+}

node_modules/liquidjs/dist/drop/comparable.d.ts

@@ -0,0 +1,8 @@
+export interface Comparable {
+    equals: (rhs: any) => boolean;
+    gt: (rhs: any) => boolean;
+    geq: (rhs: any) => boolean;
+    lt: (rhs: any) => boolean;
+    leq: (rhs: any) => boolean;
+}
+export declare function isComparable(arg: any): arg is Comparable;

node_modules/liquidjs/dist/drop/drop.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class Drop {
+    liquidMethodMissing(key: string | number): Promise<any> | any;
+}

node_modules/liquidjs/dist/drop/empty-drop.d.ts

@@ -0,0 +1,10 @@
+import { Drop } from './drop';
+import { Comparable } from './comparable';
+export declare class EmptyDrop extends Drop implements Comparable {
+    equals(value: any): boolean;
+    gt(): boolean;
+    geq(): boolean;
+    lt(): boolean;
+    leq(): boolean;
+    valueOf(): string;
+}

node_modules/liquidjs/dist/drop/forloop-drop.d.ts

@@ -0,0 +1,15 @@
+import { Drop } from './drop';
+export declare class ForloopDrop extends Drop {
+    protected i: number;
+    name: string;
+    length: number;
+    constructor(length: number, collection: string, variable: string);
+    next(): void;
+    index0(): number;
+    index(): number;
+    first(): boolean;
+    last(): boolean;
+    rindex(): number;
+    rindex0(): number;
+    valueOf(): string;
+}

node_modules/liquidjs/dist/drop/index.d.ts

@@ -0,0 +1,7 @@
+export * from './drop';
+export * from './null-drop';
+export * from './empty-drop';
+export * from './blank-drop';
+export * from './forloop-drop';
+export * from './block-drop';
+export * from './comparable';

node_modules/liquidjs/dist/drop/null-drop.d.ts

@@ -0,0 +1,10 @@
+import { Drop } from './drop';
+import { Comparable } from './comparable';
+export declare class NullDrop extends Drop implements Comparable {
+    equals(value: any): boolean;
+    gt(): boolean;
+    geq(): boolean;
+    lt(): boolean;
+    leq(): boolean;
+    valueOf(): null;
+}

node_modules/liquidjs/dist/drop/tablerowloop-drop.d.ts

@@ -0,0 +1,10 @@
+import { ForloopDrop } from './forloop-drop';
+export declare class TablerowloopDrop extends ForloopDrop {
+    private cols;
+    constructor(length: number, cols: number, collection: string, variable: string);
+    row(): number;
+    col0(): number;
+    col(): number;
+    col_first(): boolean;
+    col_last(): boolean;
+}

node_modules/liquidjs/dist/emitters/emitter.d.ts

@@ -0,0 +1,11 @@
+export interface Emitter {
+    /**
+     * Write a html value into emitter
+     * @param html string, Drop or other primitive value
+     */
+    write(html: any): void;
+    /**
+     * Buffered string
+     */
+    buffer: string;
+}

node_modules/liquidjs/dist/emitters/index.d.ts

@@ -0,0 +1,4 @@
+export * from './emitter';
+export * from './simple-emitter';
+export * from '../build/streamed-emitter-browser';
+export * from './keeping-type-emitter';

node_modules/liquidjs/dist/emitters/keeping-type-emitter.d.ts

@@ -0,0 +1,5 @@
+import { Emitter } from './emitter';
+export declare class KeepingTypeEmitter implements Emitter {
+    buffer: any;
+    write(html: any): void;
+}

node_modules/liquidjs/dist/emitters/simple-emitter.d.ts

@@ -0,0 +1,5 @@
+import { Emitter } from './emitter';
+export declare class SimpleEmitter implements Emitter {
+    buffer: string;
+    write(html: any): void;
+}

node_modules/liquidjs/dist/emitters/streamed-emitter.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Emitter } from './emitter';
+export declare class StreamedEmitter implements Emitter {
+    buffer: string;
+    stream: NodeJS.ReadWriteStream;
+    write(html: any): void;
+    error(err: Error): void;
+    end(): void;
+}

node_modules/liquidjs/dist/filters/array.d.ts

@@ -0,0 +1,26 @@
+import { FilterImpl } from '../template';
+import type { Scope } from '../context';
+export declare const join: (this: unknown, v: any[], arg: string) => any;
+export declare const last: (this: unknown, v: any) => any;
+export declare const first: (this: unknown, v: any) => any;
+export declare const reverse: (this: unknown, v: any[]) => any;
+export declare function sort<T>(this: FilterImpl, arr: T[], property?: string): IterableIterator<unknown>;
+export declare function sort_natural<T>(this: FilterImpl, input: T[], property?: string): any[];
+export declare const size: (v: string | any[]) => number;
+export declare function map(this: FilterImpl, arr: Scope[], property: string): IterableIterator<unknown>;
+export declare function sum(this: FilterImpl, arr: Scope[], property?: string): IterableIterator<unknown>;
+export declare function compact<T>(this: FilterImpl, arr: T[]): any[];
+export declare function concat<T1, T2>(this: FilterImpl, v: T1[], arg?: T2[]): (T1 | T2)[];
+export declare function push<T>(this: FilterImpl, v: T[], arg: T): T[];
+export declare function unshift<T>(this: FilterImpl, v: T[], arg: T): T[];
+export declare function pop<T>(v: T[]): T[];
+export declare function shift<T>(this: FilterImpl, v: T[]): T[];
+export declare function slice<T>(this: FilterImpl, v: T[] | string, begin: number, length?: number): T[] | string;
+export declare function where<T extends object>(this: FilterImpl, arr: T[], property: string, expected?: any): IterableIterator<unknown>;
+export declare function where_exp<T extends object>(this: FilterImpl, arr: T[], itemName: string, exp: string): IterableIterator<unknown>;
+export declare function group_by<T extends object>(this: FilterImpl, arr: T[], property: string): IterableIterator<unknown>;
+export declare function group_by_exp<T extends object>(this: FilterImpl, arr: T[], itemName: string, exp: string): IterableIterator<unknown>;
+export declare function find<T extends object>(this: FilterImpl, arr: T[], property: string, expected: string): IterableIterator<unknown>;
+export declare function find_exp<T extends object>(this: FilterImpl, arr: T[], itemName: string, exp: string): IterableIterator<unknown>;
+export declare function uniq<T>(this: FilterImpl, arr: T[]): T[];
+export declare function sample<T>(this: FilterImpl, v: T[] | string, count?: number): T | string | (T | string)[];

node_modules/liquidjs/dist/filters/date.d.ts

@@ -0,0 +1,6 @@
+import { FilterImpl } from '../template';
+export declare function date(this: FilterImpl, v: string | Date, format?: string, timezoneOffset?: number | string): string | Date;
+export declare function date_to_xmlschema(this: FilterImpl, v: string | Date): string | Date;
+export declare function date_to_rfc822(this: FilterImpl, v: string | Date): string | Date;
+export declare function date_to_string(this: FilterImpl, v: string | Date, type?: string, style?: string): string | Date;
+export declare function date_to_long_string(this: FilterImpl, v: string | Date, type?: string, style?: string): string | Date;

node_modules/liquidjs/dist/filters/html.d.ts

@@ -0,0 +1,6 @@
+import { FilterImpl } from '../template';
+export declare function escape(this: FilterImpl, str: string): string;
+export declare function xml_escape(this: FilterImpl, str: string): string;
+export declare function escape_once(this: FilterImpl, str: string): string;
+export declare function newline_to_br(this: FilterImpl, v: string): string;
+export declare function strip_html(this: FilterImpl, v: string): string;

node_modules/liquidjs/dist/filters/index.d.ts

@@ -0,0 +1,2 @@
+import { FilterImplOptions } from '../template';
+export declare const filters: Record<string, FilterImplOptions>;

node_modules/liquidjs/dist/filters/math.d.ts

@@ -0,0 +1,11 @@
+export declare const abs: (this: unknown, x: number) => any;
+export declare const at_least: (this: unknown, ...args: number[]) => any;
+export declare const at_most: (this: unknown, ...args: number[]) => any;
+export declare const ceil: (this: unknown, x: number) => any;
+export declare const divided_by: (this: unknown, dividend: number, divisor: number, integerArithmetic?: any) => any;
+export declare const floor: (this: unknown, x: number) => any;
+export declare const minus: (this: unknown, v: number, arg: number) => any;
+export declare const modulo: (this: unknown, v: number, arg: number) => any;
+export declare const times: (this: unknown, v: number, arg: number) => any;
+export declare function round(v: number, arg?: number): number;
+export declare function plus(v: number, arg: number): number;

node_modules/liquidjs/dist/filters/misc.d.ts

@@ -0,0 +1,18 @@
+import { identify } from '../util/underscore';
+import { FilterImpl } from '../template';
+declare function defaultFilter<T1 extends boolean, T2>(this: FilterImpl, value: T1, defaultValue: T2, ...args: Array<[string, any]>): T1 | T2;
+declare function json(value: any, space?: number): string;
+declare function inspect(value: any, space?: number): string;
+declare function to_integer(value: any): number;
+declare const _default: {
+    default: typeof defaultFilter;
+    raw: {
+        raw: boolean;
+        handler: typeof identify;
+    };
+    jsonify: typeof json;
+    to_integer: typeof to_integer;
+    json: typeof json;
+    inspect: typeof inspect;
+};
+export default _default;

node_modules/liquidjs/dist/filters/string.d.ts

@@ -0,0 +1,27 @@
+/**
+ * String related filters
+ *
+ * * prefer stringify() to String() since `undefined`, `null` should eval ''
+ */
+import { FilterImpl } from '../template';
+export declare function append(this: FilterImpl, v: string, arg: string): string;
+export declare function prepend(this: FilterImpl, v: string, arg: string): string;
+export declare function lstrip(this: FilterImpl, v: string, chars?: string): string;
+export declare function downcase(this: FilterImpl, v: string): string;
+export declare function upcase(this: FilterImpl, v: string): string;
+export declare function remove(this: FilterImpl, v: string, arg: string): string;
+export declare function remove_first(this: FilterImpl, v: string, l: string): string;
+export declare function remove_last(this: FilterImpl, v: string, l: string): string;
+export declare function rstrip(this: FilterImpl, str: string, chars?: string): string;
+export declare function split(this: FilterImpl, v: string, arg: string): string[];
+export declare function strip(this: FilterImpl, v: string, chars?: string): string;
+export declare function strip_newlines(this: FilterImpl, v: string): string;
+export declare function capitalize(this: FilterImpl, str: string): string;
+export declare function replace(this: FilterImpl, v: string, pattern: string, replacement: string): string;
+export declare function replace_first(this: FilterImpl, v: string, arg1: string, arg2: string): string;
+export declare function replace_last(this: FilterImpl, v: string, arg1: string, arg2: string): string;
+export declare function truncate(this: FilterImpl, v: string, l?: number, o?: string): string;
+export declare function truncatewords(this: FilterImpl, v: string, words?: number, o?: string): string;
+export declare function normalize_whitespace(this: FilterImpl, v: string): string;
+export declare function number_of_words(this: FilterImpl, input: string, mode?: 'cjk' | 'auto'): number;
+export declare function array_to_sentence_string(this: FilterImpl, array: unknown[], connector?: string): unknown;

node_modules/liquidjs/dist/filters/url.d.ts

@@ -0,0 +1,14 @@
+export declare const url_decode: (x: string) => string;
+export declare const url_encode: (x: string) => string;
+export declare const cgi_escape: (x: string) => string;
+export declare const uri_escape: (x: string) => string;
+declare const rSlugifyReplacers: {
+    raw: RegExp;
+    default: RegExp;
+    pretty: RegExp;
+    ascii: RegExp;
+    latin: RegExp;
+    none: null;
+};
+export declare function slugify(str: string, mode?: keyof typeof rSlugifyReplacers, cased?: boolean): string;
+export {};

node_modules/liquidjs/dist/fs/fs-impl.d.ts

@@ -0,0 +1,9 @@
+export declare function exists(filepath: string): Promise<boolean>;
+export declare function readFile(filepath: string): Promise<string>;
+export declare function existsSync(filepath: string): boolean;
+export declare function readFileSync(filepath: string): string;
+export declare function resolve(root: string, file: string, ext: string): string;
+export declare function fallback(file: string): string | undefined;
+export declare function dirname(filepath: string): string;
+export declare function contains(root: string, file: string): boolean;
+export { sep } from 'path';

node_modules/liquidjs/dist/fs/fs-impl.spec.d.ts

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

node_modules/liquidjs/dist/fs/fs.d.ts

@@ -0,0 +1,20 @@
+export interface FS {
+    /** check if a file exists asynchronously */
+    exists: (filepath: string) => Promise<boolean>;
+    /** check if a file exists synchronously */
+    existsSync: (filepath: string) => boolean;
+    /** read a file asynchronously */
+    readFile: (filepath: string) => Promise<string>;
+    /** read a file synchronously */
+    readFileSync: (filepath: string) => string;
+    /** resolve a file against directory, for given `ext` option */
+    resolve: (dir: string, file: string, ext: string) => string;
+    /** check if file is contained in `root`, always return `true` by default. Warning: not setting this could expose path traversal vulnerabilities. */
+    contains?: (root: string, file: string) => boolean;
+    /** defaults to "/" */
+    sep?: string;
+    /** required for relative path resolving */
+    dirname?: (file: string) => string;
+    /** fallback file for lookup failure */
+    fallback?: (file: string) => string | undefined;
+}

node_modules/liquidjs/dist/fs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './loader';
+export * from './fs';

node_modules/liquidjs/dist/fs/loader.d.ts

@@ -0,0 +1,24 @@
+import { FS } from './fs';
+export interface LoaderOptions {
+    fs: FS;
+    extname: string;
+    root: string[];
+    partials: string[];
+    layouts: string[];
+    relativeReference: boolean;
+}
+export declare enum LookupType {
+    Partials = "partials",
+    Layouts = "layouts",
+    Root = "root"
+}
+export declare class Loader {
+    shouldLoadRelative: (referencedFile: string) => boolean;
+    private options;
+    private contains;
+    constructor(options: LoaderOptions);
+    lookup(file: string, type: LookupType, sync?: boolean, currentFile?: string): Generator<unknown, string, string>;
+    candidates(file: string, dirs: string[], currentFile?: string, enforceRoot?: boolean): Generator<string, void, unknown>;
+    private dirname;
+    private lookupError;
+}

node_modules/liquidjs/dist/fs/loader.spec.d.ts

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

node_modules/liquidjs/dist/fs/map-fs.d.ts

@@ -0,0 +1,13 @@
+export declare class MapFS {
+    private mapping;
+    constructor(mapping: {
+        [key: string]: string;
+    });
+    sep: string;
+    exists(filepath: string): Promise<boolean>;
+    existsSync(filepath: string): boolean;
+    readFile(filepath: string): Promise<string>;
+    readFileSync(filepath: string): string;
+    dirname(filepath: string): string;
+    resolve(dir: string, file: string, ext: string): string;
+}

node_modules/liquidjs/dist/fs/map-fs.spec.d.ts

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

node_modules/liquidjs/dist/fs/node-require.d.ts

@@ -0,0 +1 @@
+export declare const requireResolve: (partial: string) => string;

node_modules/liquidjs/dist/index.d.ts

@@ -0,0 +1,15 @@
+export declare const version = "[VI]{version}[/VI]";
+export * as TypeGuards from './util/type-guards';
+export { toValue, createTrie, Trie, toPromise, toValueSync, assert, LiquidError, ParseError, RenderError, UndefinedVariableError, TokenizationError, AssertionError } from './util';
+export { Drop } from './drop';
+export { Emitter } from './emitters';
+export { defaultOperators, Operators, evalToken, evalQuotedToken, Expression, isFalsy, isTruthy } from './render';
+export { Context, Scope } from './context';
+export { Value, Hash, Template, FilterImplOptions, Tag, Filter, Output } from './template';
+export { Token, TopLevelToken, TagToken, ValueToken } from './tokens';
+export { TokenKind, Tokenizer, ParseStream } from './parser';
+export { filters } from './filters';
+export * from './tags';
+export { defaultOptions, LiquidOptions } from './liquid-options';
+export { FS } from './fs';
+export { Liquid } from './liquid';

node_modules/liquidjs/dist/liquid-options.d.ts

@@ -0,0 +1,157 @@
+import { LiquidCache } from './cache';
+import { FS, LookupType } from './fs';
+import { Operators } from './render';
+type OutputEscape = (value: any) => string;
+type OutputEscapeOption = 'escape' | 'json' | OutputEscape;
+export interface LiquidOptions {
+    /** A directory or an array of directories from where to resolve layout and include templates, and the filename passed to `.renderFile()`. If it's an array, the files are looked up in the order they occur in the array. Defaults to `["."]` */
+    root?: string | string[];
+    /** A directory or an array of directories from where to resolve included templates. If it's an array, the files are looked up in the order they occur in the array. Defaults to `root` */
+    partials?: string | string[];
+    /** A directory or an array of directories from where to resolve layout templates. If it's an array, the files are looked up in the order they occur in the array. Defaults to `root` */
+    layouts?: string | string[];
+    /** Allow refer to layouts/partials by relative pathname. To avoid arbitrary filesystem read, paths been referenced also need to be within corresponding root, partials, layouts. Defaults to `true`. */
+    relativeReference?: boolean;
+    /** Use jekyll style include, pass parameters to `include` variable of current scope. Defaults to `false`. */
+    jekyllInclude?: boolean;
+    /** Add a extname (if filepath doesn't include one) before template file lookup. Eg: setting to `".html"` will allow including file by basename. Defaults to `""`. */
+    extname?: string;
+    /** Whether or not to cache resolved templates. Defaults to `false`. */
+    cache?: boolean | number | LiquidCache;
+    /** Use JavaScript Truthiness. Defaults to `false`. */
+    jsTruthy?: boolean;
+    /** If set, treat the `filepath` parameter in `{%include filepath %}` and `{%layout filepath%}` as a variable, otherwise as a literal value. Defaults to `true`. */
+    dynamicPartials?: boolean;
+    /** Whether or not to assert filter existence. If set to `false`, undefined filters will be skipped. Otherwise, undefined filters will cause an exception. Defaults to `false`. */
+    strictFilters?: boolean;
+    /** Whether or not to assert variable existence.  If set to `false`, undefined variables will be rendered as empty string.  Otherwise, undefined variables will cause an exception. Defaults to `false`. */
+    strictVariables?: boolean;
+    /** Catch all errors instead of exit upon one. Please note that render errors won't be reached when parse fails. */
+    catchAllErrors?: boolean;
+    /** Hide scope variables from prototypes, useful when you're passing a not sanitized object into LiquidJS or need to hide prototypes from templates. */
+    ownPropertyOnly?: boolean;
+    /** Modifies the behavior of `strictVariables`. If set, a single undefined variable will *not* cause an exception in the context of the `if`/`elsif`/`unless` tag and the `default` filter. Instead, it will evaluate to `false` and `null`, respectively. Irrelevant if `strictVariables` is not set. Defaults to `false`. **/
+    lenientIf?: boolean;
+    /** JavaScript timezone name or timezoneOffset for `date` filter, default to local time. That means if you're in Australia (UTC+10), it'll default to `-600` or `Australia/Lindeman` */
+    timezoneOffset?: number | string;
+    /** Default date format to use if the date filter doesn't include a format. Defaults to `%A, %B %-e, %Y at %-l:%M %P %z`. */
+    dateFormat?: string;
+    /** Default locale, will be used by date filter. Defaults to system locale. */
+    locale?: string;
+    /** Strip blank characters (including ` `, `\t`, and `\r`) from the right of tags (`{% %}`) until `\n` (inclusive). Defaults to `false`. */
+    trimTagRight?: boolean;
+    /** Similar to `trimTagRight`, whereas the `\n` is exclusive. Defaults to `false`. See Whitespace Control for details. */
+    trimTagLeft?: boolean;
+    /** Strip blank characters (including ` `, `\t`, and `\r`) from the right of values (`{{ }}`) until `\n` (inclusive). Defaults to `false`. */
+    trimOutputRight?: boolean;
+    /** Similar to `trimOutputRight`, whereas the `\n` is exclusive. Defaults to `false`. See Whitespace Control for details. */
+    trimOutputLeft?: boolean;
+    /** The left delimiter for liquid tags. **/
+    tagDelimiterLeft?: string;
+    /** The right delimiter for liquid tags. **/
+    tagDelimiterRight?: string;
+    /** The left delimiter for liquid outputs. **/
+    outputDelimiterLeft?: string;
+    /** The right delimiter for liquid outputs. **/
+    outputDelimiterRight?: string;
+    /** Whether input strings to date filter preserve the given timezone **/
+    preserveTimezones?: boolean;
+    /** Whether `trim*Left`/`trim*Right` is greedy. When set to `true`, all consecutive blank characters including `\n` will be trimmed regardless of line breaks. Defaults to `true`. */
+    greedy?: boolean;
+    /** `fs` is used to override the default file-system module with a custom implementation. */
+    fs?: FS;
+    /** keyValue separator */
+    keyValueSeparator?: string;
+    /** Render from in-memory `templates` mapping instead of file system. File system related options like `fs`, 'root', and `relativeReference` will be ignored when `templates` is specified. */
+    templates?: {
+        [key: string]: string;
+    };
+    /** the global scope passed down to all partial and layout templates, i.e. templates included by `include`, `layout` and `render` tags. */
+    globals?: object;
+    /** Whether or not to keep value type when writing the Output, not working for streamed rendering. Defaults to `false`. */
+    keepOutputType?: boolean;
+    /** Default escape filter applied to output values, when set, you'll have to add `| raw` for values don't need to be escaped. Defaults to `undefined`. */
+    outputEscape?: OutputEscapeOption;
+    /** An object of operators for conditional statements. Defaults to the regular Liquid operators. */
+    operators?: Operators;
+    /** Respect parameter order when using filters like "for ... reversed limit", Defaults to `false`. */
+    orderedFilterParameters?: boolean;
+    /** For DoS handling, limit total length of templates parsed in one `parse()` call. A typical PC can handle 1e8 (100M) characters without issues. */
+    parseLimit?: number;
+    /** For DoS handling, limit total time (in ms) for each `render()` call. */
+    renderLimit?: number;
+    /** For DoS handling, limit new objects creation, including array concat/join/strftime, etc. A typical PC can handle 1e9 (1G) memory without issue. */
+    memoryLimit?: number;
+}
+export interface RenderOptions {
+    /**
+     * This call is sync or async? It's used by Liquid internal methods, you'll not need this.
+     */
+    sync?: boolean;
+    /**
+     * Same as `globals` on LiquidOptions, but only for current render() call
+     */
+    globals?: object;
+    /**
+     * Same as `strictVariables` on LiquidOptions, but only for current render() call
+     */
+    strictVariables?: boolean;
+    /**
+     * Same as `ownPropertyOnly` on LiquidOptions, but only for current render() call
+     */
+    ownPropertyOnly?: boolean;
+    /** For DoS handling, limit total renders of tag/HTML/output in one `render()` call. A typical PC can handle 1e5 renders of typical templates per second. */
+    templateLimit?: number;
+    /** For DoS handling, limit total time (in ms) for each `render()` call. */
+    renderLimit?: number;
+    /** For DoS handling, limit new objects creation, including array concat/join/strftime, etc. A typical PC can handle 1e9 (1G) memory without issue.. */
+    memoryLimit?: number;
+}
+export interface RenderFileOptions extends RenderOptions {
+    lookupType?: LookupType;
+}
+interface NormalizedOptions extends LiquidOptions {
+    root?: string[];
+    partials?: string[];
+    layouts?: string[];
+    cache?: LiquidCache;
+    outputEscape?: OutputEscape;
+}
+export interface NormalizedFullOptions extends NormalizedOptions {
+    root: string[];
+    partials: string[];
+    layouts: string[];
+    relativeReference: boolean;
+    jekyllInclude: boolean;
+    extname: string;
+    cache?: LiquidCache;
+    jsTruthy: boolean;
+    dynamicPartials: boolean;
+    fs: FS;
+    strictFilters: boolean;
+    strictVariables: boolean;
+    ownPropertyOnly: boolean;
+    lenientIf: boolean;
+    dateFormat: string;
+    locale: string;
+    trimTagRight: boolean;
+    trimTagLeft: boolean;
+    trimOutputRight: boolean;
+    trimOutputLeft: boolean;
+    tagDelimiterLeft: string;
+    tagDelimiterRight: string;
+    outputDelimiterLeft: string;
+    outputDelimiterRight: string;
+    preserveTimezones: boolean;
+    greedy: boolean;
+    globals: object;
+    keepOutputType: boolean;
+    operators: Operators;
+    parseLimit: number;
+    renderLimit: number;
+    memoryLimit: number;
+}
+export declare const defaultOptions: NormalizedFullOptions;
+export declare function normalize(options: LiquidOptions): NormalizedFullOptions;
+export declare function normalizeDirectoryList(value: any): string[];
+export {};

node_modules/liquidjs/dist/liquid-options.spec.d.ts

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

node_modules/liquidjs/dist/liquid.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { Context } from './context';
+import { TagClass, TagImplOptions, FilterImplOptions, Template } from './template';
+import { LookupType } from './fs/loader';
+import { Render } from './render';
+import { Parser } from './parser';
+import { LiquidOptions, NormalizedFullOptions, RenderOptions, RenderFileOptions } from './liquid-options';
+export declare class Liquid {
+    readonly options: NormalizedFullOptions;
+    readonly renderer: Render;
+    /**
+     * @deprecated will be removed. In tags use `this.parser` instead
+     */
+    readonly parser: Parser;
+    readonly filters: Record<string, FilterImplOptions>;
+    readonly tags: Record<string, TagClass>;
+    constructor(opts?: LiquidOptions);
+    parse(html: string, filepath?: string): Template[];
+    _render(tpl: Template[], scope: Context | object | undefined, renderOptions: RenderOptions): IterableIterator<any>;
+    render(tpl: Template[], scope?: object, renderOptions?: RenderOptions): Promise<any>;
+    renderSync(tpl: Template[], scope?: object, renderOptions?: RenderOptions): any;
+    renderToNodeStream(tpl: Template[], scope?: object, renderOptions?: RenderOptions): NodeJS.ReadableStream;
+    _parseAndRender(html: string, scope: Context | object | undefined, renderOptions: RenderOptions): IterableIterator<any>;
+    parseAndRender(html: string, scope?: Context | object, renderOptions?: RenderOptions): Promise<any>;
+    parseAndRenderSync(html: string, scope?: Context | object, renderOptions?: RenderOptions): any;
+    _parsePartialFile(file: string, sync?: boolean, currentFile?: string): Generator<unknown, Template[], string | Template[]>;
+    _parseLayoutFile(file: string, sync?: boolean, currentFile?: string): Generator<unknown, Template[], string | Template[]>;
+    _parseFile(file: string, sync?: boolean, lookupType?: LookupType, currentFile?: string): Generator<unknown, Template[]>;
+    parseFile(file: string, lookupType?: LookupType): Promise<Template[]>;
+    parseFileSync(file: string, lookupType?: LookupType): Template[];
+    _renderFile(file: string, ctx: Context | object | undefined, renderFileOptions: RenderFileOptions): Generator<any>;
+    renderFile(file: string, ctx?: Context | object, renderFileOptions?: RenderFileOptions): Promise<any>;
+    renderFileSync(file: string, ctx?: Context | object, renderFileOptions?: RenderFileOptions): any;
+    renderFileToNodeStream(file: string, scope?: object, renderOptions?: RenderOptions): Promise<NodeJS.ReadableStream>;
+    _evalValue(str: string, scope?: object | Context): IterableIterator<any>;
+    evalValue(str: string, scope?: object | Context): Promise<any>;
+    evalValueSync(str: string, scope?: object | Context): any;
+    registerFilter(name: string, filter: FilterImplOptions): void;
+    registerTag(name: string, tag: TagClass | TagImplOptions): void;
+    plugin(plugin: (this: Liquid, L: typeof Liquid) => void): void;
+    express(): (this: any, filePath: string, ctx: object, callback: (err: Error | null, rendered: string) => void) => void;
+}

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

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

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

@@ -0,0 +1,4 @@
+export * from './tokenizer';
+export * from './parser';
+export * from './parse-stream';
+export * from './token-kind';

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

@@ -0,0 +1,15 @@
+import { Token, TopLevelToken } from '../tokens';
+import { Template } from '../template';
+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 {};

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+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,
+    FilteredValue = 4096,
+    Delimited = 12
+}

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

@@ -0,0 +1,62 @@
+import { FilteredValueToken, TagToken, HTMLToken, HashToken, QuotedToken, LiquidTagToken, OutputToken, ValueToken, Token, RangeToken, FilterToken, TopLevelToken, OperatorToken, LiteralToken, IdentifierToken, NumberToken } from '../tokens';
+import { Trie, TokenizationError } from '../util';
+import { Operators, Expression } from '../render';
+import { NormalizedFullOptions } from '../liquid-options';
+import { FilterArg } from './filter-arg';
+export declare class Tokenizer {
+    input: string;
+    file?: string | undefined;
+    p: number;
+    N: number;
+    private rawBeginAt;
+    private opTrie;
+    private literalTrie;
+    constructor(input: string, operators?: Operators, file?: string | undefined, range?: [number, number]);
+    readExpression(): Expression;
+    readExpressionTokens(): IterableIterator<Token>;
+    readOperator(): OperatorToken | undefined;
+    matchTrie<T>(trie: Trie<T>): number;
+    readFilteredValue(): FilteredValueToken;
+    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, respectQuoted?: boolean): number;
+    readOutputToken(options?: NormalizedFullOptions): OutputToken;
+    readEndrawOrRawContent(options: NormalizedFullOptions): HTMLToken | TagToken;
+    readLiquidTagTokens(options?: NormalizedFullOptions): LiquidTagToken[];
+    readLiquidTagToken(options: NormalizedFullOptions): LiquidTagToken | undefined;
+    error(msg: string, pos?: number): TokenizationError;
+    assert(pred: unknown, msg: string | (() => string), pos?: number): void;
+    snapshot(begin?: number): string;
+    /**
+     * @deprecated use #readIdentifier instead
+     */
+    readWord(): IdentifierToken;
+    readIdentifier(): IdentifierToken;
+    readNonEmptyIdentifier(): IdentifierToken | undefined;
+    readTagName(): string;
+    readHashes(jekyllStyle?: boolean | string): HashToken[];
+    readHash(jekyllStyle?: boolean | string): HashToken | undefined;
+    remaining(): string;
+    advance(step?: number): void;
+    end(): boolean;
+    readTo(end: string): number;
+    readValue(): ValueToken | undefined;
+    readScopeValue(): ValueToken | undefined;
+    private readProperties;
+    readNumber(): NumberToken | undefined;
+    readLiteral(): LiteralToken | 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;
+}

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

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

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

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

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;

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

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

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

@@ -0,0 +1,10 @@
+import { QuotedToken, Token } from '../tokens';
+import type { Context } from '../context';
+export declare class Expression {
+    private postfix;
+    constructor(tokens: IterableIterator<Token>);
+    evaluate(ctx: Context, lenient?: boolean): Generator<unknown, unknown, unknown>;
+    valid(): boolean;
+}
+export declare function evalToken(token: Token | undefined, ctx: Context, lenient?: boolean): IterableIterator<unknown>;
+export declare function evalQuotedToken(token: QuotedToken): string;

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

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

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

@@ -0,0 +1,4 @@
+export * from './render';
+export * from './expression';
+export * from './operator';
+export * from './boolean';

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

@@ -0,0 +1,7 @@
+import { Context } from '../context';
+export type UnaryOperatorHandler = (operand: any, ctx: Context) => boolean;
+export type BinaryOperatorHandler = (lhs: any, rhs: any, ctx: Context) => boolean;
+export type OperatorHandler = UnaryOperatorHandler | BinaryOperatorHandler;
+export type Operators = Record<string, OperatorHandler>;
+export declare const defaultOperators: Operators;
+export declare function equals(lhs: any, rhs: any): boolean;

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

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

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

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

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

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

node_modules/liquidjs/dist/render/string.spec.d.ts

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

node_modules/liquidjs/dist/tags/assign.d.ts

@@ -0,0 +1,7 @@
+import { Liquid, TopLevelToken, TagToken, Context, Tag } from '..';
+export default class extends Tag {
+    private key;
+    private value;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(ctx: Context): Generator<unknown, void, unknown>;
+}

node_modules/liquidjs/dist/tags/block.d.ts

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

node_modules/liquidjs/dist/tags/break.d.ts

@@ -0,0 +1,4 @@
+import { Context, Emitter, Tag } from '..';
+export default class extends Tag {
+    render(ctx: Context, emitter: Emitter): void;
+}

node_modules/liquidjs/dist/tags/capture.d.ts

@@ -0,0 +1,9 @@
+import { Liquid, Tag, Template, Context, TagToken, TopLevelToken } from '..';
+import { Parser } from '../parser';
+export default class extends Tag {
+    variable: string;
+    templates: Template[];
+    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    render(ctx: Context): Generator<unknown, void, string>;
+    private readVariableName;
+}

node_modules/liquidjs/dist/tags/case.d.ts

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

node_modules/liquidjs/dist/tags/comment.d.ts

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

node_modules/liquidjs/dist/tags/continue.d.ts

@@ -0,0 +1,4 @@
+import { Tag, Emitter, Context } from '..';
+export default class extends Tag {
+    render(ctx: Context, emitter: Emitter): void;
+}

node_modules/liquidjs/dist/tags/cycle.d.ts

@@ -0,0 +1,7 @@
+import { TopLevelToken, Liquid, Emitter, TagToken, Context, Tag } from '..';
+export default class extends Tag {
+    private candidates;
+    private group?;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, unknown, unknown>;
+}

node_modules/liquidjs/dist/tags/decrement.d.ts

@@ -0,0 +1,6 @@
+import { Tag, Liquid, TopLevelToken, Emitter, TagToken, Context } from '..';
+export default class extends Tag {
+    private variable;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(context: Context, emitter: Emitter): void;
+}

node_modules/liquidjs/dist/tags/echo.d.ts

@@ -0,0 +1,6 @@
+import { Liquid, TopLevelToken, Emitter, TagToken, Context, Tag } from '..';
+export default class extends Tag {
+    private value?;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(ctx: Context, emitter: Emitter): Generator<unknown, void, unknown>;
+}

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

@@ -0,0 +1,11 @@
+import { Hash, ValueToken, Liquid, Tag, Emitter, TagToken, TopLevelToken, Context, Template } from '..';
+import { Parser } from '../parser';
+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[]>;
+}

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

@@ -0,0 +1,11 @@
+import { Liquid, Tag, Value, Emitter, TagToken, TopLevelToken, Context, Template } from '..';
+import { Parser } from '../parser';
+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>;
+}

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

@@ -0,0 +1,8 @@
+import { TopLevelToken, Liquid, Tag, Emitter, TagToken, Context } from '..';
+import { Parser } from '../parser';
+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>;
+}

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

@@ -0,0 +1,6 @@
+import { Tag, Liquid, TopLevelToken, Emitter, TagToken, Context } from '..';
+export default class extends Tag {
+    private variable;
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    render(context: Context, emitter: Emitter): void;
+}

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 };

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;
+}

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

@@ -0,0 +1,10 @@
+import { Template, Liquid, Tag, Emitter, Hash, TagToken, TopLevelToken, Context } from '..';
+import { ParsedFileName } from './render';
+import { Parser } from '../parser';
+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>;
+}

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

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

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;
+}

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

@@ -0,0 +1,18 @@
+import { TopLevelToken, Liquid, Token, Template, Tokenizer, Emitter, TagToken, Context, Tag } from '..';
+import { Parser } from '../parser';
+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>;
+}
+/**
+ * @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>;

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

@@ -0,0 +1,10 @@
+import { ValueToken, Liquid, Tag, Emitter, Hash, TagToken, TopLevelToken, Context, Template } from '..';
+import { Parser } from '../parser';
+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>;
+}

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

@@ -0,0 +1,12 @@
+import { Liquid, Tag, Value, TopLevelToken, Template, Emitter, Context, TagToken } from '..';
+import { Parser } from '../parser';
+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>;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { Context } from '../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[];
+    readonly raw: boolean;
+    private handler;
+    private liquid;
+    constructor(name: string, options: FilterImplOptions | undefined, args: FilterArg[], liquid: Liquid);
+    render(value: any, context: Context): IterableIterator<unknown>;
+}

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

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