@skeptools/skep-organization-project 0.0.15 → 0.0.16

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

@@ -1,5 +1,5 @@
 /*
- * liquidjs@10.13.0, https://github.com/harttle/liquidjs
+ * liquidjs@10.18.0, https://github.com/harttle/liquidjs
  * (c) 2016-2024 harttle
  * Released under the MIT License.
  */
@@ -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';
     }
@@ -325,7 +329,7 @@
             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) {
@@ -333,7 +337,7 @@
     }
 
     /**
-     * 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 +404,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 +507,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) {
@@ -622,7 +646,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 +760,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 +814,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 +825,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 +860,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 +898,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 +913,22 @@
         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}))$/;
+    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 +936,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 +1035,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) {
+        LiquidDate.createDateFixedToTimezone = function (dateString, locale) {
             var m = dateString.match(ISO8601_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 +1183,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));
 
@@ -1350,6 +1399,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 +1458,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 +1466,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 +1475,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]);
@@ -1431,8 +1491,12 @@
                         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 +1511,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];
                 }
             });
         };
@@ -1670,6 +1738,7 @@
         return !isFalsy(val, ctx);
     }
     function isFalsy(val, ctx) {
+        val = toValue(val);
         if (ctx.opts.jsTruthy) {
             return !val;
         }
@@ -1941,22 +2010,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 +2045,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 +2139,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 +2171,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 +2316,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 +2337,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 +2381,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 +2516,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 +2533,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;
@@ -2704,7 +2859,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 +2876,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 +2928,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 +2947,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 +3008,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;
         }
@@ -2906,7 +3060,7 @@
                 this.shouldLoadRelative = function (referencedFile) { return rRelativePath_1.test(referencedFile); };
             }
             else {
-                this.shouldLoadRelative = function (referencedFile) { return false; };
+                this.shouldLoadRelative = function (_referencedFile) { return false; };
             }
             this.contains = this.options.fs.contains || (function () { return true; });
         }
@@ -3053,8 +3207,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 +3219,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 +3240,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 +3296,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])];
                 }
             });
         };
@@ -3220,11 +3388,12 @@
     });
 
     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
@@ -3233,10 +3402,12 @@
             this.registers = {};
             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] || {});
@@ -3323,6 +3494,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];
@@ -3355,7 +3537,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 +3552,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 +3665,63 @@
         slugify: slugify
     });
 
-    var join = argumentsToValue(function (v, arg) { return toArray(v).join(arg === undefined ? ' ' : arg); });
+    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 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 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 +3738,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 +3784,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 +3831,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 +3858,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,6 +3872,7 @@
         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) {
@@ -3675,6 +3884,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 +3895,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;
@@ -3712,38 +3922,40 @@
         });
     }
     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*/];
@@ -3760,6 +3972,7 @@
                     map = new Map();
                     arr = toArray(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 +3981,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 +4010,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 = toArray(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 +4056,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 +4147,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 +4183,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 +4219,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;
-        }
-        if (!isValidDate(date))
-            return;
-        if (timezoneOffset !== undefined) {
-            date = new TimezoneDate(date, timezoneOffset);
+            date = new LiquidDate(v, locale, defaultTimezoneOffset);
         }
-        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 +4264,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 +4315,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 +4334,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 +4377,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 +4397,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 +4423,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 '';
@@ -4250,7 +4495,7 @@
     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 +4505,16 @@
             }
             _this.variable = variable.content;
             _this.collection = collection;
-            _this.hash = new Hash(_this.tokenizer.remaining());
+            _this.hash = new Hash(_this.tokenizer.remaining(), 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;
         }
@@ -4364,7 +4607,7 @@
 
     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();
@@ -4372,7 +4615,7 @@
                 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"));
         }
@@ -4404,7 +4647,7 @@
 
     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 +4655,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;
@@ -4545,10 +4788,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 +4825,7 @@
                 tokenizer.p = begin;
                 break;
             }
-            _this.hash = new Hash(tokenizer.remaining());
+            _this.hash = new Hash(tokenizer.remaining(), liquid.options.keyValueSeparator);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -4596,7 +4839,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];
@@ -4670,7 +4913,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 +4921,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 +4952,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 +4969,7 @@
             }
             else
                 tokenizer.p = begin;
-            _this.hash = new Hash(tokenizer.remaining(), _this.liquid.options.jekyllInclude);
+            _this.hash = new Hash(tokenizer.remaining(), liquid.options.jekyllInclude || liquid.options.keyValueSeparator);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -4836,37 +5079,29 @@
 
     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),
                 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),
                     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,7 +5143,7 @@
                         }
                         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*/];
@@ -4939,12 +5174,12 @@
 
     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.remaining(), liquid.options.keyValueSeparator);
+            _this.templates = parser.parseTokens(remainTokens);
             return _this;
         }
         default_1.prototype.render = function (ctx, emitter) {
@@ -4996,7 +5231,7 @@
 
     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 +5240,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"));
@@ -5098,7 +5333,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 +5344,10 @@
             }
             _this.variable = variable.content;
             _this.collection = collectionToken;
-            _this.args = new Hash(_this.tokenizer.remaining());
+            _this.args = new Hash(_this.tokenizer.remaining(), 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); })
@@ -5174,13 +5409,13 @@
 
     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),
                 test: isFalsy,
@@ -5310,10 +5545,10 @@
 
     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) {
@@ -5374,12 +5609,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 +5652,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;
@@ -5511,7 +5748,7 @@
     }());
 
     /* istanbul ignore file */
-    var version = '10.13.0';
+    var version = '10.18.0';
 
     exports.AssertionError = AssertionError;
     exports.AssignTag = default_1;
@@ -5547,7 +5784,6 @@
     exports.TablerowTag = default_1$e;
     exports.Tag = Tag;
     exports.TagToken = TagToken;
-    exports.TimezoneDate = TimezoneDate;
     exports.Token = Token;
     exports.TokenizationError = TokenizationError;
     exports.Tokenizer = Tokenizer;