@skeptools/skep-organization-project 0.0.18 → 0.0.19

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

@@ -1,8 +1,8 @@
 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 json(this: FilterImpl, value: any, space?: number): string;
+declare function inspect(this: FilterImpl, value: any, space?: number): string;
 declare function to_integer(value: any): number;
 declare const _default: {
     default: typeof defaultFilter;

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

@@ -16,6 +16,7 @@ export declare function rstrip(this: FilterImpl, str: string, chars?: string): s
 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 squish(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;
@@ -24,4 +25,4 @@ export declare function truncate(this: FilterImpl, v: string, l?: number, o?: st
 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;
+export declare function array_to_sentence_string(this: FilterImpl, input: unknown, connector?: string): any;

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

@@ -5,5 +5,6 @@ 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 declare function contains(root: string, file: string): Promise<boolean>;
+export declare function containsSync(root: string, file: string): boolean;
 export { sep } from 'path';

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

@@ -9,8 +9,10 @@ export interface FS {
     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;
+    /** check if file is contained in `root`. Node default fs uses realpath; if omitted, loader assumes contained. */
+    contains?: (root: string, file: string) => Promise<boolean>;
+    /** sync check if file is contained in `root`, allows both renderSync and render. */
+    containsSync?: (root: string, file: string) => boolean;
     /** defaults to "/" */
     sep?: string;
     /** required for relative path resolving */

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

@@ -16,9 +16,10 @@ export declare class Loader {
     shouldLoadRelative: (referencedFile: string) => boolean;
     private options;
     private contains;
+    private exists;
     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>;
+    candidates(file: string, dirs: string[], currentFile?: string): Generator<string, void, unknown>;
     private dirname;
     private lookupError;
 }

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

@@ -1,15 +1,20 @@
 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 type { LiquidErrors } from './util/error';
 export { Drop } from './drop';
+export type { Comparable, ComparableResult } from './drop';
 export { Emitter } from './emitters';
-export { defaultOperators, Operators, evalToken, evalQuotedToken, Expression, isFalsy, isTruthy } from './render';
+export { defaultOperators, Operators, evalToken, evalTokenValue, evalQuotedToken, Expression, isFalsy, isTruthy } from './render';
 export { Context, Scope } from './context';
 export { Value, Hash, Template, FilterImplOptions, Tag, Filter, Output, Variable, VariableLocation, VariableSegments, Variables, StaticAnalysis, StaticAnalysisOptions, analyze, analyzeSync, Arguments, PartialScope } from './template';
+export type { TagRenderReturn } from './template';
 export { Token, TopLevelToken, TagToken, ValueToken } from './tokens';
+export type { RangeToken, LiteralToken, QuotedToken, PropertyAccessToken, NumberToken, FilteredValueToken } from './tokens';
 export { TokenKind, Tokenizer, ParseStream, Parser } from './parser';
 export { filters } from './filters';
 export * from './tags';
-export { defaultOptions, LiquidOptions } from './liquid-options';
-export { FS } from './fs';
+export { defaultOptions } from './liquid-options';
+export type { LiquidOptions, RenderOptions, RenderFileOptions } from './liquid-options';
+export { FS, LookupType } from './fs';
 export { Liquid } from './liquid';

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

@@ -30,7 +30,10 @@ export interface LiquidOptions {
     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. */
+    /**
+     * Hide scope variables from prototypes, useful when you're passing a not sanitized object into LiquidJS or need to hide prototypes from templates.
+     * This only applies to property/index access on scope objects. Filter transforms and iteration operate on the resolved value with standard JavaScript semantics, so prototype-inherited array indices may still be surfaced by them.
+     */
     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;
@@ -64,7 +67,7 @@ export interface LiquidOptions {
     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. */
+    /** Render from an in-memory `templates` mapping instead of the file system. When `templates` is set, Liquid uses the provided mapping for template lookup (including includes, layouts, and partials), and file-system options such as `fs`, `root`, `partials`, `layouts`, and `relativeReference` are effectively bypassed for those lookups. */
     templates?: {
         [key: string]: string;
     };
@@ -78,6 +81,8 @@ export interface LiquidOptions {
     operators?: Operators;
     /** Respect parameter order when using filters like "for ... reversed limit", Defaults to `false`. */
     orderedFilterParameters?: boolean;
+    /** Allow parenthesized expressions as operands in conditions and loops, e.g. `{% if (foo | upcase) == "BAR" %}`. This is a non-standard extension to Liquid. Defaults to `false`. */
+    groupedExpressions?: 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. */
@@ -149,6 +154,7 @@ export interface NormalizedFullOptions extends NormalizedOptions {
     globals: object;
     keepOutputType: boolean;
     operators: Operators;
+    groupedExpressions: boolean;
     parseLimit: number;
     renderLimit: number;
     memoryLimit: number;