@skeptools/skep-organization-project 0.0.15 → 0.0.17

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

@@ -9,6 +9,7 @@ export declare class Parser {
     private fs;
     private cache?;
     private loader;
+    private parseLimit;
     constructor(liquid: Liquid);
     parse(html: string, filepath?: string): Template[];
     parseTokens(tokens: TopLevelToken[]): Template[];

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

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

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

@@ -23,7 +23,7 @@ export declare class Tokenizer {
     readTopLevelTokens(options?: NormalizedFullOptions): TopLevelToken[];
     readTopLevelToken(options: NormalizedFullOptions): TopLevelToken;
     readHTMLToken(stopStrings: string[]): HTMLToken;
-    readTagToken(options?: NormalizedFullOptions): TagToken;
+    readTagToken(options: NormalizedFullOptions): TagToken;
     readToDelimiter(delimiter: string, respectQuoted?: boolean): number;
     readOutputToken(options?: NormalizedFullOptions): OutputToken;
     readEndrawOrRawContent(options: NormalizedFullOptions): HTMLToken | TagToken;
@@ -39,11 +39,12 @@ export declare class Tokenizer {
     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(step?: number): void;
     end(): boolean;
+    read(): string;
     readTo(end: string): number;
     readValue(): ValueToken | undefined;
     readScopeValue(): ValueToken | undefined;

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

@@ -1,7 +1,7 @@
 import { QuotedToken, Token } from '../tokens';
 import type { Context } from '../context';
 export declare class Expression {
-    private postfix;
+    readonly postfix: Token[];
     constructor(tokens: IterableIterator<Token>);
     evaluate(ctx: Context, lenient?: boolean): Generator<unknown, unknown, unknown>;
     valid(): boolean;

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

@@ -5,3 +5,4 @@ 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;
+export declare function arrayIncludes(arr: any[], item: any): boolean;

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

@@ -1,7 +1,12 @@
 import { Liquid, TopLevelToken, TagToken, Context, Tag } from '..';
+import { Arguments } from '../template';
+import { IdentifierToken } from '../tokens';
 export default class extends Tag {
     private key;
     private value;
+    private identifier;
     constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
     render(ctx: Context): Generator<unknown, void, unknown>;
+    arguments(): Arguments;
+    localScope(): Iterable<IdentifierToken>;
 }

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

@@ -1,8 +1,11 @@
 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);
+    constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
     render(ctx: Context, emitter: Emitter): Generator<any, void, unknown>;
     private getBlockRender;
+    children(): Generator<unknown, Template[]>;
+    blockScope(): Iterable<string>;
 }

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

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

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

@@ -1,8 +1,13 @@
 import { Liquid, Tag, Template, Context, TagToken, TopLevelToken } from '..';
+import { Parser } from '../parser';
+import { IdentifierToken, QuotedToken } from '../tokens';
 export default class extends Tag {
+    identifier: IdentifierToken | QuotedToken;
     variable: string;
     templates: Template[];
-    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);
+    constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser);
+    private readVariable;
     render(ctx: Context): Generator<unknown, void, string>;
-    private readVariableName;
+    children(): Generator<unknown, Template[]>;
+    localScope(): Iterable<string | IdentifierToken | QuotedToken>;
 }

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

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

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

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

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

@@ -1,7 +1,9 @@
 import { TopLevelToken, Liquid, Emitter, TagToken, Context, Tag } from '..';
+import { Arguments } from '../template';
 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>;
+    arguments(): Arguments;
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,12 +2,14 @@ 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;
-    constructor(name: string, options: FilterImplOptions | undefined, args: FilterArg[], liquid: Liquid);
+    private token;
+    constructor(token: FilterToken, options: FilterImplOptions | undefined, liquid: Liquid);
     render(value: any, context: Context): IterableIterator<unknown>;
 }

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

@@ -1,4 +1,5 @@
 import { Context } from '../context/context';
+import { Tokenizer } from '../parser/tokenizer';
 import { Token } from '../tokens/token';
 type HashValueTokens = Record<string, Token | undefined>;
 /**
@@ -11,7 +12,7 @@ type HashValueTokens = Record<string, Token | undefined>;
  */
 export declare class Hash {
     hash: HashValueTokens;
-    constructor(markup: string, jekyllStyle?: boolean);
+    constructor(input: string | Tokenizer, jekyllStyle?: boolean | string);
     render(ctx: Context): Generator<unknown, Record<string, any>, unknown>;
 }
 export {};

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

@@ -8,3 +8,4 @@ export * from './hash';
 export * from './value';
 export * from './output';
 export * from './html';
+export * from './analysis';

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

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

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

@@ -1,6 +1,6 @@
 import { TemplateImpl } from './template-impl';
 import type { Emitter } from '../emitters/emitter';
-import type { Tokenizer } from '../parser';
+import type { Parser, Tokenizer } from '../parser';
 import type { Context } from '../context/context';
 import type { TopLevelToken, TagToken } from '../tokens';
 import type { Template } from './template';
@@ -14,5 +14,5 @@ export declare abstract class Tag extends TemplateImpl<TagToken> implements Temp
     abstract render(ctx: Context, emitter: Emitter): TagRenderReturn;
 }
 export interface TagClass {
-    new (token: TagToken, tokens: TopLevelToken[], liquid: Liquid): Tag;
+    new (token: TagToken, tokens: TopLevelToken[], liquid: Liquid, parser: Parser): Tag;
 }

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

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

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

@@ -6,5 +6,4 @@ export declare class IdentifierToken extends Token {
     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

@@ -6,7 +6,7 @@ import { Tokenizer } from '../parser';
  */
 export declare class LiquidTagToken extends DelimitedToken {
     name: string;
-    args: string;
     tokenizer: Tokenizer;
     constructor(input: string, begin: number, end: number, options: NormalizedFullOptions, file?: string);
+    get args(): string;
 }

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

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

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

@@ -1,9 +1,9 @@
 import { Token } from '../tokens/token';
 import { Template } from '../template/template';
 export declare abstract class LiquidError extends Error {
-    private token;
+    token: Token;
     context: string;
-    private originalError?;
+    originalError?: Error;
     constructor(err: Error | string, token: Token);
     protected update(): void;
     static is(obj: unknown): obj is LiquidError;
@@ -18,6 +18,11 @@ export declare class RenderError extends LiquidError {
     constructor(err: Error, tpl: Template);
     static is(obj: any): obj is RenderError;
 }
+export declare class LiquidErrors extends LiquidError {
+    errors: RenderError[];
+    constructor(errors: RenderError[]);
+    static is(obj: any): obj is LiquidErrors;
+}
 export declare class UndefinedVariableError extends LiquidError {
     constructor(err: Error, token: Token);
 }

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

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

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

@@ -8,4 +8,5 @@ export * from './type-guards';
 export * from './async';
 export * from './strftime';
 export * from './liquid-date';
-export * from './timezone-date';
+export * from './limiter';
+export * from './intl';

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

@@ -0,0 +1,6 @@
+export declare function getDateTimeFormat(): {
+    (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): Intl.DateTimeFormat;
+    new (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): Intl.DateTimeFormat;
+    supportedLocalesOf(locales: string | string[], options?: Intl.DateTimeFormatOptions | undefined): string[];
+    readonly prototype: Intl.DateTimeFormat;
+} | undefined;

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

@@ -0,0 +1,8 @@
+export declare class Limiter {
+    private message;
+    private base;
+    private limit;
+    constructor(resource: string, limit: number);
+    use(count: number): void;
+    check(count: number): void;
+}