@skeptools/skep-organization-project 0.0.16 → 0.0.18

package/node_modules/liquidjs/dist/liquid.browser.umd.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.
  */
 (function (global, factory) {
@@ -240,6 +240,9 @@
         // 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;
     }
@@ -334,6 +337,47 @@
     }
     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) {
+        var seen, array_1, array_1_1, element, key, e_1_1;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    seen = new Set();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    array_1 = __values(array), array_1_1 = array_1.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!array_1_1.done) return [3 /*break*/, 5];
+                    element = array_1_1.value;
+                    key = JSON.stringify(element);
+                    if (!!seen.has(key)) return [3 /*break*/, 4];
+                    seen.add(key);
+                    return [4 /*yield*/, element];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    array_1_1 = array_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
     }
 
     /**
@@ -569,6 +613,9 @@
         EmptyDrop.prototype.valueOf = function () {
             return '';
         };
+        EmptyDrop.is = function (value) {
+            return value instanceof EmptyDrop;
+        };
         return EmptyDrop;
     }(Drop));
 
@@ -586,6 +633,9 @@
                 return /^\s*$/.test(value);
             return _super.prototype.equals.call(this, value);
         };
+        BlankDrop.is = function (value) {
+            return value instanceof BlankDrop;
+        };
         return BlankDrop;
     }(EmptyDrop));
 
@@ -919,7 +969,11 @@
 
     // one minute in milliseconds
     var OneMinute = 60000;
-    var 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
+     */
+    var TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):?(\d{2}))$/;
     var monthNames = [
         'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
         'September', 'October', 'November', 'December'
@@ -1036,7 +1090,7 @@
          * Given that a template is expected to be parsed fewer times than rendered.
          */
         LiquidDate.createDateFixedToTimezone = function (dateString, locale) {
-            var m = dateString.match(ISO8601_TIMEZONE_PATTERN);
+            var m = dateString.match(TIMEZONE_PATTERN);
             // representing a UTC timestamp
             if (m && m[1] === 'Z') {
                 return new LiquidDate(+new Date(dateString), locale, 0);
@@ -1373,9 +1427,15 @@
             _this.name = _this.tokenizer.readTagName();
             _this.tokenizer.assert(_this.name, 'illegal liquid tag syntax');
             _this.tokenizer.skipBlank();
-            _this.args = _this.tokenizer.remaining();
             return _this;
         }
+        Object.defineProperty(LiquidTagToken.prototype, "args", {
+            get: function () {
+                return this.tokenizer.input.slice(this.tokenizer.p, this.contentRange[1]);
+            },
+            enumerable: false,
+            configurable: true
+        });
         return LiquidTagToken;
     }(DelimitedToken));
 
@@ -1486,7 +1546,7 @@
                         html = _b.sent();
                         // 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)
                             return [3 /*break*/, 7];
                         return [3 /*break*/, 6];
                     case 5:
@@ -1675,6 +1735,7 @@
                     return [4 /*yield*/, evalToken(token.rhs, ctx)];
                 case 2:
                     high = _a.sent();
+                    ctx.memoryLimit.use(high - low + 1);
                     return [2 /*return*/, range(+low, +high + 1)];
             }
         });
@@ -1806,6 +1867,9 @@
         if (lhs.length !== rhs.length)
             return false;
         return !lhs.some(function (value, i) { return !equals(value, rhs[i]); });
+    }
+    function arrayIncludes(arr, item) {
+        return arr.some(function (value) { return equals(value, item); });
     }
 
     var Node = /** @class */ (function () {
@@ -2779,10 +2843,10 @@
      *    hash['reversed'] === undefined
      */
     var Hash = /** @class */ (function () {
-        function Hash(markup, jekyllStyle) {
+        function Hash(input, jekyllStyle) {
             var e_1, _a;
             this.hash = {};
-            var tokenizer = new Tokenizer(markup, {});
+            var tokenizer = input instanceof Tokenizer ? input : new Tokenizer(input, {});
             try {
                 for (var _b = __values(tokenizer.readHashes(jekyllStyle)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var hash = _c.value;
@@ -3025,6 +3089,16 @@
                 }
             });
         };
+        Output.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return Output;
     }(TemplateImpl));
 
@@ -3044,177 +3118,849 @@
         return HTML;
     }(TemplateImpl));
 
-    var LookupType;
-    (function (LookupType) {
-        LookupType["Partials"] = "partials";
-        LookupType["Layouts"] = "layouts";
-        LookupType["Root"] = "root";
-    })(LookupType || (LookupType = {}));
-    var Loader = /** @class */ (function () {
-        function Loader(options) {
-            this.options = options;
-            if (options.relativeReference) {
-                var sep = options.fs.sep;
-                assert(sep, '`fs.sep` is required for relative reference');
-                var rRelativePath_1 = new RegExp(['.' + sep, '..' + sep, './', '../'].map(function (prefix) { return escapeRegex(prefix); }).join('|'));
-                this.shouldLoadRelative = function (referencedFile) { return rRelativePath_1.test(referencedFile); };
+    /**
+     * A variable's segments and location, which can be coerced to a string.
+     */
+    var Variable = /** @class */ (function () {
+        function Variable(segments, location) {
+            this.segments = segments;
+            this.location = location;
+        }
+        Variable.prototype.toString = function () {
+            return segmentsString(this.segments, true);
+        };
+        /** Return this variable's segments as an array, possibly with nested arrays for nested paths. */
+        Variable.prototype.toArray = function () {
+            function _visit() {
+                var _i, segments_1, segments_1_1, segment, e_1_1;
+                var e_1, _a;
+                var segments = [];
+                for (_i = 0; _i < arguments.length; _i++) {
+                    segments[_i] = arguments[_i];
+                }
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 7, 8, 9]);
+                            segments_1 = __values(segments), segments_1_1 = segments_1.next();
+                            _b.label = 1;
+                        case 1:
+                            if (!!segments_1_1.done) return [3 /*break*/, 6];
+                            segment = segments_1_1.value;
+                            if (!(segment instanceof Variable)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, Array.from(_visit.apply(void 0, __spreadArray([], __read(segment.segments), false)))];
+                        case 2:
+                            _b.sent();
+                            return [3 /*break*/, 5];
+                        case 3: return [4 /*yield*/, segment];
+                        case 4:
+                            _b.sent();
+                            _b.label = 5;
+                        case 5:
+                            segments_1_1 = segments_1.next();
+                            return [3 /*break*/, 1];
+                        case 6: return [3 /*break*/, 9];
+                        case 7:
+                            e_1_1 = _b.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 9];
+                        case 8:
+                            try {
+                                if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                            return [7 /*endfinally*/];
+                        case 9: return [2 /*return*/];
+                    }
+                });
+            }
+            return Array.from(_visit.apply(void 0, __spreadArray([], __read(this.segments), false)));
+        };
+        return Variable;
+    }());
+    /**
+     * Group variables by the string representation of their root segment.
+     */
+    var VariableMap = /** @class */ (function () {
+        function VariableMap() {
+            this.map = new Map();
+        }
+        VariableMap.prototype.get = function (key) {
+            var k = segmentsString([key.segments[0]]);
+            if (!this.map.has(k)) {
+                this.map.set(k, []);
+            }
+            return this.map.get(k);
+        };
+        VariableMap.prototype.has = function (key) {
+            return this.map.has(segmentsString([key.segments[0]]));
+        };
+        VariableMap.prototype.push = function (variable) {
+            this.get(variable).push(variable);
+        };
+        VariableMap.prototype.asObject = function () {
+            return Object.fromEntries(this.map);
+        };
+        return VariableMap;
+    }());
+    var defaultStaticAnalysisOptions = {
+        partials: true
+    };
+    function _analyze(templates, partials, sync) {
+        function updateVariables(variable, scope) {
+            var e_3, _a;
+            variables.push(variable);
+            var aliased = scope.alias(variable);
+            if (aliased !== undefined) {
+                var 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 {
-                this.shouldLoadRelative = function (_referencedFile) { return false; };
+                var root = variable.segments[0];
+                if (isString(root) && !scope.has(root)) {
+                    globals.push(variable);
+                }
+            }
+            try {
+                // Recurse for nested Variables
+                for (var _b = __values(variable.segments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var segment = _c.value;
+                    if (segment instanceof Variable) {
+                        updateVariables(segment, scope);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_3) throw e_3.error; }
             }
-            this.contains = this.options.fs.contains || (function () { return true; });
         }
-        Loader.prototype.lookup = function (file, type, sync, currentFile) {
-            var fs, dirs, _a, _b, filepath, _c, e_1_1;
-            var e_1, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+        function visit(template, scope) {
+            var _a, _b, arg, _c, _d, variable, _e, _f, ident, _g, row, col, partial, _h, _j, child, e_4_1, partialScopeNames, partialScope, _k, _l, name_1, _m, alias, argument, variables_1, _o, _p, child, e_5_1, _q, _r, child, e_6_1;
+            var e_7, _s, e_8, _t, e_9, _u, e_4, _v, e_10, _w, e_5, _x, e_6, _y;
+            return __generator(this, function (_z) {
+                switch (_z.label) {
                     case 0:
-                        fs = this.options.fs;
-                        dirs = this.options[type];
-                        _e.label = 1;
-                    case 1:
-                        _e.trys.push([1, 8, 9, 10]);
-                        _a = __values(this.candidates(file, dirs, currentFile, type !== LookupType.Root)), _b = _a.next();
-                        _e.label = 2;
-                    case 2:
-                        if (!!_b.done) return [3 /*break*/, 7];
-                        filepath = _b.value;
-                        if (!sync) return [3 /*break*/, 3];
-                        _c = fs.existsSync(filepath);
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, fs.exists(filepath)];
-                    case 4:
-                        _c = _e.sent();
-                        _e.label = 5;
-                    case 5:
-                        if (_c)
-                            return [2 /*return*/, filepath];
-                        _e.label = 6;
-                    case 6:
-                        _b = _a.next();
-                        return [3 /*break*/, 2];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        e_1_1 = _e.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        try {
-                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        if (template.arguments) {
+                            try {
+                                for (_a = __values(template.arguments()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                    arg = _b.value;
+                                    try {
+                                        for (_c = (e_8 = void 0, __values(extractVariables(arg))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                            variable = _d.value;
+                                            updateVariables(variable, scope);
+                                        }
+                                    }
+                                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                                    finally {
+                                        try {
+                                            if (_d && !_d.done && (_t = _c.return)) _t.call(_c);
+                                        }
+                                        finally { if (e_8) throw e_8.error; }
+                                    }
+                                }
+                            }
+                            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                            finally {
+                                try {
+                                    if (_b && !_b.done && (_s = _a.return)) _s.call(_a);
+                                }
+                                finally { if (e_7) throw e_7.error; }
+                            }
                         }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 10: throw this.lookupError(file, dirs);
-                }
-            });
-        };
-        Loader.prototype.candidates = function (file, dirs, currentFile, enforceRoot) {
-            var _a, fs, extname, referenced, dirs_1, dirs_1_1, dir, e_2_1, dirs_2, dirs_2_1, dir, referenced, e_3_1, filepath;
-            var e_2, _b, e_3, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _a = this.options, fs = _a.fs, extname = _a.extname;
-                        if (!(this.shouldLoadRelative(file) && currentFile)) return [3 /*break*/, 8];
-                        referenced = fs.resolve(this.dirname(currentFile), file, extname);
-                        _d.label = 1;
+                        if (template.localScope) {
+                            try {
+                                for (_e = __values(template.localScope()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    ident = _f.value;
+                                    scope.add(ident.content);
+                                    scope.deleteAlias(ident.content);
+                                    _g = __read(ident.getPosition(), 2), row = _g[0], col = _g[1];
+                                    locals.push(new Variable([ident.content], { row: row, col: col, file: ident.file }));
+                                }
+                            }
+                            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_u = _e.return)) _u.call(_e);
+                                }
+                                finally { if (e_9) throw e_9.error; }
+                            }
+                        }
+                        if (!template.children) return [3 /*break*/, 30];
+                        if (!template.partialScope) return [3 /*break*/, 20];
+                        partial = template.partialScope();
+                        if (!(partial === undefined)) return [3 /*break*/, 10];
+                        _z.label = 1;
                     case 1:
-                        _d.trys.push([1, 6, 7, 8]);
-                        dirs_1 = __values(dirs), dirs_1_1 = dirs_1.next();
-                        _d.label = 2;
+                        _z.trys.push([1, 7, 8, 9]);
+                        return [4 /*yield*/, template.children(partials, sync)];
                     case 2:
-                        if (!!dirs_1_1.done) return [3 /*break*/, 5];
-                        dir = dirs_1_1.value;
-                        if (!(!enforceRoot || this.contains(dir, referenced))) return [3 /*break*/, 4];
-                        // the relatively referenced file is within one of root dirs
-                        return [4 /*yield*/, referenced];
+                        _h = __values.apply(void 0, [(_z.sent())]), _j = _h.next();
+                        _z.label = 3;
                     case 3:
-                        // the relatively referenced file is within one of root dirs
-                        _d.sent();
-                        return [3 /*break*/, 5];
+                        if (!!_j.done) return [3 /*break*/, 6];
+                        child = _j.value;
+                        return [4 /*yield*/, visit(child, scope)];
                     case 4:
-                        dirs_1_1 = dirs_1.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_2_1 = _d.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 8];
+                        _z.sent();
+                        _z.label = 5;
+                    case 5:
+                        _j = _h.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
                     case 7:
+                        e_4_1 = _z.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
                         try {
-                            if (dirs_1_1 && !dirs_1_1.done && (_b = dirs_1.return)) _b.call(dirs_1);
+                            if (_j && !_j.done && (_v = _h.return)) _v.call(_h);
                         }
-                        finally { if (e_2) throw e_2.error; }
+                        finally { if (e_4) throw e_4.error; }
                         return [7 /*endfinally*/];
-                    case 8:
-                        _d.trys.push([8, 13, 14, 15]);
-                        dirs_2 = __values(dirs), dirs_2_1 = dirs_2.next();
-                        _d.label = 9;
-                    case 9:
-                        if (!!dirs_2_1.done) return [3 /*break*/, 12];
-                        dir = dirs_2_1.value;
-                        referenced = fs.resolve(dir, file, extname);
-                        if (!(!enforceRoot || this.contains(dir, referenced))) return [3 /*break*/, 11];
-                        return [4 /*yield*/, referenced];
+                    case 9: return [2 /*return*/];
                     case 10:
-                        _d.sent();
-                        _d.label = 11;
+                        if (seen.has(partial.name))
+                            return [2 /*return*/];
+                        partialScopeNames = new Set();
+                        partialScope = partial.isolated
+                            ? new DummyScope(partialScopeNames)
+                            : scope.push(partialScopeNames);
+                        try {
+                            for (_k = __values(partial.scope), _l = _k.next(); !_l.done; _l = _k.next()) {
+                                name_1 = _l.value;
+                                if (isString(name_1)) {
+                                    partialScopeNames.add(name_1);
+                                }
+                                else {
+                                    _m = __read(name_1, 2), alias = _m[0], argument = _m[1];
+                                    partialScopeNames.add(alias);
+                                    variables_1 = Array.from(extractVariables(argument));
+                                    if (variables_1.length) {
+                                        partialScope.setAlias(alias, variables_1[0].segments);
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        finally {
+                            try {
+                                if (_l && !_l.done && (_w = _k.return)) _w.call(_k);
+                            }
+                            finally { if (e_10) throw e_10.error; }
+                        }
+                        _z.label = 11;
                     case 11:
-                        dirs_2_1 = dirs_2.next();
-                        return [3 /*break*/, 9];
-                    case 12: return [3 /*break*/, 15];
+                        _z.trys.push([11, 17, 18, 19]);
+                        return [4 /*yield*/, template.children(partials, sync)];
+                    case 12:
+                        _o = __values.apply(void 0, [(_z.sent())]), _p = _o.next();
+                        _z.label = 13;
                     case 13:
-                        e_3_1 = _d.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 15];
+                        if (!!_p.done) return [3 /*break*/, 16];
+                        child = _p.value;
+                        return [4 /*yield*/, visit(child, partialScope)];
                     case 14:
+                        _z.sent();
+                        seen.add(partial.name);
+                        _z.label = 15;
+                    case 15:
+                        _p = _o.next();
+                        return [3 /*break*/, 13];
+                    case 16: return [3 /*break*/, 19];
+                    case 17:
+                        e_5_1 = _z.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 19];
+                    case 18:
                         try {
-                            if (dirs_2_1 && !dirs_2_1.done && (_c = dirs_2.return)) _c.call(dirs_2);
+                            if (_p && !_p.done && (_x = _o.return)) _x.call(_o);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_5) throw e_5.error; }
                         return [7 /*endfinally*/];
-                    case 15:
-                        if (!(fs.fallback !== undefined)) return [3 /*break*/, 17];
-                        filepath = fs.fallback(file);
-                        if (!(filepath !== undefined)) return [3 /*break*/, 17];
-                        return [4 /*yield*/, filepath];
-                    case 16:
-                        _d.sent();
-                        _d.label = 17;
-                    case 17: return [2 /*return*/];
+                    case 19:
+                        partialScope.pop();
+                        return [3 /*break*/, 30];
+                    case 20:
+                        if (template.blockScope) {
+                            scope.push(new Set(template.blockScope()));
+                        }
+                        _z.label = 21;
+                    case 21:
+                        _z.trys.push([21, 27, 28, 29]);
+                        return [4 /*yield*/, template.children(partials, sync)];
+                    case 22:
+                        _q = __values.apply(void 0, [(_z.sent())]), _r = _q.next();
+                        _z.label = 23;
+                    case 23:
+                        if (!!_r.done) return [3 /*break*/, 26];
+                        child = _r.value;
+                        return [4 /*yield*/, visit(child, scope)];
+                    case 24:
+                        _z.sent();
+                        _z.label = 25;
+                    case 25:
+                        _r = _q.next();
+                        return [3 /*break*/, 23];
+                    case 26: return [3 /*break*/, 29];
+                    case 27:
+                        e_6_1 = _z.sent();
+                        e_6 = { error: e_6_1 };
+                        return [3 /*break*/, 29];
+                    case 28:
+                        try {
+                            if (_r && !_r.done && (_y = _q.return)) _y.call(_q);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                        return [7 /*endfinally*/];
+                    case 29:
+                        if (template.blockScope) {
+                            scope.pop();
+                        }
+                        _z.label = 30;
+                    case 30: return [2 /*return*/];
                 }
             });
-        };
-        Loader.prototype.dirname = function (path) {
-            var fs = this.options.fs;
-            assert(fs.dirname, '`fs.dirname` is required for relative reference');
-            return fs.dirname(path);
-        };
-        Loader.prototype.lookupError = function (file, roots) {
-            var err = new Error('ENOENT');
-            err.message = "ENOENT: Failed to lookup \"".concat(file, "\" in \"").concat(roots, "\"");
-            err.code = 'ENOENT';
-            return err;
-        };
-        return Loader;
-    }());
-
-    var Parser = /** @class */ (function () {
-        function Parser(liquid) {
-            this.liquid = liquid;
-            this.cache = this.liquid.options.cache;
-            this.fs = this.liquid.options.fs;
-            this.parseFile = this.cache ? this._parseFileCached : this._parseFile;
-            this.loader = new Loader(this.liquid.options);
-            this.parseLimit = new Limiter('parse length', liquid.options.parseLimit);
         }
-        Parser.prototype.parse = function (html, filepath) {
-            html = String(html);
-            this.parseLimit.use(html.length);
-            var tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath);
-            var tokens = tokenizer.readTopLevelTokens(this.liquid.options);
-            return this.parseTokens(tokens);
+        var variables, globals, locals, rootScope, seen, templates_1, templates_1_1, template, e_2_1;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    variables = new VariableMap();
+                    globals = new VariableMap();
+                    locals = new VariableMap();
+                    rootScope = new DummyScope(new Set());
+                    seen = new Set();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    templates_1 = __values(templates), templates_1_1 = templates_1.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!templates_1_1.done) return [3 /*break*/, 5];
+                    template = templates_1_1.value;
+                    return [4 /*yield*/, visit(template, rootScope)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    templates_1_1 = templates_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (templates_1_1 && !templates_1_1.done && (_a = templates_1.return)) _a.call(templates_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/, {
+                        variables: variables.asObject(),
+                        globals: globals.asObject(),
+                        locals: locals.asObject()
+                    }];
+            }
+        });
+    }
+    /**
+     * Statically analyze a template and report variable usage.
+     */
+    function analyze(template, options) {
+        if (options === void 0) { options = {}; }
+        var opts = __assign(__assign({}, defaultStaticAnalysisOptions), options);
+        return toPromise(_analyze(template, opts.partials, false));
+    }
+    /**
+     * Statically analyze a template and report variable usage.
+     */
+    function analyzeSync(template, options) {
+        if (options === void 0) { options = {}; }
+        var opts = __assign(__assign({}, defaultStaticAnalysisOptions), options);
+        return toValueSync(_analyze(template, opts.partials, true));
+    }
+    /**
+     * A stack to manage scopes while traversing templates during static analysis.
+     */
+    var DummyScope = /** @class */ (function () {
+        function DummyScope(globals) {
+            this.stack = [{ names: globals, aliases: new Map() }];
+        }
+        /** Return true if `name` is in scope.  */
+        DummyScope.prototype.has = function (name) {
+            var e_11, _a;
+            try {
+                for (var _b = __values(this.stack), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var scope = _c.value;
+                    if (scope.names.has(name)) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+            return false;
+        };
+        DummyScope.prototype.push = function (scope) {
+            this.stack.push({ names: scope, aliases: new Map() });
+            return this;
+        };
+        DummyScope.prototype.pop = function () {
+            var _a;
+            return (_a = this.stack.pop()) === null || _a === void 0 ? void 0 : _a.names;
+        };
+        // Add a name to the template scope.
+        DummyScope.prototype.add = function (name) {
+            this.stack[0].names.add(name);
+        };
+        /** Return the variable that `variable` aliases, or `variable` if it doesn't alias anything. */
+        DummyScope.prototype.alias = function (variable) {
+            var root = variable.segments[0];
+            if (!isString(root))
+                return undefined;
+            var alias = this.getAlias(root);
+            if (alias === undefined)
+                return undefined;
+            return new Variable(__spreadArray(__spreadArray([], __read(alias), false), __read(variable.segments.slice(1)), false), variable.location);
+        };
+        // TODO: `from` could be a path with multiple segments, like `include.x`.
+        DummyScope.prototype.setAlias = function (from, to) {
+            this.stack[this.stack.length - 1].aliases.set(from, to);
+        };
+        DummyScope.prototype.deleteAlias = function (name) {
+            this.stack[this.stack.length - 1].aliases.delete(name);
+        };
+        DummyScope.prototype.getAlias = function (name) {
+            var e_12, _a;
+            try {
+                for (var _b = __values(this.stack), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var scope = _c.value;
+                    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;
+                    }
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+            return undefined;
+        };
+        return DummyScope;
+    }());
+    function extractVariables(value) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isValueToken(value)) return [3 /*break*/, 2];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(value))];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 2:
+                    if (!(value instanceof Value)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, __values(extractFilteredValueVariables(value))];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4: return [2 /*return*/];
+            }
+        });
+    }
+    function extractFilteredValueVariables(value) {
+        var _a, _b, token, e_13_1, _c, _d, filter, _e, _f, arg, e_14_1, e_15_1;
+        var e_13, _g, e_15, _h, e_14, _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    _k.trys.push([0, 5, 6, 7]);
+                    _a = __values(value.initial.postfix), _b = _a.next();
+                    _k.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    token = _b.value;
+                    if (!isValueToken(token)) return [3 /*break*/, 3];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(token))];
+                case 2:
+                    _k.sent();
+                    _k.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_13_1 = _k.sent();
+                    e_13 = { error: e_13_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                    return [7 /*endfinally*/];
+                case 7:
+                    _k.trys.push([7, 20, 21, 22]);
+                    _c = __values(value.filters), _d = _c.next();
+                    _k.label = 8;
+                case 8:
+                    if (!!_d.done) return [3 /*break*/, 19];
+                    filter = _d.value;
+                    _k.label = 9;
+                case 9:
+                    _k.trys.push([9, 16, 17, 18]);
+                    _e = (e_14 = void 0, __values(filter.args)), _f = _e.next();
+                    _k.label = 10;
+                case 10:
+                    if (!!_f.done) return [3 /*break*/, 15];
+                    arg = _f.value;
+                    if (!(isKeyValuePair(arg) && arg[1])) return [3 /*break*/, 12];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(arg[1]))];
+                case 11:
+                    _k.sent();
+                    return [3 /*break*/, 14];
+                case 12:
+                    if (!isValueToken(arg)) return [3 /*break*/, 14];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(arg))];
+                case 13:
+                    _k.sent();
+                    _k.label = 14;
+                case 14:
+                    _f = _e.next();
+                    return [3 /*break*/, 10];
+                case 15: return [3 /*break*/, 18];
+                case 16:
+                    e_14_1 = _k.sent();
+                    e_14 = { error: e_14_1 };
+                    return [3 /*break*/, 18];
+                case 17:
+                    try {
+                        if (_f && !_f.done && (_j = _e.return)) _j.call(_e);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                    return [7 /*endfinally*/];
+                case 18:
+                    _d = _c.next();
+                    return [3 /*break*/, 8];
+                case 19: return [3 /*break*/, 22];
+                case 20:
+                    e_15_1 = _k.sent();
+                    e_15 = { error: e_15_1 };
+                    return [3 /*break*/, 22];
+                case 21:
+                    try {
+                        if (_d && !_d.done && (_h = _c.return)) _h.call(_c);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                    return [7 /*endfinally*/];
+                case 22: return [2 /*return*/];
+            }
+        });
+    }
+    function extractValueTokenVariables(token) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isRangeToken(token)) return [3 /*break*/, 3];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(token.lhs))];
+                case 1:
+                    _a.sent();
+                    return [5 /*yield**/, __values(extractValueTokenVariables(token.rhs))];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 3:
+                    if (!isPropertyAccessToken(token)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, extractPropertyAccessVariable(token)];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/];
+            }
+        });
+    }
+    function extractPropertyAccessVariable(token) {
+        var e_16, _a;
+        var segments = [];
+        // token is not guaranteed to have `file` set. We'll try to get it from a prop if not.
+        var file = token.file;
+        // Here we're flattening the first segment of a path if it is a nested path.
+        var 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.apply(segments, __spreadArray([], __read(extractPropertyAccessVariable(root).segments), false));
+        }
+        try {
+            for (var _b = __values(token.props.slice(1)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var prop = _c.value;
+                file = file || prop.file;
+                if (isQuotedToken(prop) || isNumberToken(prop) || isWordToken(prop)) {
+                    segments.push(prop.content);
+                }
+                else if (isPropertyAccessToken(prop)) {
+                    segments.push(extractPropertyAccessVariable(prop));
+                }
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+        var _d = __read(token.getPosition(), 2), row = _d[0], col = _d[1];
+        return new Variable(segments, {
+            row: row,
+            col: col,
+            file: file
+        });
+    }
+    // This is used to detect segments that can be represented with dot notation
+    // when creating a string representation of VariableSegments.
+    var 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) {
+        var e_17, _a;
+        if (bracketedRoot === void 0) { bracketedRoot = false; }
+        var buf = [];
+        var root = segments[0];
+        if (isString(root)) {
+            if (!bracketedRoot || root.match(RE_PROPERTY)) {
+                buf.push("".concat(root));
+            }
+            else {
+                buf.push("['".concat(root, "']"));
+            }
+        }
+        try {
+            for (var _b = __values(segments.slice(1)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var segment = _c.value;
+                if (segment instanceof Variable) {
+                    buf.push("[".concat(segmentsString(segment.segments), "]"));
+                }
+                else if (isString(segment)) {
+                    if (segment.match(RE_PROPERTY)) {
+                        buf.push(".".concat(segment));
+                    }
+                    else {
+                        buf.push("['".concat(segment, "']"));
+                    }
+                }
+                else {
+                    buf.push("[".concat(segment, "]"));
+                }
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        return buf.join('');
+    }
+
+    var LookupType;
+    (function (LookupType) {
+        LookupType["Partials"] = "partials";
+        LookupType["Layouts"] = "layouts";
+        LookupType["Root"] = "root";
+    })(LookupType || (LookupType = {}));
+    var Loader = /** @class */ (function () {
+        function Loader(options) {
+            this.options = options;
+            if (options.relativeReference) {
+                var sep = options.fs.sep;
+                assert(sep, '`fs.sep` is required for relative reference');
+                var rRelativePath_1 = new RegExp(['.' + sep, '..' + sep, './', '../'].map(function (prefix) { return escapeRegex(prefix); }).join('|'));
+                this.shouldLoadRelative = function (referencedFile) { return rRelativePath_1.test(referencedFile); };
+            }
+            else {
+                this.shouldLoadRelative = function (_referencedFile) { return false; };
+            }
+            this.contains = this.options.fs.contains || (function () { return true; });
+        }
+        Loader.prototype.lookup = function (file, type, sync, currentFile) {
+            var fs, dirs, _a, _b, filepath, _c, e_1_1;
+            var e_1, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        fs = this.options.fs;
+                        dirs = this.options[type];
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 8, 9, 10]);
+                        _a = __values(this.candidates(file, dirs, currentFile, type !== LookupType.Root)), _b = _a.next();
+                        _e.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        filepath = _b.value;
+                        if (!sync) return [3 /*break*/, 3];
+                        _c = fs.existsSync(filepath);
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, fs.exists(filepath)];
+                    case 4:
+                        _c = _e.sent();
+                        _e.label = 5;
+                    case 5:
+                        if (_c)
+                            return [2 /*return*/, filepath];
+                        _e.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _e.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: throw this.lookupError(file, dirs);
+                }
+            });
+        };
+        Loader.prototype.candidates = function (file, dirs, currentFile, enforceRoot) {
+            var _a, fs, extname, referenced, dirs_1, dirs_1_1, dir, e_2_1, dirs_2, dirs_2_1, dir, referenced, e_3_1, filepath;
+            var e_2, _b, e_3, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = this.options, fs = _a.fs, extname = _a.extname;
+                        if (!(this.shouldLoadRelative(file) && currentFile)) return [3 /*break*/, 8];
+                        referenced = fs.resolve(this.dirname(currentFile), file, extname);
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        dirs_1 = __values(dirs), dirs_1_1 = dirs_1.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!dirs_1_1.done) return [3 /*break*/, 5];
+                        dir = dirs_1_1.value;
+                        if (!(!enforceRoot || this.contains(dir, referenced))) return [3 /*break*/, 4];
+                        // the relatively referenced file is within one of root dirs
+                        return [4 /*yield*/, referenced];
+                    case 3:
+                        // the relatively referenced file is within one of root dirs
+                        _d.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        dirs_1_1 = dirs_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (dirs_1_1 && !dirs_1_1.done && (_b = dirs_1.return)) _b.call(dirs_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        _d.trys.push([8, 13, 14, 15]);
+                        dirs_2 = __values(dirs), dirs_2_1 = dirs_2.next();
+                        _d.label = 9;
+                    case 9:
+                        if (!!dirs_2_1.done) return [3 /*break*/, 12];
+                        dir = dirs_2_1.value;
+                        referenced = fs.resolve(dir, file, extname);
+                        if (!(!enforceRoot || this.contains(dir, referenced))) return [3 /*break*/, 11];
+                        return [4 /*yield*/, referenced];
+                    case 10:
+                        _d.sent();
+                        _d.label = 11;
+                    case 11:
+                        dirs_2_1 = dirs_2.next();
+                        return [3 /*break*/, 9];
+                    case 12: return [3 /*break*/, 15];
+                    case 13:
+                        e_3_1 = _d.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 15];
+                    case 14:
+                        try {
+                            if (dirs_2_1 && !dirs_2_1.done && (_c = dirs_2.return)) _c.call(dirs_2);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 15:
+                        if (!(fs.fallback !== undefined)) return [3 /*break*/, 17];
+                        filepath = fs.fallback(file);
+                        if (!(filepath !== undefined)) return [3 /*break*/, 17];
+                        return [4 /*yield*/, filepath];
+                    case 16:
+                        _d.sent();
+                        _d.label = 17;
+                    case 17: return [2 /*return*/];
+                }
+            });
+        };
+        Loader.prototype.dirname = function (path) {
+            var fs = this.options.fs;
+            assert(fs.dirname, '`fs.dirname` is required for relative reference');
+            return fs.dirname(path);
+        };
+        Loader.prototype.lookupError = function (file, roots) {
+            var err = new Error('ENOENT');
+            err.message = "ENOENT: Failed to lookup \"".concat(file, "\" in \"").concat(roots, "\"");
+            err.code = 'ENOENT';
+            return err;
+        };
+        return Loader;
+    }());
+
+    var Parser = /** @class */ (function () {
+        function Parser(liquid) {
+            this.liquid = liquid;
+            this.cache = this.liquid.options.cache;
+            this.fs = this.liquid.options.fs;
+            this.parseFile = this.cache ? this._parseFileCached : this._parseFile;
+            this.loader = new Loader(this.liquid.options);
+            this.parseLimit = new Limiter('parse length', liquid.options.parseLimit);
+        }
+        Parser.prototype.parse = function (html, filepath) {
+            html = String(html);
+            this.parseLimit.use(html.length);
+            var tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath);
+            var tokens = tokenizer.readTopLevelTokens(this.liquid.options);
+            return this.parseTokens(tokens);
         };
         Parser.prototype.parseTokens = function (tokens) {
             var token;
@@ -3368,6 +4114,10 @@
     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;
     }
@@ -3384,7 +4134,8 @@
         isNumberToken: isNumberToken,
         isPropertyAccessToken: isPropertyAccessToken,
         isWordToken: isWordToken,
-        isRangeToken: isRangeToken
+        isRangeToken: isRangeToken,
+        isValueToken: isValueToken
     });
 
     var Context = /** @class */ (function () {
@@ -3400,6 +4151,8 @@
              */
             this.scopes = [{}];
             this.registers = {};
+            this.breakCalled = false;
+            this.continueCalled = false;
             this.sync = !!renderOptions.sync;
             this.opts = opts;
             this.globals = (_c = renderOptions.globals) !== null && _c !== void 0 ? _c : opts.globals;
@@ -3447,9 +4200,11 @@
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        scope = this.findScope(paths[0]);
+                        scope = this.findScope(paths[0]) // first prop should always be a string
+                        ;
                         return [4 /*yield*/, this._getFromScope(scope, paths)];
-                    case 1: return [2 /*return*/, _a.sent()];
+                    case 1: // first prop should always be a string
+                    return [2 /*return*/, _a.sent()];
                 }
             });
         };
@@ -3519,6 +4274,7 @@
     }());
     function readProperty(obj, key, ownPropertyOnly) {
         obj = toLiquid(obj);
+        key = toValue(key);
         if (isNil(obj))
             return obj;
         if (isArray(obj) && key < 0)
@@ -3672,8 +4428,8 @@
         this.context.memoryLimit.use(complexity);
         return array.join(sep);
     });
-    var last$1 = argumentsToValue(function (v) { return isArray(v) ? last(v) : ''; });
-    var first = argumentsToValue(function (v) { return isArray(v) ? v[0] : ''; });
+    var last$1 = argumentsToValue(function (v) { return isArrayLike(v) ? last(v) : ''; });
+    var first = argumentsToValue(function (v) { return isArrayLike(v) ? v[0] : ''; });
     var reverse = argumentsToValue(function (v) {
         var array = toArray(v);
         this.context.memoryLimit.use(array.length);
@@ -3876,7 +4632,7 @@
         return v.slice(begin, begin + length);
     }
     function where(arr, property, expected) {
-        var values, token, arr_1, arr_1_1, item, _a, _b, e_4_1;
+        var values, token, arr_1, arr_1_1, item, _a, _b, e_4_1, matcher;
         var e_4, _c;
         var _this = this;
         return __generator(this, function (_d) {
@@ -3913,11 +4669,15 @@
                     }
                     finally { if (e_4) throw e_4.error; }
                     return [7 /*endfinally*/];
-                case 8: return [2 /*return*/, arr.filter(function (_, i) {
-                        if (expected === undefined)
-                            return isTruthy(values[i], _this.context);
-                        return equals(values[i], expected);
-                    })];
+                case 8:
+                    matcher = this.context.opts.jekyllWhere
+                        ? function (v) { return EmptyDrop.is(expected) ? equals(v, expected) : (isArray(v) ? arrayIncludes(v, expected) : equals(v, expected)); }
+                        : function (v) { return equals(v, expected); };
+                    return [2 /*return*/, arr.filter(function (_, i) {
+                            if (expected === undefined)
+                                return isTruthy(values[i], _this.context);
+                            return matcher(values[i]);
+                        })];
             }
         });
     }
@@ -3970,7 +4730,7 @@
             switch (_b.label) {
                 case 0:
                     map = new Map();
-                    arr = toArray(arr);
+                    arr = toEnumerable(arr);
                     token = new Tokenizer(stringify(property)).readScopeValue();
                     this.context.memoryLimit.use(arr.length);
                     _b.label = 1;
@@ -4017,7 +4777,7 @@
                 case 0:
                     map = new Map();
                     keyTemplate = new Value(stringify(exp), this.liquid);
-                    arr = toArray(arr);
+                    arr = toEnumerable(arr);
                     this.context.memoryLimit.use(arr.length);
                     _c.label = 1;
                 case 1:
@@ -4467,7 +5227,8 @@
         __extends(default_1, _super);
         function default_1(token, remainTokens, liquid) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
-            _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 "="');
@@ -4489,6 +5250,26 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -4505,7 +5286,7 @@
             }
             _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 = [];
             var p;
@@ -4563,14 +5344,12 @@
                         if (!!collection_1_1.done) return [3 /*break*/, 9];
                         item = collection_1_1.value;
                         scope[this.variable] = item;
+                        ctx.continueCalled = ctx.breakCalled = false;
                         return [4 /*yield*/, r.renderTemplates(this.templates, ctx, emitter)];
                     case 7:
                         _c.sent();
-                        if (emitter['break']) {
-                            emitter['break'] = false;
+                        if (ctx.breakCalled)
                             return [3 /*break*/, 9];
-                        }
-                        emitter['continue'] = false;
                         scope.forloop.next();
                         _c.label = 8;
                     case 8:
@@ -4588,11 +5367,64 @@
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
                     case 12:
+                        ctx.continueCalled = ctx.breakCalled = false;
                         ctx.pop();
                         return [2 /*return*/];
                 }
             });
         };
+        default_1.prototype.children = function () {
+            var templates;
+            return __generator(this, function (_a) {
+                templates = this.templates.slice();
+                if (this.elseTemplates) {
+                    templates.push.apply(templates, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, templates];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_2_1;
+            var e_2, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.collection];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(Object.values(this.hash.hash)), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, v];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.blockScope = function () {
+            return [this.variable, 'forloop'];
+        };
         return default_1;
     }(Tag));
     function reversed(arr) {
@@ -4610,7 +5442,8 @@
         function default_1(tagToken, remainTokens, liquid, parser) {
             var _this = _super.call(this, tagToken, remainTokens, liquid) || this;
             _this.templates = [];
-            _this.variable = _this.readVariableName();
+            _this.identifier = _this.readVariable();
+            _this.variable = _this.identifier.content;
             while (remainTokens.length) {
                 var token = remainTokens.shift();
                 if (isTagToken(token) && token.name === 'endcapture')
@@ -4619,6 +5452,15 @@
             }
             throw new Error("tag ".concat(tagToken.getText(), " not closed"));
         }
+        default_1.prototype.readVariable = function () {
+            var ident = this.tokenizer.readIdentifier();
+            if (ident.content)
+                return ident;
+            ident = this.tokenizer.readQuoted();
+            if (ident)
+                return ident;
+            throw this.tokenizer.error('invalid capture name');
+        };
         default_1.prototype.render = function (ctx) {
             var r, html;
             return __generator(this, function (_a) {
@@ -4633,14 +5475,20 @@
                 }
             });
         };
-        default_1.prototype.readVariableName = function () {
-            var word = this.tokenizer.readIdentifier().content;
-            if (word)
-                return word;
-            var quoted = this.tokenizer.readQuoted();
-            if (quoted)
-                return evalQuotedToken(quoted);
-            throw this.tokenizer.error('invalid capture name');
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
         };
         return default_1;
     }(Tag));
@@ -4768,6 +5616,29 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        return [5 /*yield**/, __values(this.branches.flatMap(function (b) { return b.values; }))];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.children = function () {
+            var templates;
+            return __generator(this, function (_a) {
+                templates = this.branches.flatMap(function (b) { return b.templates; });
+                if (this.elseTemplates) {
+                    templates.push.apply(templates, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, templates];
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -4825,7 +5696,7 @@
                 tokenizer.p = begin;
                 break;
             }
-            _this.hash = new Hash(tokenizer.remaining(), liquid.options.keyValueSeparator);
+            _this.hash = new Hash(tokenizer, liquid.options.keyValueSeparator);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -4882,26 +5753,112 @@
                     case 10:
                         collection_1_1 = collection_1.next();
                         return [3 /*break*/, 7];
-                    case 11: return [3 /*break*/, 14];
-                    case 12:
-                        e_1_1 = _k.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 14];
-                    case 13:
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_1_1 = _k.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (collection_1_1 && !collection_1_1.done && (_j = collection_1.return)) _j.call(collection_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [3 /*break*/, 18];
+                    case 15: return [4 /*yield*/, liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile'])];
+                    case 16:
+                        templates = (_k.sent());
+                        return [4 /*yield*/, liquid.renderer.renderTemplates(templates, childCtx, emitter)];
+                    case 17:
+                        _k.sent();
+                        _k.label = 18;
+                    case 18: return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.children = function (partials, sync) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(partials && isString(this['file']))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.liquid._parsePartialFile(this['file'], sync, this['currentFile'])];
+                    case 1: return [2 /*return*/, (_a.sent())];
+                    case 2: return [2 /*return*/, []];
+                }
+            });
+        };
+        default_1.prototype.partialScope = function () {
+            if (isString(this['file'])) {
+                var names = Object.keys(this.hash.hash);
+                if (this['with']) {
+                    var _a = this['with'], value = _a.value, alias = _a.alias;
+                    if (isString(alias)) {
+                        names.push([alias, value]);
+                    }
+                    else if (isString(this.file)) {
+                        names.push([this.file, value]);
+                    }
+                }
+                if (this['for']) {
+                    var _b = this['for'], value = _b.value, alias = _b.alias;
+                    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 };
+            }
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_2_1, value, value;
+            var e_2, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 5, 6, 7]);
+                        _a = __values(Object.values(this.hash.hash)), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, v];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
                         try {
-                            if (collection_1_1 && !collection_1_1.done && (_j = collection_1.return)) _j.call(collection_1);
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_1) throw e_1.error; }
+                        finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
-                    case 14: return [3 /*break*/, 18];
-                    case 15: return [4 /*yield*/, liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile'])];
-                    case 16:
-                        templates = (_k.sent());
-                        return [4 /*yield*/, liquid.renderer.renderTemplates(templates, childCtx, emitter)];
-                    case 17:
-                        _k.sent();
-                        _k.label = 18;
-                    case 18: return [2 /*return*/];
+                    case 7:
+                        if (!this['with']) return [3 /*break*/, 9];
+                        value = this['with'].value;
+                        if (!isValueToken(value)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, value];
+                    case 8:
+                        _d.sent();
+                        _d.label = 9;
+                    case 9:
+                        if (!this['for']) return [3 /*break*/, 11];
+                        value = this['for'].value;
+                        if (!isValueToken(value)) return [3 /*break*/, 11];
+                        return [4 /*yield*/, value];
+                    case 10:
+                        _d.sent();
+                        _d.label = 11;
+                    case 11: return [2 /*return*/];
                 }
             });
         };
@@ -4969,7 +5926,7 @@
             }
             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);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -5009,6 +5966,53 @@
                 }
             });
         };
+        default_1.prototype.children = function (partials, sync) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(partials && isString(this['file']))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.liquid._parsePartialFile(this['file'], sync, this['currentFile'])];
+                    case 1: return [2 /*return*/, (_a.sent())];
+                    case 2: return [2 /*return*/, []];
+                }
+            });
+        };
+        default_1.prototype.partialScope = function () {
+            if (isString(this['file'])) {
+                var names = void 0;
+                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 };
+            }
+        };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [5 /*yield**/, __values(Object.values(this.hash.hash).filter(isValueToken))];
+                    case 1:
+                        _a.sent();
+                        if (!isValueToken(this['file'])) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this['file']];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (!isValueToken(this.withVar)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.withVar];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -5016,7 +6020,8 @@
         __extends(default_1, _super);
         function default_1(token, remainTokens, liquid) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
-            _this.variable = _this.tokenizer.readIdentifier().content;
+            _this.identifier = _this.tokenizer.readIdentifier();
+            _this.variable = _this.identifier.content;
             return _this;
         }
         default_1.prototype.render = function (context, emitter) {
@@ -5026,6 +6031,16 @@
             }
             emitter.write(stringify(--scope[this.variable]));
         };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -5074,6 +6089,21 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [5 /*yield**/, __values(this.candidates)];
+                    case 1:
+                        _a.sent();
+                        if (!this.group) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.group];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -5085,13 +6115,13 @@
             var p = [];
             parser.parseStream(remainTokens)
                 .on('start', function () { return _this.branches.push({
-                value: new Value(tagToken.args, _this.liquid),
+                value: new Value(tagToken.tokenizer.readFilteredValue(), _this.liquid),
                 templates: (p = [])
             }); })
                 .on('tag:elsif', function (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 = [])
                 });
             })
@@ -5150,6 +6180,19 @@
                 }
             });
         };
+        default_1.prototype.children = function () {
+            var templates;
+            return __generator(this, function (_a) {
+                templates = this.branches.flatMap(function (b) { return b.templates; });
+                if (this.elseTemplates) {
+                    templates.push.apply(templates, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, templates];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            return this.branches.map(function (b) { return b.value; });
+        };
         return default_1;
     }(Tag));
 
@@ -5157,7 +6200,8 @@
         __extends(default_1, _super);
         function default_1(token, remainTokens, liquid) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
-            _this.variable = _this.tokenizer.readIdentifier().content;
+            _this.identifier = _this.tokenizer.readIdentifier();
+            _this.variable = _this.identifier.content;
             return _this;
         }
         default_1.prototype.render = function (context, emitter) {
@@ -5169,6 +6213,16 @@
             scope[this.variable]++;
             emitter.write(stringify(val));
         };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -5178,7 +6232,7 @@
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             _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);
             return _this;
         }
@@ -5226,6 +6280,70 @@
                 }
             });
         };
+        default_1.prototype.children = function (partials) {
+            var templates, _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        templates = this.templates.slice();
+                        if (!(partials && isString(this.file))) return [3 /*break*/, 2];
+                        _b = (_a = templates.push).apply;
+                        _c = [templates];
+                        _d = [[]];
+                        return [4 /*yield*/, this.liquid._parsePartialFile(this.file, true, this['currentFile'])];
+                    case 1:
+                        _b.apply(_a, _c.concat([__spreadArray.apply(void 0, _d.concat([__read.apply(void 0, [(_e.sent())]), false]))]));
+                        _e.label = 2;
+                    case 2: return [2 /*return*/, templates];
+                }
+            });
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 5, 6, 7]);
+                        _a = __values(Object.values(this.args.hash)), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, v];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 7:
+                        if (!isValueToken(this.file)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.file];
+                    case 8:
+                        _d.sent();
+                        _d.label = 9;
+                    case 9: return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.partialScope = function () {
+            if (isString(this.file)) {
+                return { name: this.file, isolated: false, scope: Object.keys(this.args.hash) };
+            }
+        };
         return default_1;
     }(Tag));
 
@@ -5283,6 +6401,14 @@
                 ? function (superBlock, emitter) { return renderChild(new BlockDrop(function () { return renderCurrent(superBlock, emitter); }), emitter); }
                 : renderCurrent;
         };
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
+        default_1.prototype.blockScope = function () {
+            return ['block'];
+        };
         return default_1;
     }(Tag));
 
@@ -5344,7 +6470,7 @@
             }
             _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 = [];
             var p;
             var stream = parser.parseStream(remainTokens)
@@ -5404,6 +6530,53 @@
                 }
             });
         };
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.collection];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(Object.values(this.args.hash)), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, v];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.blockScope = function () {
+            return [this.variable, 'tablerowloop'];
+        };
         return default_1;
     }(Tag));
 
@@ -5417,7 +6590,7 @@
             var elseCount = 0;
             parser.parseStream(remainTokens)
                 .on('start', function () { return _this.branches.push({
-                value: new Value(tagToken.args, _this.liquid),
+                value: new Value(tagToken.tokenizer.readFilteredValue(), _this.liquid),
                 test: isFalsy,
                 templates: (p = [])
             }); })
@@ -5427,7 +6600,7 @@
                     return;
                 }
                 _this.branches.push({
-                    value: new Value(token.args, _this.liquid),
+                    value: new Value(token.tokenizer.readFilteredValue(), _this.liquid),
                     test: isTruthy,
                     templates: (p = [])
                 });
@@ -5490,6 +6663,19 @@
                 }
             });
         };
+        default_1.prototype.children = function () {
+            var children;
+            return __generator(this, function (_a) {
+                children = this.branches.flatMap(function (b) { return b.templates; });
+                if (this.elseTemplates) {
+                    children.push.apply(children, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, children];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            return this.branches.map(function (b) { return b.value; });
+        };
         return default_1;
     }(Tag));
 
@@ -5498,8 +6684,8 @@
         function default_1() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        default_1.prototype.render = function (ctx, emitter) {
-            emitter['break'] = true;
+        default_1.prototype.render = function (ctx, _emitter) {
+            ctx.breakCalled = true;
         };
         return default_1;
     }(Tag));
@@ -5509,8 +6695,8 @@
         function default_1() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        default_1.prototype.render = function (ctx, emitter) {
-            emitter['continue'] = true;
+        default_1.prototype.render = function (ctx, _emitter) {
+            ctx.continueCalled = true;
         };
         return default_1;
     }(Tag));
@@ -5540,6 +6726,19 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.value) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -5561,6 +6760,11 @@
                 }
             });
         };
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -5744,11 +6948,161 @@
                 self.renderFile(filePath, ctx).then(function (html) { return callback(null, html); }, callback);
             };
         };
+        Liquid.prototype.analyze = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, analyze(template, options)];
+                });
+            });
+        };
+        Liquid.prototype.analyzeSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return analyzeSync(template, options);
+        };
+        Liquid.prototype.parseAndAnalyze = function (html, filename, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, analyze(this.parse(html, filename), options)];
+                });
+            });
+        };
+        Liquid.prototype.parseAndAnalyzeSync = function (html, filename, options) {
+            if (options === void 0) { options = {}; }
+            return analyzeSync(this.parse(html, filename), options);
+        };
+        /** Return an array of all variables without their properties. */
+        Liquid.prototype.variables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Object.keys(analysis.variables)];
+                    }
+                });
+            });
+        };
+        /** Return an array of all variables without their properties. */
+        Liquid.prototype.variablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Object.keys(analysis.variables);
+        };
+        /** Return an array of all variables including their properties/paths. */
+        Liquid.prototype.fullVariables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(new Set(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return String(v); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all variables including their properties/paths. */
+        Liquid.prototype.fullVariablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(new Set(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return String(v); }); })));
+        };
+        /** Return an array of all variables, each as an array of properties/segments. */
+        Liquid.prototype.variableSegments = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(strictUniq(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all variables, each as an array of properties/segments. */
+        Liquid.prototype.variableSegmentsSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(strictUniq(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })));
+        };
+        /** Return an array of all expected context variables without their properties. */
+        Liquid.prototype.globalVariables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Object.keys(analysis.globals)];
+                    }
+                });
+            });
+        };
+        /** Return an array of all expected context variables without their properties. */
+        Liquid.prototype.globalVariablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var 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. */
+        Liquid.prototype.globalFullVariables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(new Set(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return String(v); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all expected context variables including their properties/paths. */
+        Liquid.prototype.globalFullVariablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(new Set(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return String(v); }); })));
+        };
+        /** Return an array of all expected context variables, each as an array of properties/segments. */
+        Liquid.prototype.globalVariableSegments = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(strictUniq(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all expected context variables, each as an array of properties/segments. */
+        Liquid.prototype.globalVariableSegmentsSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(strictUniq(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })));
+        };
         return Liquid;
     }());
 
     /* istanbul ignore file */
-    var version = '10.18.0';
+    var version = '10.20.1';
 
     exports.AssertionError = AssertionError;
     exports.AssignTag = default_1;
@@ -5778,6 +7132,7 @@
     exports.Output = Output;
     exports.ParseError = ParseError;
     exports.ParseStream = ParseStream;
+    exports.Parser = Parser;
     exports.RawTag = default_1$d;
     exports.RenderError = RenderError;
     exports.RenderTag = default_1$5;
@@ -5791,6 +7146,9 @@
     exports.UndefinedVariableError = UndefinedVariableError;
     exports.UnlessTag = default_1$f;
     exports.Value = Value;
+    exports.Variable = Variable;
+    exports.analyze = analyze;
+    exports.analyzeSync = analyzeSync;
     exports.assert = assert;
     exports.createTrie = createTrie;
     exports.defaultOperators = defaultOperators;