@skeptools/skep-organization-project 0.0.15 → 0.0.17

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

@@ -1,6 +1,6 @@
 /*
- * liquidjs@10.13.0, https://github.com/harttle/liquidjs
- * (c) 2016-2024 harttle
+ * liquidjs@10.20.1, https://github.com/harttle/liquidjs
+ * (c) 2016-2025 harttle
  * Released under the MIT License.
  */
 (function (global, factory) {
@@ -218,6 +218,10 @@
     function toValue(value) {
         return (value instanceof Drop && isFunction(value.valueOf)) ? value.valueOf() : value;
     }
+    function toNumber(value) {
+        value = Number(value);
+        return isNaN(value) ? 0 : value;
+    }
     function isNumber(value) {
         return typeof value === 'number';
     }
@@ -236,6 +240,9 @@
         // be compatible with IE 8
         return toString$1.call(value) === '[object Array]';
     }
+    function isArrayLike(value) {
+        return value && isNumber(value.length);
+    }
     function isIterable(value) {
         return isObject(value) && Symbol.iterator in value;
     }
@@ -325,15 +332,56 @@
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            return fn.apply(void 0, __spreadArray([], __read(args.map(toValue)), false));
+            return fn.call.apply(fn, __spreadArray([this], __read(args.map(toValue)), false));
         };
     }
     function escapeRegExp(text) {
         return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    }
+    /** Return an array containing unique elements from _array_. Works with nested arrays and objects. */
+    function strictUniq(array) {
+        var seen, array_1, array_1_1, element, key, e_1_1;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    seen = new Set();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    array_1 = __values(array), array_1_1 = array_1.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!array_1_1.done) return [3 /*break*/, 5];
+                    element = array_1_1.value;
+                    key = JSON.stringify(element);
+                    if (!!seen.has(key)) return [3 /*break*/, 4];
+                    seen.add(key);
+                    return [4 /*yield*/, element];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    array_1_1 = array_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
     }
 
     /**
-     * targeting ES5, extends Error won't create a proper prototype chain, need a trait to kee track of classes
+     * targeting ES5, extends Error won't create a proper prototype chain, need a trait to keep track of classes
      */
     var TRAIT = '__liquidClass__';
     var LiquidError = /** @class */ (function (_super) {
@@ -400,6 +448,22 @@
         };
         return RenderError;
     }(LiquidError));
+    var LiquidErrors = /** @class */ (function (_super) {
+        __extends(LiquidErrors, _super);
+        function LiquidErrors(errors) {
+            var _this = _super.call(this, errors[0], errors[0].token) || this;
+            _this.errors = errors;
+            _this.name = 'LiquidErrors';
+            var s = errors.length > 1 ? 's' : '';
+            _this.message = "".concat(errors.length, " error").concat(s, " found");
+            _super.prototype.update.call(_this);
+            return _this;
+        }
+        LiquidErrors.is = function (obj) {
+            return obj.name === 'LiquidErrors';
+        };
+        return LiquidErrors;
+    }(LiquidError));
     var UndefinedVariableError = /** @class */ (function (_super) {
         __extends(UndefinedVariableError, _super);
         function UndefinedVariableError(err, token) {
@@ -487,6 +551,10 @@
                 : (message || "expect ".concat(predicate, " to be true"));
             throw new AssertionError(msg);
         }
+    }
+    function assertEmpty(predicate, message) {
+        if (message === void 0) { message = "unexpected ".concat(JSON.stringify(predicate)); }
+        assert(!predicate, message);
     }
 
     var NullDrop = /** @class */ (function (_super) {
@@ -545,6 +613,9 @@
         EmptyDrop.prototype.valueOf = function () {
             return '';
         };
+        EmptyDrop.is = function (value) {
+            return value instanceof EmptyDrop;
+        };
         return EmptyDrop;
     }(Drop));
 
@@ -562,6 +633,9 @@
                 return /^\s*$/.test(value);
             return _super.prototype.equals.call(this, value);
         };
+        BlankDrop.is = function (value) {
+            return value instanceof BlankDrop;
+        };
         return BlankDrop;
     }(EmptyDrop));
 
@@ -622,7 +696,12 @@
     }(Drop));
 
     function isComparable(arg) {
-        return arg && isFunction(arg.equals);
+        return (arg &&
+            isFunction(arg.equals) &&
+            isFunction(arg.gt) &&
+            isFunction(arg.geq) &&
+            isFunction(arg.lt) &&
+            isFunction(arg.leq));
     }
 
     var nil = new NullDrop();
@@ -731,18 +810,6 @@
     }
 
     var rFormat = /%([-_0^#:]+)?(\d+)?([EO])?(.)/;
-    var monthNames = [
-        'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
-        'September', 'October', 'November', 'December'
-    ];
-    var dayNames = [
-        'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'
-    ];
-    var monthNamesShort = monthNames.map(abbr);
-    var dayNamesShort = dayNames.map(abbr);
-    function abbr(str) {
-        return str.slice(0, 3);
-    }
     // prototype extensions
     function daysInMonth(d) {
         var feb = isLeapYear(d) ? 29 : 28;
@@ -797,19 +864,7 @@
         U: 2,
         W: 2
     };
-    // default to '0'
-    var padChars = {
-        a: ' ',
-        A: ' ',
-        b: ' ',
-        B: ' ',
-        c: ' ',
-        e: ' ',
-        k: ' ',
-        l: ' ',
-        p: ' ',
-        P: ' '
-    };
+    var padSpaceChars = new Set('aAbBceklpP');
     function getTimezoneOffset(d, opts) {
         var nOffset = Math.abs(d.getTimezoneOffset());
         var h = Math.floor(nOffset / 60);
@@ -820,10 +875,10 @@
             padStart(m, 2, '0');
     }
     var formatCodes = {
-        a: function (d) { return dayNamesShort[d.getDay()]; },
-        A: function (d) { return dayNames[d.getDay()]; },
-        b: function (d) { return monthNamesShort[d.getMonth()]; },
-        B: function (d) { return monthNames[d.getMonth()]; },
+        a: function (d) { return d.getShortWeekdayName(); },
+        A: function (d) { return d.getLongWeekdayName(); },
+        b: function (d) { return d.getShortMonthName(); },
+        B: function (d) { return d.getLongMonthName(); },
         c: function (d) { return d.toLocaleString(); },
         C: function (d) { return century(d); },
         d: function (d) { return d.getDate(); },
@@ -855,12 +910,7 @@
         y: function (d) { return d.getFullYear().toString().slice(2, 4); },
         Y: function (d) { return d.getFullYear(); },
         z: getTimezoneOffset,
-        Z: function (d, opts) {
-            if (d.getTimezoneName) {
-                return d.getTimezoneName() || getTimezoneOffset(d, opts);
-            }
-            return (typeof Intl !== 'undefined' ? Intl.DateTimeFormat().resolvedOptions().timeZone : '');
-        },
+        Z: function (d, opts) { return d.getTimeZoneName() || getTimezoneOffset(d, opts); },
         't': function () { return '\t'; },
         'n': function () { return '\n'; },
         '%': function () { return '%'; }
@@ -898,7 +948,7 @@
             finally { if (e_1) throw e_1.error; }
         }
         var ret = String(convert(d, { flags: flags, width: width, modifier: modifier }));
-        var padChar = padChars[conversion] || '0';
+        var padChar = padSpaceChars.has(conversion) ? ' ' : '0';
         var padWidth = width || padWidths[conversion] || 0;
         if (flags['^'])
             ret = ret.toUpperCase();
@@ -913,9 +963,26 @@
         return padStart(ret, padWidth, padChar);
     }
 
+    function getDateTimeFormat() {
+        return (typeof Intl !== 'undefined' ? Intl.DateTimeFormat : undefined);
+    }
+
     // one minute in milliseconds
     var OneMinute = 60000;
-    var ISO8601_TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):(\d{2}))$/;
+    /**
+     * Need support both ISO8601 and RFC2822 as in major browsers & NodeJS
+     * RFC2822: https://datatracker.ietf.org/doc/html/rfc2822#section-3.3
+     */
+    var TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):?(\d{2}))$/;
+    var monthNames = [
+        'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
+        'September', 'October', 'November', 'December'
+    ];
+    var monthNamesShort = monthNames.map(function (name) { return name.slice(0, 3); });
+    var dayNames = [
+        'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'
+    ];
+    var dayNamesShort = dayNames.map(function (name) { return name.slice(0, 3); });
     /**
      * A date implementation with timezone info, just like Ruby date
      *
@@ -923,61 +990,91 @@
      * - create a Date offset by it's timezone difference, avoiding overriding a bunch of methods
      * - rewrite getTimezoneOffset() to trick strftime
      */
-    var TimezoneDate = /** @class */ (function () {
-        function TimezoneDate(init, timezone) {
-            this.date = init instanceof TimezoneDate
-                ? init.date
-                : new Date(init);
-            this.timezoneOffset = isString(timezone) ? TimezoneDate.getTimezoneOffset(timezone, this.date) : timezone;
+    var LiquidDate = /** @class */ (function () {
+        function LiquidDate(init, locale, timezone) {
+            this.locale = locale;
+            this.DateTimeFormat = getDateTimeFormat();
+            this.date = new Date(init);
+            this.timezoneFixed = timezone !== undefined;
+            if (timezone === undefined) {
+                timezone = this.date.getTimezoneOffset();
+            }
+            this.timezoneOffset = isString(timezone) ? LiquidDate.getTimezoneOffset(timezone, this.date) : timezone;
             this.timezoneName = isString(timezone) ? timezone : '';
             var diff = (this.date.getTimezoneOffset() - this.timezoneOffset) * OneMinute;
             var time = this.date.getTime() + diff;
             this.displayDate = new Date(time);
         }
-        TimezoneDate.prototype.getTime = function () {
+        LiquidDate.prototype.getTime = function () {
             return this.displayDate.getTime();
         };
-        TimezoneDate.prototype.getMilliseconds = function () {
+        LiquidDate.prototype.getMilliseconds = function () {
             return this.displayDate.getMilliseconds();
         };
-        TimezoneDate.prototype.getSeconds = function () {
+        LiquidDate.prototype.getSeconds = function () {
             return this.displayDate.getSeconds();
         };
-        TimezoneDate.prototype.getMinutes = function () {
+        LiquidDate.prototype.getMinutes = function () {
             return this.displayDate.getMinutes();
         };
-        TimezoneDate.prototype.getHours = function () {
+        LiquidDate.prototype.getHours = function () {
             return this.displayDate.getHours();
         };
-        TimezoneDate.prototype.getDay = function () {
+        LiquidDate.prototype.getDay = function () {
             return this.displayDate.getDay();
         };
-        TimezoneDate.prototype.getDate = function () {
+        LiquidDate.prototype.getDate = function () {
             return this.displayDate.getDate();
         };
-        TimezoneDate.prototype.getMonth = function () {
+        LiquidDate.prototype.getMonth = function () {
             return this.displayDate.getMonth();
         };
-        TimezoneDate.prototype.getFullYear = function () {
+        LiquidDate.prototype.getFullYear = function () {
             return this.displayDate.getFullYear();
         };
-        TimezoneDate.prototype.toLocaleString = function (locale, init) {
+        LiquidDate.prototype.toLocaleString = function (locale, init) {
             if (init === null || init === void 0 ? void 0 : init.timeZone) {
                 return this.date.toLocaleString(locale, init);
             }
             return this.displayDate.toLocaleString(locale, init);
         };
-        TimezoneDate.prototype.toLocaleTimeString = function (locale) {
+        LiquidDate.prototype.toLocaleTimeString = function (locale) {
             return this.displayDate.toLocaleTimeString(locale);
         };
-        TimezoneDate.prototype.toLocaleDateString = function (locale) {
+        LiquidDate.prototype.toLocaleDateString = function (locale) {
             return this.displayDate.toLocaleDateString(locale);
         };
-        TimezoneDate.prototype.getTimezoneOffset = function () {
+        LiquidDate.prototype.getTimezoneOffset = function () {
             return this.timezoneOffset;
         };
-        TimezoneDate.prototype.getTimezoneName = function () {
-            return this.timezoneName;
+        LiquidDate.prototype.getTimeZoneName = function () {
+            if (this.timezoneFixed)
+                return this.timezoneName;
+            if (!this.DateTimeFormat)
+                return;
+            return this.DateTimeFormat().resolvedOptions().timeZone;
+        };
+        LiquidDate.prototype.getLongMonthName = function () {
+            var _a;
+            return (_a = this.format({ month: 'long' })) !== null && _a !== void 0 ? _a : monthNames[this.getMonth()];
+        };
+        LiquidDate.prototype.getShortMonthName = function () {
+            var _a;
+            return (_a = this.format({ month: 'short' })) !== null && _a !== void 0 ? _a : monthNamesShort[this.getMonth()];
+        };
+        LiquidDate.prototype.getLongWeekdayName = function () {
+            var _a;
+            return (_a = this.format({ weekday: 'long' })) !== null && _a !== void 0 ? _a : dayNames[this.displayDate.getDay()];
+        };
+        LiquidDate.prototype.getShortWeekdayName = function () {
+            var _a;
+            return (_a = this.format({ weekday: 'short' })) !== null && _a !== void 0 ? _a : dayNamesShort[this.displayDate.getDay()];
+        };
+        LiquidDate.prototype.valid = function () {
+            return !isNaN(this.getTime());
+        };
+        LiquidDate.prototype.format = function (options) {
+            return this.DateTimeFormat && this.DateTimeFormat(this.locale, options).format(this.displayDate);
         };
         /**
          * Create a Date object fixed to it's declared Timezone. Both
@@ -992,29 +1089,46 @@
          * we create a different Date to trick strftime, it's both simpler and more performant.
          * Given that a template is expected to be parsed fewer times than rendered.
          */
-        TimezoneDate.createDateFixedToTimezone = function (dateString) {
-            var m = dateString.match(ISO8601_TIMEZONE_PATTERN);
+        LiquidDate.createDateFixedToTimezone = function (dateString, locale) {
+            var m = dateString.match(TIMEZONE_PATTERN);
             // representing a UTC timestamp
             if (m && m[1] === 'Z') {
-                return new TimezoneDate(+new Date(dateString), 0);
+                return new LiquidDate(+new Date(dateString), locale, 0);
             }
             // has a timezone specified
             if (m && m[2] && m[3] && m[4]) {
                 var _a = __read(m, 5), sign = _a[2], hours = _a[3], minutes = _a[4];
                 var offset = (sign === '+' ? -1 : 1) * (parseInt(hours, 10) * 60 + parseInt(minutes, 10));
-                return new TimezoneDate(+new Date(dateString), offset);
+                return new LiquidDate(+new Date(dateString), locale, offset);
             }
-            return new Date(dateString);
+            return new LiquidDate(dateString, locale);
         };
-        TimezoneDate.getTimezoneOffset = function (timezoneName, date) {
-            if (date === void 0) { date = new Date(); }
+        LiquidDate.getTimezoneOffset = function (timezoneName, date) {
             var localDateString = date.toLocaleString('en-US', { timeZone: timezoneName });
             var utcDateString = date.toLocaleString('en-US', { timeZone: 'UTC' });
             var localDate = new Date(localDateString);
             var utcDate = new Date(utcDateString);
             return (+utcDate - +localDate) / (60 * 1000);
         };
-        return TimezoneDate;
+        return LiquidDate;
+    }());
+
+    var Limiter = /** @class */ (function () {
+        function Limiter(resource, limit) {
+            this.base = 0;
+            this.message = "".concat(resource, " limit exceeded");
+            this.limit = limit;
+        }
+        Limiter.prototype.use = function (count) {
+            count = toNumber(count);
+            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);
+        };
+        return Limiter;
     }());
 
     var DelimitedToken = /** @class */ (function (_super) {
@@ -1123,17 +1237,6 @@
             _this.content = _this.getText();
             return _this;
         }
-        IdentifierToken.prototype.isNumber = function (allowSign) {
-            if (allowSign === void 0) { allowSign = false; }
-            var begin = allowSign && TYPES[this.input.charCodeAt(this.begin)] & SIGN
-                ? this.begin + 1
-                : this.begin;
-            for (var i = begin; i < this.end; i++) {
-                if (!(TYPES[this.input.charCodeAt(i)] & NUMBER))
-                    return false;
-            }
-            return true;
-        };
         return IdentifierToken;
     }(Token));
 
@@ -1324,9 +1427,15 @@
             _this.name = _this.tokenizer.readTagName();
             _this.tokenizer.assert(_this.name, 'illegal liquid tag syntax');
             _this.tokenizer.skipBlank();
-            _this.args = _this.tokenizer.remaining();
             return _this;
         }
+        Object.defineProperty(LiquidTagToken.prototype, "args", {
+            get: function () {
+                return this.tokenizer.input.slice(this.tokenizer.p, this.contentRange[1]);
+            },
+            enumerable: false,
+            configurable: true
+        });
         return LiquidTagToken;
     }(DelimitedToken));
 
@@ -1350,6 +1459,15 @@
         return FilteredValueToken;
     }(Token));
 
+    var polyfill = {
+        now: function () { return Date.now(); }
+    };
+    function getPerformance() {
+        return (typeof global === 'object' && global.performance) ||
+            (typeof window === 'object' && window.performance) ||
+            polyfill;
+    }
+
     var SimpleEmitter = /** @class */ (function () {
         function SimpleEmitter() {
             this.buffer = '';
@@ -1400,7 +1518,7 @@
             return emitter.stream;
         };
         Render.prototype.renderTemplates = function (templates, ctx, emitter) {
-            var templates_1, templates_1_1, tpl, html, e_1, err, e_2_1;
+            var errors, templates_1, templates_1_1, tpl, html, e_1, err, e_2_1;
             var e_2, _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -1408,6 +1526,7 @@
                         if (!emitter) {
                             emitter = ctx.opts.keepOutputType ? new KeepingTypeEmitter() : new SimpleEmitter();
                         }
+                        errors = [];
                         _b.label = 1;
                     case 1:
                         _b.trys.push([1, 8, 9, 10]);
@@ -1416,6 +1535,7 @@
                     case 2:
                         if (!!templates_1_1.done) return [3 /*break*/, 7];
                         tpl = templates_1_1.value;
+                        ctx.renderLimit.check(getPerformance().now());
                         _b.label = 3;
                     case 3:
                         _b.trys.push([3, 5, , 6]);
@@ -1426,13 +1546,17 @@
                         html = _b.sent();
                         // if not, it'll return an `html`, write to the emitter for it
                         html && emitter.write(html);
-                        if (emitter['break'] || emitter['continue'])
+                        if (ctx.breakCalled || ctx.continueCalled)
                             return [3 /*break*/, 7];
                         return [3 /*break*/, 6];
                     case 5:
                         e_1 = _b.sent();
-                        err = RenderError.is(e_1) ? e_1 : new RenderError(e_1, tpl);
-                        throw err;
+                        err = LiquidError.is(e_1) ? e_1 : new RenderError(e_1, tpl);
+                        if (ctx.opts.catchAllErrors)
+                            errors.push(err);
+                        else
+                            throw err;
+                        return [3 /*break*/, 6];
                     case 6:
                         templates_1_1 = templates_1.next();
                         return [3 /*break*/, 2];
@@ -1447,7 +1571,11 @@
                         }
                         finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
-                    case 10: return [2 /*return*/, emitter.buffer];
+                    case 10:
+                        if (errors.length) {
+                            throw new LiquidErrors(errors);
+                        }
+                        return [2 /*return*/, emitter.buffer];
                 }
             });
         };
@@ -1607,6 +1735,7 @@
                     return [4 /*yield*/, evalToken(token.rhs, ctx)];
                 case 2:
                     high = _a.sent();
+                    ctx.memoryLimit.use(high - low + 1);
                     return [2 /*return*/, range(+low, +high + 1)];
             }
         });
@@ -1670,6 +1799,7 @@
         return !isFalsy(val, ctx);
     }
     function isFalsy(val, ctx) {
+        val = toValue(val);
         if (ctx.opts.jsTruthy) {
             return !val;
         }
@@ -1737,6 +1867,9 @@
         if (lhs.length !== rhs.length)
             return false;
         return !lhs.some(function (value, i) { return !equals(value, rhs[i]); });
+    }
+    function arrayIncludes(arr, item) {
+        return arr.some(function (value) { return equals(value, item); });
     }
 
     var Node = /** @class */ (function () {
@@ -1941,22 +2074,30 @@
         '&#39;': "'"
     };
     function escape(str) {
-        return stringify(str).replace(/&|<|>|"|'/g, function (m) { return escapeMap[m]; });
+        str = stringify(str);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(/&|<|>|"|'/g, function (m) { return escapeMap[m]; });
     }
     function xml_escape(str) {
-        return escape(str);
+        return escape.call(this, str);
     }
     function unescape(str) {
-        return stringify(str).replace(/&(amp|lt|gt|#34|#39);/g, function (m) { return unescapeMap[m]; });
+        str = stringify(str);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(/&(amp|lt|gt|#34|#39);/g, function (m) { return unescapeMap[m]; });
     }
     function escape_once(str) {
-        return escape(unescape(stringify(str)));
+        return escape.call(this, unescape.call(this, str));
     }
     function newline_to_br(v) {
-        return stringify(v).replace(/\r?\n/gm, '<br />\n');
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(/\r?\n/gm, '<br />\n');
     }
     function strip_html(v) {
-        return stringify(v).replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<.*?>|<!--[\s\S]*?-->/g, '');
+        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 htmlFilters = /*#__PURE__*/Object.freeze({
@@ -1968,18 +2109,84 @@
         strip_html: strip_html
     });
 
+    var MapFS = /** @class */ (function () {
+        function MapFS(mapping) {
+            this.mapping = mapping;
+            this.sep = '/';
+        }
+        MapFS.prototype.exists = function (filepath) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.existsSync(filepath)];
+                });
+            });
+        };
+        MapFS.prototype.existsSync = function (filepath) {
+            return !isNil(this.mapping[filepath]);
+        };
+        MapFS.prototype.readFile = function (filepath) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.readFileSync(filepath)];
+                });
+            });
+        };
+        MapFS.prototype.readFileSync = function (filepath) {
+            var content = this.mapping[filepath];
+            if (isNil(content))
+                throw new Error("ENOENT: ".concat(filepath));
+            return content;
+        };
+        MapFS.prototype.dirname = function (filepath) {
+            var segments = filepath.split(this.sep);
+            segments.pop();
+            return segments.join(this.sep);
+        };
+        MapFS.prototype.resolve = function (dir, file, ext) {
+            var e_1, _a;
+            file += ext;
+            if (dir === '.')
+                return file;
+            var segments = dir.split(/\/+/);
+            try {
+                for (var _b = __values(file.split(this.sep)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var segment = _c.value;
+                    if (segment === '.' || segment === '')
+                        continue;
+                    else if (segment === '..') {
+                        if (segments.length > 1 || segments[0] !== '')
+                            segments.pop();
+                    }
+                    else
+                        segments.push(segment);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return segments.join(this.sep);
+        };
+        return MapFS;
+    }());
+
     var defaultOptions = {
         root: ['.'],
         layouts: ['.'],
         partials: ['.'],
         relativeReference: true,
         jekyllInclude: false,
+        keyValueSeparator: ':',
         cache: undefined,
         extname: '',
         fs: fs,
         dynamicPartials: true,
         jsTruthy: false,
         dateFormat: '%A, %B %-e, %Y at %-l:%M %P %z',
+        locale: '',
         trimTagRight: false,
         trimTagLeft: false,
         trimOutputRight: false,
@@ -1996,9 +2203,13 @@
         lenientIf: false,
         globals: {},
         keepOutputType: false,
-        operators: defaultOperators
+        operators: defaultOperators,
+        memoryLimit: Infinity,
+        parseLimit: Infinity,
+        renderLimit: Infinity
     };
     function normalize(options) {
+        var _a, _b;
         if (options.hasOwnProperty('root')) {
             if (!options.hasOwnProperty('partials'))
                 options.partials = options.root;
@@ -2024,6 +2235,14 @@
         options.partials = normalizeDirectoryList(options.partials);
         options.layouts = normalizeDirectoryList(options.layouts);
         options.outputEscape = options.outputEscape && getOutputEscapeFunction(options.outputEscape);
+        if (!options.locale) {
+            options.locale = (_b = (_a = getDateTimeFormat()) === null || _a === void 0 ? void 0 : _a().resolvedOptions().locale) !== null && _b !== void 0 ? _b : 'en-US';
+        }
+        if (options.templates) {
+            options.fs = new MapFS(options.templates);
+            options.relativeReference = true;
+            options.root = options.partials = options.layouts = '.';
+        }
         return options;
     }
     function getOutputEscapeFunction(nameOrFunction) {
@@ -2161,9 +2380,7 @@
             this.skipBlank();
             if (this.end())
                 return null;
-            this.assert(this.peek() === '|', "expected \"|\" before filter");
-            this.p++;
-            var begin = this.p;
+            this.assert(this.read() === '|', "expected \"|\" before filter");
             var name = this.readIdentifier();
             if (!name.size()) {
                 this.assert(this.end(), "expected filter name");
@@ -2184,7 +2401,7 @@
             else {
                 throw this.error('expected ":" after filter name');
             }
-            return new FilterToken(name.getText(), args, this.input, begin, this.p, this.file);
+            return new FilterToken(name.getText(), args, this.input, name.begin, this.p, this.file);
         };
         Tokenizer.prototype.readFilterArg = function () {
             var key = this.readValue();
@@ -2228,7 +2445,6 @@
             return new HTMLToken(this.input, begin, this.p, this.file);
         };
         Tokenizer.prototype.readTagToken = function (options) {
-            if (options === void 0) { options = defaultOptions; }
             var _a = this, file = _a.file, input = _a.input;
             var begin = this.p;
             if (this.readToDelimiter(options.tagDelimiterRight) === -1) {
@@ -2364,7 +2580,7 @@
                 return;
             var value;
             this.skipBlank();
-            var sep = jekyllStyle ? '=' : ':';
+            var sep = isString(jekyllStyle) ? jekyllStyle : (jekyllStyle ? '=' : ':');
             if (this.peek() === sep) {
                 ++this.p;
                 value = this.readValue();
@@ -2381,6 +2597,9 @@
         Tokenizer.prototype.end = function () {
             return this.p >= this.N;
         };
+        Tokenizer.prototype.read = function () {
+            return this.input[this.p++];
+        };
         Tokenizer.prototype.readTo = function (end) {
             while (this.p < this.N) {
                 ++this.p;
@@ -2624,10 +2843,10 @@
      *    hash['reversed'] === undefined
      */
     var Hash = /** @class */ (function () {
-        function Hash(markup, jekyllStyle) {
+        function Hash(input, jekyllStyle) {
             var e_1, _a;
             this.hash = {};
-            var tokenizer = new Tokenizer(markup, {});
+            var tokenizer = input instanceof Tokenizer ? input : new Tokenizer(input, {});
             try {
                 for (var _b = __values(tokenizer.readHashes(jekyllStyle)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var hash = _c.value;
@@ -2704,7 +2923,7 @@
                 var hash;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
-                        case 0: return [4 /*yield*/, new Hash(this.token.args).render(ctx)];
+                        case 0: return [4 /*yield*/, new Hash(this.token.args, ctx.opts.keyValueSeparator).render(ctx)];
                         case 1:
                             hash = (_a.sent());
                             return [4 /*yield*/, options.render.call(this, ctx, emitter, hash)];
@@ -2721,13 +2940,14 @@
     }
 
     var Filter = /** @class */ (function () {
-        function Filter(name, options, args, liquid) {
-            this.name = name;
+        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 = args;
+            this.args = token.args;
             this.liquid = liquid;
         }
         Filter.prototype.render = function (value, context) {
@@ -2772,7 +2992,7 @@
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 10: return [4 /*yield*/, this.handler.apply({ context: context, liquid: this.liquid }, __spreadArray([value], __read(argv), false))];
+                    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()];
                 }
             });
@@ -2791,10 +3011,7 @@
                 ? new Tokenizer(input, liquid.options.operators).readFilteredValue()
                 : input;
             this.initial = token.initial;
-            this.filters = token.filters.map(function (_a) {
-                var name = _a.name, args = _a.args;
-                return new Filter(name, _this.getFilter(liquid, name), args, liquid);
-            });
+            this.filters = token.filters.map(function (token) { return new Filter(token, _this.getFilter(liquid, token.name), liquid); });
         }
         Value.prototype.value = function (ctx, lenient) {
             var val, _a, _b, filter, e_1_1;
@@ -2855,7 +3072,8 @@
             var filters = _this.value.filters;
             var outputEscape = liquid.options.outputEscape;
             if (!((_a = filters[filters.length - 1]) === null || _a === void 0 ? void 0 : _a.raw) && outputEscape) {
-                filters.push(new Filter(toString.call(outputEscape), outputEscape, [], liquid));
+                var token_1 = new FilterToken(toString.call(outputEscape), [], '', 0, 0);
+                filters.push(new Filter(token_1, outputEscape, liquid));
             }
             return _this;
         }
@@ -2871,6 +3089,16 @@
                 }
             });
         };
+        Output.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return Output;
     }(TemplateImpl));
 
@@ -2890,87 +3118,759 @@
         return HTML;
     }(TemplateImpl));
 
-    var LookupType;
-    (function (LookupType) {
-        LookupType["Partials"] = "partials";
-        LookupType["Layouts"] = "layouts";
-        LookupType["Root"] = "root";
-    })(LookupType || (LookupType = {}));
-    var Loader = /** @class */ (function () {
-        function Loader(options) {
-            this.options = options;
-            if (options.relativeReference) {
-                var sep = options.fs.sep;
-                assert(sep, '`fs.sep` is required for relative reference');
-                var rRelativePath_1 = new RegExp(['.' + sep, '..' + sep, './', '../'].map(function (prefix) { return escapeRegex(prefix); }).join('|'));
-                this.shouldLoadRelative = function (referencedFile) { return rRelativePath_1.test(referencedFile); };
+    /**
+     * A variable's segments and location, which can be coerced to a string.
+     */
+    var Variable = /** @class */ (function () {
+        function Variable(segments, location) {
+            this.segments = segments;
+            this.location = location;
+        }
+        Variable.prototype.toString = function () {
+            return segmentsString(this.segments, true);
+        };
+        /** Return this variable's segments as an array, possibly with nested arrays for nested paths. */
+        Variable.prototype.toArray = function () {
+            function _visit() {
+                var _i, segments_1, segments_1_1, segment, e_1_1;
+                var e_1, _a;
+                var segments = [];
+                for (_i = 0; _i < arguments.length; _i++) {
+                    segments[_i] = arguments[_i];
+                }
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 7, 8, 9]);
+                            segments_1 = __values(segments), segments_1_1 = segments_1.next();
+                            _b.label = 1;
+                        case 1:
+                            if (!!segments_1_1.done) return [3 /*break*/, 6];
+                            segment = segments_1_1.value;
+                            if (!(segment instanceof Variable)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, Array.from(_visit.apply(void 0, __spreadArray([], __read(segment.segments), false)))];
+                        case 2:
+                            _b.sent();
+                            return [3 /*break*/, 5];
+                        case 3: return [4 /*yield*/, segment];
+                        case 4:
+                            _b.sent();
+                            _b.label = 5;
+                        case 5:
+                            segments_1_1 = segments_1.next();
+                            return [3 /*break*/, 1];
+                        case 6: return [3 /*break*/, 9];
+                        case 7:
+                            e_1_1 = _b.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 9];
+                        case 8:
+                            try {
+                                if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                            return [7 /*endfinally*/];
+                        case 9: return [2 /*return*/];
+                    }
+                });
+            }
+            return Array.from(_visit.apply(void 0, __spreadArray([], __read(this.segments), false)));
+        };
+        return Variable;
+    }());
+    /**
+     * Group variables by the string representation of their root segment.
+     */
+    var VariableMap = /** @class */ (function () {
+        function VariableMap() {
+            this.map = new Map();
+        }
+        VariableMap.prototype.get = function (key) {
+            var k = segmentsString([key.segments[0]]);
+            if (!this.map.has(k)) {
+                this.map.set(k, []);
+            }
+            return this.map.get(k);
+        };
+        VariableMap.prototype.has = function (key) {
+            return this.map.has(segmentsString([key.segments[0]]));
+        };
+        VariableMap.prototype.push = function (variable) {
+            this.get(variable).push(variable);
+        };
+        VariableMap.prototype.asObject = function () {
+            return Object.fromEntries(this.map);
+        };
+        return VariableMap;
+    }());
+    var defaultStaticAnalysisOptions = {
+        partials: true
+    };
+    function _analyze(templates, partials, sync) {
+        function updateVariables(variable, scope) {
+            var e_3, _a;
+            variables.push(variable);
+            var aliased = scope.alias(variable);
+            if (aliased !== undefined) {
+                var root = aliased.segments[0];
+                // TODO: What if a a template renders a rendered template? Do we need scope.parent?
+                if (isString(root) && !rootScope.has(root)) {
+                    globals.push(aliased);
+                }
             }
             else {
-                this.shouldLoadRelative = function (referencedFile) { return false; };
+                var root = variable.segments[0];
+                if (isString(root) && !scope.has(root)) {
+                    globals.push(variable);
+                }
+            }
+            try {
+                // Recurse for nested Variables
+                for (var _b = __values(variable.segments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var segment = _c.value;
+                    if (segment instanceof Variable) {
+                        updateVariables(segment, scope);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_3) throw e_3.error; }
             }
-            this.contains = this.options.fs.contains || (function () { return true; });
         }
-        Loader.prototype.lookup = function (file, type, sync, currentFile) {
-            var fs, dirs, _a, _b, filepath, _c, e_1_1;
-            var e_1, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+        function visit(template, scope) {
+            var _a, _b, arg, _c, _d, variable, _e, _f, ident, _g, row, col, partial, _h, _j, child, e_4_1, partialScopeNames, partialScope, _k, _l, name_1, _m, alias, argument, variables_1, _o, _p, child, e_5_1, _q, _r, child, e_6_1;
+            var e_7, _s, e_8, _t, e_9, _u, e_4, _v, e_10, _w, e_5, _x, e_6, _y;
+            return __generator(this, function (_z) {
+                switch (_z.label) {
                     case 0:
-                        fs = this.options.fs;
-                        dirs = this.options[type];
-                        _e.label = 1;
+                        if (template.arguments) {
+                            try {
+                                for (_a = __values(template.arguments()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                    arg = _b.value;
+                                    try {
+                                        for (_c = (e_8 = void 0, __values(extractVariables(arg))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                            variable = _d.value;
+                                            updateVariables(variable, scope);
+                                        }
+                                    }
+                                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                                    finally {
+                                        try {
+                                            if (_d && !_d.done && (_t = _c.return)) _t.call(_c);
+                                        }
+                                        finally { if (e_8) throw e_8.error; }
+                                    }
+                                }
+                            }
+                            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                            finally {
+                                try {
+                                    if (_b && !_b.done && (_s = _a.return)) _s.call(_a);
+                                }
+                                finally { if (e_7) throw e_7.error; }
+                            }
+                        }
+                        if (template.localScope) {
+                            try {
+                                for (_e = __values(template.localScope()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    ident = _f.value;
+                                    scope.add(ident.content);
+                                    scope.deleteAlias(ident.content);
+                                    _g = __read(ident.getPosition(), 2), row = _g[0], col = _g[1];
+                                    locals.push(new Variable([ident.content], { row: row, col: col, file: ident.file }));
+                                }
+                            }
+                            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_u = _e.return)) _u.call(_e);
+                                }
+                                finally { if (e_9) throw e_9.error; }
+                            }
+                        }
+                        if (!template.children) return [3 /*break*/, 30];
+                        if (!template.partialScope) return [3 /*break*/, 20];
+                        partial = template.partialScope();
+                        if (!(partial === undefined)) return [3 /*break*/, 10];
+                        _z.label = 1;
                     case 1:
-                        _e.trys.push([1, 8, 9, 10]);
-                        _a = __values(this.candidates(file, dirs, currentFile, type !== LookupType.Root)), _b = _a.next();
-                        _e.label = 2;
+                        _z.trys.push([1, 7, 8, 9]);
+                        return [4 /*yield*/, template.children(partials, sync)];
                     case 2:
-                        if (!!_b.done) return [3 /*break*/, 7];
-                        filepath = _b.value;
-                        if (!sync) return [3 /*break*/, 3];
-                        _c = fs.existsSync(filepath);
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, fs.exists(filepath)];
+                        _h = __values.apply(void 0, [(_z.sent())]), _j = _h.next();
+                        _z.label = 3;
+                    case 3:
+                        if (!!_j.done) return [3 /*break*/, 6];
+                        child = _j.value;
+                        return [4 /*yield*/, visit(child, scope)];
                     case 4:
-                        _c = _e.sent();
-                        _e.label = 5;
+                        _z.sent();
+                        _z.label = 5;
                     case 5:
-                        if (_c)
-                            return [2 /*return*/, filepath];
-                        _e.label = 6;
-                    case 6:
-                        _b = _a.next();
-                        return [3 /*break*/, 2];
-                    case 7: return [3 /*break*/, 10];
+                        _j = _h.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_4_1 = _z.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 9];
                     case 8:
-                        e_1_1 = _e.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
                         try {
-                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                            if (_j && !_j.done && (_v = _h.return)) _v.call(_h);
                         }
-                        finally { if (e_1) throw e_1.error; }
+                        finally { if (e_4) throw e_4.error; }
                         return [7 /*endfinally*/];
-                    case 10: throw this.lookupError(file, dirs);
-                }
-            });
-        };
-        Loader.prototype.candidates = function (file, dirs, currentFile, enforceRoot) {
-            var _a, fs, extname, referenced, dirs_1, dirs_1_1, dir, e_2_1, dirs_2, dirs_2_1, dir, referenced, e_3_1, filepath;
-            var e_2, _b, e_3, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _a = this.options, fs = _a.fs, extname = _a.extname;
-                        if (!(this.shouldLoadRelative(file) && currentFile)) return [3 /*break*/, 8];
-                        referenced = fs.resolve(this.dirname(currentFile), file, extname);
-                        _d.label = 1;
-                    case 1:
-                        _d.trys.push([1, 6, 7, 8]);
-                        dirs_1 = __values(dirs), dirs_1_1 = dirs_1.next();
-                        _d.label = 2;
-                    case 2:
-                        if (!!dirs_1_1.done) return [3 /*break*/, 5];
+                    case 9: return [2 /*return*/];
+                    case 10:
+                        if (seen.has(partial.name))
+                            return [2 /*return*/];
+                        partialScopeNames = new Set();
+                        partialScope = partial.isolated
+                            ? new DummyScope(partialScopeNames)
+                            : scope.push(partialScopeNames);
+                        try {
+                            for (_k = __values(partial.scope), _l = _k.next(); !_l.done; _l = _k.next()) {
+                                name_1 = _l.value;
+                                if (isString(name_1)) {
+                                    partialScopeNames.add(name_1);
+                                }
+                                else {
+                                    _m = __read(name_1, 2), alias = _m[0], argument = _m[1];
+                                    partialScopeNames.add(alias);
+                                    variables_1 = Array.from(extractVariables(argument));
+                                    if (variables_1.length) {
+                                        partialScope.setAlias(alias, variables_1[0].segments);
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        finally {
+                            try {
+                                if (_l && !_l.done && (_w = _k.return)) _w.call(_k);
+                            }
+                            finally { if (e_10) throw e_10.error; }
+                        }
+                        _z.label = 11;
+                    case 11:
+                        _z.trys.push([11, 17, 18, 19]);
+                        return [4 /*yield*/, template.children(partials, sync)];
+                    case 12:
+                        _o = __values.apply(void 0, [(_z.sent())]), _p = _o.next();
+                        _z.label = 13;
+                    case 13:
+                        if (!!_p.done) return [3 /*break*/, 16];
+                        child = _p.value;
+                        return [4 /*yield*/, visit(child, partialScope)];
+                    case 14:
+                        _z.sent();
+                        seen.add(partial.name);
+                        _z.label = 15;
+                    case 15:
+                        _p = _o.next();
+                        return [3 /*break*/, 13];
+                    case 16: return [3 /*break*/, 19];
+                    case 17:
+                        e_5_1 = _z.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 19];
+                    case 18:
+                        try {
+                            if (_p && !_p.done && (_x = _o.return)) _x.call(_o);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 19:
+                        partialScope.pop();
+                        return [3 /*break*/, 30];
+                    case 20:
+                        if (template.blockScope) {
+                            scope.push(new Set(template.blockScope()));
+                        }
+                        _z.label = 21;
+                    case 21:
+                        _z.trys.push([21, 27, 28, 29]);
+                        return [4 /*yield*/, template.children(partials, sync)];
+                    case 22:
+                        _q = __values.apply(void 0, [(_z.sent())]), _r = _q.next();
+                        _z.label = 23;
+                    case 23:
+                        if (!!_r.done) return [3 /*break*/, 26];
+                        child = _r.value;
+                        return [4 /*yield*/, visit(child, scope)];
+                    case 24:
+                        _z.sent();
+                        _z.label = 25;
+                    case 25:
+                        _r = _q.next();
+                        return [3 /*break*/, 23];
+                    case 26: return [3 /*break*/, 29];
+                    case 27:
+                        e_6_1 = _z.sent();
+                        e_6 = { error: e_6_1 };
+                        return [3 /*break*/, 29];
+                    case 28:
+                        try {
+                            if (_r && !_r.done && (_y = _q.return)) _y.call(_q);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                        return [7 /*endfinally*/];
+                    case 29:
+                        if (template.blockScope) {
+                            scope.pop();
+                        }
+                        _z.label = 30;
+                    case 30: return [2 /*return*/];
+                }
+            });
+        }
+        var variables, globals, locals, rootScope, seen, templates_1, templates_1_1, template, e_2_1;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    variables = new VariableMap();
+                    globals = new VariableMap();
+                    locals = new VariableMap();
+                    rootScope = new DummyScope(new Set());
+                    seen = new Set();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    templates_1 = __values(templates), templates_1_1 = templates_1.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!templates_1_1.done) return [3 /*break*/, 5];
+                    template = templates_1_1.value;
+                    return [4 /*yield*/, visit(template, rootScope)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    templates_1_1 = templates_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (templates_1_1 && !templates_1_1.done && (_a = templates_1.return)) _a.call(templates_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/, {
+                        variables: variables.asObject(),
+                        globals: globals.asObject(),
+                        locals: locals.asObject()
+                    }];
+            }
+        });
+    }
+    /**
+     * Statically analyze a template and report variable usage.
+     */
+    function analyze(template, options) {
+        if (options === void 0) { options = {}; }
+        var opts = __assign(__assign({}, defaultStaticAnalysisOptions), options);
+        return toPromise(_analyze(template, opts.partials, false));
+    }
+    /**
+     * Statically analyze a template and report variable usage.
+     */
+    function analyzeSync(template, options) {
+        if (options === void 0) { options = {}; }
+        var opts = __assign(__assign({}, defaultStaticAnalysisOptions), options);
+        return toValueSync(_analyze(template, opts.partials, true));
+    }
+    /**
+     * A stack to manage scopes while traversing templates during static analysis.
+     */
+    var DummyScope = /** @class */ (function () {
+        function DummyScope(globals) {
+            this.stack = [{ names: globals, aliases: new Map() }];
+        }
+        /** Return true if `name` is in scope.  */
+        DummyScope.prototype.has = function (name) {
+            var e_11, _a;
+            try {
+                for (var _b = __values(this.stack), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var scope = _c.value;
+                    if (scope.names.has(name)) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+            return false;
+        };
+        DummyScope.prototype.push = function (scope) {
+            this.stack.push({ names: scope, aliases: new Map() });
+            return this;
+        };
+        DummyScope.prototype.pop = function () {
+            var _a;
+            return (_a = this.stack.pop()) === null || _a === void 0 ? void 0 : _a.names;
+        };
+        // Add a name to the template scope.
+        DummyScope.prototype.add = function (name) {
+            this.stack[0].names.add(name);
+        };
+        /** Return the variable that `variable` aliases, or `variable` if it doesn't alias anything. */
+        DummyScope.prototype.alias = function (variable) {
+            var root = variable.segments[0];
+            if (!isString(root))
+                return undefined;
+            var alias = this.getAlias(root);
+            if (alias === undefined)
+                return undefined;
+            return new Variable(__spreadArray(__spreadArray([], __read(alias), false), __read(variable.segments.slice(1)), false), variable.location);
+        };
+        // TODO: `from` could be a path with multiple segments, like `include.x`.
+        DummyScope.prototype.setAlias = function (from, to) {
+            this.stack[this.stack.length - 1].aliases.set(from, to);
+        };
+        DummyScope.prototype.deleteAlias = function (name) {
+            this.stack[this.stack.length - 1].aliases.delete(name);
+        };
+        DummyScope.prototype.getAlias = function (name) {
+            var e_12, _a;
+            try {
+                for (var _b = __values(this.stack), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var scope = _c.value;
+                    if (scope.aliases.has(name)) {
+                        return scope.aliases.get(name);
+                    }
+                    // If a scope has defined `name`, then it masks aliases in parent scopes.
+                    if (scope.names.has(name)) {
+                        return undefined;
+                    }
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+            return undefined;
+        };
+        return DummyScope;
+    }());
+    function extractVariables(value) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isValueToken(value)) return [3 /*break*/, 2];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(value))];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 2:
+                    if (!(value instanceof Value)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, __values(extractFilteredValueVariables(value))];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4: return [2 /*return*/];
+            }
+        });
+    }
+    function extractFilteredValueVariables(value) {
+        var _a, _b, token, e_13_1, _c, _d, filter, _e, _f, arg, e_14_1, e_15_1;
+        var e_13, _g, e_15, _h, e_14, _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    _k.trys.push([0, 5, 6, 7]);
+                    _a = __values(value.initial.postfix), _b = _a.next();
+                    _k.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    token = _b.value;
+                    if (!isValueToken(token)) return [3 /*break*/, 3];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(token))];
+                case 2:
+                    _k.sent();
+                    _k.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_13_1 = _k.sent();
+                    e_13 = { error: e_13_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                    return [7 /*endfinally*/];
+                case 7:
+                    _k.trys.push([7, 20, 21, 22]);
+                    _c = __values(value.filters), _d = _c.next();
+                    _k.label = 8;
+                case 8:
+                    if (!!_d.done) return [3 /*break*/, 19];
+                    filter = _d.value;
+                    _k.label = 9;
+                case 9:
+                    _k.trys.push([9, 16, 17, 18]);
+                    _e = (e_14 = void 0, __values(filter.args)), _f = _e.next();
+                    _k.label = 10;
+                case 10:
+                    if (!!_f.done) return [3 /*break*/, 15];
+                    arg = _f.value;
+                    if (!(isKeyValuePair(arg) && arg[1])) return [3 /*break*/, 12];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(arg[1]))];
+                case 11:
+                    _k.sent();
+                    return [3 /*break*/, 14];
+                case 12:
+                    if (!isValueToken(arg)) return [3 /*break*/, 14];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(arg))];
+                case 13:
+                    _k.sent();
+                    _k.label = 14;
+                case 14:
+                    _f = _e.next();
+                    return [3 /*break*/, 10];
+                case 15: return [3 /*break*/, 18];
+                case 16:
+                    e_14_1 = _k.sent();
+                    e_14 = { error: e_14_1 };
+                    return [3 /*break*/, 18];
+                case 17:
+                    try {
+                        if (_f && !_f.done && (_j = _e.return)) _j.call(_e);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                    return [7 /*endfinally*/];
+                case 18:
+                    _d = _c.next();
+                    return [3 /*break*/, 8];
+                case 19: return [3 /*break*/, 22];
+                case 20:
+                    e_15_1 = _k.sent();
+                    e_15 = { error: e_15_1 };
+                    return [3 /*break*/, 22];
+                case 21:
+                    try {
+                        if (_d && !_d.done && (_h = _c.return)) _h.call(_c);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                    return [7 /*endfinally*/];
+                case 22: return [2 /*return*/];
+            }
+        });
+    }
+    function extractValueTokenVariables(token) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isRangeToken(token)) return [3 /*break*/, 3];
+                    return [5 /*yield**/, __values(extractValueTokenVariables(token.lhs))];
+                case 1:
+                    _a.sent();
+                    return [5 /*yield**/, __values(extractValueTokenVariables(token.rhs))];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 3:
+                    if (!isPropertyAccessToken(token)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, extractPropertyAccessVariable(token)];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/];
+            }
+        });
+    }
+    function extractPropertyAccessVariable(token) {
+        var e_16, _a;
+        var segments = [];
+        // token is not guaranteed to have `file` set. We'll try to get it from a prop if not.
+        var file = token.file;
+        // Here we're flattening the first segment of a path if it is a nested path.
+        var root = token.props[0];
+        file = file || root.file;
+        if (isQuotedToken(root) || isNumberToken(root) || isWordToken(root)) {
+            segments.push(root.content);
+        }
+        else if (isPropertyAccessToken(root)) {
+            // Flatten paths that start with a nested path.
+            segments.push.apply(segments, __spreadArray([], __read(extractPropertyAccessVariable(root).segments), false));
+        }
+        try {
+            for (var _b = __values(token.props.slice(1)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var prop = _c.value;
+                file = file || prop.file;
+                if (isQuotedToken(prop) || isNumberToken(prop) || isWordToken(prop)) {
+                    segments.push(prop.content);
+                }
+                else if (isPropertyAccessToken(prop)) {
+                    segments.push(extractPropertyAccessVariable(prop));
+                }
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+        var _d = __read(token.getPosition(), 2), row = _d[0], col = _d[1];
+        return new Variable(segments, {
+            row: row,
+            col: col,
+            file: file
+        });
+    }
+    // This is used to detect segments that can be represented with dot notation
+    // when creating a string representation of VariableSegments.
+    var RE_PROPERTY = /^[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*$/;
+    /**
+     * Return a string representation of segments using dot notation where possible.
+     * @param segments - The property names and array indices that make up a path to a variable.
+     * @param bracketedRoot - If false (the default), don't surround the root segment with square brackets.
+     */
+    function segmentsString(segments, bracketedRoot) {
+        var e_17, _a;
+        if (bracketedRoot === void 0) { bracketedRoot = false; }
+        var buf = [];
+        var root = segments[0];
+        if (isString(root)) {
+            if (!bracketedRoot || root.match(RE_PROPERTY)) {
+                buf.push("".concat(root));
+            }
+            else {
+                buf.push("['".concat(root, "']"));
+            }
+        }
+        try {
+            for (var _b = __values(segments.slice(1)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var segment = _c.value;
+                if (segment instanceof Variable) {
+                    buf.push("[".concat(segmentsString(segment.segments), "]"));
+                }
+                else if (isString(segment)) {
+                    if (segment.match(RE_PROPERTY)) {
+                        buf.push(".".concat(segment));
+                    }
+                    else {
+                        buf.push("['".concat(segment, "']"));
+                    }
+                }
+                else {
+                    buf.push("[".concat(segment, "]"));
+                }
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        return buf.join('');
+    }
+
+    var LookupType;
+    (function (LookupType) {
+        LookupType["Partials"] = "partials";
+        LookupType["Layouts"] = "layouts";
+        LookupType["Root"] = "root";
+    })(LookupType || (LookupType = {}));
+    var Loader = /** @class */ (function () {
+        function Loader(options) {
+            this.options = options;
+            if (options.relativeReference) {
+                var sep = options.fs.sep;
+                assert(sep, '`fs.sep` is required for relative reference');
+                var rRelativePath_1 = new RegExp(['.' + sep, '..' + sep, './', '../'].map(function (prefix) { return escapeRegex(prefix); }).join('|'));
+                this.shouldLoadRelative = function (referencedFile) { return rRelativePath_1.test(referencedFile); };
+            }
+            else {
+                this.shouldLoadRelative = function (_referencedFile) { return false; };
+            }
+            this.contains = this.options.fs.contains || (function () { return true; });
+        }
+        Loader.prototype.lookup = function (file, type, sync, currentFile) {
+            var fs, dirs, _a, _b, filepath, _c, e_1_1;
+            var e_1, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        fs = this.options.fs;
+                        dirs = this.options[type];
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 8, 9, 10]);
+                        _a = __values(this.candidates(file, dirs, currentFile, type !== LookupType.Root)), _b = _a.next();
+                        _e.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        filepath = _b.value;
+                        if (!sync) return [3 /*break*/, 3];
+                        _c = fs.existsSync(filepath);
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, fs.exists(filepath)];
+                    case 4:
+                        _c = _e.sent();
+                        _e.label = 5;
+                    case 5:
+                        if (_c)
+                            return [2 /*return*/, filepath];
+                        _e.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _e.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: throw this.lookupError(file, dirs);
+                }
+            });
+        };
+        Loader.prototype.candidates = function (file, dirs, currentFile, enforceRoot) {
+            var _a, fs, extname, referenced, dirs_1, dirs_1_1, dir, e_2_1, dirs_2, dirs_2_1, dir, referenced, e_3_1, filepath;
+            var e_2, _b, e_3, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = this.options, fs = _a.fs, extname = _a.extname;
+                        if (!(this.shouldLoadRelative(file) && currentFile)) return [3 /*break*/, 8];
+                        referenced = fs.resolve(this.dirname(currentFile), file, extname);
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        dirs_1 = __values(dirs), dirs_1_1 = dirs_1.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!dirs_1_1.done) return [3 /*break*/, 5];
                         dir = dirs_1_1.value;
                         if (!(!enforceRoot || this.contains(dir, referenced))) return [3 /*break*/, 4];
                         // the relatively referenced file is within one of root dirs
@@ -3053,8 +3953,11 @@
             this.fs = this.liquid.options.fs;
             this.parseFile = this.cache ? this._parseFileCached : this._parseFile;
             this.loader = new Loader(this.liquid.options);
+            this.parseLimit = new Limiter('parse length', liquid.options.parseLimit);
         }
         Parser.prototype.parse = function (html, filepath) {
+            html = String(html);
+            this.parseLimit.use(html.length);
             var tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath);
             var tokens = tokenizer.readTopLevelTokens(this.liquid.options);
             return this.parseTokens(tokens);
@@ -3062,9 +3965,20 @@
         Parser.prototype.parseTokens = function (tokens) {
             var token;
             var templates = [];
+            var errors = [];
             while ((token = tokens.shift())) {
-                templates.push(this.parseToken(token, tokens));
+                try {
+                    templates.push(this.parseToken(token, tokens));
+                }
+                catch (err) {
+                    if (this.liquid.options.catchAllErrors)
+                        errors.push(err);
+                    else
+                        throw err;
+                }
             }
+            if (errors.length)
+                throw new LiquidErrors(errors);
             return templates;
         };
         Parser.prototype.parseToken = function (token, remainTokens) {
@@ -3072,7 +3986,7 @@
                 if (isTagToken(token)) {
                     var TagClass = this.liquid.tags[token.name];
                     assert(TagClass, "tag \"".concat(token.name, "\" not found"));
-                    return new TagClass(token, remainTokens, this.liquid);
+                    return new TagClass(token, remainTokens, this.liquid, this);
                 }
                 if (isOutputToken(token)) {
                     return new Output(token, this.liquid);
@@ -3128,22 +4042,22 @@
             });
         };
         Parser.prototype._parseFile = function (file, sync, type, currentFile) {
-            var filepath, _a, _b, _c;
+            var filepath, _a, _b;
             if (type === void 0) { type = LookupType.Root; }
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0: return [4 /*yield*/, this.loader.lookup(file, type, sync, currentFile)];
                     case 1:
-                        filepath = _d.sent();
-                        _b = (_a = this.liquid).parse;
+                        filepath = _c.sent();
+                        _a = this.parse;
                         if (!sync) return [3 /*break*/, 2];
-                        _c = this.fs.readFileSync(filepath);
+                        _b = this.fs.readFileSync(filepath);
                         return [3 /*break*/, 4];
                     case 2: return [4 /*yield*/, this.fs.readFile(filepath)];
                     case 3:
-                        _c = _d.sent();
-                        _d.label = 4;
-                    case 4: return [2 /*return*/, _b.apply(_a, [_c, filepath])];
+                        _b = _c.sent();
+                        _c.label = 4;
+                    case 4: return [2 /*return*/, _a.apply(this, [_b, filepath])];
                 }
             });
         };
@@ -3200,6 +4114,10 @@
     function isRangeToken(val) {
         return getKind(val) === exports.TokenKind.Range;
     }
+    function isValueToken(val) {
+        // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range
+        return (getKind(val) & 1667) > 0;
+    }
     function getKind(val) {
         return val ? val.kind : -1;
     }
@@ -3216,27 +4134,33 @@
         isNumberToken: isNumberToken,
         isPropertyAccessToken: isPropertyAccessToken,
         isWordToken: isWordToken,
-        isRangeToken: isRangeToken
+        isRangeToken: isRangeToken,
+        isValueToken: isValueToken
     });
 
     var Context = /** @class */ (function () {
-        function Context(env, opts, renderOptions) {
+        function Context(env, opts, renderOptions, _a) {
             if (env === void 0) { env = {}; }
             if (opts === void 0) { opts = defaultOptions; }
             if (renderOptions === void 0) { renderOptions = {}; }
-            var _a, _b, _c;
+            var _b = _a === void 0 ? {} : _a, memoryLimit = _b.memoryLimit, renderLimit = _b.renderLimit;
+            var _c, _d, _e, _f, _g;
             /**
              * insert a Context-level empty scope,
              * for tags like `{% capture %}` `{% assign %}` to operate
              */
             this.scopes = [{}];
             this.registers = {};
+            this.breakCalled = false;
+            this.continueCalled = false;
             this.sync = !!renderOptions.sync;
             this.opts = opts;
-            this.globals = (_a = renderOptions.globals) !== null && _a !== void 0 ? _a : opts.globals;
+            this.globals = (_c = renderOptions.globals) !== null && _c !== void 0 ? _c : opts.globals;
             this.environments = isObject(env) ? env : Object(env);
-            this.strictVariables = (_b = renderOptions.strictVariables) !== null && _b !== void 0 ? _b : this.opts.strictVariables;
-            this.ownPropertyOnly = (_c = renderOptions.ownPropertyOnly) !== null && _c !== void 0 ? _c : opts.ownPropertyOnly;
+            this.strictVariables = (_d = renderOptions.strictVariables) !== null && _d !== void 0 ? _d : this.opts.strictVariables;
+            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));
         }
         Context.prototype.getRegister = function (key) {
             return (this.registers[key] = this.registers[key] || {});
@@ -3276,9 +4200,11 @@
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        scope = this.findScope(paths[0]);
+                        scope = this.findScope(paths[0]) // first prop should always be a string
+                        ;
                         return [4 /*yield*/, this._getFromScope(scope, paths)];
-                    case 1: return [2 /*return*/, _a.sent()];
+                    case 1: // first prop should always be a string
+                    return [2 /*return*/, _a.sent()];
                 }
             });
         };
@@ -3323,6 +4249,17 @@
         Context.prototype.bottom = function () {
             return this.scopes[0];
         };
+        Context.prototype.spawn = function (scope) {
+            if (scope === void 0) { scope = {}; }
+            return new Context(scope, this.opts, {
+                sync: this.sync,
+                globals: this.globals,
+                strictVariables: this.strictVariables
+            }, {
+                renderLimit: this.renderLimit,
+                memoryLimit: this.memoryLimit
+            });
+        };
         Context.prototype.findScope = function (key) {
             for (var i = this.scopes.length - 1; i >= 0; i--) {
                 var candidate = this.scopes[i];
@@ -3337,6 +4274,7 @@
     }());
     function readProperty(obj, key, ownPropertyOnly) {
         obj = toLiquid(obj);
+        key = toValue(key);
         if (isNil(obj))
             return obj;
         if (isArray(obj) && key < 0)
@@ -3355,7 +4293,7 @@
         return value;
     }
     function readJSProperty(obj, key, ownPropertyOnly) {
-        if (ownPropertyOnly && !Object.hasOwnProperty.call(obj, key) && !(obj instanceof Drop))
+        if (ownPropertyOnly && !hasOwnProperty.call(obj, key) && !(obj instanceof Drop))
             return undefined;
         return obj[key];
     }
@@ -3370,7 +4308,7 @@
         return obj['last'];
     }
     function readSize(obj) {
-        if (obj.hasOwnProperty('size') || obj['size'] !== undefined)
+        if (hasOwnProperty.call(obj, 'size') || obj['size'] !== undefined)
             return obj['size'];
         if (isArray(obj) || isString(obj))
             return obj.length;
@@ -3483,51 +4421,63 @@
         slugify: slugify
     });
 
-    var join = argumentsToValue(function (v, arg) { return toArray(v).join(arg === undefined ? ' ' : arg); });
-    var last$1 = argumentsToValue(function (v) { return isArray(v) ? last(v) : ''; });
-    var first = argumentsToValue(function (v) { return isArray(v) ? v[0] : ''; });
-    var reverse = argumentsToValue(function (v) { return __spreadArray([], __read(toArray(v)), false).reverse(); });
+    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 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) {
-        var values, _a, _b, item, _c, _d, _e, _f, e_1_1;
-        var e_1, _g;
-        return __generator(this, function (_h) {
-            switch (_h.label) {
+        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) {
+            switch (_f.label) {
                 case 0:
                     values = [];
-                    _h.label = 1;
+                    array = toArray(arr);
+                    this.context.memoryLimit.use(array.length);
+                    _f.label = 1;
                 case 1:
-                    _h.trys.push([1, 8, 9, 10]);
-                    _a = __values(toArray(arr)), _b = _a.next();
-                    _h.label = 2;
+                    _f.trys.push([1, 8, 9, 10]);
+                    array_1 = __values(array), array_1_1 = array_1.next();
+                    _f.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 7];
-                    item = _b.value;
-                    _d = (_c = values).push;
-                    _e = [item];
+                    if (!!array_1_1.done) return [3 /*break*/, 7];
+                    item = array_1_1.value;
+                    _b = (_a = values).push;
+                    _c = [item];
                     if (!property) return [3 /*break*/, 4];
                     return [4 /*yield*/, this.context._getFromScope(item, stringify(property).split('.'), false)];
                 case 3:
-                    _f = _h.sent();
+                    _d = _f.sent();
                     return [3 /*break*/, 5];
                 case 4:
-                    _f = item;
-                    _h.label = 5;
+                    _d = item;
+                    _f.label = 5;
                 case 5:
-                    _d.apply(_c, [_e.concat([
-                            _f
+                    _b.apply(_a, [_c.concat([
+                            _d
                         ])]);
-                    _h.label = 6;
+                    _f.label = 6;
                 case 6:
-                    _b = _a.next();
+                    array_1_1 = array_1.next();
                     return [3 /*break*/, 2];
                 case 7: return [3 /*break*/, 10];
                 case 8:
-                    e_1_1 = _h.sent();
+                    e_1_1 = _f.sent();
                     e_1 = { error: e_1_1 };
                     return [3 /*break*/, 10];
                 case 9:
                     try {
-                        if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                        if (array_1_1 && !array_1_1.done && (_e = array_1.return)) _e.call(array_1);
                     }
                     finally { if (e_1) throw e_1.error; }
                     return [7 /*endfinally*/];
@@ -3544,40 +4494,44 @@
         var compare = property === undefined
             ? caseInsensitiveCompare
             : function (lhs, rhs) { return caseInsensitiveCompare(lhs[propertyString], rhs[propertyString]); };
-        return __spreadArray([], __read(toArray(input)), false).sort(compare);
+        var array = toArray(input);
+        this.context.memoryLimit.use(array.length);
+        return __spreadArray([], __read(array), false).sort(compare);
     }
     var size = function (v) { return (v && v.length) || 0; };
     function map(arr, property) {
-        var results, _a, _b, item, _c, _d, e_2_1;
-        var e_2, _e;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var results, array, array_2, array_2_1, item, _a, _b, e_2_1;
+        var e_2, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     results = [];
-                    _f.label = 1;
+                    array = toArray(arr);
+                    this.context.memoryLimit.use(array.length);
+                    _d.label = 1;
                 case 1:
-                    _f.trys.push([1, 6, 7, 8]);
-                    _a = __values(toArray(arr)), _b = _a.next();
-                    _f.label = 2;
+                    _d.trys.push([1, 6, 7, 8]);
+                    array_2 = __values(array), array_2_1 = array_2.next();
+                    _d.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 5];
-                    item = _b.value;
-                    _d = (_c = results).push;
+                    if (!!array_2_1.done) return [3 /*break*/, 5];
+                    item = array_2_1.value;
+                    _b = (_a = results).push;
                     return [4 /*yield*/, this.context._getFromScope(item, stringify(property), false)];
                 case 3:
-                    _d.apply(_c, [_f.sent()]);
-                    _f.label = 4;
+                    _b.apply(_a, [_d.sent()]);
+                    _d.label = 4;
                 case 4:
-                    _b = _a.next();
+                    array_2_1 = array_2.next();
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_2_1 = _f.sent();
+                    e_2_1 = _d.sent();
                     e_2 = { error: e_2_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
-                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        if (array_2_1 && !array_2_1.done && (_c = array_2.return)) _c.call(array_2);
                     }
                     finally { if (e_2) throw e_2.error; }
                     return [7 /*endfinally*/];
@@ -3586,44 +4540,45 @@
         });
     }
     function sum(arr, property) {
-        var sum, _a, _b, item, data, _c, _d, e_3_1;
-        var e_3, _e;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var sum, array, array_3, array_3_1, item, data, _a, _b, e_3_1;
+        var e_3, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     sum = 0;
-                    _f.label = 1;
+                    array = toArray(arr);
+                    _d.label = 1;
                 case 1:
-                    _f.trys.push([1, 8, 9, 10]);
-                    _a = __values(toArray(arr)), _b = _a.next();
-                    _f.label = 2;
+                    _d.trys.push([1, 8, 9, 10]);
+                    array_3 = __values(array), array_3_1 = array_3.next();
+                    _d.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 7];
-                    item = _b.value;
-                    _c = Number;
+                    if (!!array_3_1.done) return [3 /*break*/, 7];
+                    item = array_3_1.value;
+                    _a = Number;
                     if (!property) return [3 /*break*/, 4];
                     return [4 /*yield*/, this.context._getFromScope(item, stringify(property), false)];
                 case 3:
-                    _d = _f.sent();
+                    _b = _d.sent();
                     return [3 /*break*/, 5];
                 case 4:
-                    _d = item;
-                    _f.label = 5;
+                    _b = item;
+                    _d.label = 5;
                 case 5:
-                    data = _c.apply(void 0, [_d]);
+                    data = _a.apply(void 0, [_b]);
                     sum += Number.isNaN(data) ? 0 : data;
-                    _f.label = 6;
+                    _d.label = 6;
                 case 6:
-                    _b = _a.next();
+                    array_3_1 = array_3.next();
                     return [3 /*break*/, 2];
                 case 7: return [3 /*break*/, 10];
                 case 8:
-                    e_3_1 = _f.sent();
+                    e_3_1 = _d.sent();
                     e_3 = { error: e_3_1 };
                     return [3 /*break*/, 10];
                 case 9:
                     try {
-                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        if (array_3_1 && !array_3_1.done && (_c = array_3.return)) _c.call(array_3);
                     }
                     finally { if (e_3) throw e_3.error; }
                     return [7 /*endfinally*/];
@@ -3632,17 +4587,24 @@
         });
     }
     function compact(arr) {
-        return toArray(arr).filter(function (x) { return !isNil(toValue(x)); });
+        var array = toArray(arr);
+        this.context.memoryLimit.use(array.length);
+        return array.filter(function (x) { return !isNil(toValue(x)); });
     }
     function concat(v, arg) {
         if (arg === void 0) { arg = []; }
-        return toArray(v).concat(toArray(arg));
+        var lhs = toArray(v);
+        var rhs = toArray(arg);
+        this.context.memoryLimit.use(lhs.length + rhs.length);
+        return lhs.concat(rhs);
     }
     function push(v, arg) {
-        return concat(v, [arg]);
+        return concat.call(this, v, [arg]);
     }
     function unshift(v, arg) {
-        var clone = __spreadArray([], __read(toArray(v)), false);
+        var array = toArray(v);
+        this.context.memoryLimit.use(array.length);
+        var clone = __spreadArray([], __read(array), false);
         clone.unshift(arg);
         return clone;
     }
@@ -3652,7 +4614,9 @@
         return clone;
     }
     function shift(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.shift();
         return clone;
     }
@@ -3664,10 +4628,11 @@
         if (!isArray(v))
             v = stringify(v);
         begin = begin < 0 ? v.length + begin : begin;
+        this.context.memoryLimit.use(length);
         return v.slice(begin, begin + length);
     }
     function where(arr, property, expected) {
-        var values, token, arr_1, arr_1_1, item, _a, _b, e_4_1;
+        var values, token, arr_1, arr_1_1, item, _a, _b, e_4_1, matcher;
         var e_4, _c;
         var _this = this;
         return __generator(this, function (_d) {
@@ -3675,6 +4640,7 @@
                 case 0:
                     values = [];
                     arr = toArray(arr);
+                    this.context.memoryLimit.use(arr.length);
                     token = new Tokenizer(stringify(property)).readScopeValue();
                     _d.label = 1;
                 case 1:
@@ -3685,7 +4651,7 @@
                     if (!!arr_1_1.done) return [3 /*break*/, 5];
                     item = arr_1_1.value;
                     _b = (_a = values).push;
-                    return [4 /*yield*/, evalToken(token, new Context(item))];
+                    return [4 /*yield*/, evalToken(token, this.context.spawn(item))];
                 case 3:
                     _b.apply(_a, [_d.sent()]);
                     _d.label = 4;
@@ -3703,47 +4669,53 @@
                     }
                     finally { if (e_4) throw e_4.error; }
                     return [7 /*endfinally*/];
-                case 8: return [2 /*return*/, arr.filter(function (_, i) {
-                        if (expected === undefined)
-                            return isTruthy(values[i], _this.context);
-                        return equals(values[i], expected);
-                    })];
+                case 8:
+                    matcher = this.context.opts.jekyllWhere
+                        ? function (v) { return EmptyDrop.is(expected) ? equals(v, expected) : (isArray(v) ? arrayIncludes(v, expected) : equals(v, expected)); }
+                        : function (v) { return equals(v, expected); };
+                    return [2 /*return*/, arr.filter(function (_, i) {
+                            if (expected === undefined)
+                                return isTruthy(values[i], _this.context);
+                            return matcher(values[i]);
+                        })];
             }
         });
     }
     function where_exp(arr, itemName, exp) {
-        var filtered, keyTemplate, _a, _b, item, value, e_5_1;
-        var e_5, _c, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        var filtered, keyTemplate, array, array_4, array_4_1, item, value, e_5_1;
+        var e_5, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     filtered = [];
                     keyTemplate = new Value(stringify(exp), this.liquid);
-                    _e.label = 1;
+                    array = toArray(arr);
+                    this.context.memoryLimit.use(array.length);
+                    _c.label = 1;
                 case 1:
-                    _e.trys.push([1, 6, 7, 8]);
-                    _a = __values(toArray(arr)), _b = _a.next();
-                    _e.label = 2;
+                    _c.trys.push([1, 6, 7, 8]);
+                    array_4 = __values(array), array_4_1 = array_4.next();
+                    _c.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 5];
-                    item = _b.value;
-                    return [4 /*yield*/, keyTemplate.value(new Context((_d = {}, _d[itemName] = item, _d)))];
+                    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)))];
                 case 3:
-                    value = _e.sent();
+                    value = _c.sent();
                     if (value)
                         filtered.push(item);
-                    _e.label = 4;
+                    _c.label = 4;
                 case 4:
-                    _b = _a.next();
+                    array_4_1 = array_4.next();
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_5_1 = _e.sent();
+                    e_5_1 = _c.sent();
                     e_5 = { error: e_5_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        if (array_4_1 && !array_4_1.done && (_a = array_4.return)) _a.call(array_4);
                     }
                     finally { if (e_5) throw e_5.error; }
                     return [7 /*endfinally*/];
@@ -3758,8 +4730,9 @@
             switch (_b.label) {
                 case 0:
                     map = new Map();
-                    arr = toArray(arr);
+                    arr = toEnumerable(arr);
                     token = new Tokenizer(stringify(property)).readScopeValue();
+                    this.context.memoryLimit.use(arr.length);
                     _b.label = 1;
                 case 1:
                     _b.trys.push([1, 6, 7, 8]);
@@ -3768,7 +4741,7 @@
                 case 2:
                     if (!!arr_2_1.done) return [3 /*break*/, 5];
                     item = arr_2_1.value;
-                    return [4 /*yield*/, evalToken(token, new Context(item))];
+                    return [4 /*yield*/, evalToken(token, this.context.spawn(item))];
                 case 3:
                     key = _b.sent();
                     if (!map.has(key))
@@ -3797,39 +4770,41 @@
         });
     }
     function group_by_exp(arr, itemName, exp) {
-        var map, keyTemplate, _a, _b, item, key, e_7_1;
-        var e_7, _c, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        var map, keyTemplate, arr_3, arr_3_1, item, key, e_7_1;
+        var e_7, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     map = new Map();
                     keyTemplate = new Value(stringify(exp), this.liquid);
-                    _e.label = 1;
+                    arr = toEnumerable(arr);
+                    this.context.memoryLimit.use(arr.length);
+                    _c.label = 1;
                 case 1:
-                    _e.trys.push([1, 6, 7, 8]);
-                    _a = __values(toArray(arr)), _b = _a.next();
-                    _e.label = 2;
+                    _c.trys.push([1, 6, 7, 8]);
+                    arr_3 = __values(arr), arr_3_1 = arr_3.next();
+                    _c.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 5];
-                    item = _b.value;
-                    return [4 /*yield*/, keyTemplate.value(new Context((_d = {}, _d[itemName] = item, _d)))];
+                    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)))];
                 case 3:
-                    key = _e.sent();
+                    key = _c.sent();
                     if (!map.has(key))
                         map.set(key, []);
                     map.get(key).push(item);
-                    _e.label = 4;
+                    _c.label = 4;
                 case 4:
-                    _b = _a.next();
+                    arr_3_1 = arr_3.next();
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_7_1 = _e.sent();
+                    e_7_1 = _c.sent();
                     e_7 = { error: e_7_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        if (arr_3_1 && !arr_3_1.done && (_a = arr_3.return)) _a.call(arr_3);
                     }
                     finally { if (e_7) throw e_7.error; }
                     return [7 /*endfinally*/];
@@ -3841,92 +4816,89 @@
         });
     }
     function find(arr, property, expected) {
-        var token, _a, _b, item, value, e_8_1;
-        var e_8, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+        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) {
                 case 0:
                     token = new Tokenizer(stringify(property)).readScopeValue();
-                    _d.label = 1;
+                    array = toArray(arr);
+                    _b.label = 1;
                 case 1:
-                    _d.trys.push([1, 6, 7, 8]);
-                    _a = __values(toArray(arr)), _b = _a.next();
-                    _d.label = 2;
+                    _b.trys.push([1, 6, 7, 8]);
+                    array_5 = __values(array), array_5_1 = array_5.next();
+                    _b.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 5];
-                    item = _b.value;
-                    return [4 /*yield*/, evalToken(token, new Context(item))];
+                    if (!!array_5_1.done) return [3 /*break*/, 5];
+                    item = array_5_1.value;
+                    return [4 /*yield*/, evalToken(token, this.context.spawn(item))];
                 case 3:
-                    value = _d.sent();
+                    value = _b.sent();
                     if (equals(value, expected))
                         return [2 /*return*/, item];
-                    _d.label = 4;
+                    _b.label = 4;
                 case 4:
-                    _b = _a.next();
+                    array_5_1 = array_5.next();
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_8_1 = _d.sent();
+                    e_8_1 = _b.sent();
                     e_8 = { error: e_8_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        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*/, null];
+                case 8: return [2 /*return*/];
             }
         });
     }
     function find_exp(arr, itemName, exp) {
-        var predicate, _a, _b, item, value, e_9_1;
-        var e_9, _c, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        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) {
                 case 0:
                     predicate = new Value(stringify(exp), this.liquid);
-                    _e.label = 1;
+                    array = toArray(arr);
+                    _c.label = 1;
                 case 1:
-                    _e.trys.push([1, 6, 7, 8]);
-                    _a = __values(toArray(arr)), _b = _a.next();
-                    _e.label = 2;
+                    _c.trys.push([1, 6, 7, 8]);
+                    array_6 = __values(array), array_6_1 = array_6.next();
+                    _c.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 5];
-                    item = _b.value;
-                    return [4 /*yield*/, predicate.value(new Context((_d = {}, _d[itemName] = item, _d)))];
+                    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 = _e.sent();
+                    value = _c.sent();
                     if (value)
                         return [2 /*return*/, item];
-                    _e.label = 4;
+                    _c.label = 4;
                 case 4:
-                    _b = _a.next();
+                    array_6_1 = array_6.next();
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_9_1 = _e.sent();
+                    e_9_1 = _c.sent();
                     e_9 = { error: e_9_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        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*/, null];
+                case 8: return [2 /*return*/];
             }
         });
     }
     function uniq(arr) {
-        arr = toValue(arr);
-        var u = {};
-        return (arr || []).filter(function (val) {
-            if (hasOwnProperty.call(u, String(val)))
-                return false;
-            u[String(val)] = true;
-            return true;
-        });
+        arr = toArray(arr);
+        this.context.memoryLimit.use(arr.length);
+        return __spreadArray([], __read(new Set(arr)), false);
     }
     function sample(v, count) {
         if (count === void 0) { count = 1; }
@@ -3935,6 +4907,7 @@
             return [];
         if (!isArray(v))
             v = stringify(v);
+        this.context.memoryLimit.use(count);
         var shuffled = __spreadArray([], __read(v), false).sort(function () { return Math.random() - 0.5; });
         if (count === 1)
             return shuffled[0];
@@ -3970,6 +4943,9 @@
     });
 
     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);
+        this.context.memoryLimit.use(size);
         var date = parseDate(v, this.context.opts, timezoneOffset);
         if (!date)
             return v;
@@ -4003,39 +4979,30 @@
     }
     function parseDate(v, opts, timezoneOffset) {
         var date;
+        var defaultTimezoneOffset = timezoneOffset !== null && timezoneOffset !== void 0 ? timezoneOffset : opts.timezoneOffset;
+        var locale = opts.locale;
         v = toValue(v);
         if (v === 'now' || v === 'today') {
-            date = new Date();
+            date = new LiquidDate(Date.now(), locale, defaultTimezoneOffset);
         }
         else if (isNumber(v)) {
-            date = new Date(v * 1000);
+            date = new LiquidDate(v * 1000, locale, defaultTimezoneOffset);
         }
         else if (isString(v)) {
             if (/^\d+$/.test(v)) {
-                date = new Date(+v * 1000);
+                date = new LiquidDate(+v * 1000, locale, defaultTimezoneOffset);
             }
-            else if (opts.preserveTimezones) {
-                date = TimezoneDate.createDateFixedToTimezone(v);
+            else if (opts.preserveTimezones && timezoneOffset === undefined) {
+                date = LiquidDate.createDateFixedToTimezone(v, locale);
             }
             else {
-                date = new Date(v);
+                date = new LiquidDate(v, locale, defaultTimezoneOffset);
             }
         }
         else {
-            date = v;
+            date = new LiquidDate(v, locale, defaultTimezoneOffset);
         }
-        if (!isValidDate(date))
-            return;
-        if (timezoneOffset !== undefined) {
-            date = new TimezoneDate(date, timezoneOffset);
-        }
-        else if (!(date instanceof TimezoneDate) && opts.timezoneOffset !== undefined) {
-            date = new TimezoneDate(date, opts.timezoneOffset);
-        }
-        return date;
-    }
-    function isValidDate(date) {
-        return (date instanceof Date || date instanceof TimezoneDate) && !isNaN(date.getTime());
+        return date.valid() ? date : undefined;
     }
 
     var dateFilters = /*#__PURE__*/Object.freeze({
@@ -4057,33 +5024,50 @@
     var rNonCJKWord = /[^\u4E00-\u9FFF\uF900-\uFAFF\u3400-\u4DBF\u3040-\u309F\u30A0-\u30FF\uAC00-\uD7AF\s]+/gu;
     function append(v, arg) {
         assert(arguments.length === 2, 'append expect 2 arguments');
-        return stringify(v) + stringify(arg);
+        var lhs = stringify(v);
+        var rhs = stringify(arg);
+        this.context.memoryLimit.use(lhs.length + rhs.length);
+        return lhs + rhs;
     }
     function prepend(v, arg) {
         assert(arguments.length === 2, 'prepend expect 2 arguments');
-        return stringify(arg) + stringify(v);
+        var lhs = stringify(v);
+        var rhs = stringify(arg);
+        this.context.memoryLimit.use(lhs.length + rhs.length);
+        return rhs + lhs;
     }
     function lstrip(v, chars) {
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
         if (chars) {
             chars = escapeRegExp(stringify(chars));
-            return stringify(v).replace(new RegExp("^[".concat(chars, "]+"), 'g'), '');
+            return str.replace(new RegExp("^[".concat(chars, "]+"), 'g'), '');
         }
-        return stringify(v).replace(/^\s+/, '');
+        return str.replace(/^\s+/, '');
     }
     function downcase(v) {
-        return stringify(v).toLowerCase();
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.toLowerCase();
     }
-    function upcase(str) {
+    function upcase(v) {
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
         return stringify(str).toUpperCase();
     }
     function remove(v, arg) {
-        return stringify(v).split(stringify(arg)).join('');
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.split(stringify(arg)).join('');
     }
     function remove_first(v, l) {
-        return stringify(v).replace(stringify(l), '');
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(stringify(l), '');
     }
     function remove_last(v, l) {
         var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
         var pattern = stringify(l);
         var index = str.lastIndexOf(pattern);
         if (index === -1)
@@ -4091,14 +5075,18 @@
         return str.substring(0, index) + str.substring(index + pattern.length);
     }
     function rstrip(str, chars) {
+        str = stringify(str);
+        this.context.memoryLimit.use(str.length);
         if (chars) {
             chars = escapeRegExp(stringify(chars));
-            return stringify(str).replace(new RegExp("[".concat(chars, "]+$"), 'g'), '');
+            return str.replace(new RegExp("[".concat(chars, "]+$"), 'g'), '');
         }
-        return stringify(str).replace(/\s+$/, '');
+        return str.replace(/\s+$/, '');
     }
     function split(v, arg) {
-        var arr = stringify(v).split(stringify(arg));
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        var arr = str.split(stringify(arg));
         // align to ruby split, which is the behavior of shopify/liquid
         // see: https://ruby-doc.org/core-2.4.0/String.html#method-i-split
         while (arr.length && arr[arr.length - 1] === '')
@@ -4106,29 +5094,39 @@
         return arr;
     }
     function strip(v, chars) {
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
         if (chars) {
             chars = escapeRegExp(stringify(chars));
-            return stringify(v)
+            return str
                 .replace(new RegExp("^[".concat(chars, "]+"), 'g'), '')
                 .replace(new RegExp("[".concat(chars, "]+$"), 'g'), '');
         }
-        return stringify(v).trim();
+        return str.trim();
     }
     function strip_newlines(v) {
-        return stringify(v).replace(/\r?\n/gm, '');
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(/\r?\n/gm, '');
     }
     function capitalize(str) {
         str = stringify(str);
+        this.context.memoryLimit.use(str.length);
         return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
     }
     function replace(v, pattern, replacement) {
-        return stringify(v).split(stringify(pattern)).join(replacement);
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.split(stringify(pattern)).join(replacement);
     }
     function replace_first(v, arg1, arg2) {
-        return stringify(v).replace(stringify(arg1), arg2);
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(stringify(arg1), arg2);
     }
     function replace_last(v, arg1, arg2) {
         var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
         var pattern = stringify(arg1);
         var index = str.lastIndexOf(pattern);
         if (index === -1)
@@ -4139,15 +5137,18 @@
     function truncate(v, l, o) {
         if (l === void 0) { l = 50; }
         if (o === void 0) { o = '...'; }
-        v = stringify(v);
-        if (v.length <= l)
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        if (str.length <= l)
             return v;
-        return v.substring(0, l - o.length) + o;
+        return str.substring(0, l - o.length) + o;
     }
     function truncatewords(v, words, o) {
         if (words === void 0) { words = 15; }
         if (o === void 0) { o = '...'; }
-        var arr = stringify(v).split(/\s+/);
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        var arr = str.split(/\s+/);
         if (words <= 0)
             words = 1;
         var ret = arr.slice(0, words).join(' ');
@@ -4156,11 +5157,14 @@
         return ret;
     }
     function normalize_whitespace(v) {
-        v = stringify(v);
-        return v.replace(/\s+/g, ' ');
+        var str = stringify(v);
+        this.context.memoryLimit.use(str.length);
+        return str.replace(/\s+/g, ' ');
     }
     function number_of_words(input, mode) {
-        input = stringify(input).trim();
+        var str = stringify(input);
+        this.context.memoryLimit.use(str.length);
+        input = str.trim();
         if (!input)
             return 0;
         switch (mode) {
@@ -4179,6 +5183,7 @@
     }
     function array_to_sentence_string(array, connector) {
         if (connector === void 0) { connector = 'and'; }
+        this.context.memoryLimit.use(array.length);
         switch (array.length) {
             case 0:
                 return '';
@@ -4222,7 +5227,8 @@
         __extends(default_1, _super);
         function default_1(token, remainTokens, liquid) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
-            _this.key = _this.tokenizer.readIdentifier().content;
+            _this.identifier = _this.tokenizer.readIdentifier();
+            _this.key = _this.identifier.content;
             _this.tokenizer.assert(_this.key, 'expected variable name');
             _this.tokenizer.skipBlank();
             _this.tokenizer.assert(_this.tokenizer.peek() === '=', 'expected "="');
@@ -4244,13 +5250,33 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
     var MODIFIERS = ['offset', 'limit', 'reversed'];
     var default_1$1 = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(token, remainTokens, liquid) {
+        function default_1(token, remainTokens, liquid, parser) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             var variable = _this.tokenizer.readIdentifier();
             var inStr = _this.tokenizer.readIdentifier();
@@ -4260,18 +5286,16 @@
             }
             _this.variable = variable.content;
             _this.collection = collection;
-            _this.hash = new Hash(_this.tokenizer.remaining());
+            _this.hash = new Hash(_this.tokenizer, liquid.options.keyValueSeparator);
             _this.templates = [];
             _this.elseTemplates = [];
             var p;
-            var stream = _this.liquid.parser.parseStream(remainTokens)
+            var stream = parser.parseStream(remainTokens)
                 .on('start', function () { return (p = _this.templates); })
-                .on('tag:else', function () { return (p = _this.elseTemplates); })
-                .on('tag:endfor', function () { return stream.stop(); })
+                .on('tag:else', function (tag) { assertEmpty(tag.args); p = _this.elseTemplates; })
+                .on('tag:endfor', function (tag) { assertEmpty(tag.args); stream.stop(); })
                 .on('template', function (tpl) { return p.push(tpl); })
-                .on('end', function () {
-                throw new Error("tag ".concat(token.getText(), " not closed"));
-            });
+                .on('end', function () { throw new Error("tag ".concat(token.getText(), " not closed")); });
             stream.start();
             return _this;
         }
@@ -4320,14 +5344,12 @@
                         if (!!collection_1_1.done) return [3 /*break*/, 9];
                         item = collection_1_1.value;
                         scope[this.variable] = item;
+                        ctx.continueCalled = ctx.breakCalled = false;
                         return [4 /*yield*/, r.renderTemplates(this.templates, ctx, emitter)];
                     case 7:
                         _c.sent();
-                        if (emitter['break']) {
-                            emitter['break'] = false;
+                        if (ctx.breakCalled)
                             return [3 /*break*/, 9];
-                        }
-                        emitter['continue'] = false;
                         scope.forloop.next();
                         _c.label = 8;
                     case 8:
@@ -4345,11 +5367,64 @@
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
                     case 12:
+                        ctx.continueCalled = ctx.breakCalled = false;
                         ctx.pop();
                         return [2 /*return*/];
                 }
             });
         };
+        default_1.prototype.children = function () {
+            var templates;
+            return __generator(this, function (_a) {
+                templates = this.templates.slice();
+                if (this.elseTemplates) {
+                    templates.push.apply(templates, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, templates];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_2_1;
+            var e_2, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.collection];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(Object.values(this.hash.hash)), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, v];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.blockScope = function () {
+            return [this.variable, 'forloop'];
+        };
         return default_1;
     }(Tag));
     function reversed(arr) {
@@ -4364,18 +5439,28 @@
 
     var default_1$2 = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(tagToken, remainTokens, liquid) {
+        function default_1(tagToken, remainTokens, liquid, parser) {
             var _this = _super.call(this, tagToken, remainTokens, liquid) || this;
             _this.templates = [];
-            _this.variable = _this.readVariableName();
+            _this.identifier = _this.readVariable();
+            _this.variable = _this.identifier.content;
             while (remainTokens.length) {
                 var token = remainTokens.shift();
                 if (isTagToken(token) && token.name === 'endcapture')
                     return _this;
-                _this.templates.push(liquid.parser.parseToken(token, remainTokens));
+                _this.templates.push(parser.parseToken(token, remainTokens));
             }
             throw new Error("tag ".concat(tagToken.getText(), " not closed"));
         }
+        default_1.prototype.readVariable = function () {
+            var ident = this.tokenizer.readIdentifier();
+            if (ident.content)
+                return ident;
+            ident = this.tokenizer.readQuoted();
+            if (ident)
+                return ident;
+            throw this.tokenizer.error('invalid capture name');
+        };
         default_1.prototype.render = function (ctx) {
             var r, html;
             return __generator(this, function (_a) {
@@ -4390,21 +5475,27 @@
                 }
             });
         };
-        default_1.prototype.readVariableName = function () {
-            var word = this.tokenizer.readIdentifier().content;
-            if (word)
-                return word;
-            var quoted = this.tokenizer.readQuoted();
-            if (quoted)
-                return evalQuotedToken(quoted);
-            throw this.tokenizer.error('invalid capture name');
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
         };
         return default_1;
     }(Tag));
 
     var default_1$3 = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(tagToken, remainTokens, liquid) {
+        function default_1(tagToken, remainTokens, liquid, parser) {
             var _this = _super.call(this, tagToken, remainTokens, liquid) || this;
             _this.branches = [];
             _this.elseTemplates = [];
@@ -4412,7 +5503,7 @@
             _this.elseTemplates = [];
             var p = [];
             var elseCount = 0;
-            var stream = _this.liquid.parser.parseStream(remainTokens)
+            var stream = parser.parseStream(remainTokens)
                 .on('tag:when', function (token) {
                 if (elseCount > 0) {
                     return;
@@ -4525,6 +5616,29 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        return [5 /*yield**/, __values(this.branches.flatMap(function (b) { return b.values; }))];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.children = function () {
+            var templates;
+            return __generator(this, function (_a) {
+                templates = this.branches.flatMap(function (b) { return b.templates; });
+                if (this.elseTemplates) {
+                    templates.push.apply(templates, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, templates];
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -4545,10 +5659,10 @@
 
     var default_1$5 = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(token, remainTokens, liquid) {
+        function default_1(token, remainTokens, liquid, parser) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             var tokenizer = _this.tokenizer;
-            _this.file = parseFilePath(tokenizer, _this.liquid);
+            _this.file = parseFilePath(tokenizer, _this.liquid, parser);
             _this.currentFile = token.file;
             while (!tokenizer.end()) {
                 tokenizer.skipBlank();
@@ -4582,7 +5696,7 @@
                 tokenizer.p = begin;
                 break;
             }
-            _this.hash = new Hash(tokenizer.remaining());
+            _this.hash = new Hash(tokenizer, liquid.options.keyValueSeparator);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -4596,7 +5710,7 @@
                     case 1:
                         filepath = (_k.sent());
                         assert(filepath, function () { return "illegal file path \"".concat(filepath, "\""); });
-                        childCtx = new Context({}, ctx.opts, { sync: ctx.sync, globals: ctx.globals, strictVariables: ctx.strictVariables });
+                        childCtx = ctx.spawn();
                         scope = childCtx.bottom();
                         _b = __assign;
                         _c = [scope];
@@ -4662,6 +5776,92 @@
                 }
             });
         };
+        default_1.prototype.children = function (partials, sync) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(partials && isString(this['file']))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.liquid._parsePartialFile(this['file'], sync, this['currentFile'])];
+                    case 1: return [2 /*return*/, (_a.sent())];
+                    case 2: return [2 /*return*/, []];
+                }
+            });
+        };
+        default_1.prototype.partialScope = function () {
+            if (isString(this['file'])) {
+                var names = Object.keys(this.hash.hash);
+                if (this['with']) {
+                    var _a = this['with'], value = _a.value, alias = _a.alias;
+                    if (isString(alias)) {
+                        names.push([alias, value]);
+                    }
+                    else if (isString(this.file)) {
+                        names.push([this.file, value]);
+                    }
+                }
+                if (this['for']) {
+                    var _b = this['for'], value = _b.value, alias = _b.alias;
+                    if (isString(alias)) {
+                        names.push([alias, value]);
+                    }
+                    else if (isString(this.file)) {
+                        names.push([this.file, value]);
+                    }
+                }
+                return { name: this['file'], isolated: true, scope: names };
+            }
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_2_1, value, value;
+            var e_2, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 5, 6, 7]);
+                        _a = __values(Object.values(this.hash.hash)), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, v];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        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 (!isValueToken(value)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, value];
+                    case 8:
+                        _d.sent();
+                        _d.label = 9;
+                    case 9:
+                        if (!this['for']) return [3 /*break*/, 11];
+                        value = this['for'].value;
+                        if (!isValueToken(value)) return [3 /*break*/, 11];
+                        return [4 /*yield*/, value];
+                    case 10:
+                        _d.sent();
+                        _d.label = 11;
+                    case 11: return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
     /**
@@ -4670,7 +5870,7 @@
      * @return Token for expression (not quoted)
      * @throws TypeError if cannot read next token
      */
-    function parseFilePath(tokenizer, liquid) {
+    function parseFilePath(tokenizer, liquid, parser) {
         if (liquid.options.dynamicPartials) {
             var file = tokenizer.readValue();
             tokenizer.assert(file, 'illegal file path');
@@ -4678,13 +5878,13 @@
                 return;
             if (isQuotedToken(file)) {
                 // for filenames like "files/{{file}}", eval as liquid template
-                var templates_1 = liquid.parse(evalQuotedToken(file));
+                var templates_1 = parser.parse(evalQuotedToken(file));
                 return optimize(templates_1);
             }
             return file;
         }
         var tokens = __spreadArray([], __read(tokenizer.readFileNameTemplate(liquid.options)), false);
-        var templates = optimize(liquid.parser.parseTokens(tokens));
+        var templates = optimize(parser.parseTokens(tokens));
         return templates === 'none' ? undefined : templates;
     }
     function optimize(templates) {
@@ -4709,10 +5909,10 @@
 
     var default_1$6 = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(token, remainTokens, liquid) {
+        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);
+            _this['file'] = parseFilePath(tokenizer, _this.liquid, parser);
             _this['currentFile'] = token.file;
             var begin = tokenizer.p;
             var withStr = tokenizer.readIdentifier();
@@ -4726,7 +5926,7 @@
             }
             else
                 tokenizer.p = begin;
-            _this.hash = new Hash(tokenizer.remaining(), _this.liquid.options.jekyllInclude);
+            _this.hash = new Hash(tokenizer, liquid.options.jekyllInclude || liquid.options.keyValueSeparator);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -4766,6 +5966,53 @@
                 }
             });
         };
+        default_1.prototype.children = function (partials, sync) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(partials && isString(this['file']))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.liquid._parsePartialFile(this['file'], sync, this['currentFile'])];
+                    case 1: return [2 /*return*/, (_a.sent())];
+                    case 2: return [2 /*return*/, []];
+                }
+            });
+        };
+        default_1.prototype.partialScope = function () {
+            if (isString(this['file'])) {
+                var names = void 0;
+                if (this.liquid.options.jekyllInclude) {
+                    names = ['include'];
+                }
+                else {
+                    names = Object.keys(this.hash.hash);
+                    if (this.withVar) {
+                        names.push([this['file'], this.withVar]);
+                    }
+                }
+                return { name: this['file'], isolated: false, scope: names };
+            }
+        };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [5 /*yield**/, __values(Object.values(this.hash.hash).filter(isValueToken))];
+                    case 1:
+                        _a.sent();
+                        if (!isValueToken(this['file'])) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this['file']];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (!isValueToken(this.withVar)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.withVar];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -4773,7 +6020,8 @@
         __extends(default_1, _super);
         function default_1(token, remainTokens, liquid) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
-            _this.variable = _this.tokenizer.readIdentifier().content;
+            _this.identifier = _this.tokenizer.readIdentifier();
+            _this.variable = _this.identifier.content;
             return _this;
         }
         default_1.prototype.render = function (context, emitter) {
@@ -4783,6 +6031,16 @@
             }
             emitter.write(stringify(--scope[this.variable]));
         };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -4831,42 +6089,49 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [5 /*yield**/, __values(this.candidates)];
+                    case 1:
+                        _a.sent();
+                        if (!this.group) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.group];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
     var default_1$9 = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(tagToken, remainTokens, liquid) {
+        function default_1(tagToken, remainTokens, liquid, parser) {
             var _this = _super.call(this, tagToken, remainTokens, liquid) || this;
             _this.branches = [];
-            _this.elseTemplates = [];
             var p = [];
-            var elseCount = 0;
-            liquid.parser.parseStream(remainTokens)
+            parser.parseStream(remainTokens)
                 .on('start', function () { return _this.branches.push({
-                value: new Value(tagToken.args, _this.liquid),
+                value: new Value(tagToken.tokenizer.readFilteredValue(), _this.liquid),
                 templates: (p = [])
             }); })
                 .on('tag:elsif', function (token) {
-                if (elseCount > 0) {
-                    p = [];
-                    return;
-                }
+                assert(!_this.elseTemplates, 'unexpected elsif after else');
                 _this.branches.push({
-                    value: new Value(token.args, _this.liquid),
+                    value: new Value(token.tokenizer.readFilteredValue(), _this.liquid),
                     templates: (p = [])
                 });
             })
-                .on('tag:else', function () {
-                elseCount++;
-                p = _this.elseTemplates;
-            })
-                .on('tag:endif', function () { this.stop(); })
-                .on('template', function (tpl) {
-                if (p !== _this.elseTemplates || elseCount === 1) {
-                    p.push(tpl);
-                }
+                .on('tag:else', function (tag) {
+                assertEmpty(tag.args);
+                assert(!_this.elseTemplates, 'duplicated else');
+                p = _this.elseTemplates = [];
             })
+                .on('tag:endif', function (tag) { assertEmpty(tag.args); this.stop(); })
+                .on('template', function (tpl) { return p.push(tpl); })
                 .on('end', function () { throw new Error("tag ".concat(tagToken.getText(), " not closed")); })
                 .start();
             return _this;
@@ -4908,13 +6173,26 @@
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 9: return [4 /*yield*/, r.renderTemplates(this.elseTemplates, ctx, emitter)];
+                    case 9: return [4 /*yield*/, r.renderTemplates(this.elseTemplates || [], ctx, emitter)];
                     case 10:
                         _e.sent();
                         return [2 /*return*/];
                 }
             });
         };
+        default_1.prototype.children = function () {
+            var templates;
+            return __generator(this, function (_a) {
+                templates = this.branches.flatMap(function (b) { return b.templates; });
+                if (this.elseTemplates) {
+                    templates.push.apply(templates, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, templates];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            return this.branches.map(function (b) { return b.value; });
+        };
         return default_1;
     }(Tag));
 
@@ -4922,7 +6200,8 @@
         __extends(default_1, _super);
         function default_1(token, remainTokens, liquid) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
-            _this.variable = _this.tokenizer.readIdentifier().content;
+            _this.identifier = _this.tokenizer.readIdentifier();
+            _this.variable = _this.identifier.content;
             return _this;
         }
         default_1.prototype.render = function (context, emitter) {
@@ -4934,17 +6213,27 @@
             scope[this.variable]++;
             emitter.write(stringify(val));
         };
+        default_1.prototype.localScope = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.identifier];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
     var default_1$b = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(token, remainTokens, liquid) {
+        function default_1(token, remainTokens, liquid, parser) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
-            _this.file = parseFilePath(_this.tokenizer, _this.liquid);
+            _this.file = parseFilePath(_this.tokenizer, _this.liquid, parser);
             _this['currentFile'] = token.file;
-            _this.args = new Hash(_this.tokenizer.remaining());
-            _this.templates = _this.liquid.parser.parseTokens(remainTokens);
+            _this.args = new Hash(_this.tokenizer, liquid.options.keyValueSeparator);
+            _this.templates = parser.parseTokens(remainTokens);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -4991,12 +6280,76 @@
                 }
             });
         };
+        default_1.prototype.children = function (partials) {
+            var templates, _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        templates = this.templates.slice();
+                        if (!(partials && isString(this.file))) return [3 /*break*/, 2];
+                        _b = (_a = templates.push).apply;
+                        _c = [templates];
+                        _d = [[]];
+                        return [4 /*yield*/, this.liquid._parsePartialFile(this.file, true, this['currentFile'])];
+                    case 1:
+                        _b.apply(_a, _c.concat([__spreadArray.apply(void 0, _d.concat([__read.apply(void 0, [(_e.sent())]), false]))]));
+                        _e.label = 2;
+                    case 2: return [2 /*return*/, templates];
+                }
+            });
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 5, 6, 7]);
+                        _a = __values(Object.values(this.args.hash)), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, v];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 7:
+                        if (!isValueToken(this.file)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.file];
+                    case 8:
+                        _d.sent();
+                        _d.label = 9;
+                    case 9: return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.partialScope = function () {
+            if (isString(this.file)) {
+                return { name: this.file, isolated: false, scope: Object.keys(this.args.hash) };
+            }
+        };
         return default_1;
     }(Tag));
 
     var default_1$c = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(token, remainTokens, liquid) {
+        function default_1(token, remainTokens, liquid, parser) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             _this.templates = [];
             var match = /\w+/.exec(token.args);
@@ -5005,7 +6358,7 @@
                 var token_1 = remainTokens.shift();
                 if (isTagToken(token_1) && token_1.name === 'endblock')
                     return _this;
-                var template = liquid.parser.parseToken(token_1, remainTokens);
+                var template = parser.parseToken(token_1, remainTokens);
                 _this.templates.push(template);
             }
             throw new Error("tag ".concat(token.getText(), " not closed"));
@@ -5048,6 +6401,14 @@
                 ? function (superBlock, emitter) { return renderChild(new BlockDrop(function () { return renderCurrent(superBlock, emitter); }), emitter); }
                 : renderCurrent;
         };
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
+        default_1.prototype.blockScope = function () {
+            return ['block'];
+        };
         return default_1;
     }(Tag));
 
@@ -5098,7 +6459,7 @@
 
     var default_1$e = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(tagToken, remainTokens, liquid) {
+        function default_1(tagToken, remainTokens, liquid, parser) {
             var _this = _super.call(this, tagToken, remainTokens, liquid) || this;
             var variable = _this.tokenizer.readIdentifier();
             _this.tokenizer.skipBlank();
@@ -5109,10 +6470,10 @@
             }
             _this.variable = variable.content;
             _this.collection = collectionToken;
-            _this.args = new Hash(_this.tokenizer.remaining());
+            _this.args = new Hash(_this.tokenizer, liquid.options.keyValueSeparator);
             _this.templates = [];
             var p;
-            var stream = _this.liquid.parser.parseStream(remainTokens)
+            var stream = parser.parseStream(remainTokens)
                 .on('start', function () { return (p = _this.templates); })
                 .on('tag:endtablerow', function () { return stream.stop(); })
                 .on('template', function (tpl) { return p.push(tpl); })
@@ -5169,20 +6530,67 @@
                 }
             });
         };
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            var _a, _b, v, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.collection];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(Object.values(this.args.hash)), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        v = _b.value;
+                        if (!isValueToken(v)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, v];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        };
+        default_1.prototype.blockScope = function () {
+            return [this.variable, 'tablerowloop'];
+        };
         return default_1;
     }(Tag));
 
     var default_1$f = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(tagToken, remainTokens, liquid) {
+        function default_1(tagToken, remainTokens, liquid, parser) {
             var _this = _super.call(this, tagToken, remainTokens, liquid) || this;
             _this.branches = [];
             _this.elseTemplates = [];
             var p = [];
             var elseCount = 0;
-            _this.liquid.parser.parseStream(remainTokens)
+            parser.parseStream(remainTokens)
                 .on('start', function () { return _this.branches.push({
-                value: new Value(tagToken.args, _this.liquid),
+                value: new Value(tagToken.tokenizer.readFilteredValue(), _this.liquid),
                 test: isFalsy,
                 templates: (p = [])
             }); })
@@ -5192,7 +6600,7 @@
                     return;
                 }
                 _this.branches.push({
-                    value: new Value(token.args, _this.liquid),
+                    value: new Value(token.tokenizer.readFilteredValue(), _this.liquid),
                     test: isTruthy,
                     templates: (p = [])
                 });
@@ -5255,6 +6663,19 @@
                 }
             });
         };
+        default_1.prototype.children = function () {
+            var children;
+            return __generator(this, function (_a) {
+                children = this.branches.flatMap(function (b) { return b.templates; });
+                if (this.elseTemplates) {
+                    children.push.apply(children, __spreadArray([], __read(this.elseTemplates), false));
+                }
+                return [2 /*return*/, children];
+            });
+        };
+        default_1.prototype.arguments = function () {
+            return this.branches.map(function (b) { return b.value; });
+        };
         return default_1;
     }(Tag));
 
@@ -5263,8 +6684,8 @@
         function default_1() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        default_1.prototype.render = function (ctx, emitter) {
-            emitter['break'] = true;
+        default_1.prototype.render = function (ctx, _emitter) {
+            ctx.breakCalled = true;
         };
         return default_1;
     }(Tag));
@@ -5274,8 +6695,8 @@
         function default_1() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        default_1.prototype.render = function (ctx, emitter) {
-            emitter['continue'] = true;
+        default_1.prototype.render = function (ctx, _emitter) {
+            ctx.continueCalled = true;
         };
         return default_1;
     }(Tag));
@@ -5305,15 +6726,28 @@
                 }
             });
         };
+        default_1.prototype.arguments = function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.value) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.value];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        };
         return default_1;
     }(Tag));
 
     var default_1$j = /** @class */ (function (_super) {
         __extends(default_1, _super);
-        function default_1(token, remainTokens, liquid) {
+        function default_1(token, remainTokens, liquid, parser) {
             var _this = _super.call(this, token, remainTokens, liquid) || this;
             var tokens = _this.tokenizer.readLiquidTagTokens(_this.liquid.options);
-            _this.templates = _this.liquid.parser.parseTokens(tokens);
+            _this.templates = parser.parseTokens(tokens);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -5326,6 +6760,11 @@
                 }
             });
         };
+        default_1.prototype.children = function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.templates];
+            });
+        };
         return default_1;
     }(Tag));
 
@@ -5374,12 +6813,14 @@
             this.filters = {};
             this.tags = {};
             this.options = normalize(opts);
+            // eslint-disable-next-line deprecation/deprecation
             this.parser = new Parser(this);
             forOwn(tags, function (conf, name) { return _this.registerTag(name, conf); });
             forOwn(filters, function (handler, name) { return _this.registerFilter(name, handler); });
         }
         Liquid.prototype.parse = function (html, filepath) {
-            return this.parser.parse(html, filepath);
+            var parser = new Parser(this);
+            return parser.parse(html, filepath);
         };
         Liquid.prototype._render = function (tpl, scope, renderOptions) {
             var ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions);
@@ -5415,23 +6856,23 @@
             return toValueSync(this._parseAndRender(html, scope, __assign(__assign({}, renderOptions), { sync: true })));
         };
         Liquid.prototype._parsePartialFile = function (file, sync, currentFile) {
-            return this.parser.parseFile(file, sync, LookupType.Partials, currentFile);
+            return new Parser(this).parseFile(file, sync, LookupType.Partials, currentFile);
         };
         Liquid.prototype._parseLayoutFile = function (file, sync, currentFile) {
-            return this.parser.parseFile(file, sync, LookupType.Layouts, currentFile);
+            return new Parser(this).parseFile(file, sync, LookupType.Layouts, currentFile);
         };
         Liquid.prototype._parseFile = function (file, sync, lookupType, currentFile) {
-            return this.parser.parseFile(file, sync, lookupType, currentFile);
+            return new Parser(this).parseFile(file, sync, lookupType, currentFile);
         };
         Liquid.prototype.parseFile = function (file, lookupType) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, toPromise(this.parser.parseFile(file, false, lookupType))];
+                    return [2 /*return*/, toPromise(new Parser(this).parseFile(file, false, lookupType))];
                 });
             });
         };
         Liquid.prototype.parseFileSync = function (file, lookupType) {
-            return toValueSync(this.parser.parseFile(file, true, lookupType));
+            return toValueSync(new Parser(this).parseFile(file, true, lookupType));
         };
         Liquid.prototype._renderFile = function (file, ctx, renderFileOptions) {
             var templates;
@@ -5507,11 +6948,161 @@
                 self.renderFile(filePath, ctx).then(function (html) { return callback(null, html); }, callback);
             };
         };
+        Liquid.prototype.analyze = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, analyze(template, options)];
+                });
+            });
+        };
+        Liquid.prototype.analyzeSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return analyzeSync(template, options);
+        };
+        Liquid.prototype.parseAndAnalyze = function (html, filename, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, analyze(this.parse(html, filename), options)];
+                });
+            });
+        };
+        Liquid.prototype.parseAndAnalyzeSync = function (html, filename, options) {
+            if (options === void 0) { options = {}; }
+            return analyzeSync(this.parse(html, filename), options);
+        };
+        /** Return an array of all variables without their properties. */
+        Liquid.prototype.variables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Object.keys(analysis.variables)];
+                    }
+                });
+            });
+        };
+        /** Return an array of all variables without their properties. */
+        Liquid.prototype.variablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Object.keys(analysis.variables);
+        };
+        /** Return an array of all variables including their properties/paths. */
+        Liquid.prototype.fullVariables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(new Set(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return String(v); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all variables including their properties/paths. */
+        Liquid.prototype.fullVariablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(new Set(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return String(v); }); })));
+        };
+        /** Return an array of all variables, each as an array of properties/segments. */
+        Liquid.prototype.variableSegments = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(strictUniq(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all variables, each as an array of properties/segments. */
+        Liquid.prototype.variableSegmentsSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(strictUniq(Object.values(analysis.variables).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })));
+        };
+        /** Return an array of all expected context variables without their properties. */
+        Liquid.prototype.globalVariables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Object.keys(analysis.globals)];
+                    }
+                });
+            });
+        };
+        /** Return an array of all expected context variables without their properties. */
+        Liquid.prototype.globalVariablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Object.keys(analysis.globals);
+        };
+        /** Return an array of all expected context variables including their properties/paths. */
+        Liquid.prototype.globalFullVariables = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(new Set(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return String(v); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all expected context variables including their properties/paths. */
+        Liquid.prototype.globalFullVariablesSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(new Set(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return String(v); }); })));
+        };
+        /** Return an array of all expected context variables, each as an array of properties/segments. */
+        Liquid.prototype.globalVariableSegments = function (template, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var analysis;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, analyze(isString(template) ? this.parse(template) : template, options)];
+                        case 1:
+                            analysis = _a.sent();
+                            return [2 /*return*/, Array.from(strictUniq(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })))];
+                    }
+                });
+            });
+        };
+        /** Return an array of all expected context variables, each as an array of properties/segments. */
+        Liquid.prototype.globalVariableSegmentsSync = function (template, options) {
+            if (options === void 0) { options = {}; }
+            var analysis = analyzeSync(isString(template) ? this.parse(template) : template, options);
+            return Array.from(strictUniq(Object.values(analysis.globals).flatMap(function (a) { return a.map(function (v) { return v.toArray(); }); })));
+        };
         return Liquid;
     }());
 
     /* istanbul ignore file */
-    var version = '10.13.0';
+    var version = '10.20.1';
 
     exports.AssertionError = AssertionError;
     exports.AssignTag = default_1;
@@ -5541,13 +7132,13 @@
     exports.Output = Output;
     exports.ParseError = ParseError;
     exports.ParseStream = ParseStream;
+    exports.Parser = Parser;
     exports.RawTag = default_1$d;
     exports.RenderError = RenderError;
     exports.RenderTag = default_1$5;
     exports.TablerowTag = default_1$e;
     exports.Tag = Tag;
     exports.TagToken = TagToken;
-    exports.TimezoneDate = TimezoneDate;
     exports.Token = Token;
     exports.TokenizationError = TokenizationError;
     exports.Tokenizer = Tokenizer;
@@ -5555,6 +7146,9 @@
     exports.UndefinedVariableError = UndefinedVariableError;
     exports.UnlessTag = default_1$f;
     exports.Value = Value;
+    exports.Variable = Variable;
+    exports.analyze = analyze;
+    exports.analyzeSync = analyzeSync;
     exports.assert = assert;
     exports.createTrie = createTrie;
     exports.defaultOperators = defaultOperators;