@skeptools/skep-organization-project 0.0.14 → 0.0.16

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

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

package/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';

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

@@ -1,7 +1,6 @@
-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);
+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;

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

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

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

@@ -1,21 +1,19 @@
-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 {
+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[]): Tag | Output | HTML;
+    parseToken(token: TopLevelToken, remainTokens: TopLevelToken[]): import("../template").Tag | Output | HTML;
     parseStream(tokens: TopLevelToken[]): ParseStream<TopLevelToken>;
     private _parseFileCached;
     private _parseFile;

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

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

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

@@ -11,5 +11,6 @@ export declare enum TokenKind {
     Range = 512,
     Quoted = 1024,
     Operator = 2048,
+    FilteredValue = 4096,
     Delimited = 12
 }

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

@@ -1,59 +1,56 @@
-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 { 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 { Trie } from '../util/operator-trie';
-import { Expression } from '../render/expression';
-import { LiquidTagToken } from '../tokens/liquid-tag-token';
+import { FilterArg } from './filter-arg';
 export declare class Tokenizer {
     input: string;
-    private trie;
-    file: string;
+    file?: string | undefined;
     p: number;
     N: number;
     private rawBeginAt;
-    constructor(input: string, trie?: Trie, file?: string);
+    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): number;
+    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;
-    mkError(msg: string, begin: number): TokenizationError;
+    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
+     * @deprecated use #readIdentifier instead
      */
     readWord(): IdentifierToken;
     readIdentifier(): IdentifierToken;
+    readNonEmptyIdentifier(): IdentifierToken | undefined;
     readTagName(): string;
-    readHashes(jekyllStyle?: boolean): HashToken[];
-    readHash(jekyllStyle?: boolean): HashToken | undefined;
+    readHashes(jekyllStyle?: boolean | string): HashToken[];
+    readHash(jekyllStyle?: boolean | string): HashToken | undefined;
     remaining(): string;
-    advance(i?: number): void;
+    advance(step?: number): void;
     end(): boolean;
+    read(): string;
     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;

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

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

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

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

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

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

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

@@ -1,14 +1,10 @@
-import { QuotedToken } from '../tokens/quoted-token';
-import { Token } from '../tokens/token';
-import { Context } from '../context/context';
+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;
 }
-/**
- * @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 evalToken(token: Token | undefined, ctx: Context, lenient?: boolean): IterableIterator<unknown>;
 export declare function evalQuotedToken(token: QuotedToken): string;

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

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

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

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

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

@@ -1,5 +1,7 @@
-import { Context } from '../context/context';
-export interface Operators {
-    [key: string]: (lhs: any, rhs: any, ctx: Context) => boolean;
-}
+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;

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { Context } from '../context/context';
-import { Template } from '../template/template';
-import { Emitter } from '../emitters/emitter';
+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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/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[]>;
+}

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

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

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

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

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

package/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/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>;

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

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

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

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

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

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

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

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

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

@@ -1,8 +1,7 @@
-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';
+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);

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

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

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

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

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

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

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