@skeptools/skep-organization-project 0.0.17 → 0.0.19

package/node_modules/liquidjs/dist/liquid.browser.umd.js

@@ -1,6 +1,6 @@
 /*
- * liquidjs@10.20.1, https://github.com/harttle/liquidjs
- * (c) 2016-2025 harttle
+ * liquidjs@10.30.1, https://github.com/harttle/liquidjs
+ * (c) 2016-2026 harttle
  * Released under the MIT License.
  */
 (function (global, factory) {
@@ -160,7 +160,7 @@
     var Drop = /** @class */ (function () {
         function Drop() {
         }
-        Drop.prototype.liquidMethodMissing = function (key) {
+        Drop.prototype.liquidMethodMissing = function (key, context) {
             return undefined;
         };
         return Drop;
@@ -182,9 +182,6 @@
     function isIterator(val) {
         return val && isFunction(val.next) && isFunction(val.throw) && isFunction(val.return);
     }
-    function escapeRegex(str) {
-        return str.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
-    }
     function stringify(value) {
         value = toValue(value);
         if (isString(value))
@@ -195,6 +192,25 @@
             return value.map(function (x) { return stringify(x); }).join('');
         return String(value);
     }
+    function advanceCodePoints(str, from, count) {
+        var index = from;
+        for (var i = 0; i < count && index < str.length; i++)
+            index += str.codePointAt(index) > 0xFFFF ? 2 : 1;
+        return index;
+    }
+    function codePointLength(str) {
+        var length = 0;
+        for (var index = 0; index < str.length; index = advanceCodePoints(str, index, 1))
+            length++;
+        return length;
+    }
+    function readArrayElement(arr, index, ownPropertyOnly) {
+        if (index < 0)
+            index = arr.length + index;
+        if (ownPropertyOnly && !hasOwnProperty.call(arr, index))
+            return undefined;
+        return arr[index];
+    }
     function toEnumerable(val) {
         val = toValue(val);
         if (isArray(val))
@@ -219,8 +235,7 @@
         return (value instanceof Drop && isFunction(value.valueOf)) ? value.valueOf() : value;
     }
     function toNumber(value) {
-        value = Number(value);
-        return isNaN(value) ? 0 : value;
+        return +toValue(value) || 0;
     }
     function isNumber(value) {
         return typeof value === 'number';
@@ -296,9 +311,9 @@
     function pad(str, length, ch, add) {
         str = String(str);
         var n = length - str.length;
-        while (n-- > 0)
-            str = add(str, ch);
-        return str;
+        if (n <= 0)
+            return str;
+        return add(str, ch.repeat(n));
     }
     function identify(val) {
         return val;
@@ -310,13 +325,26 @@
     function ellipsis(str, N) {
         return str.length > N ? str.slice(0, N - 3) + '...' : str;
     }
+    function orderedCompare(a, b) {
+        if (isNil(a) && isNil(b))
+            return 0;
+        if (isNil(a))
+            return 1;
+        if (isNil(b))
+            return -1;
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    }
     // compare string in case-insensitive way, undefined values to the tail
     function caseInsensitiveCompare(a, b) {
-        if (a == null && b == null)
+        if (isNil(a) && isNil(b))
             return 0;
-        if (a == null)
+        if (isNil(a))
             return 1;
-        if (b == null)
+        if (isNil(b))
             return -1;
         a = toLowerCase.call(a);
         b = toLowerCase.call(b);
@@ -335,8 +363,14 @@
             return fn.call.apply(fn, __spreadArray([this], __read(args.map(toValue)), false));
         };
     }
-    function escapeRegExp(text) {
-        return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    function argumentsToNumber(fn) {
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return fn.call.apply(fn, __spreadArray([this], __read(args.map(toNumber)), false));
+        };
     }
     /** Return an array containing unique elements from _array_. Works with nested arrays and objects. */
     function strictUniq(array) {
@@ -563,7 +597,15 @@
             return _super !== null && _super.apply(this, arguments) || this;
         }
         NullDrop.prototype.equals = function (value) {
-            return isNil(toValue(value));
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = isNil;
+                        return [4 /*yield*/, toValue(value)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+                }
+            });
         };
         NullDrop.prototype.gt = function () {
             return false;
@@ -589,14 +631,21 @@
             return _super !== null && _super.apply(this, arguments) || this;
         }
         EmptyDrop.prototype.equals = function (value) {
-            if (value instanceof EmptyDrop)
-                return false;
-            value = toValue(value);
-            if (isString(value) || isArray(value))
-                return value.length === 0;
-            if (isObject(value))
-                return Object.keys(value).length === 0;
-            return false;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (value instanceof EmptyDrop)
+                            return [2 /*return*/, false];
+                        return [4 /*yield*/, toValue(value)];
+                    case 1:
+                        value = _a.sent();
+                        if (isString(value) || isArray(value))
+                            return [2 /*return*/, value.length === 0];
+                        if (isObject(value))
+                            return [2 /*return*/, Object.keys(value).length === 0];
+                        return [2 /*return*/, false];
+                }
+            });
         };
         EmptyDrop.prototype.gt = function () {
             return false;
@@ -625,13 +674,23 @@
             return _super !== null && _super.apply(this, arguments) || this;
         }
         BlankDrop.prototype.equals = function (value) {
-            if (value === false)
-                return true;
-            if (isNil(toValue(value)))
-                return true;
-            if (isString(value))
-                return /^\s*$/.test(value);
-            return _super.prototype.equals.call(this, value);
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (value === false)
+                            return [2 /*return*/, true];
+                        _a = isNil;
+                        return [4 /*yield*/, toValue(value)];
+                    case 1:
+                        if (_a.apply(void 0, [_b.sent()]))
+                            return [2 /*return*/, true];
+                        if (isString(value))
+                            return [2 /*return*/, /^\s*$/.test(value)];
+                        return [4 /*yield*/, _super.prototype.equals.call(this, value)];
+                    case 2: return [2 /*return*/, _b.sent()];
+                }
+            });
         };
         BlankDrop.is = function (value) {
             return value instanceof BlankDrop;
@@ -675,6 +734,45 @@
         return ForloopDrop;
     }(Drop));
 
+    var SimpleEmitter = /** @class */ (function () {
+        function SimpleEmitter() {
+            this.buffer = '';
+        }
+        SimpleEmitter.prototype.write = function (html) {
+            this.buffer += stringify(html);
+        };
+        return SimpleEmitter;
+    }());
+
+    var StreamedEmitter = /** @class */ (function () {
+        function StreamedEmitter() {
+            this.buffer = '';
+            this.stream = null;
+            throw new Error('streaming not supported in browser');
+        }
+        return StreamedEmitter;
+    }());
+
+    var KeepingTypeEmitter = /** @class */ (function () {
+        function KeepingTypeEmitter() {
+            this.buffer = '';
+        }
+        KeepingTypeEmitter.prototype.write = function (html) {
+            html = toValue(html);
+            // This will only preserve the type if the value is isolated.
+            // I.E:
+            // {{ my-port }} -> 42
+            // {{ my-host }}:{{ my-port }} -> 'host:42'
+            if (typeof html !== 'string' && this.buffer === '') {
+                this.buffer = html;
+            }
+            else {
+                this.buffer = stringify(this.buffer) + stringify(html);
+            }
+        };
+        return KeepingTypeEmitter;
+    }());
+
     var BlockDrop = /** @class */ (function (_super) {
         __extends(BlockDrop, _super);
         function BlockDrop(
@@ -690,7 +788,17 @@
          * {{ block.super }}
          */
         BlockDrop.prototype.super = function () {
-            return this.superBlockRender();
+            var emitter;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        emitter = new SimpleEmitter();
+                        return [4 /*yield*/, this.superBlockRender(emitter)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, emitter.buffer];
+                }
+            });
         };
         return BlockDrop;
     }(Drop));
@@ -714,8 +822,17 @@
         'blank': new BlankDrop()
     };
 
+    // Tries are built once per input object and reused: the Tokenizer rebuilds them
+    // on every instantiation, but `input` (operators/literalValues) is a stable
+    // reference. WeakMap-keying by `input` lets short-lived operator objects (and
+    // their tries) be garbage collected. The returned trie is treated as read-only
+    // by callers (matchTrie only reads it); do not mutate it.
+    var trieCache = new WeakMap();
     function createTrie(input) {
         var e_1, _a;
+        var cached = trieCache.get(input);
+        if (cached)
+            return cached;
         var trie = {};
         try {
             for (var _b = __values(Object.entries(input)), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -740,9 +857,20 @@
             }
             finally { if (e_1) throw e_1.error; }
         }
+        trieCache.set(input, trie);
         return trie;
     }
 
+    function toLiquidAsync(asyncFn, syncFn) {
+        var syncImpl = syncFn || asyncFn;
+        return function (sync) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return sync ? syncImpl.apply(void 0, __spreadArray([], __read(args), false)) : asyncFn.apply(void 0, __spreadArray([], __read(args), false));
+        };
+    }
     // convert an async iterator to a Promise
     function toPromise(val) {
         return __awaiter(this, void 0, void 0, function () {
@@ -757,7 +885,7 @@
                         _a.label = 1;
                     case 1:
                         state = val[next](value);
-                        done = state.done;
+                        done = !!state.done;
                         value = state.value;
                         next = 'next';
                         _a.label = 2;
@@ -793,7 +921,7 @@
         var next = 'next';
         do {
             var state = val[next](value);
-            done = state.done;
+            done = !!state.done;
             value = state.value;
             next = 'next';
             if (isIterator(value)) {
@@ -823,12 +951,9 @@
         return num + d.getDate();
     }
     function getWeekOfYear(d, startDay) {
-        // Skip to startDay of this week
-        var now = getDayOfYear(d) + (startDay - d.getDay());
-        // Find the first startDay of the year
-        var jan1 = new Date(d.getFullYear(), 0, 1);
-        var then = (7 - jan1.getDay() + startDay);
-        return String(Math.floor((now - then) / 7) + 1);
+        // Days before the first startDay of the year belong to week 0
+        var daysSinceStartDay = (d.getDay() - startDay + 7) % 7;
+        return String(Math.floor((getDayOfYear(d) - 1 - daysSinceStartDay + 7) / 7));
     }
     function isLeapYear(d) {
         var year = d.getFullYear();
@@ -846,10 +971,11 @@
         }
     }
     function century(d) {
-        return parseInt(d.getFullYear().toString().substring(0, 2), 10);
+        return Math.floor(d.getFullYear() / 100);
     }
     // default to 0
     var padWidths = {
+        C: 2,
         d: 2,
         e: 2,
         H: 2,
@@ -862,7 +988,9 @@
         M: 2,
         S: 2,
         U: 2,
-        W: 2
+        W: 2,
+        y: 2,
+        Y: 4
     };
     var padSpaceChars = new Set('aAbBceklpP');
     function getTimezoneOffset(d, opts) {
@@ -892,14 +1020,16 @@
         m: function (d) { return d.getMonth() + 1; },
         M: function (d) { return d.getMinutes(); },
         N: function (d, opts) {
+            var _a;
             var width = Number(opts.width) || 9;
-            var str = String(d.getMilliseconds()).slice(0, width);
+            var str = padStart(String(d.getMilliseconds()), 3, '0').slice(0, width);
+            (_a = opts.memoryLimit) === null || _a === void 0 ? void 0 : _a.use(width - str.length);
             return padEnd(str, width, '0');
         },
         p: function (d) { return (d.getHours() < 12 ? 'AM' : 'PM'); },
         P: function (d) { return (d.getHours() < 12 ? 'am' : 'pm'); },
         q: function (d) { return ordinal(d); },
-        s: function (d) { return Math.round(d.getTime() / 1000); },
+        s: function (d) { return Math.floor(d.dateValue() / 1000); },
         S: function (d) { return d.getSeconds(); },
         u: function (d) { return d.getDay() || 7; },
         U: function (d) { return getWeekOfYear(d, 0); },
@@ -907,7 +1037,7 @@
         W: function (d) { return getWeekOfYear(d, 1); },
         x: function (d) { return d.toLocaleDateString(); },
         X: function (d) { return d.toLocaleTimeString(); },
-        y: function (d) { return d.getFullYear().toString().slice(2, 4); },
+        y: function (d) { return (d.getFullYear() % 100 + 100) % 100; },
         Y: function (d) { return d.getFullYear(); },
         z: getTimezoneOffset,
         Z: function (d, opts) { return d.getTimeZoneName() || getTimezoneOffset(d, opts); },
@@ -916,18 +1046,18 @@
         '%': function () { return '%'; }
     };
     formatCodes.h = formatCodes.b;
-    function strftime(d, formatStr) {
+    function strftime(d, formatStr, memoryLimit) {
         var output = '';
         var remaining = formatStr;
         var match;
         while ((match = rFormat.exec(remaining))) {
             output += remaining.slice(0, match.index);
             remaining = remaining.slice(match.index + match[0].length);
-            output += format(d, match);
+            output += format(d, match, memoryLimit);
         }
         return output + remaining;
     }
-    function format(d, match) {
+    function format(d, match, memoryLimit) {
         var e_1, _a;
         var _b = __read(match, 5), input = _b[0], _c = _b[1], flagStr = _c === void 0 ? '' : _c, width = _b[2], modifier = _b[3], conversion = _b[4];
         var convert = formatCodes[conversion];
@@ -947,9 +1077,9 @@
             }
             finally { if (e_1) throw e_1.error; }
         }
-        var ret = String(convert(d, { flags: flags, width: width, modifier: modifier }));
+        var ret = String(convert(d, { flags: flags, width: width, modifier: modifier, memoryLimit: memoryLimit }));
         var padChar = padSpaceChars.has(conversion) ? ' ' : '0';
-        var padWidth = width || padWidths[conversion] || 0;
+        var padWidth = Number(width) || padWidths[conversion] || 0;
         if (flags['^'])
             ret = ret.toUpperCase();
         else if (flags['#'])
@@ -960,6 +1090,9 @@
             padChar = '0';
         if (flags['-'])
             padWidth = 0;
+        memoryLimit === null || memoryLimit === void 0 ? void 0 : memoryLimit.use(Number(padWidth) - ret.length);
+        if (padChar === '0' && ret[0] === '-')
+            return '-' + padStart(ret.slice(1), padWidth - 1, padChar);
         return padStart(ret, padWidth, padChar);
     }
 
@@ -1008,6 +1141,15 @@
         LiquidDate.prototype.getTime = function () {
             return this.displayDate.getTime();
         };
+        /**
+         * The underlying UTC timestamp in milliseconds, unaffected by the display
+         * timezone. Use this (not `getTime()`) for timezone-invariant values like
+         * `%s`: `getTime()` reads `displayDate`, which is deliberately shifted by
+         * the display timezone offset so wall-clock getters can delegate to Date.
+         */
+        LiquidDate.prototype.dateValue = function () {
+            return this.date.getTime();
+        };
         LiquidDate.prototype.getMilliseconds = function () {
             return this.displayDate.getMilliseconds();
         };
@@ -1120,13 +1262,15 @@
             this.limit = limit;
         }
         Limiter.prototype.use = function (count) {
-            count = toNumber(count);
-            assert(this.base + count <= this.limit, this.message);
-            this.base += count;
+            if (+count > 0) {
+                assert(this.base + +count <= this.limit, this.message);
+                this.base += +count;
+            }
         };
         Limiter.prototype.check = function (count) {
-            count = toNumber(count);
-            assert(count <= this.limit, this.message);
+            if (+count > 0) {
+                assert(+count <= this.limit, this.message);
+            }
         };
         return Limiter;
     }());
@@ -1168,19 +1312,13 @@
             var trimTagLeft = options.trimTagLeft, trimTagRight = options.trimTagRight, tagDelimiterLeft = options.tagDelimiterLeft, tagDelimiterRight = options.tagDelimiterRight;
             var _a = __read([begin + tagDelimiterLeft.length, end - tagDelimiterRight.length], 2), valueBegin = _a[0], valueEnd = _a[1];
             _this = _super.call(this, exports.TokenKind.Tag, [valueBegin, valueEnd], input, begin, end, trimTagLeft, trimTagRight, file) || this;
-            _this.tokenizer = new Tokenizer(input, options.operators, file, _this.contentRange);
+            _this.tokenizer = new Tokenizer(input, options.operators, file, _this.contentRange, options.groupedExpressions);
             _this.name = _this.tokenizer.readTagName();
             _this.tokenizer.assert(_this.name, "illegal tag syntax, tag name expected");
             _this.tokenizer.skipBlank();
+            _this.args = _this.tokenizer.input.slice(_this.tokenizer.p, _this.contentRange[1]);
             return _this;
         }
-        Object.defineProperty(TagToken.prototype, "args", {
-            get: function () {
-                return this.tokenizer.input.slice(this.tokenizer.p, this.contentRange[1]);
-            },
-            enumerable: false,
-            configurable: true
-        });
         return TagToken;
     }(DelimitedToken));
 
@@ -1291,8 +1429,7 @@
             return _this;
         }
         OperatorToken.prototype.getPrecedence = function () {
-            var key = this.getText();
-            return key in operatorPrecedences ? operatorPrecedences[key] : 1;
+            return this.operator in operatorPrecedences ? operatorPrecedences[this.operator] : 1;
         };
         return OperatorToken;
     }(Token));
@@ -1423,7 +1560,7 @@
         __extends(LiquidTagToken, _super);
         function LiquidTagToken(input, begin, end, options, file) {
             var _this = _super.call(this, exports.TokenKind.Tag, [begin, end], input, begin, end, false, false, file) || this;
-            _this.tokenizer = new Tokenizer(input, options.operators, file, _this.contentRange);
+            _this.tokenizer = new Tokenizer(input, options.operators, file, _this.contentRange, options.groupedExpressions);
             _this.name = _this.tokenizer.readTagName();
             _this.tokenizer.assert(_this.name, 'illegal liquid tag syntax');
             _this.tokenizer.skipBlank();
@@ -1468,45 +1605,6 @@
             polyfill;
     }
 
-    var SimpleEmitter = /** @class */ (function () {
-        function SimpleEmitter() {
-            this.buffer = '';
-        }
-        SimpleEmitter.prototype.write = function (html) {
-            this.buffer += stringify(html);
-        };
-        return SimpleEmitter;
-    }());
-
-    var StreamedEmitter = /** @class */ (function () {
-        function StreamedEmitter() {
-            this.buffer = '';
-            this.stream = null;
-            throw new Error('streaming not supported in browser');
-        }
-        return StreamedEmitter;
-    }());
-
-    var KeepingTypeEmitter = /** @class */ (function () {
-        function KeepingTypeEmitter() {
-            this.buffer = '';
-        }
-        KeepingTypeEmitter.prototype.write = function (html) {
-            html = toValue(html);
-            // This will only preserve the type if the value is isolated.
-            // I.E:
-            // {{ my-port }} -> 42
-            // {{ my-host }}:{{ my-port }} -> 'host:42'
-            if (typeof html !== 'string' && this.buffer === '') {
-                this.buffer = html;
-            }
-            else {
-                this.buffer = stringify(this.buffer) + stringify(html);
-            }
-        };
-        return KeepingTypeEmitter;
-    }());
-
     var Render = /** @class */ (function () {
         function Render() {
         }
@@ -1526,6 +1624,7 @@
                         if (!emitter) {
                             emitter = ctx.opts.keepOutputType ? new KeepingTypeEmitter() : new SimpleEmitter();
                         }
+                        ctx.renderLimit.check(getPerformance().now());
                         errors = [];
                         _b.label = 1;
                     case 1:
@@ -1582,6 +1681,71 @@
         return Render;
     }());
 
+    function isKeyValuePair(arr) {
+        return isArray(arr);
+    }
+
+    var Filter = /** @class */ (function () {
+        function Filter(token, options, liquid) {
+            this.token = token;
+            this.name = token.name;
+            this.handler = isFunction(options)
+                ? options
+                : (isFunction(options === null || options === void 0 ? void 0 : options.handler) ? options.handler : identify);
+            this.raw = !isFunction(options) && !!(options === null || options === void 0 ? void 0 : options.raw);
+            this.args = token.args;
+            this.liquid = liquid;
+        }
+        Filter.prototype.render = function (value, context) {
+            var argv, _a, _b, arg, _c, _d, _e, _f, _g, e_1_1;
+            var e_1, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        argv = [];
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 8, 9, 10]);
+                        _a = __values(this.args), _b = _a.next();
+                        _j.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        arg = _b.value;
+                        if (!isKeyValuePair(arg)) return [3 /*break*/, 4];
+                        _d = (_c = argv).push;
+                        _e = [arg[0]];
+                        return [4 /*yield*/, evalToken(arg[1], context)];
+                    case 3:
+                        _d.apply(_c, [_e.concat([_j.sent()])]);
+                        return [3 /*break*/, 6];
+                    case 4:
+                        _g = (_f = argv).push;
+                        return [4 /*yield*/, evalToken(arg, context)];
+                    case 5:
+                        _g.apply(_f, [_j.sent()]);
+                        _j.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _j.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_h = _a.return)) _h.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [4 /*yield*/, this.handler.apply({ context: context, token: this.token, liquid: this.liquid }, __spreadArray([value], __read(argv), false))];
+                    case 11: return [2 /*return*/, _j.sent()];
+                }
+            });
+        };
+        return Filter;
+    }());
+
     var Expression = /** @class */ (function () {
         function Expression(tokens) {
             this.postfix = __spreadArray([], __read(toPostfix(tokens)), false);
@@ -1648,6 +1812,11 @@
         };
         return Expression;
     }());
+    /**
+     * Evaluate `token`, preserving Drops.
+     * Operators use this so `Comparable` drops (`empty`, `nil`, `blank`) and custom drops
+     * are compared as drops rather than as their `valueOf()` result.
+     */
     function evalToken(token, ctx, lenient) {
         if (lenient === void 0) { lenient = false; }
         return __generator(this, function (_a) {
@@ -1664,13 +1833,90 @@
                     if (!isRangeToken(token)) return [3 /*break*/, 4];
                     return [4 /*yield*/, evalRangeToken(token, ctx)];
                 case 3: return [2 /*return*/, _a.sent()];
-                case 4: return [2 /*return*/];
+                case 4:
+                    if (!isFilteredValueToken(token)) return [3 /*break*/, 6];
+                    return [4 /*yield*/, evalFilteredValueToken(token, ctx, lenient)];
+                case 5: return [2 /*return*/, _a.sent()];
+                case 6: return [2 /*return*/];
+            }
+        });
+    }
+    function evalFilteredValueToken(token, ctx, lenient) {
+        var val, _loop_1, _a, _b, filterToken, e_2_1;
+        var e_2, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    assert(ctx.liquid, 'FilteredValueToken evaluation requires liquid instance in context');
+                    lenient = lenient || (ctx.opts.lenientIf && token.filters.length > 0 && token.filters[0].name === 'default');
+                    return [4 /*yield*/, token.initial.evaluate(ctx, lenient)];
+                case 1:
+                    val = _d.sent();
+                    _loop_1 = function (filterToken) {
+                        var filterImpl, filter;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0:
+                                    filterImpl = ctx.liquid.filters[filterToken.name];
+                                    assert(filterImpl || !ctx.liquid.options.strictFilters, function () { return "undefined filter: ".concat(filterToken.name); });
+                                    filter = new Filter(filterToken, filterImpl, ctx.liquid);
+                                    return [4 /*yield*/, filter.render(val, ctx)];
+                                case 1:
+                                    val = _e.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _d.label = 2;
+                case 2:
+                    _d.trys.push([2, 7, 8, 9]);
+                    _a = __values(token.filters), _b = _a.next();
+                    _d.label = 3;
+                case 3:
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    filterToken = _b.value;
+                    return [5 /*yield**/, _loop_1(filterToken)];
+                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*/, val];
+            }
+        });
+    }
+    /**
+     * Evaluate `token` to the value filters and tags consume.
+     * Awaits a promise returned by `Drop.valueOf()`.
+     */
+    function evalTokenValue(token, ctx, lenient) {
+        var _a;
+        if (lenient === void 0) { lenient = false; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = toValue;
+                    return [4 /*yield*/, evalToken(token, ctx, lenient)];
+                case 1: return [4 /*yield*/, _a.apply(void 0, [_b.sent()])];
+                case 2: return [2 /*return*/, _b.sent()];
             }
         });
     }
     function evalPropertyAccessToken(token, ctx, lenient) {
-        var props, _a, _b, prop, _c, _d, e_2_1, variable, e_3;
-        var e_2, _e;
+        var props, _a, _b, prop, _c, _d, e_3_1, variable, e_4;
+        var e_3, _e;
         return __generator(this, function (_f) {
             switch (_f.label) {
                 case 0:
@@ -1684,7 +1930,7 @@
                     if (!!_b.done) return [3 /*break*/, 5];
                     prop = _b.value;
                     _d = (_c = props).push;
-                    return [4 /*yield*/, evalToken(prop, ctx, false)];
+                    return [4 /*yield*/, evalTokenValue(prop, ctx, false)];
                 case 3:
                     _d.apply(_c, [(_f.sent())]);
                     _f.label = 4;
@@ -1693,14 +1939,14 @@
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_2_1 = _f.sent();
-                    e_2 = { error: e_2_1 };
+                    e_3_1 = _f.sent();
+                    e_3 = { error: e_3_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
                         if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
                     }
-                    finally { if (e_2) throw e_2.error; }
+                    finally { if (e_3) throw e_3.error; }
                     return [7 /*endfinally*/];
                 case 8:
                     _f.trys.push([8, 14, , 15]);
@@ -1714,10 +1960,10 @@
                 case 12: return [2 /*return*/, _f.sent()];
                 case 13: return [3 /*break*/, 15];
                 case 14:
-                    e_3 = _f.sent();
-                    if (lenient && e_3.name === 'InternalUndefinedVariableError')
+                    e_4 = _f.sent();
+                    if (lenient && e_4.name === 'InternalUndefinedVariableError')
                         return [2 /*return*/, null];
-                    throw (new UndefinedVariableError(e_3, token));
+                    throw (new UndefinedVariableError(e_4, token));
                 case 15: return [2 /*return*/];
             }
         });
@@ -1729,20 +1975,20 @@
         var low, high;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, evalToken(token.lhs, ctx)];
+                case 0: return [4 /*yield*/, evalTokenValue(token.lhs, ctx)];
                 case 1:
-                    low = _a.sent();
-                    return [4 /*yield*/, evalToken(token.rhs, ctx)];
+                    low = (_a.sent());
+                    return [4 /*yield*/, evalTokenValue(token.rhs, ctx)];
                 case 2:
-                    high = _a.sent();
+                    high = (_a.sent());
                     ctx.memoryLimit.use(high - low + 1);
                     return [2 /*return*/, range(+low, +high + 1)];
             }
         });
     }
     function toPostfix(tokens) {
-        var ops, tokens_1, tokens_1_1, token, e_4_1;
-        var e_4, _a;
+        var ops, tokens_1, tokens_1_1, token, e_5_1;
+        var e_5, _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -1775,14 +2021,14 @@
                     return [3 /*break*/, 2];
                 case 9: return [3 /*break*/, 12];
                 case 10:
-                    e_4_1 = _b.sent();
-                    e_4 = { error: e_4_1 };
+                    e_5_1 = _b.sent();
+                    e_5 = { error: e_5_1 };
                     return [3 /*break*/, 12];
                 case 11:
                     try {
                         if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
                     }
-                    finally { if (e_4) throw e_4.error; }
+                    finally { if (e_5) throw e_5.error; }
                     return [7 /*endfinally*/];
                 case 12:
                     if (!ops.length) return [3 /*break*/, 14];
@@ -1809,67 +2055,245 @@
     }
 
     var defaultOperators = {
-        '==': equals,
-        '!=': function (l, r) { return !equals(l, r); },
+        '==': function (l, r) { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, equals(l, r)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); },
+        '!=': function (l, r) { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, equals(l, r)];
+                case 1: return [2 /*return*/, !(_a.sent())];
+            }
+        }); },
         '>': function (l, r) {
-            if (isComparable(l))
-                return l.gt(r);
-            if (isComparable(r))
-                return r.lt(l);
-            return toValue(l) > toValue(r);
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!isComparable(l)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, l.gt(r)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2:
+                        if (!isComparable(r)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, r.lt(l)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4: return [4 /*yield*/, toValue(l)];
+                    case 5:
+                        _a = (_b.sent());
+                        return [4 /*yield*/, toValue(r)];
+                    case 6: return [2 /*return*/, _a > (_b.sent())];
+                }
+            });
         },
         '<': function (l, r) {
-            if (isComparable(l))
-                return l.lt(r);
-            if (isComparable(r))
-                return r.gt(l);
-            return toValue(l) < toValue(r);
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!isComparable(l)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, l.lt(r)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2:
+                        if (!isComparable(r)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, r.gt(l)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4: return [4 /*yield*/, toValue(l)];
+                    case 5:
+                        _a = (_b.sent());
+                        return [4 /*yield*/, toValue(r)];
+                    case 6: return [2 /*return*/, _a < (_b.sent())];
+                }
+            });
         },
         '>=': function (l, r) {
-            if (isComparable(l))
-                return l.geq(r);
-            if (isComparable(r))
-                return r.leq(l);
-            return toValue(l) >= toValue(r);
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!isComparable(l)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, l.geq(r)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2:
+                        if (!isComparable(r)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, r.leq(l)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4: return [4 /*yield*/, toValue(l)];
+                    case 5:
+                        _a = (_b.sent());
+                        return [4 /*yield*/, toValue(r)];
+                    case 6: return [2 /*return*/, _a >= (_b.sent())];
+                }
+            });
         },
         '<=': function (l, r) {
-            if (isComparable(l))
-                return l.leq(r);
-            if (isComparable(r))
-                return r.geq(l);
-            return toValue(l) <= toValue(r);
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!isComparable(l)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, l.leq(r)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2:
+                        if (!isComparable(r)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, r.geq(l)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4: return [4 /*yield*/, toValue(l)];
+                    case 5:
+                        _a = (_b.sent());
+                        return [4 /*yield*/, toValue(r)];
+                    case 6: return [2 /*return*/, _a <= (_b.sent())];
+                }
+            });
         },
         'contains': function (l, r) {
-            l = toValue(l);
-            if (isArray(l))
-                return l.some(function (i) { return equals(i, r); });
-            if (isFunction(l === null || l === void 0 ? void 0 : l.indexOf))
-                return l.indexOf(toValue(r)) > -1;
-            return false;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, toValue(l)];
+                    case 1:
+                        l = _c.sent();
+                        if (!isArray(l)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, arrayIncludes(l, r)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                    case 3:
+                        if (!isFunction(l === null || l === void 0 ? void 0 : l.indexOf)) return [3 /*break*/, 5];
+                        _b = (_a = l).indexOf;
+                        return [4 /*yield*/, toValue(r)];
+                    case 4: return [2 /*return*/, _b.apply(_a, [_c.sent()]) > -1];
+                    case 5: return [2 /*return*/, false];
+                }
+            });
         },
-        'not': function (v, ctx) { return isFalsy(toValue(v), ctx); },
-        'and': function (l, r, ctx) { return isTruthy(toValue(l), ctx) && isTruthy(toValue(r), ctx); },
-        'or': function (l, r, ctx) { return isTruthy(toValue(l), ctx) || isTruthy(toValue(r), ctx); }
+        'not': function (v, ctx) { var _a; return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = isFalsy;
+                    return [4 /*yield*/, toValue(v)];
+                case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent(), ctx])];
+            }
+        }); },
+        'and': function (l, r, ctx) { var _a, _b, _c; return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _b = isTruthy;
+                    return [4 /*yield*/, toValue(l)];
+                case 1:
+                    _a = _b.apply(void 0, [_d.sent(), ctx]);
+                    if (!_a) return [3 /*break*/, 3];
+                    _c = isTruthy;
+                    return [4 /*yield*/, toValue(r)];
+                case 2:
+                    _a = _c.apply(void 0, [_d.sent(), ctx]);
+                    _d.label = 3;
+                case 3: return [2 /*return*/, _a];
+            }
+        }); },
+        'or': function (l, r, ctx) { var _a, _b, _c; return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _b = isTruthy;
+                    return [4 /*yield*/, toValue(l)];
+                case 1:
+                    _a = _b.apply(void 0, [_d.sent(), ctx]);
+                    if (_a) return [3 /*break*/, 3];
+                    _c = isTruthy;
+                    return [4 /*yield*/, toValue(r)];
+                case 2:
+                    _a = _c.apply(void 0, [_d.sent(), ctx]);
+                    _d.label = 3;
+                case 3: return [2 /*return*/, _a];
+            }
+        }); }
     };
     function equals(lhs, rhs) {
-        if (isComparable(lhs))
-            return lhs.equals(rhs);
-        if (isComparable(rhs))
-            return rhs.equals(lhs);
-        lhs = toValue(lhs);
-        rhs = toValue(rhs);
-        if (isArray(lhs)) {
-            return isArray(rhs) && arrayEquals(lhs, rhs);
-        }
-        return lhs === rhs;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!isComparable(lhs)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, lhs.equals(rhs)];
+                case 1: return [2 /*return*/, _b.sent()];
+                case 2:
+                    if (!isComparable(rhs)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, rhs.equals(lhs)];
+                case 3: return [2 /*return*/, _b.sent()];
+                case 4: return [4 /*yield*/, toValue(lhs)];
+                case 5:
+                    lhs = _b.sent();
+                    return [4 /*yield*/, toValue(rhs)];
+                case 6:
+                    rhs = _b.sent();
+                    if (!isArray(lhs)) return [3 /*break*/, 9];
+                    _a = isArray(rhs);
+                    if (!_a) return [3 /*break*/, 8];
+                    return [4 /*yield*/, arrayEquals(lhs, rhs)];
+                case 7:
+                    _a = (_b.sent());
+                    _b.label = 8;
+                case 8: return [2 /*return*/, _a];
+                case 9: return [2 /*return*/, lhs === rhs];
+            }
+        });
     }
     function arrayEquals(lhs, rhs) {
-        if (lhs.length !== rhs.length)
-            return false;
-        return !lhs.some(function (value, i) { return !equals(value, rhs[i]); });
+        var i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (lhs.length !== rhs.length)
+                        return [2 /*return*/, false];
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < lhs.length)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, equals(lhs[i], rhs[i])];
+                case 2:
+                    if (!(_a.sent()))
+                        return [2 /*return*/, false];
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, true];
+            }
+        });
     }
     function arrayIncludes(arr, item) {
-        return arr.some(function (value) { return equals(value, item); });
+        var arr_1, arr_1_1, value, e_1_1;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, 6, 7]);
+                    arr_1 = __values(arr), arr_1_1 = arr_1.next();
+                    _b.label = 1;
+                case 1:
+                    if (!!arr_1_1.done) return [3 /*break*/, 4];
+                    value = arr_1_1.value;
+                    return [4 /*yield*/, equals(value, item)];
+                case 2:
+                    if (_b.sent())
+                        return [2 /*return*/, true];
+                    _b.label = 3;
+                case 3:
+                    arr_1_1 = arr_1.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/, false];
+            }
+        });
     }
 
     var Node = /** @class */ (function () {
@@ -2012,6 +2436,20 @@
         sep: sep
     });
 
+    function chargeJsonReplacerValue(memoryLimit, val) {
+        if (typeof val === 'string') {
+            memoryLimit.use(val.length);
+        }
+        else if (val === null || typeof val === 'number' || typeof val === 'boolean') {
+            memoryLimit.use(JSON.stringify(val).length);
+        }
+        else if (Array.isArray(val)) {
+            memoryLimit.use(val.length + 1);
+        }
+        else if (typeof val === 'object') {
+            memoryLimit.use(2);
+        }
+    }
     function defaultFilter(value, defaultValue) {
         var args = [];
         for (var _i = 2; _i < arguments.length; _i++) {
@@ -2026,20 +2464,30 @@
     }
     function json(value, space) {
         if (space === void 0) { space = 0; }
-        return JSON.stringify(value, null, space);
+        var memoryLimit = this.context.memoryLimit;
+        return JSON.stringify(value, function (_key, val) {
+            chargeJsonReplacerValue(memoryLimit, val);
+            return val;
+        }, space);
     }
     function inspect(value, space) {
         if (space === void 0) { space = 0; }
+        var memoryLimit = this.context.memoryLimit;
         var ancestors = [];
         return JSON.stringify(value, function (_key, value) {
-            if (typeof value !== 'object' || value === null)
+            if (typeof value !== 'object' || value === null) {
+                chargeJsonReplacerValue(memoryLimit, value);
                 return value;
+            }
             // `this` is the object that value is contained in, i.e., its direct parent.
             while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this)
                 ancestors.pop();
-            if (ancestors.includes(value))
+            if (ancestors.includes(value)) {
+                memoryLimit.use('[Circular]'.length);
                 return '[Circular]';
+            }
             ancestors.push(value);
+            chargeJsonReplacerValue(memoryLimit, value);
             return value;
         }, space);
     }
@@ -2094,10 +2542,44 @@
         this.context.memoryLimit.use(str.length);
         return str.replace(/\r?\n/gm, '<br />\n');
     }
+    // Raw-text blocks (HTML5) plus '<...>' as the catch-all kind; a regex
+    // equivalent is O(n^2) in V8 on unclosed openers.
     function strip_html(v) {
+        var e_1, _a;
         var str = stringify(v);
         this.context.memoryLimit.use(str.length);
-        return str.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<.*?>|<!--[\s\S]*?-->/g, '');
+        var blocks = new Map([['<script', '</script>'], ['<style', '</style>'], ['<!--', '-->'], ['<', '>']]);
+        var out = '';
+        var i = 0;
+        while (i < str.length) {
+            var lt = str.indexOf('<', i);
+            if (lt < 0)
+                return out + str.slice(i);
+            out += str.slice(i, lt);
+            try {
+                for (var blocks_1 = (e_1 = void 0, __values(blocks)), blocks_1_1 = blocks_1.next(); !blocks_1_1.done; blocks_1_1 = blocks_1.next()) {
+                    var _b = __read(blocks_1_1.value, 2), opener_1 = _b[0], closer = _b[1];
+                    if (!str.startsWith(opener_1, lt))
+                        continue;
+                    var e = str.indexOf(closer, lt + opener_1.length);
+                    if (e >= 0) {
+                        i = e + closer.length;
+                        break;
+                    }
+                    blocks.delete(opener_1);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (i <= lt)
+                return out + str.slice(lt);
+        }
+        return out;
     }
 
     var htmlFilters = /*#__PURE__*/Object.freeze({
@@ -2204,6 +2686,7 @@
         globals: {},
         keepOutputType: false,
         operators: defaultOperators,
+        groupedExpressions: false,
         memoryLimit: Infinity,
         parseLimit: Infinity,
         renderLimit: Infinity
@@ -2300,8 +2783,9 @@
     }
 
     var Tokenizer = /** @class */ (function () {
-        function Tokenizer(input, operators, file, range) {
+        function Tokenizer(input, operators, file, range, groupedExpressions) {
             if (operators === void 0) { operators = defaultOptions.operators; }
+            if (groupedExpressions === void 0) { groupedExpressions = false; }
             this.input = input;
             this.file = file;
             this.rawBeginAt = -1;
@@ -2309,6 +2793,7 @@
             this.N = range ? range[1] : input.length;
             this.opTrie = createTrie(operators);
             this.literalTrie = createTrie(literalValues);
+            this.groupedExpressions = groupedExpressions;
         }
         Tokenizer.prototype.readExpression = function () {
             return new Expression(this.readExpressionTokens());
@@ -2380,6 +2865,8 @@
             this.skipBlank();
             if (this.end())
                 return null;
+            if (this.peek() === ')' || this.peek() === ',')
+                return null;
             this.assert(this.read() === '|', "expected \"|\" before filter");
             var name = this.readIdentifier();
             if (!name.size()) {
@@ -2394,10 +2881,10 @@
                     var arg = this.readFilterArg();
                     arg && args.push(arg);
                     this.skipBlank();
-                    this.assert(this.end() || this.peek() === ',' || this.peek() === '|', function () { return "unexpected character ".concat(_this.snapshot()); });
+                    this.assert(this.end() || this.peek() === ',' || this.peek() === '|' || this.peek() === ')', function () { return "unexpected character ".concat(_this.snapshot()); });
                 } while (this.peek() === ',');
             }
-            else if (this.peek() === '|' || this.end()) ;
+            else if (this.peek() === '|' || this.peek() === ')' || this.peek() === ',' || this.end()) ;
             else {
                 throw this.error('expected ":" after filter name');
             }
@@ -2611,7 +3098,10 @@
         Tokenizer.prototype.readValue = function () {
             this.skipBlank();
             var begin = this.p;
-            var variable = this.readLiteral() || this.readQuoted() || this.readRange() || this.readNumber();
+            var variable = this.readLiteral() || this.readQuoted() || this.readNumber();
+            if (!variable && this.peek() === '(') {
+                variable = this.readGroupOrRange();
+            }
             var props = this.readProperties(!variable);
             if (!props.length)
                 return variable;
@@ -2691,17 +3181,31 @@
             this.p = end;
             return literal;
         };
-        Tokenizer.prototype.readRange = function () {
+        Tokenizer.prototype.readGroupOrRange = function () {
+            var _this = this;
             this.skipBlank();
             var begin = this.p;
             if (this.peek() !== '(')
                 return;
             ++this.p;
             var lhs = this.readValueOrThrow();
-            this.p += 2;
-            var rhs = this.readValueOrThrow();
-            ++this.p;
-            return new RangeToken(this.input, begin, this.p, lhs, rhs, this.file);
+            this.skipBlank();
+            if (this.peek() === '.' && this.peek(1) === '.') {
+                this.p += 2;
+                var rhs = this.readValueOrThrow();
+                this.skipBlank();
+                this.assert(this.read() === ')', 'invalid range syntax');
+                return new RangeToken(this.input, begin, this.p, lhs, rhs, this.file);
+            }
+            if (this.groupedExpressions) {
+                var initial = new Expression(__spreadArray([lhs], __read(this.readExpressionTokens()), false));
+                this.assert(initial.valid(), function () { return "invalid value expression: ".concat(_this.snapshot()); });
+                var filters = this.readFilters();
+                this.skipBlank();
+                this.assert(this.read() === ')', 'unbalanced parentheses');
+                return new FilteredValueToken(initial, filters, this.input, begin, this.p, this.file);
+            }
+            throw this.error('invalid range syntax');
         };
         Tokenizer.prototype.readValueOrThrow = function () {
             var _this = this;
@@ -2733,7 +3237,7 @@
                 switch (_a.label) {
                     case 0:
                         outputDelimiterLeft = options.outputDelimiterLeft;
-                        htmlStopStrings = [',', ' ', outputDelimiterLeft];
+                        htmlStopStrings = [',', ' ', '\r', '\n', '\t', outputDelimiterLeft];
                         htmlStopStringSet = new Set(htmlStopStrings);
                         _a.label = 1;
                     case 1:
@@ -2935,71 +3439,6 @@
         }(Tag));
     }
 
-    function isKeyValuePair(arr) {
-        return isArray(arr);
-    }
-
-    var Filter = /** @class */ (function () {
-        function Filter(token, options, liquid) {
-            this.token = token;
-            this.name = token.name;
-            this.handler = isFunction(options)
-                ? options
-                : (isFunction(options === null || options === void 0 ? void 0 : options.handler) ? options.handler : identify);
-            this.raw = !isFunction(options) && !!(options === null || options === void 0 ? void 0 : options.raw);
-            this.args = token.args;
-            this.liquid = liquid;
-        }
-        Filter.prototype.render = function (value, context) {
-            var argv, _a, _b, arg, _c, _d, _e, _f, _g, e_1_1;
-            var e_1, _h;
-            return __generator(this, function (_j) {
-                switch (_j.label) {
-                    case 0:
-                        argv = [];
-                        _j.label = 1;
-                    case 1:
-                        _j.trys.push([1, 8, 9, 10]);
-                        _a = __values(this.args), _b = _a.next();
-                        _j.label = 2;
-                    case 2:
-                        if (!!_b.done) return [3 /*break*/, 7];
-                        arg = _b.value;
-                        if (!isKeyValuePair(arg)) return [3 /*break*/, 4];
-                        _d = (_c = argv).push;
-                        _e = [arg[0]];
-                        return [4 /*yield*/, evalToken(arg[1], context)];
-                    case 3:
-                        _d.apply(_c, [_e.concat([_j.sent()])]);
-                        return [3 /*break*/, 6];
-                    case 4:
-                        _g = (_f = argv).push;
-                        return [4 /*yield*/, evalToken(arg, context)];
-                    case 5:
-                        _g.apply(_f, [_j.sent()]);
-                        _j.label = 6;
-                    case 6:
-                        _b = _a.next();
-                        return [3 /*break*/, 2];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        e_1_1 = _j.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        try {
-                            if (_b && !_b.done && (_h = _a.return)) _h.call(_a);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 10: return [4 /*yield*/, this.handler.apply({ context: context, token: this.token, liquid: this.liquid }, __spreadArray([value], __read(argv), false))];
-                    case 11: return [2 /*return*/, _j.sent()];
-                }
-            });
-        };
-        return Filter;
-    }());
-
     var Value = /** @class */ (function () {
         /**
          * @param str the value to be valuated, eg.: "foobar" | truncate: 3
@@ -3008,7 +3447,7 @@
             var _this = this;
             this.filters = [];
             var token = typeof input === 'string'
-                ? new Tokenizer(input, liquid.options.operators).readFilteredValue()
+                ? new Tokenizer(input, liquid.options.operators, undefined, undefined, liquid.options.groupedExpressions).readFilteredValue()
                 : input;
             this.initial = token.initial;
             this.filters = token.filters.map(function (token) { return new Filter(token, _this.getFilter(liquid, token.name), liquid); });
@@ -3067,7 +3506,7 @@
             var _this = this;
             var _a;
             _this = _super.call(this, token) || this;
-            var tokenizer = new Tokenizer(token.input, liquid.options.operators, token.file, token.contentRange);
+            var tokenizer = new Tokenizer(token.input, liquid.options.operators, token.file, token.contentRange, liquid.options.groupedExpressions);
             _this.value = new Value(tokenizer.readFilteredValue(), liquid);
             var filters = _this.value.filters;
             var outputEscape = liquid.options.outputEscape;
@@ -3078,12 +3517,15 @@
             return _this;
         }
         Output.prototype.render = function (ctx, emitter) {
-            var val;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.value.value(ctx, false)];
-                    case 1:
-                        val = _a.sent();
+            var val, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = toValue;
+                        return [4 /*yield*/, this.value.value(ctx, false)];
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [_b.sent()])];
+                    case 2:
+                        val = _b.sent();
                         emitter.write(val);
                         return [2 /*return*/];
                 }
@@ -3688,60 +4130,159 @@
                     return [5 /*yield**/, __values(extractValueTokenVariables(token.rhs))];
                 case 2:
                     _a.sent();
-                    return [3 /*break*/, 5];
+                    return [3 /*break*/, 7];
                 case 3:
-                    if (!isPropertyAccessToken(token)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, extractPropertyAccessVariable(token)];
+                    if (!isFilteredValueToken(token)) return [3 /*break*/, 5];
+                    return [5 /*yield**/, __values(extractGroupedExpressionTokenVariables(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);
+                    return [3 /*break*/, 7];
+                case 5:
+                    if (!isPropertyAccessToken(token)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, extractPropertyAccessVariable(token)];
+                case 6:
+                    _a.sent();
+                    _a.label = 7;
+                case 7: return [2 /*return*/];
             }
-            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.
+    function extractGroupedExpressionTokenVariables(token) {
+        var _a, _b, t, e_16_1, _c, _d, filter, _e, _f, arg, e_17_1, e_18_1;
+        var e_16, _g, e_18, _h, e_17, _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    if (!isFilteredValueToken(token))
+                        return [2 /*return*/];
+                    _k.label = 1;
+                case 1:
+                    _k.trys.push([1, 6, 7, 8]);
+                    _a = __values(token.initial.postfix), _b = _a.next();
+                    _k.label = 2;
+                case 2:
+                    if (!!_b.done) return [3 /*break*/, 5];
+                    t = _b.value;
+                    if (!isValueToken(t)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(t))];
+                case 3:
+                    _k.sent();
+                    _k.label = 4;
+                case 4:
+                    _b = _a.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_16_1 = _k.sent();
+                    e_16 = { error: e_16_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                    }
+                    finally { if (e_16) throw e_16.error; }
+                    return [7 /*endfinally*/];
+                case 8:
+                    _k.trys.push([8, 21, 22, 23]);
+                    _c = __values(token.filters), _d = _c.next();
+                    _k.label = 9;
+                case 9:
+                    if (!!_d.done) return [3 /*break*/, 20];
+                    filter = _d.value;
+                    _k.label = 10;
+                case 10:
+                    _k.trys.push([10, 17, 18, 19]);
+                    _e = (e_17 = void 0, __values(filter.args)), _f = _e.next();
+                    _k.label = 11;
+                case 11:
+                    if (!!_f.done) return [3 /*break*/, 16];
+                    arg = _f.value;
+                    if (!(isKeyValuePair(arg) && arg[1])) return [3 /*break*/, 13];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(arg[1]))];
+                case 12:
+                    _k.sent();
+                    return [3 /*break*/, 15];
+                case 13:
+                    if (!isValueToken(arg)) return [3 /*break*/, 15];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(arg))];
+                case 14:
+                    _k.sent();
+                    _k.label = 15;
+                case 15:
+                    _f = _e.next();
+                    return [3 /*break*/, 11];
+                case 16: return [3 /*break*/, 19];
+                case 17:
+                    e_17_1 = _k.sent();
+                    e_17 = { error: e_17_1 };
+                    return [3 /*break*/, 19];
+                case 18:
+                    try {
+                        if (_f && !_f.done && (_j = _e.return)) _j.call(_e);
+                    }
+                    finally { if (e_17) throw e_17.error; }
+                    return [7 /*endfinally*/];
+                case 19:
+                    _d = _c.next();
+                    return [3 /*break*/, 9];
+                case 20: return [3 /*break*/, 23];
+                case 21:
+                    e_18_1 = _k.sent();
+                    e_18 = { error: e_18_1 };
+                    return [3 /*break*/, 23];
+                case 22:
+                    try {
+                        if (_d && !_d.done && (_h = _c.return)) _h.call(_c);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                    return [7 /*endfinally*/];
+                case 23: return [2 /*return*/];
+            }
+        });
+    }
+    function extractPropertyAccessVariable(token) {
+        var e_19, _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_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_19) throw e_19.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.
@@ -3749,7 +4290,7 @@
      * @param bracketedRoot - If false (the default), don't surround the root segment with square brackets.
      */
     function segmentsString(segments, bracketedRoot) {
-        var e_17, _a;
+        var e_20, _a;
         if (bracketedRoot === void 0) { bracketedRoot = false; }
         var buf = [];
         var root = segments[0];
@@ -3780,66 +4321,77 @@
                 }
             }
         }
-        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_17) throw e_17.error; }
+            finally { if (e_20) throw e_20.error; }
         }
         return buf.join('');
     }
 
-    var LookupType;
     (function (LookupType) {
         LookupType["Partials"] = "partials";
         LookupType["Layouts"] = "layouts";
         LookupType["Root"] = "root";
-    })(LookupType || (LookupType = {}));
+    })(exports.LookupType || (exports.LookupType = {}));
     var Loader = /** @class */ (function () {
         function Loader(options) {
+            var _this = this;
+            var _a, _b, _c, _d;
             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); };
+                var prefixes_1 = ['.' + sep, '..' + sep, './', '../'];
+                this.shouldLoadRelative = function (referencedFile) { return prefixes_1.some(function (prefix) { return referencedFile.startsWith(prefix); }); };
             }
             else {
                 this.shouldLoadRelative = function (_referencedFile) { return false; };
             }
-            this.contains = this.options.fs.contains || (function () { return true; });
+            var fs = options.fs;
+            this.contains = toLiquidAsync(((_a = fs.contains) === null || _a === void 0 ? void 0 : _a.bind(fs)) || (function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, true];
+            }); }); }), ((_b = fs.containsSync) === null || _b === void 0 ? void 0 : _b.bind(fs)) || (function () { return true; }));
+            this.exists = toLiquidAsync(((_c = fs.exists) === null || _c === void 0 ? void 0 : _c.bind(fs)) || (function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, false];
+            }); }); }), (_d = fs.existsSync) === null || _d === void 0 ? void 0 : _d.bind(fs));
         }
         Loader.prototype.lookup = function (file, type, sync, currentFile) {
-            var fs, dirs, _a, _b, filepath, _c, e_1_1;
-            var e_1, _d;
+            var dirs, _a, _b, filepath, allowed, dirs_1, dirs_1_1, dir, e_1_1, e_2_1;
+            var e_2, _c, 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.trys.push([1, 14, 15, 16]);
+                        _a = __values(this.candidates(file, dirs, currentFile)), _b = _a.next();
                         _e.label = 2;
                     case 2:
-                        if (!!_b.done) return [3 /*break*/, 7];
+                        if (!!_b.done) return [3 /*break*/, 13];
                         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)];
+                        allowed = false;
+                        _e.label = 3;
+                    case 3:
+                        _e.trys.push([3, 8, 9, 10]);
+                        dirs_1 = (e_1 = void 0, __values(dirs)), dirs_1_1 = dirs_1.next();
+                        _e.label = 4;
                     case 4:
-                        _c = _e.sent();
-                        _e.label = 5;
+                        if (!!dirs_1_1.done) return [3 /*break*/, 7];
+                        dir = dirs_1_1.value;
+                        return [4 /*yield*/, this.contains(!!sync, dir, filepath)];
                     case 5:
-                        if (_c)
-                            return [2 /*return*/, filepath];
+                        if (_e.sent()) {
+                            allowed = true;
+                            return [3 /*break*/, 7];
+                        }
                         _e.label = 6;
                     case 6:
-                        _b = _a.next();
-                        return [3 /*break*/, 2];
+                        dirs_1_1 = dirs_1.next();
+                        return [3 /*break*/, 4];
                     case 7: return [3 /*break*/, 10];
                     case 8:
                         e_1_1 = _e.sent();
@@ -3847,88 +4399,84 @@
                         return [3 /*break*/, 10];
                     case 9:
                         try {
-                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                            if (dirs_1_1 && !dirs_1_1.done && (_d = dirs_1.return)) _d.call(dirs_1);
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 10: throw this.lookupError(file, dirs);
+                    case 10:
+                        if (!allowed)
+                            return [3 /*break*/, 12];
+                        return [4 /*yield*/, this.exists(!!sync, filepath)];
+                    case 11:
+                        if (_e.sent())
+                            return [2 /*return*/, filepath];
+                        _e.label = 12;
+                    case 12:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 13: return [3 /*break*/, 16];
+                    case 14:
+                        e_2_1 = _e.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 16];
+                    case 15:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 16: 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) {
+        Loader.prototype.candidates = function (file, dirs, currentFile) {
+            var _a, fs, extname, referenced, dirs_2, dirs_2_1, dir, referenced, e_3_1, filepath;
+            var e_3, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         _a = this.options, fs = _a.fs, extname = _a.extname;
-                        if (!(this.shouldLoadRelative(file) && currentFile)) return [3 /*break*/, 8];
+                        if (!(this.shouldLoadRelative(file) && currentFile)) return [3 /*break*/, 2];
                         referenced = fs.resolve(this.dirname(currentFile), file, extname);
-                        _d.label = 1;
+                        return [4 /*yield*/, referenced];
                     case 1:
-                        _d.trys.push([1, 6, 7, 8]);
-                        dirs_1 = __values(dirs), dirs_1_1 = dirs_1.next();
-                        _d.label = 2;
+                        _c.sent();
+                        _c.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]);
+                        _c.trys.push([2, 7, 8, 9]);
                         dirs_2 = __values(dirs), dirs_2_1 = dirs_2.next();
-                        _d.label = 9;
-                    case 9:
-                        if (!!dirs_2_1.done) return [3 /*break*/, 12];
+                        _c.label = 3;
+                    case 3:
+                        if (!!dirs_2_1.done) return [3 /*break*/, 6];
                         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:
+                    case 4:
+                        _c.sent();
+                        _c.label = 5;
+                    case 5:
                         dirs_2_1 = dirs_2.next();
-                        return [3 /*break*/, 9];
-                    case 12: return [3 /*break*/, 15];
-                    case 13:
-                        e_3_1 = _d.sent();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_3_1 = _c.sent();
                         e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 15];
-                    case 14:
+                        return [3 /*break*/, 9];
+                    case 8:
                         try {
-                            if (dirs_2_1 && !dirs_2_1.done && (_c = dirs_2.return)) _c.call(dirs_2);
+                            if (dirs_2_1 && !dirs_2_1.done && (_b = dirs_2.return)) _b.call(dirs_2);
                         }
                         finally { if (e_3) throw e_3.error; }
                         return [7 /*endfinally*/];
-                    case 15:
-                        if (!(fs.fallback !== undefined)) return [3 /*break*/, 17];
+                    case 9:
+                        if (!(fs.fallback !== undefined)) return [3 /*break*/, 11];
                         filepath = fs.fallback(file);
-                        if (!(filepath !== undefined)) return [3 /*break*/, 17];
+                        if (!(filepath !== undefined)) return [3 /*break*/, 11];
                         return [4 /*yield*/, filepath];
-                    case 16:
-                        _d.sent();
-                        _d.label = 17;
-                    case 17: return [2 /*return*/];
+                    case 10:
+                        _c.sent();
+                        _c.label = 11;
+                    case 11: return [2 /*return*/];
                 }
             });
         };
@@ -3948,17 +4496,22 @@
 
     var Parser = /** @class */ (function () {
         function Parser(liquid) {
+            var _this = this;
+            var _a, _b;
             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);
+            this.readFile = toLiquidAsync(((_a = this.fs.readFile) === null || _a === void 0 ? void 0 : _a.bind(this.fs)) || (function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                throw new Error('readFile not implemented');
+            }); }); }), (_b = this.fs.readFileSync) === null || _b === void 0 ? void 0 : _b.bind(this.fs));
         }
         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 tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath, undefined, this.liquid.options.groupedExpressions);
             var tokens = tokenizer.readTopLevelTokens(this.liquid.options);
             return this.parseTokens(tokens);
         };
@@ -4005,7 +4558,7 @@
         };
         Parser.prototype._parseFileCached = function (file, sync, type, currentFile) {
             var cache, key, tpls, task, taskOrTpl, _a, err_1;
-            if (type === void 0) { type = LookupType.Root; }
+            if (type === void 0) { type = exports.LookupType.Root; }
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -4042,22 +4595,16 @@
             });
         };
         Parser.prototype._parseFile = function (file, sync, type, currentFile) {
-            var filepath, _a, _b;
-            if (type === void 0) { type = LookupType.Root; }
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var filepath, _a;
+            if (type === void 0) { type = exports.LookupType.Root; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0: return [4 /*yield*/, this.loader.lookup(file, type, sync, currentFile)];
                     case 1:
-                        filepath = _c.sent();
+                        filepath = _b.sent();
                         _a = this.parse;
-                        if (!sync) return [3 /*break*/, 2];
-                        _b = this.fs.readFileSync(filepath);
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.fs.readFile(filepath)];
-                    case 3:
-                        _b = _c.sent();
-                        _c.label = 4;
-                    case 4: return [2 /*return*/, _a.apply(this, [_b, filepath])];
+                        return [4 /*yield*/, this.readFile(!!sync, filepath)];
+                    case 2: return [2 /*return*/, _a.apply(this, [_b.sent(), filepath])];
                 }
             });
         };
@@ -4078,6 +4625,7 @@
         TokenKind[TokenKind["Quoted"] = 1024] = "Quoted";
         TokenKind[TokenKind["Operator"] = 2048] = "Operator";
         TokenKind[TokenKind["FilteredValue"] = 4096] = "FilteredValue";
+        TokenKind[TokenKind["GroupedExpression"] = 8192] = "GroupedExpression";
         TokenKind[TokenKind["Delimited"] = 12] = "Delimited";
     })(exports.TokenKind || (exports.TokenKind = {}));
 
@@ -4114,9 +4662,12 @@
     function isRangeToken(val) {
         return getKind(val) === exports.TokenKind.Range;
     }
+    function isFilteredValueToken(val) {
+        return getKind(val) === exports.TokenKind.FilteredValue;
+    }
     function isValueToken(val) {
-        // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range
-        return (getKind(val) & 1667) > 0;
+        // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range | TokenKind.FilteredValue
+        return (getKind(val) & 5763) > 0;
     }
     function getKind(val) {
         return val ? val.kind : -1;
@@ -4135,21 +4686,29 @@
         isPropertyAccessToken: isPropertyAccessToken,
         isWordToken: isWordToken,
         isRangeToken: isRangeToken,
+        isFilteredValueToken: isFilteredValueToken,
         isValueToken: isValueToken
     });
 
+    function createScope(from) {
+        var scope = Object.create(null);
+        if (from)
+            Object.assign(scope, from);
+        return scope;
+    }
+
     var Context = /** @class */ (function () {
         function Context(env, opts, renderOptions, _a) {
             if (env === void 0) { env = {}; }
             if (opts === void 0) { opts = defaultOptions; }
             if (renderOptions === void 0) { renderOptions = {}; }
-            var _b = _a === void 0 ? {} : _a, memoryLimit = _b.memoryLimit, renderLimit = _b.renderLimit;
+            var _b = _a === void 0 ? {} : _a, memoryLimit = _b.memoryLimit, renderLimit = _b.renderLimit, liquid = _b.liquid;
             var _c, _d, _e, _f, _g;
             /**
              * insert a Context-level empty scope,
              * for tags like `{% capture %}` `{% assign %}` to operate
              */
-            this.scopes = [{}];
+            this.scopes = [createScope()];
             this.registers = {};
             this.breakCalled = false;
             this.continueCalled = false;
@@ -4161,9 +4720,11 @@
             this.ownPropertyOnly = (_e = renderOptions.ownPropertyOnly) !== null && _e !== void 0 ? _e : opts.ownPropertyOnly;
             this.memoryLimit = memoryLimit !== null && memoryLimit !== void 0 ? memoryLimit : new Limiter('memory alloc', (_f = renderOptions.memoryLimit) !== null && _f !== void 0 ? _f : opts.memoryLimit);
             this.renderLimit = renderLimit !== null && renderLimit !== void 0 ? renderLimit : new Limiter('template render', getPerformance().now() + ((_g = renderOptions.renderLimit) !== null && _g !== void 0 ? _g : opts.renderLimit));
+            this.liquid = liquid;
         }
-        Context.prototype.getRegister = function (key) {
-            return (this.registers[key] = this.registers[key] || {});
+        Context.prototype.getRegister = function (key, defaultValue) {
+            if (defaultValue === void 0) { defaultValue = undefined; }
+            return (this.registers[key] = this.registers[key] || defaultValue);
         };
         Context.prototype.setRegister = function (key, value) {
             return (this.registers[key] = value);
@@ -4226,7 +4787,7 @@
                         _a.label = 1;
                     case 1:
                         if (!(i < paths.length)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, readProperty(scope, paths[i], this.ownPropertyOnly)];
+                        return [4 /*yield*/, this.readProperty(scope, paths[i])];
                     case 2:
                         scope = _a.sent();
                         if (strictVariables && isUndefined(scope)) {
@@ -4254,10 +4815,12 @@
             return new Context(scope, this.opts, {
                 sync: this.sync,
                 globals: this.globals,
-                strictVariables: this.strictVariables
+                strictVariables: this.strictVariables,
+                ownPropertyOnly: this.ownPropertyOnly
             }, {
                 renderLimit: this.renderLimit,
-                memoryLimit: this.memoryLimit
+                memoryLimit: this.memoryLimit,
+                liquid: this.liquid
             });
         };
         Context.prototype.findScope = function (key) {
@@ -4270,42 +4833,42 @@
                 return this.environments;
             return this.globals;
         };
+        Context.prototype.readProperty = function (obj, key) {
+            obj = toLiquid(obj);
+            key = toValue(key);
+            if (isNil(obj))
+                return obj;
+            if (isArray(obj) && isNumber(key))
+                return readArrayElement(obj, key, this.ownPropertyOnly);
+            var value = readJSProperty(obj, key, this.ownPropertyOnly);
+            if (value === undefined && obj instanceof Drop)
+                return obj.liquidMethodMissing(key, this);
+            if (isFunction(value))
+                return value.call(obj);
+            if (key === 'size')
+                return readSize(obj);
+            else if (key === 'first')
+                return readFirst(obj, this.ownPropertyOnly);
+            else if (key === 'last')
+                return readLast(obj, this.ownPropertyOnly);
+            return value;
+        };
         return Context;
     }());
-    function readProperty(obj, key, ownPropertyOnly) {
-        obj = toLiquid(obj);
-        key = toValue(key);
-        if (isNil(obj))
-            return obj;
-        if (isArray(obj) && key < 0)
-            return obj[obj.length + +key];
-        var value = readJSProperty(obj, key, ownPropertyOnly);
-        if (value === undefined && obj instanceof Drop)
-            return obj.liquidMethodMissing(key);
-        if (isFunction(value))
-            return value.call(obj);
-        if (key === 'size')
-            return readSize(obj);
-        else if (key === 'first')
-            return readFirst(obj);
-        else if (key === 'last')
-            return readLast(obj);
-        return value;
-    }
     function readJSProperty(obj, key, ownPropertyOnly) {
         if (ownPropertyOnly && !hasOwnProperty.call(obj, key) && !(obj instanceof Drop))
             return undefined;
         return obj[key];
     }
-    function readFirst(obj) {
+    function readFirst(obj, ownPropertyOnly) {
         if (isArray(obj))
-            return obj[0];
-        return obj['first'];
+            return readArrayElement(obj, 0, ownPropertyOnly);
+        return readJSProperty(obj, 'first', ownPropertyOnly);
     }
-    function readLast(obj) {
+    function readLast(obj, ownPropertyOnly) {
         if (isArray(obj))
-            return obj[obj.length - 1];
-        return obj['last'];
+            return readArrayElement(obj, -1, ownPropertyOnly);
+        return readJSProperty(obj, 'last', ownPropertyOnly);
     }
     function readSize(obj) {
         if (hasOwnProperty.call(obj, 'size') || obj['size'] !== undefined)
@@ -4324,29 +4887,32 @@
         BlockMode[BlockMode["STORE"] = 1] = "STORE";
     })(BlockMode || (BlockMode = {}));
 
-    var abs = argumentsToValue(Math.abs);
-    var at_least = argumentsToValue(Math.max);
-    var at_most = argumentsToValue(Math.min);
-    var ceil = argumentsToValue(Math.ceil);
-    var divided_by = argumentsToValue(function (dividend, divisor, integerArithmetic) {
+    var abs = argumentsToNumber(Math.abs);
+    var at_least = argumentsToNumber(Math.max);
+    var at_most = argumentsToNumber(Math.min);
+    var ceil = argumentsToNumber(Math.ceil);
+    var divided_by = argumentsToNumber(function (dividend, divisor, integerArithmetic) {
         if (integerArithmetic === void 0) { integerArithmetic = false; }
         return integerArithmetic ? Math.floor(dividend / divisor) : dividend / divisor;
     });
-    var floor = argumentsToValue(Math.floor);
-    var minus = argumentsToValue(function (v, arg) { return v - arg; });
-    var modulo = argumentsToValue(function (v, arg) { return v % arg; });
-    var times = argumentsToValue(function (v, arg) { return v * arg; });
+    var floor = argumentsToNumber(Math.floor);
+    var minus = argumentsToNumber(function (v, arg) { return v - arg; });
+    var plus = argumentsToNumber(function (lhs, rhs) { return lhs + rhs; });
+    var modulo = argumentsToNumber(function (v, arg) { return ((v % arg) + arg) % arg; });
+    var times = argumentsToNumber(function (v, arg) { return v * arg; });
+    function shiftDecimal(n, exponent) {
+        var _a = __read(String(n).split('e'), 2), mantissa = _a[0], _b = _a[1], power = _b === void 0 ? '0' : _b;
+        return Number("".concat(mantissa, "e").concat(Number(power) + exponent));
+    }
     function round(v, arg) {
         if (arg === void 0) { arg = 0; }
-        v = toValue(v);
-        arg = toValue(arg);
-        var amp = Math.pow(10, arg);
-        return Math.round(v * amp) / amp;
-    }
-    function plus(v, arg) {
-        v = toValue(v);
-        arg = toValue(arg);
-        return Number(v) + Number(arg);
+        v = toNumber(v);
+        arg = toNumber(arg);
+        var scaled = shiftDecimal(Math.abs(v), arg);
+        if (!(scaled <= Number.MAX_SAFE_INTEGER))
+            return v;
+        var rounded = shiftDecimal(Math.round(scaled), -arg);
+        return v < 0 ? -rounded : rounded;
     }
 
     var mathFilters = /*#__PURE__*/Object.freeze({
@@ -4358,13 +4924,13 @@
         divided_by: divided_by,
         floor: floor,
         minus: minus,
+        plus: plus,
         modulo: modulo,
         times: times,
-        round: round,
-        plus: plus
+        round: round
     });
 
-    var url_decode = function (x) { return decodeURIComponent(stringify(x)).replace(/\+/g, ' '); };
+    var url_decode = function (x) { return decodeURIComponent(stringify(x).replace(/\+/g, ' ')); };
     var url_encode = function (x) { return encodeURIComponent(stringify(x)).replace(/%20/g, '+'); };
     var cgi_escape = function (x) { return encodeURIComponent(stringify(x))
         .replace(/%20/g, '+')
@@ -4424,18 +4990,24 @@
     var join = argumentsToValue(function (v, arg) {
         var array = toArray(v);
         var sep = isNil(arg) ? ' ' : stringify(arg);
-        var complexity = array.length * (1 + sep.length);
-        this.context.memoryLimit.use(complexity);
-        return array.join(sep);
+        var outputSize = sep.length * Math.max(array.length - 1, 0);
+        for (var i = 0; i < array.length; i++)
+            outputSize += String(array[i]).length;
+        this.context.memoryLimit.use(outputSize);
+        return Array.prototype.join.call(array, sep);
+    });
+    var last$1 = argumentsToValue(function (v) {
+        return isArrayLike(v) ? readArrayElement(v, -1, this.context.ownPropertyOnly) : '';
+    });
+    var first = argumentsToValue(function (v) {
+        return isArrayLike(v) ? readArrayElement(v, 0, this.context.ownPropertyOnly) : '';
     });
-    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);
         return __spreadArray([], __read(array), false).reverse();
     });
-    function sort(arr, property) {
+    function sortBy(arr, property, comparator) {
         var values, array, array_1, array_1_1, item, _a, _b, _c, _d, e_1_1;
         var e_1, _e;
         return __generator(this, function (_f) {
@@ -4481,22 +5053,25 @@
                     }
                     finally { if (e_1) throw e_1.error; }
                     return [7 /*endfinally*/];
-                case 10: return [2 /*return*/, values.sort(function (lhs, rhs) {
-                        var lvalue = lhs[1];
-                        var rvalue = rhs[1];
-                        return lvalue < rvalue ? -1 : (lvalue > rvalue ? 1 : 0);
-                    }).map(function (tuple) { return tuple[0]; })];
+                case 10: return [2 /*return*/, values.sort(function (lhs, rhs) { return comparator(lhs[1], rhs[1]); }).map(function (tuple) { return tuple[0]; })];
             }
         });
     }
-    function sort_natural(input, property) {
-        var propertyString = stringify(property);
-        var compare = property === undefined
-            ? caseInsensitiveCompare
-            : function (lhs, rhs) { return caseInsensitiveCompare(lhs[propertyString], rhs[propertyString]); };
-        var array = toArray(input);
-        this.context.memoryLimit.use(array.length);
-        return __spreadArray([], __read(array), false).sort(compare);
+    function sort(arr, property) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(sortBy.call(this, arr, property, orderedCompare))];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }
+    function sort_natural(arr, property) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(sortBy.call(this, arr, property, caseInsensitiveCompare))];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
     }
     var size = function (v) { return (v && v.length) || 0; };
     function map(arr, property) {
@@ -4589,14 +5164,14 @@
     function compact(arr) {
         var array = toArray(arr);
         this.context.memoryLimit.use(array.length);
-        return array.filter(function (x) { return !isNil(toValue(x)); });
+        return Array.prototype.filter.call(array, function (x) { return !isNil(toValue(x)); });
     }
     function concat(v, arg) {
         if (arg === void 0) { arg = []; }
         var lhs = toArray(v);
         var rhs = toArray(arg);
         this.context.memoryLimit.use(lhs.length + rhs.length);
-        return lhs.concat(rhs);
+        return Array.prototype.concat.call(lhs, rhs);
     }
     function push(v, arg) {
         return concat.call(this, v, [arg]);
@@ -4609,7 +5184,9 @@
         return clone;
     }
     function pop(v) {
-        var clone = __spreadArray([], __read(toArray(v)), false);
+        var array = toArray(v);
+        this.context.memoryLimit.use(array.length);
+        var clone = __spreadArray([], __read(array), false);
         clone.pop();
         return clone;
     }
@@ -4627,61 +5204,82 @@
             return [];
         if (!isArray(v))
             v = stringify(v);
-        begin = begin < 0 ? v.length + begin : begin;
+        begin = begin < 0 ? (isArray(v) ? v.length : codePointLength(v)) + begin : begin;
+        if (begin < 0 || length < 0)
+            return isArray(v) ? [] : '';
         this.context.memoryLimit.use(length);
-        return v.slice(begin, begin + length);
+        if (isArray(v))
+            return Array.prototype.slice.call(v, begin, begin + length);
+        var start = advanceCodePoints(v, 0, begin);
+        return v.slice(start, advanceCodePoints(v, start, length));
     }
-    function where(arr, property, expected) {
-        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) {
-            switch (_d.label) {
+    function matches(value, expected) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!this.context.opts.jekyllWhere) return [3 /*break*/, 6];
+                    if (!EmptyDrop.is(expected)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, equals(value, expected)];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    if (!isArray(value)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, arrayIncludes(value, expected)];
+                case 3: return [2 /*return*/, _a.sent()];
+                case 4: return [4 /*yield*/, equals(value, expected)];
+                case 5: return [2 /*return*/, _a.sent()];
+                case 6:
+                    if (expected === undefined)
+                        return [2 /*return*/, isTruthy(value, this.context)];
+                    return [4 /*yield*/, equals(value, expected)];
+                case 7: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }
+    function filter(include, arr, property, expected) {
+        var token, result, arr_1, arr_1_1, item, value, e_4_1;
+        var e_4, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
-                    values = [];
                     arr = toArray(arr);
                     this.context.memoryLimit.use(arr.length);
                     token = new Tokenizer(stringify(property)).readScopeValue();
-                    _d.label = 1;
+                    result = [];
+                    _b.label = 1;
                 case 1:
-                    _d.trys.push([1, 6, 7, 8]);
+                    _b.trys.push([1, 7, 8, 9]);
                     arr_1 = __values(arr), arr_1_1 = arr_1.next();
-                    _d.label = 2;
+                    _b.label = 2;
                 case 2:
-                    if (!!arr_1_1.done) return [3 /*break*/, 5];
+                    if (!!arr_1_1.done) return [3 /*break*/, 6];
                     item = arr_1_1.value;
-                    _b = (_a = values).push;
                     return [4 /*yield*/, evalToken(token, this.context.spawn(item))];
                 case 3:
-                    _b.apply(_a, [_d.sent()]);
-                    _d.label = 4;
+                    value = _b.sent();
+                    return [4 /*yield*/, matches.call(this, value, expected)];
                 case 4:
+                    if ((_b.sent()) === include)
+                        result.push(item);
+                    _b.label = 5;
+                case 5:
                     arr_1_1 = arr_1.next();
                     return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_4_1 = _d.sent();
-                    e_4 = { error: e_4_1 };
-                    return [3 /*break*/, 8];
+                case 6: return [3 /*break*/, 9];
                 case 7:
+                    e_4_1 = _b.sent();
+                    e_4 = { error: e_4_1 };
+                    return [3 /*break*/, 9];
+                case 8:
                     try {
-                        if (arr_1_1 && !arr_1_1.done && (_c = arr_1.return)) _c.call(arr_1);
+                        if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1);
                     }
                     finally { if (e_4) throw e_4.error; }
                     return [7 /*endfinally*/];
-                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]);
-                        })];
+                case 9: return [2 /*return*/, result];
             }
         });
     }
-    function where_exp(arr, itemName, exp) {
+    function filter_exp(include, arr, itemName, exp) {
         var filtered, keyTemplate, array, array_4, array_4_1, item, value, e_5_1;
         var e_5, _a, _b;
         return __generator(this, function (_c) {
@@ -4699,10 +5297,12 @@
                 case 2:
                     if (!!array_4_1.done) return [3 /*break*/, 5];
                     item = array_4_1.value;
-                    return [4 /*yield*/, keyTemplate.value(this.context.spawn((_b = {}, _b[itemName] = item, _b)))];
+                    this.context.push((_b = {}, _b[itemName] = item, _b));
+                    return [4 /*yield*/, keyTemplate.value(this.context)];
                 case 3:
                     value = _c.sent();
-                    if (value)
+                    this.context.pop();
+                    if (value === include)
                         filtered.push(item);
                     _c.label = 4;
                 case 4:
@@ -4723,6 +5323,38 @@
             }
         });
     }
+    function where(arr, property, expected) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(filter.call(this, true, arr, property, expected))];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }
+    function reject(arr, property, expected) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(filter.call(this, false, arr, property, expected))];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }
+    function where_exp(arr, itemName, exp) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(filter_exp.call(this, true, arr, itemName, exp))];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }
+    function reject_exp(arr, itemName, exp) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(filter_exp.call(this, false, arr, itemName, exp))];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }
     function group_by(arr, property) {
         var map, token, arr_2, arr_2_1, item, key, e_6_1;
         var e_6, _a;
@@ -4787,9 +5419,11 @@
                 case 2:
                     if (!!arr_3_1.done) return [3 /*break*/, 5];
                     item = arr_3_1.value;
-                    return [4 /*yield*/, keyTemplate.value(this.context.spawn((_b = {}, _b[itemName] = item, _b)))];
+                    this.context.push((_b = {}, _b[itemName] = item, _b));
+                    return [4 /*yield*/, keyTemplate.value(this.context)];
                 case 3:
                     key = _c.sent();
+                    this.context.pop();
                     if (!map.has(key))
                         map.set(key, []);
                     map.get(key).push(item);
@@ -4815,83 +5449,122 @@
             }
         });
     }
-    function find(arr, property, expected) {
-        var token, array, array_5, array_5_1, item, value, e_8_1;
-        var e_8, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+    function search(arr, property, expected) {
+        var token, array, index, value;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     token = new Tokenizer(stringify(property)).readScopeValue();
                     array = toArray(arr);
-                    _b.label = 1;
+                    index = 0;
+                    _a.label = 1;
                 case 1:
-                    _b.trys.push([1, 6, 7, 8]);
-                    array_5 = __values(array), array_5_1 = array_5.next();
-                    _b.label = 2;
+                    if (!(index < array.length)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, evalToken(token, this.context.spawn(array[index]))];
                 case 2:
-                    if (!!array_5_1.done) return [3 /*break*/, 5];
-                    item = array_5_1.value;
-                    return [4 /*yield*/, evalToken(token, this.context.spawn(item))];
+                    value = _a.sent();
+                    return [4 /*yield*/, matches.call(this, value, expected)];
                 case 3:
-                    value = _b.sent();
-                    if (equals(value, expected))
-                        return [2 /*return*/, item];
-                    _b.label = 4;
+                    if (_a.sent())
+                        return [2 /*return*/, [index, array[index]]];
+                    _a.label = 4;
                 case 4:
-                    array_5_1 = array_5.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_8_1 = _b.sent();
-                    e_8 = { error: e_8_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (array_5_1 && !array_5_1.done && (_a = array_5.return)) _a.call(array_5);
-                    }
-                    finally { if (e_8) throw e_8.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [2 /*return*/];
+                    index++;
+                    return [3 /*break*/, 1];
+                case 5: return [2 /*return*/];
             }
         });
     }
-    function find_exp(arr, itemName, exp) {
-        var predicate, array, array_6, array_6_1, item, value, e_9_1;
-        var e_9, _a, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
+    function search_exp(arr, itemName, exp) {
+        var predicate, array, index, value;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
                     predicate = new Value(stringify(exp), this.liquid);
                     array = toArray(arr);
-                    _c.label = 1;
+                    index = 0;
+                    _b.label = 1;
+                case 1:
+                    if (!(index < array.length)) return [3 /*break*/, 4];
+                    this.context.push((_a = {}, _a[itemName] = array[index], _a));
+                    return [4 /*yield*/, predicate.value(this.context)];
+                case 2:
+                    value = _b.sent();
+                    this.context.pop();
+                    if (value)
+                        return [2 /*return*/, [index, array[index]]];
+                    _b.label = 3;
+                case 3:
+                    index++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }
+    function has(arr, property, expected) {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(search.call(this, arr, property, expected))];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, !!result];
+            }
+        });
+    }
+    function has_exp(arr, itemName, exp) {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(search_exp.call(this, arr, itemName, exp))];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, !!result];
+            }
+        });
+    }
+    function find_index(arr, property, expected) {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(search.call(this, arr, property, expected))];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result ? result[0] : undefined];
+            }
+        });
+    }
+    function find_index_exp(arr, itemName, exp) {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(search_exp.call(this, arr, itemName, exp))];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result ? result[0] : undefined];
+            }
+        });
+    }
+    function find(arr, property, expected) {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(search.call(this, arr, property, expected))];
                 case 1:
-                    _c.trys.push([1, 6, 7, 8]);
-                    array_6 = __values(array), array_6_1 = array_6.next();
-                    _c.label = 2;
-                case 2:
-                    if (!!array_6_1.done) return [3 /*break*/, 5];
-                    item = array_6_1.value;
-                    return [4 /*yield*/, predicate.value(this.context.spawn((_b = {}, _b[itemName] = item, _b)))];
-                case 3:
-                    value = _c.sent();
-                    if (value)
-                        return [2 /*return*/, item];
-                    _c.label = 4;
-                case 4:
-                    array_6_1 = array_6.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_9_1 = _c.sent();
-                    e_9 = { error: e_9_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (array_6_1 && !array_6_1.done && (_a = array_6.return)) _a.call(array_6);
-                    }
-                    finally { if (e_9) throw e_9.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [2 /*return*/];
+                    result = _a.sent();
+                    return [2 /*return*/, result ? result[1] : undefined];
+            }
+        });
+    }
+    function find_exp(arr, itemName, exp) {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(search_exp.call(this, arr, itemName, exp))];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result ? result[1] : undefined];
             }
         });
     }
@@ -4907,7 +5580,7 @@
             return [];
         if (!isArray(v))
             v = stringify(v);
-        this.context.memoryLimit.use(count);
+        this.context.memoryLimit.use(v.length);
         var shuffled = __spreadArray([], __read(v), false).sort(function () { return Math.random() - 0.5; });
         if (count === 1)
             return shuffled[0];
@@ -4933,9 +5606,15 @@
         shift: shift,
         slice: slice,
         where: where,
+        reject: reject,
         where_exp: where_exp,
+        reject_exp: reject_exp,
         group_by: group_by,
         group_by_exp: group_by_exp,
+        has: has,
+        has_exp: has_exp,
+        find_index: find_index,
+        find_index_exp: find_index_exp,
         find: find,
         find_exp: find_exp,
         uniq: uniq,
@@ -4943,21 +5622,25 @@
     });
 
     function date(v, format, timezoneOffset) {
-        var _a, _b, _c;
-        var size = ((_a = v === null || v === void 0 ? void 0 : v.length) !== null && _a !== void 0 ? _a : 0) + ((_b = format === null || format === void 0 ? void 0 : format.length) !== null && _b !== void 0 ? _b : 0) + ((_c = timezoneOffset === null || timezoneOffset === void 0 ? void 0 : timezoneOffset.length) !== null && _c !== void 0 ? _c : 0);
+        var _a, _b;
+        var size = ((_a = v === null || v === void 0 ? void 0 : v.length) !== null && _a !== void 0 ? _a : 0) + ((_b = timezoneOffset === null || timezoneOffset === void 0 ? void 0 : timezoneOffset.length) !== null && _b !== void 0 ? _b : 0);
         this.context.memoryLimit.use(size);
         var date = parseDate(v, this.context.opts, timezoneOffset);
         if (!date)
             return v;
         format = toValue(format);
         format = isNil(format) ? this.context.opts.dateFormat : stringify(format);
-        return strftime(date, format);
+        this.context.memoryLimit.use(format.length);
+        return strftime(date, format, this.context.memoryLimit);
     }
     function date_to_xmlschema(v) {
         return date.call(this, v, '%Y-%m-%dT%H:%M:%S%:z');
     }
     function date_to_rfc822(v) {
-        return date.call(this, v, '%a, %d %b %Y %H:%M:%S %z');
+        var date = parseDate(v, this.context.opts, undefined, 'en-US');
+        if (!date)
+            return v;
+        return strftime(date, '%a, %d %b %Y %H:%M:%S %z', this.context.memoryLimit);
     }
     function date_to_string(v, type, style) {
         return stringify_date.call(this, v, '%b', type, style);
@@ -4969,20 +5652,24 @@
         var date = parseDate(v, this.context.opts);
         if (!date)
             return v;
+        var ml = this.context.memoryLimit;
         if (type === 'ordinal') {
             var d = date.getDate();
             return style === 'US'
-                ? strftime(date, "".concat(month_type, " ").concat(d, "%q, %Y"))
-                : strftime(date, "".concat(d, "%q ").concat(month_type, " %Y"));
+                ? strftime(date, "".concat(month_type, " ").concat(d, "%q, %Y"), ml)
+                : strftime(date, "".concat(d, "%q ").concat(month_type, " %Y"), ml);
         }
-        return strftime(date, "%d ".concat(month_type, " %Y"));
+        return strftime(date, "%d ".concat(month_type, " %Y"), ml);
     }
-    function parseDate(v, opts, timezoneOffset) {
+    function parseDate(v, opts, timezoneOffset, locale) {
+        if (locale === void 0) { locale = opts.locale; }
         var date;
         var defaultTimezoneOffset = timezoneOffset !== null && timezoneOffset !== void 0 ? timezoneOffset : opts.timezoneOffset;
-        var locale = opts.locale;
         v = toValue(v);
-        if (v === 'now' || v === 'today') {
+        if (isNil(v)) {
+            return undefined;
+        }
+        else if (v === 'now' || v === 'today') {
             date = new LiquidDate(Date.now(), locale, defaultTimezoneOffset);
         }
         else if (isNumber(v)) {
@@ -5036,14 +5723,46 @@
         this.context.memoryLimit.use(lhs.length + rhs.length);
         return rhs + lhs;
     }
+    function getTrimStart(str, chars) {
+        var e_1, _a;
+        var start = 0;
+        try {
+            for (var str_1 = __values(str), str_1_1 = str_1.next(); !str_1_1.done; str_1_1 = str_1.next()) {
+                var char = str_1_1.value;
+                if (!chars.has(char))
+                    break;
+                start += char.length;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (str_1_1 && !str_1_1.done && (_a = str_1.return)) _a.call(str_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return start;
+    }
+    function getTrimEnd(str, chars, start) {
+        if (start === void 0) { start = 0; }
+        var end = str.length;
+        while (end > start) {
+            var size = end - start >= 2 && str.codePointAt(end - 2) > 0xFFFF ? 2 : 1;
+            if (!chars.has(str.slice(end - size, end)))
+                break;
+            end -= size;
+        }
+        return end;
+    }
     function lstrip(v, chars) {
         var str = stringify(v);
         this.context.memoryLimit.use(str.length);
         if (chars) {
-            chars = escapeRegExp(stringify(chars));
-            return str.replace(new RegExp("^[".concat(chars, "]+"), 'g'), '');
+            chars = stringify(chars);
+            this.context.memoryLimit.use(chars.length);
+            return str.slice(getTrimStart(str, new Set(chars)));
         }
-        return str.replace(/^\s+/, '');
+        return str.trimStart();
     }
     function downcase(v) {
         var str = stringify(v);
@@ -5057,18 +5776,20 @@
     }
     function remove(v, arg) {
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
-        return str.split(stringify(arg)).join('');
+        arg = stringify(arg);
+        this.context.memoryLimit.use(str.length + arg.length);
+        return str.split(arg).join('');
     }
     function remove_first(v, l) {
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
-        return str.replace(stringify(l), '');
+        l = stringify(l);
+        this.context.memoryLimit.use(str.length + l.length);
+        return str.replace(l, '');
     }
     function remove_last(v, l) {
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
         var pattern = stringify(l);
+        this.context.memoryLimit.use(str.length + pattern.length);
         var index = str.lastIndexOf(pattern);
         if (index === -1)
             return str;
@@ -5078,10 +5799,11 @@
         str = stringify(str);
         this.context.memoryLimit.use(str.length);
         if (chars) {
-            chars = escapeRegExp(stringify(chars));
-            return str.replace(new RegExp("[".concat(chars, "]+$"), 'g'), '');
+            chars = stringify(chars);
+            this.context.memoryLimit.use(chars.length);
+            return str.slice(0, getTrimEnd(str, new Set(chars)));
         }
-        return str.replace(/\s+$/, '');
+        return str.trimEnd();
     }
     function split(v, arg) {
         var str = stringify(v);
@@ -5097,10 +5819,10 @@
         var str = stringify(v);
         this.context.memoryLimit.use(str.length);
         if (chars) {
-            chars = escapeRegExp(stringify(chars));
-            return str
-                .replace(new RegExp("^[".concat(chars, "]+"), 'g'), '')
-                .replace(new RegExp("[".concat(chars, "]+$"), 'g'), '');
+            var set = new Set(stringify(chars));
+            this.context.memoryLimit.use(set.size);
+            var start = getTrimStart(str, set);
+            return str.slice(start, getTrimEnd(str, set, start));
         }
         return str.trim();
     }
@@ -5109,6 +5831,11 @@
         this.context.memoryLimit.use(str.length);
         return str.replace(/\r?\n/gm, '');
     }
+    function squish(v) {
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(/\s+/g, ' ').trim();
+    }
     function capitalize(str) {
         str = stringify(str);
         this.context.memoryLimit.use(str.length);
@@ -5116,39 +5843,47 @@
     }
     function replace(v, pattern, replacement) {
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
-        return str.split(stringify(pattern)).join(replacement);
+        pattern = stringify(pattern);
+        replacement = stringify(replacement);
+        var parts = str.split(pattern);
+        var outputSize = str.length + (parts.length - 1) * (replacement.length - pattern.length);
+        this.context.memoryLimit.use(outputSize);
+        return parts.join(replacement);
     }
     function replace_first(v, arg1, arg2) {
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
-        return str.replace(stringify(arg1), arg2);
+        arg1 = stringify(arg1);
+        arg2 = stringify(arg2);
+        this.context.memoryLimit.use(str.length + arg1.length + arg2.length);
+        return str.replace(arg1, function () { return arg2; });
     }
     function replace_last(v, arg1, arg2) {
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
         var pattern = stringify(arg1);
+        var replacement = stringify(arg2);
+        this.context.memoryLimit.use(str.length + pattern.length + replacement.length);
         var index = str.lastIndexOf(pattern);
         if (index === -1)
             return str;
-        var replacement = stringify(arg2);
         return str.substring(0, index) + replacement + str.substring(index + pattern.length);
     }
     function truncate(v, l, o) {
         if (l === void 0) { l = 50; }
         if (o === void 0) { o = '...'; }
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
-        if (str.length <= l)
+        o = stringify(o);
+        this.context.memoryLimit.use(str.length + o.length);
+        if (str.length <= l || advanceCodePoints(str, 0, l) >= str.length)
             return v;
-        return str.substring(0, l - o.length) + o;
+        return str.slice(0, advanceCodePoints(str, 0, Math.max(l - codePointLength(o), 0))) + o;
     }
     function truncatewords(v, words, o) {
         if (words === void 0) { words = 15; }
         if (o === void 0) { o = '...'; }
         var str = stringify(v);
-        this.context.memoryLimit.use(str.length);
-        var arr = str.split(/\s+/);
+        o = stringify(o);
+        this.context.memoryLimit.use(str.length + o.length);
+        var arr = str.trimStart().split(/\s+/);
         if (words <= 0)
             words = 1;
         var ret = arr.slice(0, words).join(' ');
@@ -5181,9 +5916,14 @@
                 return input.split(/\s+/).length;
         }
     }
-    function array_to_sentence_string(array, connector) {
+    function array_to_sentence_string(input, connector) {
         if (connector === void 0) { connector = 'and'; }
-        this.context.memoryLimit.use(array.length);
+        var array = toArray(input);
+        connector = stringify(connector);
+        var outputSize = connector.length + array.length * 2;
+        for (var i = 0; i < array.length; i++)
+            outputSize += stringify(array[i]).length;
+        this.context.memoryLimit.use(outputSize);
         switch (array.length) {
             case 0:
                 return '';
@@ -5210,6 +5950,7 @@
         split: split,
         strip: strip,
         strip_newlines: strip_newlines,
+        squish: squish,
         capitalize: capitalize,
         replace: replace,
         replace_first: replace_first,
@@ -5221,7 +5962,117 @@
         array_to_sentence_string: array_to_sentence_string
     });
 
-    var filters = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, htmlFilters), mathFilters), urlFilters), arrayFilters), dateFilters), stringFilters), misc);
+    function base64Encode(str) {
+        var bytes = new TextEncoder().encode(str);
+        var binary = '';
+        for (var i = 0; i < bytes.length; i += 0x8000) {
+            binary += String.fromCharCode.apply(String, __spreadArray([], __read(bytes.subarray(i, i + 0x8000)), false));
+        }
+        return btoa(binary);
+    }
+    function base64Decode(str) {
+        return new TextDecoder().decode(Uint8Array.from(atob(str), function (c) { return c.charCodeAt(0); }));
+    }
+
+    /**
+     * Base64 related filters
+     *
+     * Implements base64_encode and base64_decode filters for Shopify compatibility
+     */
+    function base64_encode(value) {
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+            this.context.memoryLimit.use(value.byteLength);
+            return value.toString('base64');
+        }
+        var str = stringify(value);
+        this.context.memoryLimit.use(str.length);
+        return base64Encode(str);
+    }
+    function base64_decode(value) {
+        var str = stringify(value);
+        this.context.memoryLimit.use(str.length);
+        assert(isBase64(str), 'invalid base64 provided to base64_decode');
+        return base64Decode(str);
+    }
+    function isBase64(str) {
+        str = str.replace(/[\t\n\f\r ]/g, '');
+        if (str.length % 4 === 0)
+            str = str.replace(/==?$/, '');
+        return str.length % 4 !== 1 && /^[A-Za-z0-9+/]*$/.test(str);
+    }
+
+    var base64Filters = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        base64_encode: base64_encode,
+        base64_decode: base64_decode
+    });
+
+    function bufferToHex(buffer) {
+        var bytes = new Uint8Array(buffer);
+        var hex = '';
+        for (var i = 0; i < bytes.length; i++) {
+            hex += bytes[i].toString(16).padStart(2, '0');
+        }
+        return hex;
+    }
+    function sha256(str) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, digest;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = new TextEncoder().encode(str);
+                        return [4 /*yield*/, crypto.subtle.digest('SHA-256', data)];
+                    case 1:
+                        digest = _a.sent();
+                        return [2 /*return*/, bufferToHex(digest)];
+                }
+            });
+        });
+    }
+    function hmacSha256(str, key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encoder, cryptoKey, signature;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        encoder = new TextEncoder();
+                        return [4 /*yield*/, crypto.subtle.importKey('raw', encoder.encode(key), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'])];
+                    case 1:
+                        cryptoKey = _a.sent();
+                        return [4 /*yield*/, crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(str))];
+                    case 2:
+                        signature = _a.sent();
+                        return [2 /*return*/, bufferToHex(signature)];
+                }
+            });
+        });
+    }
+
+    /**
+     * Crypto related filters
+     *
+     * Implements sha256 and hmac_sha256 filters for Shopify compatibility
+     */
+    function sha256$1(value) {
+        var str = stringify(value);
+        this.context.memoryLimit.use(str.length);
+        return sha256(str);
+    }
+    function hmac_sha256(value, key) {
+        var str = stringify(value);
+        var keyStr = stringify(key);
+        this.context.memoryLimit.use(str.length + keyStr.length);
+        return hmacSha256(str, keyStr);
+    }
+
+    var cryptoFilters = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        sha256: sha256$1,
+        hmac_sha256: hmac_sha256
+    });
+
+    var filters = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, htmlFilters), mathFilters), urlFilters), arrayFilters), dateFilters), stringFilters), base64Filters), cryptoFilters), misc);
 
     var default_1 = /** @class */ (function (_super) {
         __extends(default_1, _super);
@@ -5317,10 +6168,10 @@
                         return [2 /*return*/];
                     case 3:
                         continueKey = 'continue-' + this.variable + '-' + this.collection.getText();
-                        ctx.push({ continue: ctx.getRegister(continueKey) });
+                        ctx.push(createScope({ continue: ctx.getRegister(continueKey, {}) }));
                         return [4 /*yield*/, this.hash.render(ctx)];
                     case 4:
-                        hash = _c.sent();
+                        hash = (_c.sent());
                         ctx.pop();
                         modifiers = this.liquid.options.orderedFilterParameters
                             ? Object.keys(hash).filter(function (x) { return MODIFIERS.includes(x); })
@@ -5333,7 +6184,7 @@
                             return reversed(collection);
                         }, collection);
                         ctx.setRegister(continueKey, (hash['offset'] || 0) + collection.length);
-                        scope = { forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) };
+                        scope = createScope({ forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) });
                         ctx.push(scope);
                         _c.label = 5;
                     case 5:
@@ -5550,69 +6401,72 @@
                         r = this.liquid.renderer;
                         _a = toValue;
                         return [4 /*yield*/, this.value.value(ctx, ctx.opts.lenientIf)];
-                    case 1:
-                        target = _a.apply(void 0, [_h.sent()]);
-                        branchHit = false;
-                        _h.label = 2;
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [_h.sent()])];
                     case 2:
-                        _h.trys.push([2, 14, 15, 16]);
-                        _b = __values(this.branches), _c = _b.next();
+                        target = _h.sent();
+                        branchHit = false;
                         _h.label = 3;
                     case 3:
-                        if (!!_c.done) return [3 /*break*/, 13];
-                        branch = _c.value;
+                        _h.trys.push([3, 16, 17, 18]);
+                        _b = __values(this.branches), _c = _b.next();
                         _h.label = 4;
                     case 4:
-                        _h.trys.push([4, 10, 11, 12]);
-                        _d = (e_1 = void 0, __values(branch.values)), _e = _d.next();
+                        if (!!_c.done) return [3 /*break*/, 15];
+                        branch = _c.value;
                         _h.label = 5;
                     case 5:
-                        if (!!_e.done) return [3 /*break*/, 9];
+                        _h.trys.push([5, 12, 13, 14]);
+                        _d = (e_1 = void 0, __values(branch.values)), _e = _d.next();
+                        _h.label = 6;
+                    case 6:
+                        if (!!_e.done) return [3 /*break*/, 11];
                         valueToken = _e.value;
                         return [4 /*yield*/, evalToken(valueToken, ctx, ctx.opts.lenientIf)];
-                    case 6:
+                    case 7:
                         value = _h.sent();
-                        if (!equals(target, value)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, equals(target, value)];
+                    case 8:
+                        if (!_h.sent()) return [3 /*break*/, 10];
                         return [4 /*yield*/, r.renderTemplates(branch.templates, ctx, emitter)];
-                    case 7:
+                    case 9:
                         _h.sent();
                         branchHit = true;
-                        return [3 /*break*/, 9];
-                    case 8:
-                        _e = _d.next();
-                        return [3 /*break*/, 5];
-                    case 9: return [3 /*break*/, 12];
+                        return [3 /*break*/, 11];
                     case 10:
+                        _e = _d.next();
+                        return [3 /*break*/, 6];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
                         e_1_1 = _h.sent();
                         e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 12];
-                    case 11:
+                        return [3 /*break*/, 14];
+                    case 13:
                         try {
                             if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 12:
-                        _c = _b.next();
-                        return [3 /*break*/, 3];
-                    case 13: return [3 /*break*/, 16];
                     case 14:
+                        _c = _b.next();
+                        return [3 /*break*/, 4];
+                    case 15: return [3 /*break*/, 18];
+                    case 16:
                         e_2_1 = _h.sent();
                         e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 16];
-                    case 15:
+                        return [3 /*break*/, 18];
+                    case 17:
                         try {
                             if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
                         }
                         finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
-                    case 16:
-                        if (!!branchHit) return [3 /*break*/, 18];
+                    case 18:
+                        if (!!branchHit) return [3 /*break*/, 20];
                         return [4 /*yield*/, r.renderTemplates(this.elseTemplates, ctx, emitter)];
-                    case 17:
+                    case 19:
                         _h.sent();
-                        _h.label = 18;
-                    case 18: return [2 /*return*/];
+                        _h.label = 20;
+                    case 20: return [2 /*return*/];
                 }
             });
         };
@@ -5682,7 +6536,11 @@
                                 alias = tokenizer.readIdentifier();
                             else
                                 tokenizer.p = beforeAs;
-                            _this[keyword.content] = { value: value, alias: alias && alias.content };
+                            var binding = { value: value, alias: alias && alias.content };
+                            if (keyword.content === 'with')
+                                _this.with = binding;
+                            else
+                                _this.forBinding = binding;
                             tokenizer.skipBlank();
                             if (tokenizer.peek() === ',')
                                 tokenizer.advance();
@@ -5706,7 +6564,7 @@
                 switch (_k.label) {
                     case 0:
                         _a = this, liquid = _a.liquid, hash = _a.hash;
-                        return [4 /*yield*/, renderFilePath(this['file'], ctx, liquid)];
+                        return [4 /*yield*/, renderFilePath(this.file, ctx, liquid)];
                     case 1:
                         filepath = (_k.sent());
                         assert(filepath, function () { return "illegal file path \"".concat(filepath, "\""); });
@@ -5717,8 +6575,8 @@
                         return [4 /*yield*/, hash.render(ctx)];
                     case 2:
                         _b.apply(void 0, _c.concat([_k.sent()]));
-                        if (!this['with']) return [3 /*break*/, 4];
-                        _d = this['with'], value = _d.value, alias = _d.alias;
+                        if (!this.with) return [3 /*break*/, 4];
+                        _d = this.with, value = _d.value, alias = _d.alias;
                         _e = scope;
                         _f = alias || filepath;
                         return [4 /*yield*/, evalToken(value, ctx)];
@@ -5726,8 +6584,8 @@
                         _e[_f] = _k.sent();
                         _k.label = 4;
                     case 4:
-                        if (!this['for']) return [3 /*break*/, 15];
-                        _g = this['for'], value = _g.value, alias = _g.alias;
+                        if (!this.forBinding) return [3 /*break*/, 15];
+                        _g = this.forBinding, value = _g.value, alias = _g.alias;
                         _h = toEnumerable;
                         return [4 /*yield*/, evalToken(value, ctx)];
                     case 5:
@@ -5742,7 +6600,7 @@
                         if (!!collection_1_1.done) return [3 /*break*/, 11];
                         item = collection_1_1.value;
                         scope[alias] = item;
-                        return [4 /*yield*/, liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile'])];
+                        return [4 /*yield*/, liquid._parsePartialFile(filepath, childCtx.sync, this.currentFile)];
                     case 8:
                         templates = (_k.sent());
                         return [4 /*yield*/, liquid.renderer.renderTemplates(templates, childCtx, emitter)];
@@ -5765,7 +6623,7 @@
                         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 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)];
@@ -5780,18 +6638,18 @@
             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'])];
+                        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'])) {
+            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 (this.with) {
+                    var _a = this.with, value = _a.value, alias = _a.alias;
                     if (isString(alias)) {
                         names.push([alias, value]);
                     }
@@ -5799,8 +6657,8 @@
                         names.push([this.file, value]);
                     }
                 }
-                if (this['for']) {
-                    var _b = this['for'], value = _b.value, alias = _b.alias;
+                if (this.forBinding) {
+                    var _b = this.forBinding, value = _b.value, alias = _b.alias;
                     if (isString(alias)) {
                         names.push([alias, value]);
                     }
@@ -5808,7 +6666,7 @@
                         names.push([this.file, value]);
                     }
                 }
-                return { name: this['file'], isolated: true, scope: names };
+                return { name: this.file, isolated: true, scope: names };
             }
         };
         default_1.prototype.arguments = function () {
@@ -5843,16 +6701,16 @@
                         finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
                     case 7:
-                        if (!this['with']) return [3 /*break*/, 9];
-                        value = this['with'].value;
+                        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 (!this.forBinding) return [3 /*break*/, 11];
+                        value = this.forBinding.value;
                         if (!isValueToken(value)) return [3 /*break*/, 11];
                         return [4 /*yield*/, value];
                     case 10:
@@ -5912,8 +6770,8 @@
         function default_1(token, remainTokens, liquid, parser) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             var tokenizer = token.tokenizer;
-            _this['file'] = parseFilePath(tokenizer, _this.liquid, parser);
-            _this['currentFile'] = token.file;
+            _this.file = parseFilePath(tokenizer, _this.liquid, parser);
+            _this.currentFile = token.file;
             var begin = tokenizer.p;
             var withStr = tokenizer.readIdentifier();
             if (withStr.content === 'with') {
@@ -5930,36 +6788,37 @@
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
-            var _a, liquid, hash, withVar, renderer, filepath, saved, scope, _b, _c, templates;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var _a, liquid, hash, withVar, renderer, filepath, saved, scope, _b, _c, _d, templates;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         _a = this, liquid = _a.liquid, hash = _a.hash, withVar = _a.withVar;
                         renderer = liquid.renderer;
-                        return [4 /*yield*/, renderFilePath(this['file'], ctx, liquid)];
+                        return [4 /*yield*/, renderFilePath(this.file, ctx, liquid)];
                     case 1:
-                        filepath = (_d.sent());
+                        filepath = (_e.sent());
                         assert(filepath, function () { return "illegal file path \"".concat(filepath, "\""); });
                         saved = ctx.saveRegister('blocks', 'blockMode');
                         ctx.setRegister('blocks', {});
                         ctx.setRegister('blockMode', BlockMode.OUTPUT);
+                        _b = createScope;
                         return [4 /*yield*/, hash.render(ctx)];
                     case 2:
-                        scope = (_d.sent());
+                        scope = _b.apply(void 0, [(_e.sent())]);
                         if (!withVar) return [3 /*break*/, 4];
-                        _b = scope;
-                        _c = filepath;
+                        _c = scope;
+                        _d = filepath;
                         return [4 /*yield*/, evalToken(withVar, ctx)];
                     case 3:
-                        _b[_c] = _d.sent();
-                        _d.label = 4;
-                    case 4: return [4 /*yield*/, liquid._parsePartialFile(filepath, ctx.sync, this['currentFile'])];
+                        _c[_d] = _e.sent();
+                        _e.label = 4;
+                    case 4: return [4 /*yield*/, liquid._parsePartialFile(filepath, ctx.sync, this.currentFile)];
                     case 5:
-                        templates = (_d.sent());
-                        ctx.push(ctx.opts.jekyllInclude ? { include: scope } : scope);
+                        templates = (_e.sent());
+                        ctx.push(ctx.opts.jekyllInclude ? createScope({ include: scope }) : scope);
                         return [4 /*yield*/, renderer.renderTemplates(templates, ctx, emitter)];
                     case 6:
-                        _d.sent();
+                        _e.sent();
                         ctx.pop();
                         ctx.restoreRegister(saved);
                         return [2 /*return*/];
@@ -5970,15 +6829,15 @@
             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'])];
+                        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'])) {
+            if (isString(this.file)) {
                 var names = void 0;
                 if (this.liquid.options.jekyllInclude) {
                     names = ['include'];
@@ -5986,10 +6845,10 @@
                 else {
                     names = Object.keys(this.hash.hash);
                     if (this.withVar) {
-                        names.push([this['file'], this.withVar]);
+                        names.push([this.file, this.withVar]);
                     }
                 }
-                return { name: this['file'], isolated: false, scope: names };
+                return { name: this.file, isolated: false, scope: names };
             }
         };
         default_1.prototype.arguments = function () {
@@ -5998,8 +6857,8 @@
                     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']];
+                        if (!isValueToken(this.file)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.file];
                     case 2:
                         _a.sent();
                         _a.label = 3;
@@ -6049,6 +6908,7 @@
         function default_1(token, remainTokens, liquid) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             _this.candidates = [];
+            var begin = _this.tokenizer.p;
             var group = _this.tokenizer.readValue();
             _this.tokenizer.skipBlank();
             if (group) {
@@ -6057,35 +6917,45 @@
                     _this.tokenizer.advance();
                 }
                 else
-                    _this.candidates.push(group);
+                    _this.tokenizer.p = begin;
             }
             while (!_this.tokenizer.end()) {
-                var value = _this.tokenizer.readValue();
-                if (value)
-                    _this.candidates.push(value);
+                var value = _this.tokenizer.readFilteredValue();
+                _this.candidates.push(value);
                 _this.tokenizer.readTo(',');
             }
             _this.tokenizer.assert(_this.candidates.length, function () { return "empty candidates: \"".concat(token.getText(), "\""); });
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
-            var group, fingerprint, groups, idx, candidate;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var group, fingerprint, groups, idx, candidate, val, _a, outputEscape;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0: return [4 /*yield*/, evalToken(this.group, ctx)];
                     case 1:
-                        group = (_a.sent());
-                        fingerprint = "cycle:".concat(group, ":") + this.candidates.join(',');
-                        groups = ctx.getRegister('cycle');
+                        group = (_c.sent());
+                        fingerprint = "cycle:".concat(group, ":") + this.candidates.map(function (c) { return c.getText(); }).join(',');
+                        groups = ctx.getRegister('cycle', {});
                         idx = groups[fingerprint];
                         if (idx === undefined) {
                             idx = groups[fingerprint] = 0;
                         }
-                        candidate = this.candidates[idx];
+                        candidate = new Value(this.candidates[idx], this.liquid);
                         idx = (idx + 1) % this.candidates.length;
                         groups[fingerprint] = idx;
-                        return [4 /*yield*/, evalToken(candidate, ctx)];
-                    case 2: return [2 /*return*/, _a.sent()];
+                        _a = toValue;
+                        return [4 /*yield*/, candidate.value(ctx, false)];
+                    case 2: return [4 /*yield*/, _a.apply(void 0, [_c.sent()])];
+                    case 3:
+                        val = _c.sent();
+                        outputEscape = this.liquid.options.outputEscape;
+                        if (!(outputEscape && !((_b = candidate.filters[candidate.filters.length - 1]) === null || _b === void 0 ? void 0 : _b.raw))) return [3 /*break*/, 5];
+                        return [4 /*yield*/, outputEscape.call({ context: ctx, token: this.token, liquid: this.liquid }, val)];
+                    case 4:
+                        val = _c.sent();
+                        _c.label = 5;
+                    case 5: return [2 /*return*/, val];
                 }
             });
         };
@@ -6137,45 +7007,47 @@
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
-            var r, _a, _b, _c, value, templates, v, e_1_1;
-            var e_1, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+            var r, _a, _b, _c, value, templates, v, _d, e_1_1;
+            var e_1, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         r = this.liquid.renderer;
-                        _e.label = 1;
+                        _f.label = 1;
                     case 1:
-                        _e.trys.push([1, 7, 8, 9]);
+                        _f.trys.push([1, 8, 9, 10]);
                         _a = __values(this.branches), _b = _a.next();
-                        _e.label = 2;
+                        _f.label = 2;
                     case 2:
-                        if (!!_b.done) return [3 /*break*/, 6];
+                        if (!!_b.done) return [3 /*break*/, 7];
                         _c = _b.value, value = _c.value, templates = _c.templates;
+                        _d = toValue;
                         return [4 /*yield*/, value.value(ctx, ctx.opts.lenientIf)];
-                    case 3:
-                        v = _e.sent();
-                        if (!isTruthy(v, ctx)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, r.renderTemplates(templates, ctx, emitter)];
+                    case 3: return [4 /*yield*/, _d.apply(void 0, [_f.sent()])];
                     case 4:
-                        _e.sent();
-                        return [2 /*return*/];
+                        v = _f.sent();
+                        if (!isTruthy(v, ctx)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, r.renderTemplates(templates, ctx, emitter)];
                     case 5:
+                        _f.sent();
+                        return [2 /*return*/];
+                    case 6:
                         _b = _a.next();
                         return [3 /*break*/, 2];
-                    case 6: return [3 /*break*/, 9];
-                    case 7:
-                        e_1_1 = _e.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 9];
+                    case 7: return [3 /*break*/, 10];
                     case 8:
+                        e_1_1 = _f.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 (_b && !_b.done && (_e = _a.return)) _e.call(_a);
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 9: return [4 /*yield*/, r.renderTemplates(this.elseTemplates || [], ctx, emitter)];
-                    case 10:
-                        _e.sent();
+                    case 10: return [4 /*yield*/, r.renderTemplates(this.elseTemplates || [], ctx, emitter)];
+                    case 11:
+                        _f.sent();
                         return [2 /*return*/];
                 }
             });
@@ -6231,15 +7103,15 @@
         function default_1(token, remainTokens, liquid, parser) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             _this.file = parseFilePath(_this.tokenizer, _this.liquid, parser);
-            _this['currentFile'] = token.file;
+            _this.currentFile = token.file;
             _this.args = new Hash(_this.tokenizer, liquid.options.keyValueSeparator);
             _this.templates = parser.parseTokens(remainTokens);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
-            var _a, liquid, args, file, renderer, filepath, templates, html, blocks, _b, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var _a, liquid, args, file, renderer, filepath, templates, html, blocks, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         _a = this, liquid = _a.liquid, args = _a.args, file = _a.file;
                         renderer = liquid.renderer;
@@ -6247,34 +7119,35 @@
                         ctx.setRegister('blockMode', BlockMode.OUTPUT);
                         return [4 /*yield*/, renderer.renderTemplates(this.templates, ctx, emitter)];
                     case 1:
-                        _d.sent();
+                        _e.sent();
                         return [2 /*return*/];
                     case 2: return [4 /*yield*/, renderFilePath(this.file, ctx, liquid)];
                     case 3:
-                        filepath = (_d.sent());
+                        filepath = (_e.sent());
                         assert(filepath, function () { return "illegal file path \"".concat(filepath, "\""); });
-                        return [4 /*yield*/, liquid._parseLayoutFile(filepath, ctx.sync, this['currentFile'])];
+                        return [4 /*yield*/, liquid._parseLayoutFile(filepath, ctx.sync, this.currentFile)];
                     case 4:
-                        templates = (_d.sent());
+                        templates = (_e.sent());
                         // render remaining contents and store rendered results
                         ctx.setRegister('blockMode', BlockMode.STORE);
                         return [4 /*yield*/, renderer.renderTemplates(this.templates, ctx)];
                     case 5:
-                        html = _d.sent();
-                        blocks = ctx.getRegister('blocks');
+                        html = _e.sent();
+                        blocks = ctx.getRegister('blocks', {});
                         // set whole content to anonymous block if anonymous doesn't specified
                         if (blocks[''] === undefined)
                             blocks[''] = function (parent, emitter) { return emitter.write(html); };
                         ctx.setRegister('blockMode', BlockMode.OUTPUT);
                         // render the layout file use stored blocks
                         _c = (_b = ctx).push;
+                        _d = createScope;
                         return [4 /*yield*/, args.render(ctx)];
                     case 6:
                         // render the layout file use stored blocks
-                        _c.apply(_b, [(_d.sent())]);
+                        _c.apply(_b, [_d.apply(void 0, [(_e.sent())])]);
                         return [4 /*yield*/, renderer.renderTemplates(templates, ctx, emitter)];
                     case 7:
-                        _d.sent();
+                        _e.sent();
                         ctx.pop();
                         return [2 /*return*/];
                 }
@@ -6290,7 +7163,7 @@
                         _b = (_a = templates.push).apply;
                         _c = [templates];
                         _d = [[]];
-                        return [4 /*yield*/, this.liquid._parsePartialFile(this.file, true, this['currentFile'])];
+                        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;
@@ -6370,7 +7243,7 @@
                     case 0:
                         blockRender = this.getBlockRender(ctx);
                         if (!(ctx.getRegister('blockMode') === BlockMode.STORE)) return [3 /*break*/, 1];
-                        ctx.getRegister('blocks')[this.block] = blockRender;
+                        ctx.getRegister('blocks', {})[this.block] = blockRender;
                         return [3 /*break*/, 3];
                     case 1: return [4 /*yield*/, blockRender(new BlockDrop(), emitter)];
                     case 2:
@@ -6381,24 +7254,30 @@
             });
         };
         default_1.prototype.getBlockRender = function (ctx) {
+            var self = this;
             var _a = this, liquid = _a.liquid, templates = _a.templates;
-            var renderChild = ctx.getRegister('blocks')[this.block];
+            var renderChild = ctx.getRegister('blocks', {})[this.block];
             var renderCurrent = function (superBlock, emitter) {
+                var stack;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            // add {{ block.super }} support when rendering
-                            ctx.push({ block: superBlock });
+                            stack = ctx.getRegister('blockStack', []);
+                            if (stack.includes(self))
+                                throw new Error('block tag cannot be nested');
+                            stack.push(self);
+                            ctx.push(createScope({ block: superBlock }));
                             return [4 /*yield*/, liquid.renderer.renderTemplates(templates, ctx, emitter)];
                         case 1:
                             _a.sent();
                             ctx.pop();
+                            stack.pop();
                             return [2 /*return*/];
                     }
                 });
             };
             return renderChild
-                ? function (superBlock, emitter) { return renderChild(new BlockDrop(function () { return renderCurrent(superBlock, emitter); }), emitter); }
+                ? function (superBlock, emitter) { return renderChild(new BlockDrop(function (emitter) { return renderCurrent(superBlock, emitter); }), emitter); }
                 : renderCurrent;
         };
         default_1.prototype.children = function () {
@@ -6501,7 +7380,7 @@
                         cols = args.cols || collection.length;
                         r = this.liquid.renderer;
                         tablerowloop = new TablerowloopDrop(collection.length, cols, this.collection.getText(), this.variable);
-                        scope = { tablerowloop: tablerowloop };
+                        scope = createScope({ tablerowloop: tablerowloop });
                         ctx.push(scope);
                         idx = 0;
                         _b.label = 3;
@@ -6620,45 +7499,47 @@
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
-            var r, _a, _b, _c, value, test_1, templates, v, e_1_1;
-            var e_1, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+            var r, _a, _b, _c, value, test_1, templates, v, _d, e_1_1;
+            var e_1, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         r = this.liquid.renderer;
-                        _e.label = 1;
+                        _f.label = 1;
                     case 1:
-                        _e.trys.push([1, 7, 8, 9]);
+                        _f.trys.push([1, 8, 9, 10]);
                         _a = __values(this.branches), _b = _a.next();
-                        _e.label = 2;
+                        _f.label = 2;
                     case 2:
-                        if (!!_b.done) return [3 /*break*/, 6];
+                        if (!!_b.done) return [3 /*break*/, 7];
                         _c = _b.value, value = _c.value, test_1 = _c.test, templates = _c.templates;
+                        _d = toValue;
                         return [4 /*yield*/, value.value(ctx, ctx.opts.lenientIf)];
-                    case 3:
-                        v = _e.sent();
-                        if (!test_1(v, ctx)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, r.renderTemplates(templates, ctx, emitter)];
+                    case 3: return [4 /*yield*/, _d.apply(void 0, [_f.sent()])];
                     case 4:
-                        _e.sent();
-                        return [2 /*return*/];
+                        v = _f.sent();
+                        if (!test_1(v, ctx)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, r.renderTemplates(templates, ctx, emitter)];
                     case 5:
+                        _f.sent();
+                        return [2 /*return*/];
+                    case 6:
                         _b = _a.next();
                         return [3 /*break*/, 2];
-                    case 6: return [3 /*break*/, 9];
-                    case 7:
-                        e_1_1 = _e.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 9];
+                    case 7: return [3 /*break*/, 10];
                     case 8:
+                        e_1_1 = _f.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 (_b && !_b.done && (_e = _a.return)) _e.call(_a);
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 9: return [4 /*yield*/, r.renderTemplates(this.elseTemplates, ctx, emitter)];
-                    case 10:
-                        _e.sent();
+                    case 10: return [4 /*yield*/, r.renderTemplates(this.elseTemplates, ctx, emitter)];
+                    case 11:
+                        _f.sent();
                         return [2 /*return*/];
                 }
             });
@@ -6712,15 +7593,25 @@
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
-            var val;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var val, _a, outputEscape;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         if (!this.value)
                             return [2 /*return*/];
+                        _a = toValue;
                         return [4 /*yield*/, this.value.value(ctx, false)];
-                    case 1:
-                        val = _a.sent();
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [_c.sent()])];
+                    case 2:
+                        val = _c.sent();
+                        outputEscape = this.liquid.options.outputEscape;
+                        if (!(outputEscape && !((_b = this.value.filters[this.value.filters.length - 1]) === null || _b === void 0 ? void 0 : _b.raw))) return [3 /*break*/, 4];
+                        return [4 /*yield*/, outputEscape.call({ context: ctx, token: this.token, liquid: this.liquid }, val)];
+                    case 3:
+                        val = _c.sent();
+                        _c.label = 4;
+                    case 4:
                         emitter.write(val);
                         return [2 /*return*/];
                 }
@@ -6810,8 +7701,8 @@
             if (opts === void 0) { opts = {}; }
             var _this = this;
             this.renderer = new Render();
-            this.filters = {};
-            this.tags = {};
+            this.filters = Object.create(null);
+            this.tags = Object.create(null);
             this.options = normalize(opts);
             // eslint-disable-next-line deprecation/deprecation
             this.parser = new Parser(this);
@@ -6823,7 +7714,7 @@
             return parser.parse(html, filepath);
         };
         Liquid.prototype._render = function (tpl, scope, renderOptions) {
-            var ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions);
+            var ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions, { liquid: this });
             return this.renderer.renderTemplates(tpl, ctx);
         };
         Liquid.prototype.render = function (tpl, scope, renderOptions) {
@@ -6838,7 +7729,7 @@
         };
         Liquid.prototype.renderToNodeStream = function (tpl, scope, renderOptions) {
             if (renderOptions === void 0) { renderOptions = {}; }
-            var ctx = new Context(scope, this.options, renderOptions);
+            var ctx = new Context(scope, this.options, renderOptions, { liquid: this });
             return this.renderer.renderTemplatesToNodeStream(tpl, ctx);
         };
         Liquid.prototype._parseAndRender = function (html, scope, renderOptions) {
@@ -6856,10 +7747,10 @@
             return toValueSync(this._parseAndRender(html, scope, __assign(__assign({}, renderOptions), { sync: true })));
         };
         Liquid.prototype._parsePartialFile = function (file, sync, currentFile) {
-            return new Parser(this).parseFile(file, sync, LookupType.Partials, currentFile);
+            return new Parser(this).parseFile(file, sync, exports.LookupType.Partials, currentFile);
         };
         Liquid.prototype._parseLayoutFile = function (file, sync, currentFile) {
-            return new Parser(this).parseFile(file, sync, LookupType.Layouts, currentFile);
+            return new Parser(this).parseFile(file, sync, exports.LookupType.Layouts, currentFile);
         };
         Liquid.prototype._parseFile = function (file, sync, lookupType, currentFile) {
             return new Parser(this).parseFile(file, sync, lookupType, currentFile);
@@ -6911,7 +7802,7 @@
         };
         Liquid.prototype._evalValue = function (str, scope) {
             var value = new Value(str, this);
-            var ctx = scope instanceof Context ? scope : new Context(scope, this.options);
+            var ctx = scope instanceof Context ? scope : new Context(scope, this.options, {}, { liquid: this });
             return value.value(ctx);
         };
         Liquid.prototype.evalValue = function (str, scope) {
@@ -6927,6 +7818,9 @@
         Liquid.prototype.registerFilter = function (name, filter) {
             this.filters[name] = filter;
         };
+        Liquid.prototype.unregisterFilter = function (name) {
+            delete this.filters[name];
+        };
         Liquid.prototype.registerTag = function (name, tag) {
             this.tags[name] = isFunction(tag) ? tag : createTagClass(tag);
         };
@@ -7102,7 +7996,7 @@
     }());
 
     /* istanbul ignore file */
-    var version = '10.20.1';
+    var version = '10.30.1';
 
     exports.AssertionError = AssertionError;
     exports.AssignTag = default_1;
@@ -7155,6 +8049,7 @@
     exports.defaultOptions = defaultOptions;
     exports.evalQuotedToken = evalQuotedToken;
     exports.evalToken = evalToken;
+    exports.evalTokenValue = evalTokenValue;
     exports.filters = filters;
     exports.isFalsy = isFalsy;
     exports.isTruthy = isTruthy;