@skeptools/skep-organization-project 0.0.16 → 0.0.18

package/node_modules/liquidjs/dist/liquid.node.js

@@ -1,6 +1,6 @@
 /*
- * liquidjs@10.18.0, https://github.com/harttle/liquidjs
- * (c) 2016-2024 harttle
+ * liquidjs@10.20.1, https://github.com/harttle/liquidjs
+ * (c) 2016-2025 harttle
  * Released under the MIT License.
  */
 'use strict';
@@ -128,6 +128,9 @@ function isArray(value) {
     // be compatible with IE 8
     return toString$1.call(value) === '[object Array]';
 }
+function isArrayLike(value) {
+    return value && isNumber(value.length);
+}
 function isIterable(value) {
     return isObject(value) && Symbol.iterator in value;
 }
@@ -213,6 +216,17 @@ function argumentsToValue(fn) {
 }
 function escapeRegExp(text) {
     return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+}
+/** Return an array containing unique elements from _array_. Works with nested arrays and objects. */
+function* strictUniq(array) {
+    const seen = new Set();
+    for (const element of array) {
+        const key = JSON.stringify(element);
+        if (!seen.has(key)) {
+            seen.add(key);
+            yield element;
+        }
+    }
 }
 
 /**
@@ -413,6 +427,9 @@ class EmptyDrop extends Drop {
     valueOf() {
         return '';
     }
+    static is(value) {
+        return value instanceof EmptyDrop;
+    }
 }
 
 class BlankDrop extends EmptyDrop {
@@ -425,6 +442,9 @@ class BlankDrop extends EmptyDrop {
             return /^\s*$/.test(value);
         return super.equals(value);
     }
+    static is(value) {
+        return value instanceof BlankDrop;
+    }
 }
 
 class ForloopDrop extends Drop {
@@ -711,7 +731,11 @@ function getDateTimeFormat() {
 
 // one minute in milliseconds
 const OneMinute = 60000;
-const ISO8601_TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):(\d{2}))$/;
+/**
+ * Need support both ISO8601 and RFC2822 as in major browsers & NodeJS
+ * RFC2822: https://datatracker.ietf.org/doc/html/rfc2822#section-3.3
+ */
+const TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):?(\d{2}))$/;
 const monthNames = [
     'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
     'September', 'October', 'November', 'December'
@@ -824,7 +848,7 @@ class LiquidDate {
      * Given that a template is expected to be parsed fewer times than rendered.
      */
     static createDateFixedToTimezone(dateString, locale) {
-        const m = dateString.match(ISO8601_TIMEZONE_PATTERN);
+        const m = dateString.match(TIMEZONE_PATTERN);
         // representing a UTC timestamp
         if (m && m[1] === 'Z') {
             return new LiquidDate(+new Date(dateString), locale, 0);
@@ -1110,7 +1134,9 @@ class LiquidTagToken extends DelimitedToken {
         this.name = this.tokenizer.readTagName();
         this.tokenizer.assert(this.name, 'illegal liquid tag syntax');
         this.tokenizer.skipBlank();
-        this.args = this.tokenizer.remaining();
+    }
+    get args() {
+        return this.tokenizer.input.slice(this.tokenizer.p, this.contentRange[1]);
     }
 }
 
@@ -1203,7 +1229,7 @@ class Render {
                 const html = yield tpl.render(ctx, emitter);
                 // if not, it'll return an `html`, write to the emitter for it
                 html && emitter.write(html);
-                if (emitter['break'] || emitter['continue'])
+                if (ctx.breakCalled || ctx.continueCalled)
                     break;
             }
             catch (e) {
@@ -1287,6 +1313,7 @@ function evalQuotedToken(token) {
 function* evalRangeToken(token, ctx) {
     const low = yield evalToken(token.lhs, ctx);
     const high = yield evalToken(token.rhs, ctx);
+    ctx.memoryLimit.use(high - low + 1);
     return range(+low, +high + 1);
 }
 function* toPostfix(tokens) {
@@ -1378,6 +1405,9 @@ function arrayEquals(lhs, rhs) {
     if (lhs.length !== rhs.length)
         return false;
     return !lhs.some((value, i) => !equals(value, rhs[i]));
+}
+function arrayIncludes(arr, item) {
+    return arr.some(value => equals(value, item));
 }
 
 class Node {
@@ -2264,9 +2294,9 @@ class Tag extends TemplateImpl {
  *    hash['reversed'] === undefined
  */
 class Hash {
-    constructor(markup, jekyllStyle) {
+    constructor(input, jekyllStyle) {
         this.hash = {};
-        const tokenizer = new Tokenizer(markup, {});
+        const tokenizer = input instanceof Tokenizer ? input : new Tokenizer(input, {});
         for (const hash of tokenizer.readHashes(jekyllStyle)) {
             this.hash[hash.name.content] = hash.value;
         }
@@ -2365,6 +2395,9 @@ class Output extends TemplateImpl {
         const val = yield this.value.value(ctx, false);
         emitter.write(val);
     }
+    *arguments() {
+        yield this.value;
+    }
 }
 
 class HTML extends TemplateImpl {
@@ -2377,6 +2410,335 @@ class HTML extends TemplateImpl {
     }
 }
 
+/**
+ * A variable's segments and location, which can be coerced to a string.
+ */
+class Variable {
+    constructor(segments, location) {
+        this.segments = segments;
+        this.location = location;
+    }
+    toString() {
+        return segmentsString(this.segments, true);
+    }
+    /** Return this variable's segments as an array, possibly with nested arrays for nested paths. */
+    toArray() {
+        function* _visit(...segments) {
+            for (const segment of segments) {
+                if (segment instanceof Variable) {
+                    yield Array.from(_visit(...segment.segments));
+                }
+                else {
+                    yield segment;
+                }
+            }
+        }
+        return Array.from(_visit(...this.segments));
+    }
+}
+/**
+ * Group variables by the string representation of their root segment.
+ */
+class VariableMap {
+    constructor() {
+        this.map = new Map();
+    }
+    get(key) {
+        const k = segmentsString([key.segments[0]]);
+        if (!this.map.has(k)) {
+            this.map.set(k, []);
+        }
+        return this.map.get(k);
+    }
+    has(key) {
+        return this.map.has(segmentsString([key.segments[0]]));
+    }
+    push(variable) {
+        this.get(variable).push(variable);
+    }
+    asObject() {
+        return Object.fromEntries(this.map);
+    }
+}
+const defaultStaticAnalysisOptions = {
+    partials: true
+};
+function* _analyze(templates, partials, sync) {
+    const variables = new VariableMap();
+    const globals = new VariableMap();
+    const locals = new VariableMap();
+    const rootScope = new DummyScope(new Set());
+    // Names of partial templates that we've already analyzed.
+    const seen = new Set();
+    function updateVariables(variable, scope) {
+        variables.push(variable);
+        const aliased = scope.alias(variable);
+        if (aliased !== undefined) {
+            const root = aliased.segments[0];
+            // TODO: What if a a template renders a rendered template? Do we need scope.parent?
+            if (isString(root) && !rootScope.has(root)) {
+                globals.push(aliased);
+            }
+        }
+        else {
+            const root = variable.segments[0];
+            if (isString(root) && !scope.has(root)) {
+                globals.push(variable);
+            }
+        }
+        // Recurse for nested Variables
+        for (const segment of variable.segments) {
+            if (segment instanceof Variable) {
+                updateVariables(segment, scope);
+            }
+        }
+    }
+    function* visit(template, scope) {
+        if (template.arguments) {
+            for (const arg of template.arguments()) {
+                for (const variable of extractVariables(arg)) {
+                    updateVariables(variable, scope);
+                }
+            }
+        }
+        if (template.localScope) {
+            for (const ident of template.localScope()) {
+                scope.add(ident.content);
+                scope.deleteAlias(ident.content);
+                const [row, col] = ident.getPosition();
+                locals.push(new Variable([ident.content], { row, col, file: ident.file }));
+            }
+        }
+        if (template.children) {
+            if (template.partialScope) {
+                const partial = template.partialScope();
+                if (partial === undefined) {
+                    // Layouts, for example, can have children that are not partials.
+                    for (const child of (yield template.children(partials, sync))) {
+                        yield visit(child, scope);
+                    }
+                    return;
+                }
+                if (seen.has(partial.name))
+                    return;
+                const partialScopeNames = new Set();
+                const partialScope = partial.isolated
+                    ? new DummyScope(partialScopeNames)
+                    : scope.push(partialScopeNames);
+                for (const name of partial.scope) {
+                    if (isString(name)) {
+                        partialScopeNames.add(name);
+                    }
+                    else {
+                        const [alias, argument] = name;
+                        partialScopeNames.add(alias);
+                        const variables = Array.from(extractVariables(argument));
+                        if (variables.length) {
+                            partialScope.setAlias(alias, variables[0].segments);
+                        }
+                    }
+                }
+                for (const child of (yield template.children(partials, sync))) {
+                    yield visit(child, partialScope);
+                    seen.add(partial.name);
+                }
+                partialScope.pop();
+            }
+            else {
+                if (template.blockScope) {
+                    scope.push(new Set(template.blockScope()));
+                }
+                for (const child of (yield template.children(partials, sync))) {
+                    yield visit(child, scope);
+                }
+                if (template.blockScope) {
+                    scope.pop();
+                }
+            }
+        }
+    }
+    for (const template of templates) {
+        yield visit(template, rootScope);
+    }
+    return {
+        variables: variables.asObject(),
+        globals: globals.asObject(),
+        locals: locals.asObject()
+    };
+}
+/**
+ * Statically analyze a template and report variable usage.
+ */
+function analyze(template, options = {}) {
+    const opts = { ...defaultStaticAnalysisOptions, ...options };
+    return toPromise(_analyze(template, opts.partials, false));
+}
+/**
+ * Statically analyze a template and report variable usage.
+ */
+function analyzeSync(template, options = {}) {
+    const opts = { ...defaultStaticAnalysisOptions, ...options };
+    return toValueSync(_analyze(template, opts.partials, true));
+}
+/**
+ * A stack to manage scopes while traversing templates during static analysis.
+ */
+class DummyScope {
+    constructor(globals) {
+        this.stack = [{ names: globals, aliases: new Map() }];
+    }
+    /** Return true if `name` is in scope.  */
+    has(name) {
+        for (const scope of this.stack) {
+            if (scope.names.has(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    push(scope) {
+        this.stack.push({ names: scope, aliases: new Map() });
+        return this;
+    }
+    pop() {
+        return this.stack.pop()?.names;
+    }
+    // Add a name to the template scope.
+    add(name) {
+        this.stack[0].names.add(name);
+    }
+    /** Return the variable that `variable` aliases, or `variable` if it doesn't alias anything. */
+    alias(variable) {
+        const root = variable.segments[0];
+        if (!isString(root))
+            return undefined;
+        const alias = this.getAlias(root);
+        if (alias === undefined)
+            return undefined;
+        return new Variable([...alias, ...variable.segments.slice(1)], variable.location);
+    }
+    // TODO: `from` could be a path with multiple segments, like `include.x`.
+    setAlias(from, to) {
+        this.stack[this.stack.length - 1].aliases.set(from, to);
+    }
+    deleteAlias(name) {
+        this.stack[this.stack.length - 1].aliases.delete(name);
+    }
+    getAlias(name) {
+        for (const scope of this.stack) {
+            if (scope.aliases.has(name)) {
+                return scope.aliases.get(name);
+            }
+            // If a scope has defined `name`, then it masks aliases in parent scopes.
+            if (scope.names.has(name)) {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+}
+function* extractVariables(value) {
+    if (isValueToken(value)) {
+        yield* extractValueTokenVariables(value);
+    }
+    else if (value instanceof Value) {
+        yield* extractFilteredValueVariables(value);
+    }
+}
+function* extractFilteredValueVariables(value) {
+    for (const token of value.initial.postfix) {
+        if (isValueToken(token)) {
+            yield* extractValueTokenVariables(token);
+        }
+    }
+    for (const filter of value.filters) {
+        for (const arg of filter.args) {
+            if (isKeyValuePair(arg) && arg[1]) {
+                yield* extractValueTokenVariables(arg[1]);
+            }
+            else if (isValueToken(arg)) {
+                yield* extractValueTokenVariables(arg);
+            }
+        }
+    }
+}
+function* extractValueTokenVariables(token) {
+    if (isRangeToken(token)) {
+        yield* extractValueTokenVariables(token.lhs);
+        yield* extractValueTokenVariables(token.rhs);
+    }
+    else if (isPropertyAccessToken(token)) {
+        yield extractPropertyAccessVariable(token);
+    }
+}
+function extractPropertyAccessVariable(token) {
+    const segments = [];
+    // token is not guaranteed to have `file` set. We'll try to get it from a prop if not.
+    let file = token.file;
+    // Here we're flattening the first segment of a path if it is a nested path.
+    const root = token.props[0];
+    file = file || root.file;
+    if (isQuotedToken(root) || isNumberToken(root) || isWordToken(root)) {
+        segments.push(root.content);
+    }
+    else if (isPropertyAccessToken(root)) {
+        // Flatten paths that start with a nested path.
+        segments.push(...extractPropertyAccessVariable(root).segments);
+    }
+    for (const prop of token.props.slice(1)) {
+        file = file || prop.file;
+        if (isQuotedToken(prop) || isNumberToken(prop) || isWordToken(prop)) {
+            segments.push(prop.content);
+        }
+        else if (isPropertyAccessToken(prop)) {
+            segments.push(extractPropertyAccessVariable(prop));
+        }
+    }
+    const [row, col] = token.getPosition();
+    return new Variable(segments, {
+        row,
+        col,
+        file
+    });
+}
+// This is used to detect segments that can be represented with dot notation
+// when creating a string representation of VariableSegments.
+const RE_PROPERTY = /^[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*$/;
+/**
+ * Return a string representation of segments using dot notation where possible.
+ * @param segments - The property names and array indices that make up a path to a variable.
+ * @param bracketedRoot - If false (the default), don't surround the root segment with square brackets.
+ */
+function segmentsString(segments, bracketedRoot = false) {
+    const buf = [];
+    const root = segments[0];
+    if (isString(root)) {
+        if (!bracketedRoot || root.match(RE_PROPERTY)) {
+            buf.push(`${root}`);
+        }
+        else {
+            buf.push(`['${root}']`);
+        }
+    }
+    for (const segment of segments.slice(1)) {
+        if (segment instanceof Variable) {
+            buf.push(`[${segmentsString(segment.segments)}]`);
+        }
+        else if (isString(segment)) {
+            if (segment.match(RE_PROPERTY)) {
+                buf.push(`.${segment}`);
+            }
+            else {
+                buf.push(`['${segment}']`);
+            }
+        }
+        else {
+            buf.push(`[${segment}]`);
+        }
+    }
+    return buf.join('');
+}
+
 var LookupType;
 (function (LookupType) {
     LookupType["Partials"] = "partials";
@@ -2575,6 +2937,10 @@ function isWordToken(val) {
 function isRangeToken(val) {
     return getKind(val) === exports.TokenKind.Range;
 }
+function isValueToken(val) {
+    // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range
+    return (getKind(val) & 1667) > 0;
+}
 function getKind(val) {
     return val ? val.kind : -1;
 }
@@ -2591,7 +2957,8 @@ var typeGuards = /*#__PURE__*/Object.freeze({
   isNumberToken: isNumberToken,
   isPropertyAccessToken: isPropertyAccessToken,
   isWordToken: isWordToken,
-  isRangeToken: isRangeToken
+  isRangeToken: isRangeToken,
+  isValueToken: isValueToken
 });
 
 /******************************************************************************
@@ -2628,6 +2995,8 @@ class Context {
          */
         this.scopes = [{}];
         this.registers = {};
+        this.breakCalled = false;
+        this.continueCalled = false;
         this.sync = !!renderOptions.sync;
         this.opts = opts;
         this.globals = renderOptions.globals ?? opts.globals;
@@ -2663,7 +3032,7 @@ class Context {
         return toValueSync(this._get(paths));
     }
     *_get(paths) {
-        const scope = this.findScope(paths[0]);
+        const scope = this.findScope(paths[0]); // first prop should always be a string
         return yield this._getFromScope(scope, paths);
     }
     /**
@@ -2715,6 +3084,7 @@ class Context {
 }
 function readProperty(obj, key, ownPropertyOnly) {
     obj = toLiquid(obj);
+    key = toValue(key);
     if (isNil(obj))
         return obj;
     if (isArray(obj) && key < 0)
@@ -2862,8 +3232,8 @@ const join = argumentsToValue(function (v, arg) {
     this.context.memoryLimit.use(complexity);
     return array.join(sep);
 });
-const last$1 = argumentsToValue((v) => isArray(v) ? last(v) : '');
-const first = argumentsToValue((v) => isArray(v) ? v[0] : '');
+const last$1 = argumentsToValue((v) => isArrayLike(v) ? last(v) : '');
+const first = argumentsToValue((v) => isArrayLike(v) ? v[0] : '');
 const reverse = argumentsToValue(function (v) {
     const array = toArray(v);
     this.context.memoryLimit.use(array.length);
@@ -2964,10 +3334,13 @@ function* where(arr, property, expected) {
     for (const item of arr) {
         values.push(yield evalToken(token, this.context.spawn(item)));
     }
+    const matcher = this.context.opts.jekyllWhere
+        ? (v) => EmptyDrop.is(expected) ? equals(v, expected) : (isArray(v) ? arrayIncludes(v, expected) : equals(v, expected))
+        : (v) => equals(v, expected);
     return arr.filter((_, i) => {
         if (expected === undefined)
             return isTruthy(values[i], this.context);
-        return equals(values[i], expected);
+        return matcher(values[i]);
     });
 }
 function* where_exp(arr, itemName, exp) {
@@ -2984,7 +3357,7 @@ function* where_exp(arr, itemName, exp) {
 }
 function* group_by(arr, property) {
     const map = new Map();
-    arr = toArray(arr);
+    arr = toEnumerable(arr);
     const token = new Tokenizer(stringify(property)).readScopeValue();
     this.context.memoryLimit.use(arr.length);
     for (const item of arr) {
@@ -2998,7 +3371,7 @@ function* group_by(arr, property) {
 function* group_by_exp(arr, itemName, exp) {
     const map = new Map();
     const keyTemplate = new Value(stringify(exp), this.liquid);
-    arr = toArray(arr);
+    arr = toEnumerable(arr);
     this.context.memoryLimit.use(arr.length);
     for (const item of arr) {
         const key = yield keyTemplate.value(this.context.spawn({ [itemName]: item }));
@@ -3358,7 +3731,8 @@ const filters = {
 class AssignTag extends Tag {
     constructor(token, remainTokens, liquid) {
         super(token, remainTokens, liquid);
-        this.key = this.tokenizer.readIdentifier().content;
+        this.identifier = this.tokenizer.readIdentifier();
+        this.key = this.identifier.content;
         this.tokenizer.assert(this.key, 'expected variable name');
         this.tokenizer.skipBlank();
         this.tokenizer.assert(this.tokenizer.peek() === '=', 'expected "="');
@@ -3368,6 +3742,12 @@ class AssignTag extends Tag {
     *render(ctx) {
         ctx.bottom()[this.key] = yield this.value.value(ctx, this.liquid.options.lenientIf);
     }
+    *arguments() {
+        yield this.value;
+    }
+    *localScope() {
+        yield this.identifier;
+    }
 }
 
 const MODIFIERS = ['offset', 'limit', 'reversed'];
@@ -3382,7 +3762,7 @@ class ForTag extends Tag {
         }
         this.variable = variable.content;
         this.collection = collection;
-        this.hash = new Hash(this.tokenizer.remaining(), liquid.options.keyValueSeparator);
+        this.hash = new Hash(this.tokenizer, liquid.options.keyValueSeparator);
         this.templates = [];
         this.elseTemplates = [];
         let p;
@@ -3420,16 +3800,33 @@ class ForTag extends Tag {
         ctx.push(scope);
         for (const item of collection) {
             scope[this.variable] = item;
+            ctx.continueCalled = ctx.breakCalled = false;
             yield r.renderTemplates(this.templates, ctx, emitter);
-            if (emitter['break']) {
-                emitter['break'] = false;
+            if (ctx.breakCalled)
                 break;
-            }
-            emitter['continue'] = false;
             scope.forloop.next();
         }
+        ctx.continueCalled = ctx.breakCalled = false;
         ctx.pop();
     }
+    *children() {
+        const templates = this.templates.slice();
+        if (this.elseTemplates) {
+            templates.push(...this.elseTemplates);
+        }
+        return templates;
+    }
+    *arguments() {
+        yield this.collection;
+        for (const v of Object.values(this.hash.hash)) {
+            if (isValueToken(v)) {
+                yield v;
+            }
+        }
+    }
+    blockScope() {
+        return [this.variable, 'forloop'];
+    }
 }
 function reversed(arr) {
     return [...arr].reverse();
@@ -3445,7 +3842,8 @@ class CaptureTag extends Tag {
     constructor(tagToken, remainTokens, liquid, parser) {
         super(tagToken, remainTokens, liquid);
         this.templates = [];
-        this.variable = this.readVariableName();
+        this.identifier = this.readVariable();
+        this.variable = this.identifier.content;
         while (remainTokens.length) {
             const token = remainTokens.shift();
             if (isTagToken(token) && token.name === 'endcapture')
@@ -3454,19 +3852,25 @@ class CaptureTag extends Tag {
         }
         throw new Error(`tag ${tagToken.getText()} not closed`);
     }
+    readVariable() {
+        let ident = this.tokenizer.readIdentifier();
+        if (ident.content)
+            return ident;
+        ident = this.tokenizer.readQuoted();
+        if (ident)
+            return ident;
+        throw this.tokenizer.error('invalid capture name');
+    }
     *render(ctx) {
         const r = this.liquid.renderer;
         const html = yield r.renderTemplates(this.templates, ctx);
         ctx.bottom()[this.variable] = html;
     }
-    readVariableName() {
-        const word = this.tokenizer.readIdentifier().content;
-        if (word)
-            return word;
-        const quoted = this.tokenizer.readQuoted();
-        if (quoted)
-            return evalQuotedToken(quoted);
-        throw this.tokenizer.error('invalid capture name');
+    *children() {
+        return this.templates;
+    }
+    *localScope() {
+        yield this.identifier;
     }
 }
 
@@ -3534,6 +3938,17 @@ class CaseTag extends Tag {
             yield r.renderTemplates(this.elseTemplates, ctx, emitter);
         }
     }
+    *arguments() {
+        yield this.value;
+        yield* this.branches.flatMap(b => b.values);
+    }
+    *children() {
+        const templates = this.branches.flatMap(b => b.templates);
+        if (this.elseTemplates) {
+            templates.push(...this.elseTemplates);
+        }
+        return templates;
+    }
 }
 
 class CommentTag extends Tag {
@@ -3587,7 +4002,7 @@ class RenderTag extends Tag {
             tokenizer.p = begin;
             break;
         }
-        this.hash = new Hash(tokenizer.remaining(), liquid.options.keyValueSeparator);
+        this.hash = new Hash(tokenizer, liquid.options.keyValueSeparator);
     }
     *render(ctx, emitter) {
         const { liquid, hash } = this;
@@ -3616,6 +4031,55 @@ class RenderTag extends Tag {
             yield liquid.renderer.renderTemplates(templates, childCtx, emitter);
         }
     }
+    *children(partials, sync) {
+        if (partials && isString(this['file'])) {
+            return (yield this.liquid._parsePartialFile(this['file'], sync, this['currentFile']));
+        }
+        return [];
+    }
+    partialScope() {
+        if (isString(this['file'])) {
+            const names = Object.keys(this.hash.hash);
+            if (this['with']) {
+                const { value, alias } = this['with'];
+                if (isString(alias)) {
+                    names.push([alias, value]);
+                }
+                else if (isString(this.file)) {
+                    names.push([this.file, value]);
+                }
+            }
+            if (this['for']) {
+                const { value, alias } = this['for'];
+                if (isString(alias)) {
+                    names.push([alias, value]);
+                }
+                else if (isString(this.file)) {
+                    names.push([this.file, value]);
+                }
+            }
+            return { name: this['file'], isolated: true, scope: names };
+        }
+    }
+    *arguments() {
+        for (const v of Object.values(this.hash.hash)) {
+            if (isValueToken(v)) {
+                yield v;
+            }
+        }
+        if (this['with']) {
+            const { value } = this['with'];
+            if (isValueToken(value)) {
+                yield value;
+            }
+        }
+        if (this['for']) {
+            const { value } = this['for'];
+            if (isValueToken(value)) {
+                yield value;
+            }
+        }
+    }
 }
 /**
  * @return null for "none",
@@ -3672,7 +4136,7 @@ class IncludeTag extends Tag {
         }
         else
             tokenizer.p = begin;
-        this.hash = new Hash(tokenizer.remaining(), liquid.options.jekyllInclude || liquid.options.keyValueSeparator);
+        this.hash = new Hash(tokenizer, liquid.options.jekyllInclude || liquid.options.keyValueSeparator);
     }
     *render(ctx, emitter) {
         const { liquid, hash, withVar } = this;
@@ -3691,12 +4155,43 @@ class IncludeTag extends Tag {
         ctx.pop();
         ctx.restoreRegister(saved);
     }
+    *children(partials, sync) {
+        if (partials && isString(this['file'])) {
+            return (yield this.liquid._parsePartialFile(this['file'], sync, this['currentFile']));
+        }
+        return [];
+    }
+    partialScope() {
+        if (isString(this['file'])) {
+            let names;
+            if (this.liquid.options.jekyllInclude) {
+                names = ['include'];
+            }
+            else {
+                names = Object.keys(this.hash.hash);
+                if (this.withVar) {
+                    names.push([this['file'], this.withVar]);
+                }
+            }
+            return { name: this['file'], isolated: false, scope: names };
+        }
+    }
+    *arguments() {
+        yield* Object.values(this.hash.hash).filter(isValueToken);
+        if (isValueToken(this['file'])) {
+            yield this['file'];
+        }
+        if (isValueToken(this.withVar)) {
+            yield this.withVar;
+        }
+    }
 }
 
 class DecrementTag extends Tag {
     constructor(token, remainTokens, liquid) {
         super(token, remainTokens, liquid);
-        this.variable = this.tokenizer.readIdentifier().content;
+        this.identifier = this.tokenizer.readIdentifier();
+        this.variable = this.identifier.content;
     }
     render(context, emitter) {
         const scope = context.environments;
@@ -3705,6 +4200,9 @@ class DecrementTag extends Tag {
         }
         emitter.write(stringify(--scope[this.variable]));
     }
+    *localScope() {
+        yield this.identifier;
+    }
 }
 
 class CycleTag extends Tag {
@@ -3742,6 +4240,12 @@ class CycleTag extends Tag {
         groups[fingerprint] = idx;
         return yield evalToken(candidate, ctx);
     }
+    *arguments() {
+        yield* this.candidates;
+        if (this.group) {
+            yield this.group;
+        }
+    }
 }
 
 class IfTag extends Tag {
@@ -3751,13 +4255,13 @@ class IfTag extends Tag {
         let p = [];
         parser.parseStream(remainTokens)
             .on('start', () => this.branches.push({
-            value: new Value(tagToken.args, this.liquid),
+            value: new Value(tagToken.tokenizer.readFilteredValue(), this.liquid),
             templates: (p = [])
         }))
             .on('tag:elsif', (token) => {
             assert(!this.elseTemplates, 'unexpected elsif after else');
             this.branches.push({
-                value: new Value(token.args, this.liquid),
+                value: new Value(token.tokenizer.readFilteredValue(), this.liquid),
                 templates: (p = [])
             });
         })
@@ -3782,12 +4286,23 @@ class IfTag extends Tag {
         }
         yield r.renderTemplates(this.elseTemplates || [], ctx, emitter);
     }
+    *children() {
+        const templates = this.branches.flatMap(b => b.templates);
+        if (this.elseTemplates) {
+            templates.push(...this.elseTemplates);
+        }
+        return templates;
+    }
+    arguments() {
+        return this.branches.map(b => b.value);
+    }
 }
 
 class IncrementTag extends Tag {
     constructor(token, remainTokens, liquid) {
         super(token, remainTokens, liquid);
-        this.variable = this.tokenizer.readIdentifier().content;
+        this.identifier = this.tokenizer.readIdentifier();
+        this.variable = this.identifier.content;
     }
     render(context, emitter) {
         const scope = context.environments;
@@ -3798,6 +4313,9 @@ class IncrementTag extends Tag {
         scope[this.variable]++;
         emitter.write(stringify(val));
     }
+    *localScope() {
+        yield this.identifier;
+    }
 }
 
 class LayoutTag extends Tag {
@@ -3805,7 +4323,7 @@ class LayoutTag extends Tag {
         super(token, remainTokens, liquid);
         this.file = parseFilePath(this.tokenizer, this.liquid, parser);
         this['currentFile'] = token.file;
-        this.args = new Hash(this.tokenizer.remaining(), liquid.options.keyValueSeparator);
+        this.args = new Hash(this.tokenizer, liquid.options.keyValueSeparator);
         this.templates = parser.parseTokens(remainTokens);
     }
     *render(ctx, emitter) {
@@ -3832,6 +4350,28 @@ class LayoutTag extends Tag {
         yield renderer.renderTemplates(templates, ctx, emitter);
         ctx.pop();
     }
+    *children(partials) {
+        const templates = this.templates.slice();
+        if (partials && isString(this.file)) {
+            templates.push(...(yield this.liquid._parsePartialFile(this.file, true, this['currentFile'])));
+        }
+        return templates;
+    }
+    *arguments() {
+        for (const v of Object.values(this.args.hash)) {
+            if (isValueToken(v)) {
+                yield v;
+            }
+        }
+        if (isValueToken(this.file)) {
+            yield this.file;
+        }
+    }
+    partialScope() {
+        if (isString(this.file)) {
+            return { name: this.file, isolated: false, scope: Object.keys(this.args.hash) };
+        }
+    }
 }
 
 class BlockTag extends Tag {
@@ -3871,6 +4411,12 @@ class BlockTag extends Tag {
             ? (superBlock, emitter) => renderChild(new BlockDrop(() => renderCurrent(superBlock, emitter)), emitter)
             : renderCurrent;
     }
+    *children() {
+        return this.templates;
+    }
+    blockScope() {
+        return ['block'];
+    }
 }
 
 class RawTag extends Tag {
@@ -3925,7 +4471,7 @@ class TablerowTag extends Tag {
         }
         this.variable = variable.content;
         this.collection = collectionToken;
-        this.args = new Hash(this.tokenizer.remaining(), liquid.options.keyValueSeparator);
+        this.args = new Hash(this.tokenizer, liquid.options.keyValueSeparator);
         this.templates = [];
         let p;
         const stream = parser.parseStream(remainTokens)
@@ -3963,6 +4509,20 @@ class TablerowTag extends Tag {
             emitter.write('</tr>');
         ctx.pop();
     }
+    *children() {
+        return this.templates;
+    }
+    *arguments() {
+        yield this.collection;
+        for (const v of Object.values(this.args.hash)) {
+            if (isValueToken(v)) {
+                yield v;
+            }
+        }
+    }
+    blockScope() {
+        return [this.variable, 'tablerowloop'];
+    }
 }
 
 class UnlessTag extends Tag {
@@ -3974,7 +4534,7 @@ class UnlessTag extends Tag {
         let elseCount = 0;
         parser.parseStream(remainTokens)
             .on('start', () => this.branches.push({
-            value: new Value(tagToken.args, this.liquid),
+            value: new Value(tagToken.tokenizer.readFilteredValue(), this.liquid),
             test: isFalsy,
             templates: (p = [])
         }))
@@ -3984,7 +4544,7 @@ class UnlessTag extends Tag {
                 return;
             }
             this.branches.push({
-                value: new Value(token.args, this.liquid),
+                value: new Value(token.tokenizer.readFilteredValue(), this.liquid),
                 test: isTruthy,
                 templates: (p = [])
             });
@@ -4013,17 +4573,27 @@ class UnlessTag extends Tag {
         }
         yield r.renderTemplates(this.elseTemplates, ctx, emitter);
     }
+    *children() {
+        const children = this.branches.flatMap(b => b.templates);
+        if (this.elseTemplates) {
+            children.push(...this.elseTemplates);
+        }
+        return children;
+    }
+    arguments() {
+        return this.branches.map(b => b.value);
+    }
 }
 
 class BreakTag extends Tag {
-    render(ctx, emitter) {
-        emitter['break'] = true;
+    render(ctx, _emitter) {
+        ctx.breakCalled = true;
     }
 }
 
 class ContinueTag extends Tag {
-    render(ctx, emitter) {
-        emitter['continue'] = true;
+    render(ctx, _emitter) {
+        ctx.continueCalled = true;
     }
 }
 
@@ -4041,6 +4611,11 @@ class EchoTag extends Tag {
         const val = yield this.value.value(ctx, false);
         emitter.write(val);
     }
+    *arguments() {
+        if (this.value) {
+            yield this.value;
+        }
+    }
 }
 
 class LiquidTag extends Tag {
@@ -4052,6 +4627,9 @@ class LiquidTag extends Tag {
     *render(ctx, emitter) {
         yield this.liquid.renderer.renderTemplates(this.templates, ctx, emitter);
     }
+    *children() {
+        return this.templates;
+    }
 }
 
 class InlineCommentTag extends Tag {
@@ -4190,10 +4768,82 @@ class Liquid {
             self.renderFile(filePath, ctx).then(html => callback(null, html), callback);
         };
     }
+    async analyze(template, options = {}) {
+        return analyze(template, options);
+    }
+    analyzeSync(template, options = {}) {
+        return analyzeSync(template, options);
+    }
+    async parseAndAnalyze(html, filename, options = {}) {
+        return analyze(this.parse(html, filename), options);
+    }
+    parseAndAnalyzeSync(html, filename, options = {}) {
+        return analyzeSync(this.parse(html, filename), options);
+    }
+    /** Return an array of all variables without their properties. */
+    async variables(template, options = {}) {
+        const analysis = await analyze(isString(template) ? this.parse(template) : template, options);
+        return Object.keys(analysis.variables);
+    }
+    /** Return an array of all variables without their properties. */
+    variablesSync(template, options = {}) {
+        const analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+        return Object.keys(analysis.variables);
+    }
+    /** Return an array of all variables including their properties/paths. */
+    async fullVariables(template, options = {}) {
+        const analysis = await analyze(isString(template) ? this.parse(template) : template, options);
+        return Array.from(new Set(Object.values(analysis.variables).flatMap((a) => a.map((v) => String(v)))));
+    }
+    /** Return an array of all variables including their properties/paths. */
+    fullVariablesSync(template, options = {}) {
+        const analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+        return Array.from(new Set(Object.values(analysis.variables).flatMap((a) => a.map((v) => String(v)))));
+    }
+    /** Return an array of all variables, each as an array of properties/segments. */
+    async variableSegments(template, options = {}) {
+        const analysis = await analyze(isString(template) ? this.parse(template) : template, options);
+        return Array.from(strictUniq(Object.values(analysis.variables).flatMap((a) => a.map((v) => v.toArray()))));
+    }
+    /** Return an array of all variables, each as an array of properties/segments. */
+    variableSegmentsSync(template, options = {}) {
+        const analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+        return Array.from(strictUniq(Object.values(analysis.variables).flatMap((a) => a.map((v) => v.toArray()))));
+    }
+    /** Return an array of all expected context variables without their properties. */
+    async globalVariables(template, options = {}) {
+        const analysis = await analyze(isString(template) ? this.parse(template) : template, options);
+        return Object.keys(analysis.globals);
+    }
+    /** Return an array of all expected context variables without their properties. */
+    globalVariablesSync(template, options = {}) {
+        const analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+        return Object.keys(analysis.globals);
+    }
+    /** Return an array of all expected context variables including their properties/paths. */
+    async globalFullVariables(template, options = {}) {
+        const analysis = await analyze(isString(template) ? this.parse(template) : template, options);
+        return Array.from(new Set(Object.values(analysis.globals).flatMap((a) => a.map((v) => String(v)))));
+    }
+    /** Return an array of all expected context variables including their properties/paths. */
+    globalFullVariablesSync(template, options = {}) {
+        const analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+        return Array.from(new Set(Object.values(analysis.globals).flatMap((a) => a.map((v) => String(v)))));
+    }
+    /** Return an array of all expected context variables, each as an array of properties/segments. */
+    async globalVariableSegments(template, options = {}) {
+        const analysis = await analyze(isString(template) ? this.parse(template) : template, options);
+        return Array.from(strictUniq(Object.values(analysis.globals).flatMap((a) => a.map((v) => v.toArray()))));
+    }
+    /** Return an array of all expected context variables, each as an array of properties/segments. */
+    globalVariableSegmentsSync(template, options = {}) {
+        const analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+        return Array.from(strictUniq(Object.values(analysis.globals).flatMap((a) => a.map((v) => v.toArray()))));
+    }
 }
 
 /* istanbul ignore file */
-const version = '10.18.0';
+const version = '10.20.1';
 
 exports.AssertionError = AssertionError;
 exports.AssignTag = AssignTag;
@@ -4223,6 +4873,7 @@ exports.LiquidTag = LiquidTag;
 exports.Output = Output;
 exports.ParseError = ParseError;
 exports.ParseStream = ParseStream;
+exports.Parser = Parser;
 exports.RawTag = RawTag;
 exports.RenderError = RenderError;
 exports.RenderTag = RenderTag;
@@ -4236,6 +4887,9 @@ exports.TypeGuards = typeGuards;
 exports.UndefinedVariableError = UndefinedVariableError;
 exports.UnlessTag = UnlessTag;
 exports.Value = Value;
+exports.Variable = Variable;
+exports.analyze = analyze;
+exports.analyzeSync = analyzeSync;
 exports.assert = assert;
 exports.createTrie = createTrie;
 exports.defaultOperators = defaultOperators;