@skeptools/skep-organization-project 0.0.15 → 0.0.16

package/node_modules/liquidjs/dist/{liquid.browser.esm.js → liquid.browser.mjs}

@@ -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.
  */
@@ -89,6 +89,10 @@ function toArray(val) {
 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';
 }
@@ -188,14 +192,14 @@ function caseInsensitiveCompare(a, b) {
     return 0;
 }
 function argumentsToValue(fn) {
-    return (...args) => fn(...args.map(toValue));
+    return function (...args) { return fn.call(this, ...args.map(toValue)); };
 }
 function escapeRegExp(text) {
     return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
 }
 
 /**
- * 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
  */
 const TRAIT = '__liquidClass__';
 class LiquidError extends Error {
@@ -249,6 +253,19 @@ class RenderError extends LiquidError {
         return obj.name === 'RenderError';
     }
 }
+class LiquidErrors extends LiquidError {
+    constructor(errors) {
+        super(errors[0], errors[0].token);
+        this.errors = errors;
+        this.name = 'LiquidErrors';
+        const s = errors.length > 1 ? 's' : '';
+        this.message = `${errors.length} error${s} found`;
+        super.update();
+    }
+    static is(obj) {
+        return obj.name === 'LiquidErrors';
+    }
+}
 class UndefinedVariableError extends LiquidError {
     constructor(err, token) {
         super(err, token);
@@ -327,6 +344,9 @@ function assert(predicate, message) {
             : (message || `expect ${predicate} to be true`);
         throw new AssertionError(msg);
     }
+}
+function assertEmpty(predicate, message = `unexpected ${JSON.stringify(predicate)}`) {
+    assert(!predicate, message);
 }
 
 class NullDrop extends Drop {
@@ -440,7 +460,12 @@ class BlockDrop extends 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));
 }
 
 const nil = new NullDrop();
@@ -560,18 +585,6 @@ function toValueSync(val) {
 }
 
 const rFormat = /%([-_0^#:]+)?(\d+)?([EO])?(.)/;
-const monthNames = [
-    'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
-    'September', 'October', 'November', 'December'
-];
-const dayNames = [
-    'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'
-];
-const monthNamesShort = monthNames.map(abbr);
-const dayNamesShort = dayNames.map(abbr);
-function abbr(str) {
-    return str.slice(0, 3);
-}
 // prototype extensions
 function daysInMonth(d) {
     const feb = isLeapYear(d) ? 29 : 28;
@@ -626,19 +639,7 @@ const padWidths = {
     U: 2,
     W: 2
 };
-// default to '0'
-const padChars = {
-    a: ' ',
-    A: ' ',
-    b: ' ',
-    B: ' ',
-    c: ' ',
-    e: ' ',
-    k: ' ',
-    l: ' ',
-    p: ' ',
-    P: ' '
-};
+const padSpaceChars = new Set('aAbBceklpP');
 function getTimezoneOffset(d, opts) {
     const nOffset = Math.abs(d.getTimezoneOffset());
     const h = Math.floor(nOffset / 60);
@@ -649,10 +650,10 @@ function getTimezoneOffset(d, opts) {
         padStart(m, 2, '0');
 }
 const formatCodes = {
-    a: (d) => dayNamesShort[d.getDay()],
-    A: (d) => dayNames[d.getDay()],
-    b: (d) => monthNamesShort[d.getMonth()],
-    B: (d) => monthNames[d.getMonth()],
+    a: (d) => d.getShortWeekdayName(),
+    A: (d) => d.getLongWeekdayName(),
+    b: (d) => d.getShortMonthName(),
+    B: (d) => d.getLongMonthName(),
     c: (d) => d.toLocaleString(),
     C: (d) => century(d),
     d: (d) => d.getDate(),
@@ -684,12 +685,7 @@ const formatCodes = {
     y: (d) => d.getFullYear().toString().slice(2, 4),
     Y: (d) => d.getFullYear(),
     z: getTimezoneOffset,
-    Z: (d, opts) => {
-        if (d.getTimezoneName) {
-            return d.getTimezoneName() || getTimezoneOffset(d, opts);
-        }
-        return (typeof Intl !== 'undefined' ? Intl.DateTimeFormat().resolvedOptions().timeZone : '');
-    },
+    Z: (d, opts) => d.getTimeZoneName() || getTimezoneOffset(d, opts),
     't': () => '\t',
     'n': () => '\n',
     '%': () => '%'
@@ -715,7 +711,7 @@ function format(d, match) {
     for (const flag of flagStr)
         flags[flag] = true;
     let ret = String(convert(d, { flags, width, modifier }));
-    let padChar = padChars[conversion] || '0';
+    let padChar = padSpaceChars.has(conversion) ? ' ' : '0';
     let padWidth = width || padWidths[conversion] || 0;
     if (flags['^'])
         ret = ret.toUpperCase();
@@ -730,9 +726,22 @@ function format(d, match) {
     return padStart(ret, padWidth, padChar);
 }
 
+function getDateTimeFormat() {
+    return (typeof Intl !== 'undefined' ? Intl.DateTimeFormat : undefined);
+}
+
 // one minute in milliseconds
 const OneMinute = 60000;
 const ISO8601_TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):(\d{2}))$/;
+const monthNames = [
+    'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
+    'September', 'October', 'November', 'December'
+];
+const monthNamesShort = monthNames.map(name => name.slice(0, 3));
+const dayNames = [
+    'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'
+];
+const dayNamesShort = dayNames.map(name => name.slice(0, 3));
 /**
  * A date implementation with timezone info, just like Ruby date
  *
@@ -740,12 +749,16 @@ const ISO8601_TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):(\d{2}))$/;
  * - create a Date offset by it's timezone difference, avoiding overriding a bunch of methods
  * - rewrite getTimezoneOffset() to trick strftime
  */
-class TimezoneDate {
-    constructor(init, timezone) {
-        this.date = init instanceof TimezoneDate
-            ? init.date
-            : new Date(init);
-        this.timezoneOffset = isString(timezone) ? TimezoneDate.getTimezoneOffset(timezone, this.date) : timezone;
+class LiquidDate {
+    constructor(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 : '';
         const diff = (this.date.getTimezoneOffset() - this.timezoneOffset) * OneMinute;
         const time = this.date.getTime() + diff;
@@ -793,8 +806,34 @@ class TimezoneDate {
     getTimezoneOffset() {
         return this.timezoneOffset;
     }
-    getTimezoneName() {
-        return this.timezoneName;
+    getTimeZoneName() {
+        if (this.timezoneFixed)
+            return this.timezoneName;
+        if (!this.DateTimeFormat)
+            return;
+        return this.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    getLongMonthName() {
+        var _a;
+        return (_a = this.format({ month: 'long' })) !== null && _a !== void 0 ? _a : monthNames[this.getMonth()];
+    }
+    getShortMonthName() {
+        var _a;
+        return (_a = this.format({ month: 'short' })) !== null && _a !== void 0 ? _a : monthNamesShort[this.getMonth()];
+    }
+    getLongWeekdayName() {
+        var _a;
+        return (_a = this.format({ weekday: 'long' })) !== null && _a !== void 0 ? _a : dayNames[this.displayDate.getDay()];
+    }
+    getShortWeekdayName() {
+        var _a;
+        return (_a = this.format({ weekday: 'short' })) !== null && _a !== void 0 ? _a : dayNamesShort[this.displayDate.getDay()];
+    }
+    valid() {
+        return !isNaN(this.getTime());
+    }
+    format(options) {
+        return this.DateTimeFormat && this.DateTimeFormat(this.locale, options).format(this.displayDate);
     }
     /**
      * Create a Date object fixed to it's declared Timezone. Both
@@ -809,21 +848,21 @@ class TimezoneDate {
      * 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.
      */
-    static createDateFixedToTimezone(dateString) {
+    static createDateFixedToTimezone(dateString, locale) {
         const 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]) {
             const [, , sign, hours, minutes] = m;
             const 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);
     }
-    static getTimezoneOffset(timezoneName, date = new Date()) {
+    static getTimezoneOffset(timezoneName, date) {
         const localDateString = date.toLocaleString('en-US', { timeZone: timezoneName });
         const utcDateString = date.toLocaleString('en-US', { timeZone: 'UTC' });
         const localDate = new Date(localDateString);
@@ -832,6 +871,23 @@ class TimezoneDate {
     }
 }
 
+class Limiter {
+    constructor(resource, limit) {
+        this.base = 0;
+        this.message = `${resource} limit exceeded`;
+        this.limit = limit;
+    }
+    use(count) {
+        count = toNumber(count);
+        assert(this.base + count <= this.limit, this.message);
+        this.base += count;
+    }
+    check(count) {
+        count = toNumber(count);
+        assert(count <= this.limit, this.message);
+    }
+}
+
 class DelimitedToken extends Token {
     constructor(kind, [contentBegin, contentEnd], input, begin, end, trimLeft, trimRight, file) {
         super(kind, input, begin, end, file);
@@ -912,16 +968,6 @@ class IdentifierToken extends Token {
         this.file = file;
         this.content = this.getText();
     }
-    isNumber(allowSign = false) {
-        const begin = allowSign && TYPES[this.input.charCodeAt(this.begin)] & SIGN
-            ? this.begin + 1
-            : this.begin;
-        for (let i = begin; i < this.end; i++) {
-            if (!(TYPES[this.input.charCodeAt(i)] & NUMBER))
-                return false;
-        }
-        return true;
-    }
 }
 
 class LiteralToken extends Token {
@@ -1110,6 +1156,15 @@ class FilteredValueToken extends Token {
     }
 }
 
+const polyfill = {
+    now: () => Date.now()
+};
+function getPerformance() {
+    return (typeof global === 'object' && global.performance) ||
+        (typeof window === 'object' && window.performance) ||
+        polyfill;
+}
+
 class SimpleEmitter {
     constructor() {
         this.buffer = '';
@@ -1157,7 +1212,9 @@ class Render {
         if (!emitter) {
             emitter = ctx.opts.keepOutputType ? new KeepingTypeEmitter() : new SimpleEmitter();
         }
+        const errors = [];
         for (const tpl of templates) {
+            ctx.renderLimit.check(getPerformance().now());
             try {
                 // if tpl.render supports emitter, it'll return empty `html`
                 const html = yield tpl.render(ctx, emitter);
@@ -1167,10 +1224,16 @@ class Render {
                     break;
             }
             catch (e) {
-                const err = RenderError.is(e) ? e : new RenderError(e, tpl);
-                throw err;
+                const err = LiquidError.is(e) ? e : new RenderError(e, tpl);
+                if (ctx.opts.catchAllErrors)
+                    errors.push(err);
+                else
+                    throw err;
             }
         }
+        if (errors.length) {
+            throw new LiquidErrors(errors);
+        }
         return emitter.buffer;
     }
 }
@@ -1264,6 +1327,7 @@ function isTruthy(val, ctx) {
     return !isFalsy(val, ctx);
 }
 function isFalsy(val, ctx) {
+    val = toValue(val);
     if (ctx.opts.jsTruthy) {
         return !val;
     }
@@ -1522,22 +1586,30 @@ const unescapeMap = {
     '&#39;': "'"
 };
 function escape(str) {
-    return stringify(str).replace(/&|<|>|"|'/g, m => escapeMap[m]);
+    str = stringify(str);
+    this.context.memoryLimit.use(str.length);
+    return str.replace(/&|<|>|"|'/g, m => 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, m => unescapeMap[m]);
+    str = stringify(str);
+    this.context.memoryLimit.use(str.length);
+    return str.replace(/&(amp|lt|gt|#34|#39);/g, m => 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');
+    const 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, '');
+    const 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({
@@ -1549,18 +1621,68 @@ var htmlFilters = /*#__PURE__*/Object.freeze({
   strip_html: strip_html
 });
 
+class MapFS {
+    constructor(mapping) {
+        this.mapping = mapping;
+        this.sep = '/';
+    }
+    exists(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.existsSync(filepath);
+        });
+    }
+    existsSync(filepath) {
+        return !isNil(this.mapping[filepath]);
+    }
+    readFile(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readFileSync(filepath);
+        });
+    }
+    readFileSync(filepath) {
+        const content = this.mapping[filepath];
+        if (isNil(content))
+            throw new Error(`ENOENT: ${filepath}`);
+        return content;
+    }
+    dirname(filepath) {
+        const segments = filepath.split(this.sep);
+        segments.pop();
+        return segments.join(this.sep);
+    }
+    resolve(dir, file, ext) {
+        file += ext;
+        if (dir === '.')
+            return file;
+        const segments = dir.split(/\/+/);
+        for (const segment of file.split(this.sep)) {
+            if (segment === '.' || segment === '')
+                continue;
+            else if (segment === '..') {
+                if (segments.length > 1 || segments[0] !== '')
+                    segments.pop();
+            }
+            else
+                segments.push(segment);
+        }
+        return segments.join(this.sep);
+    }
+}
+
 const 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,
@@ -1577,9 +1699,13 @@ const defaultOptions = {
     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;
@@ -1605,6 +1731,14 @@ function normalize(options) {
     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) {
@@ -1731,9 +1865,7 @@ class Tokenizer {
         this.skipBlank();
         if (this.end())
             return null;
-        this.assert(this.peek() === '|', `expected "|" before filter`);
-        this.p++;
-        const begin = this.p;
+        this.assert(this.read() === '|', `expected "|" before filter`);
         const name = this.readIdentifier();
         if (!name.size()) {
             this.assert(this.end(), `expected filter name`);
@@ -1754,7 +1886,7 @@ class Tokenizer {
         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);
     }
     readFilterArg() {
         const key = this.readValue();
@@ -1795,7 +1927,7 @@ class Tokenizer {
         }
         return new HTMLToken(this.input, begin, this.p, this.file);
     }
-    readTagToken(options = defaultOptions) {
+    readTagToken(options) {
         const { file, input } = this;
         const begin = this.p;
         if (this.readToDelimiter(options.tagDelimiterRight) === -1) {
@@ -1926,7 +2058,7 @@ class Tokenizer {
             return;
         let value;
         this.skipBlank();
-        const sep = jekyllStyle ? '=' : ':';
+        const sep = isString(jekyllStyle) ? jekyllStyle : (jekyllStyle ? '=' : ':');
         if (this.peek() === sep) {
             ++this.p;
             value = this.readValue();
@@ -1942,6 +2074,9 @@ class Tokenizer {
     end() {
         return this.p >= this.N;
     }
+    read() {
+        return this.input[this.p++];
+    }
     readTo(end) {
         while (this.p < this.N) {
             ++this.p;
@@ -2190,7 +2325,7 @@ function createTagClass(options) {
             }
         }
         *render(ctx, emitter) {
-            const hash = (yield new Hash(this.token.args).render(ctx));
+            const hash = (yield new Hash(this.token.args, ctx.opts.keyValueSeparator).render(ctx));
             return yield options.render.call(this, ctx, emitter, hash);
         }
     };
@@ -2201,13 +2336,14 @@ function isKeyValuePair(arr) {
 }
 
 class Filter {
-    constructor(name, options, args, liquid) {
-        this.name = name;
+    constructor(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;
     }
     *render(value, context) {
@@ -2218,7 +2354,7 @@ class Filter {
             else
                 argv.push(yield evalToken(arg, context));
         }
-        return yield this.handler.apply({ context, liquid: this.liquid }, [value, ...argv]);
+        return yield this.handler.apply({ context, token: this.token, liquid: this.liquid }, [value, ...argv]);
     }
 }
 
@@ -2232,7 +2368,7 @@ class Value {
             ? new Tokenizer(input, liquid.options.operators).readFilteredValue()
             : input;
         this.initial = token.initial;
-        this.filters = token.filters.map(({ name, args }) => new Filter(name, this.getFilter(liquid, name), args, liquid));
+        this.filters = token.filters.map(token => new Filter(token, this.getFilter(liquid, token.name), liquid));
     }
     *value(ctx, lenient) {
         lenient = lenient || (ctx.opts.lenientIf && this.filters.length > 0 && this.filters[0].name === 'default');
@@ -2258,7 +2394,8 @@ class Output extends TemplateImpl {
         const filters = this.value.filters;
         const 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));
+            const token = new FilterToken(toString.call(outputEscape), [], '', 0, 0);
+            filters.push(new Filter(token, outputEscape, liquid));
         }
     }
     *render(ctx, emitter) {
@@ -2293,7 +2430,7 @@ class Loader {
             this.shouldLoadRelative = (referencedFile) => rRelativePath.test(referencedFile);
         }
         else {
-            this.shouldLoadRelative = (referencedFile) => false;
+            this.shouldLoadRelative = (_referencedFile) => false;
         }
         this.contains = this.options.fs.contains || (() => true);
     }
@@ -2350,8 +2487,11 @@ class Parser {
         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);
     }
     parse(html, filepath) {
+        html = String(html);
+        this.parseLimit.use(html.length);
         const tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath);
         const tokens = tokenizer.readTopLevelTokens(this.liquid.options);
         return this.parseTokens(tokens);
@@ -2359,9 +2499,20 @@ class Parser {
     parseTokens(tokens) {
         let token;
         const templates = [];
+        const 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;
     }
     parseToken(token, remainTokens) {
@@ -2369,7 +2520,7 @@ class Parser {
             if (isTagToken(token)) {
                 const TagClass = this.liquid.tags[token.name];
                 assert(TagClass, `tag "${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);
@@ -2407,7 +2558,7 @@ class Parser {
     }
     *_parseFile(file, sync, type = LookupType.Root, currentFile) {
         const filepath = yield this.loader.lookup(file, type, sync, currentFile);
-        return this.liquid.parse(sync ? this.fs.readFileSync(filepath) : yield this.fs.readFile(filepath), filepath);
+        return this.parse(sync ? this.fs.readFileSync(filepath) : yield this.fs.readFile(filepath), filepath);
     }
 }
 
@@ -2482,8 +2633,8 @@ var typeGuards = /*#__PURE__*/Object.freeze({
 });
 
 class Context {
-    constructor(env = {}, opts = defaultOptions, renderOptions = {}) {
-        var _a, _b, _c;
+    constructor(env = {}, opts = defaultOptions, renderOptions = {}, { memoryLimit, renderLimit } = {}) {
+        var _a, _b, _c, _d, _e;
         /**
          * insert a Context-level empty scope,
          * for tags like `{% capture %}` `{% assign %}` to operate
@@ -2496,6 +2647,8 @@ class Context {
         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.memoryLimit = memoryLimit !== null && memoryLimit !== void 0 ? memoryLimit : new Limiter('memory alloc', (_d = renderOptions.memoryLimit) !== null && _d !== void 0 ? _d : opts.memoryLimit);
+        this.renderLimit = renderLimit !== null && renderLimit !== void 0 ? renderLimit : new Limiter('template render', getPerformance().now() + ((_e = renderOptions.renderLimit) !== null && _e !== void 0 ? _e : opts.renderLimit));
     }
     getRegister(key) {
         return (this.registers[key] = this.registers[key] || {});
@@ -2552,6 +2705,16 @@ class Context {
     bottom() {
         return this.scopes[0];
     }
+    spawn(scope = {}) {
+        return new Context(scope, this.opts, {
+            sync: this.sync,
+            globals: this.globals,
+            strictVariables: this.strictVariables
+        }, {
+            renderLimit: this.renderLimit,
+            memoryLimit: this.memoryLimit
+        });
+    }
     findScope(key) {
         for (let i = this.scopes.length - 1; i >= 0; i--) {
             const candidate = this.scopes[i];
@@ -2583,7 +2746,7 @@ function readProperty(obj, key, ownPropertyOnly) {
     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];
 }
@@ -2598,7 +2761,7 @@ function readLast(obj) {
     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;
@@ -2705,13 +2868,25 @@ var urlFilters = /*#__PURE__*/Object.freeze({
   slugify: slugify
 });
 
-const join = argumentsToValue((v, arg) => toArray(v).join(arg === undefined ? ' ' : arg));
+const join = argumentsToValue(function (v, arg) {
+    const array = toArray(v);
+    const sep = isNil(arg) ? ' ' : stringify(arg);
+    const complexity = array.length * (1 + sep.length);
+    this.context.memoryLimit.use(complexity);
+    return array.join(sep);
+});
 const last$1 = argumentsToValue((v) => isArray(v) ? last(v) : '');
 const first = argumentsToValue((v) => isArray(v) ? v[0] : '');
-const reverse = argumentsToValue((v) => [...toArray(v)].reverse());
+const reverse = argumentsToValue(function (v) {
+    const array = toArray(v);
+    this.context.memoryLimit.use(array.length);
+    return [...array].reverse();
+});
 function* sort(arr, property) {
     const values = [];
-    for (const item of toArray(arr)) {
+    const array = toArray(arr);
+    this.context.memoryLimit.use(array.length);
+    for (const item of array) {
         values.push([
             item,
             property ? yield this.context._getFromScope(item, stringify(property).split('.'), false) : item
@@ -2728,35 +2903,47 @@ function sort_natural(input, property) {
     const compare = property === undefined
         ? caseInsensitiveCompare
         : (lhs, rhs) => caseInsensitiveCompare(lhs[propertyString], rhs[propertyString]);
-    return [...toArray(input)].sort(compare);
+    const array = toArray(input);
+    this.context.memoryLimit.use(array.length);
+    return [...array].sort(compare);
 }
 const size = (v) => (v && v.length) || 0;
 function* map(arr, property) {
     const results = [];
-    for (const item of toArray(arr)) {
+    const array = toArray(arr);
+    this.context.memoryLimit.use(array.length);
+    for (const item of array) {
         results.push(yield this.context._getFromScope(item, stringify(property), false));
     }
     return results;
 }
 function* sum(arr, property) {
     let sum = 0;
-    for (const item of toArray(arr)) {
+    const array = toArray(arr);
+    for (const item of array) {
         const data = Number(property ? yield this.context._getFromScope(item, stringify(property), false) : item);
         sum += Number.isNaN(data) ? 0 : data;
     }
     return sum;
 }
 function compact(arr) {
-    return toArray(arr).filter(x => !isNil(toValue(x)));
+    const array = toArray(arr);
+    this.context.memoryLimit.use(array.length);
+    return array.filter(x => !isNil(toValue(x)));
 }
 function concat(v, arg = []) {
-    return toArray(v).concat(toArray(arg));
+    const lhs = toArray(v);
+    const 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) {
-    const clone = [...toArray(v)];
+    const array = toArray(v);
+    this.context.memoryLimit.use(array.length);
+    const clone = [...array];
     clone.unshift(arg);
     return clone;
 }
@@ -2766,7 +2953,9 @@ function pop(v) {
     return clone;
 }
 function shift(v) {
-    const clone = [...toArray(v)];
+    const array = toArray(v);
+    this.context.memoryLimit.use(array.length);
+    const clone = [...array];
     clone.shift();
     return clone;
 }
@@ -2777,14 +2966,16 @@ function slice(v, begin, length = 1) {
     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) {
     const values = [];
     arr = toArray(arr);
+    this.context.memoryLimit.use(arr.length);
     const token = new Tokenizer(stringify(property)).readScopeValue();
     for (const item of arr) {
-        values.push(yield evalToken(token, new Context(item)));
+        values.push(yield evalToken(token, this.context.spawn(item)));
     }
     return arr.filter((_, i) => {
         if (expected === undefined)
@@ -2795,8 +2986,10 @@ function* where(arr, property, expected) {
 function* where_exp(arr, itemName, exp) {
     const filtered = [];
     const keyTemplate = new Value(stringify(exp), this.liquid);
-    for (const item of toArray(arr)) {
-        const value = yield keyTemplate.value(new Context({ [itemName]: item }));
+    const array = toArray(arr);
+    this.context.memoryLimit.use(array.length);
+    for (const item of array) {
+        const value = yield keyTemplate.value(this.context.spawn({ [itemName]: item }));
         if (value)
             filtered.push(item);
     }
@@ -2806,8 +2999,9 @@ function* group_by(arr, property) {
     const map = new Map();
     arr = toArray(arr);
     const token = new Tokenizer(stringify(property)).readScopeValue();
+    this.context.memoryLimit.use(arr.length);
     for (const item of arr) {
-        const key = yield evalToken(token, new Context(item));
+        const key = yield evalToken(token, this.context.spawn(item));
         if (!map.has(key))
             map.set(key, []);
         map.get(key).push(item);
@@ -2817,8 +3011,10 @@ function* group_by(arr, property) {
 function* group_by_exp(arr, itemName, exp) {
     const map = new Map();
     const keyTemplate = new Value(stringify(exp), this.liquid);
-    for (const item of toArray(arr)) {
-        const key = yield keyTemplate.value(new Context({ [itemName]: item }));
+    arr = toArray(arr);
+    this.context.memoryLimit.use(arr.length);
+    for (const item of arr) {
+        const key = yield keyTemplate.value(this.context.spawn({ [itemName]: item }));
         if (!map.has(key))
             map.set(key, []);
         map.get(key).push(item);
@@ -2827,31 +3023,26 @@ function* group_by_exp(arr, itemName, exp) {
 }
 function* find(arr, property, expected) {
     const token = new Tokenizer(stringify(property)).readScopeValue();
-    for (const item of toArray(arr)) {
-        const value = yield evalToken(token, new Context(item));
+    const array = toArray(arr);
+    for (const item of array) {
+        const value = yield evalToken(token, this.context.spawn(item));
         if (equals(value, expected))
             return item;
     }
-    return null;
 }
 function* find_exp(arr, itemName, exp) {
     const predicate = new Value(stringify(exp), this.liquid);
-    for (const item of toArray(arr)) {
-        const value = yield predicate.value(new Context({ [itemName]: item }));
+    const array = toArray(arr);
+    for (const item of array) {
+        const value = yield predicate.value(this.context.spawn({ [itemName]: item }));
         if (value)
             return item;
     }
-    return null;
 }
 function uniq(arr) {
-    arr = toValue(arr);
-    const u = {};
-    return (arr || []).filter(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 [...new Set(arr)];
 }
 function sample(v, count = 1) {
     v = toValue(v);
@@ -2859,6 +3050,7 @@ function sample(v, count = 1) {
         return [];
     if (!isArray(v))
         v = stringify(v);
+    this.context.memoryLimit.use(count);
     const shuffled = [...v].sort(() => Math.random() - 0.5);
     if (count === 1)
         return shuffled[0];
@@ -2894,6 +3086,9 @@ var arrayFilters = /*#__PURE__*/Object.freeze({
 });
 
 function date(v, format, timezoneOffset) {
+    var _a, _b, _c;
+    const 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);
     const date = parseDate(v, this.context.opts, timezoneOffset);
     if (!date)
         return v;
@@ -2927,39 +3122,30 @@ function stringify_date(v, month_type, type, style) {
 }
 function parseDate(v, opts, timezoneOffset) {
     let date;
+    const defaultTimezoneOffset = timezoneOffset !== null && timezoneOffset !== void 0 ? timezoneOffset : opts.timezoneOffset;
+    const 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);
-    }
-    else if (!(date instanceof TimezoneDate) && opts.timezoneOffset !== undefined) {
-        date = new TimezoneDate(date, opts.timezoneOffset);
+        date = new LiquidDate(v, locale, defaultTimezoneOffset);
     }
-    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({
@@ -2981,33 +3167,50 @@ const rCJKWord = /[\u4E00-\u9FFF\uF900-\uFAFF\u3400-\u4DBF\u3040-\u309F\u30A0-\u
 const 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);
+    const lhs = stringify(v);
+    const 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);
+    const lhs = stringify(v);
+    const rhs = stringify(arg);
+    this.context.memoryLimit.use(lhs.length + rhs.length);
+    return rhs + lhs;
 }
 function lstrip(v, chars) {
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
     if (chars) {
         chars = escapeRegExp(stringify(chars));
-        return stringify(v).replace(new RegExp(`^[${chars}]+`, 'g'), '');
+        return str.replace(new RegExp(`^[${chars}]+`, 'g'), '');
     }
-    return stringify(v).replace(/^\s+/, '');
+    return str.replace(/^\s+/, '');
 }
 function downcase(v) {
-    return stringify(v).toLowerCase();
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
+    return str.toLowerCase();
 }
-function upcase(str) {
+function upcase(v) {
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
     return stringify(str).toUpperCase();
 }
 function remove(v, arg) {
-    return stringify(v).split(stringify(arg)).join('');
+    const 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), '');
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
+    return str.replace(stringify(l), '');
 }
 function remove_last(v, l) {
     const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
     const pattern = stringify(l);
     const index = str.lastIndexOf(pattern);
     if (index === -1)
@@ -3015,14 +3218,18 @@ function remove_last(v, l) {
     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(`[${chars}]+$`, 'g'), '');
+        return str.replace(new RegExp(`[${chars}]+$`, 'g'), '');
     }
-    return stringify(str).replace(/\s+$/, '');
+    return str.replace(/\s+$/, '');
 }
 function split(v, arg) {
-    const arr = stringify(v).split(stringify(arg));
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
+    const 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] === '')
@@ -3030,29 +3237,39 @@ function split(v, arg) {
     return arr;
 }
 function strip(v, chars) {
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
     if (chars) {
         chars = escapeRegExp(stringify(chars));
-        return stringify(v)
+        return str
             .replace(new RegExp(`^[${chars}]+`, 'g'), '')
             .replace(new RegExp(`[${chars}]+$`, 'g'), '');
     }
-    return stringify(v).trim();
+    return str.trim();
 }
 function strip_newlines(v) {
-    return stringify(v).replace(/\r?\n/gm, '');
+    const 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);
+    const 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);
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
+    return str.replace(stringify(arg1), arg2);
 }
 function replace_last(v, arg1, arg2) {
     const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
     const pattern = stringify(arg1);
     const index = str.lastIndexOf(pattern);
     if (index === -1)
@@ -3061,13 +3278,16 @@ function replace_last(v, arg1, arg2) {
     return str.substring(0, index) + replacement + str.substring(index + pattern.length);
 }
 function truncate(v, l = 50, o = '...') {
-    v = stringify(v);
-    if (v.length <= l)
+    const 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 = 15, o = '...') {
-    const arr = stringify(v).split(/\s+/);
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
+    const arr = str.split(/\s+/);
     if (words <= 0)
         words = 1;
     let ret = arr.slice(0, words).join(' ');
@@ -3076,11 +3296,14 @@ function truncatewords(v, words = 15, o = '...') {
     return ret;
 }
 function normalize_whitespace(v) {
-    v = stringify(v);
-    return v.replace(/\s+/g, ' ');
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
+    return str.replace(/\s+/g, ' ');
 }
 function number_of_words(input, mode) {
-    input = stringify(input).trim();
+    const str = stringify(input);
+    this.context.memoryLimit.use(str.length);
+    input = str.trim();
     if (!input)
         return 0;
     switch (mode) {
@@ -3098,6 +3321,7 @@ function number_of_words(input, mode) {
     }
 }
 function array_to_sentence_string(array, connector = 'and') {
+    this.context.memoryLimit.use(array.length);
     switch (array.length) {
         case 0:
             return '';
@@ -3154,7 +3378,7 @@ class AssignTag extends Tag {
 
 const MODIFIERS = ['offset', 'limit', 'reversed'];
 class ForTag extends Tag {
-    constructor(token, remainTokens, liquid) {
+    constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
         const variable = this.tokenizer.readIdentifier();
         const inStr = this.tokenizer.readIdentifier();
@@ -3164,18 +3388,16 @@ class ForTag extends Tag {
         }
         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 = [];
         let p;
-        const stream = this.liquid.parser.parseStream(remainTokens)
+        const stream = parser.parseStream(remainTokens)
             .on('start', () => (p = this.templates))
-            .on('tag:else', () => (p = this.elseTemplates))
-            .on('tag:endfor', () => stream.stop())
+            .on('tag:else', tag => { assertEmpty(tag.args); p = this.elseTemplates; })
+            .on('tag:endfor', tag => { assertEmpty(tag.args); stream.stop(); })
             .on('template', (tpl) => p.push(tpl))
-            .on('end', () => {
-            throw new Error(`tag ${token.getText()} not closed`);
-        });
+            .on('end', () => { throw new Error(`tag ${token.getText()} not closed`); });
         stream.start();
     }
     *render(ctx, emitter) {
@@ -3226,7 +3448,7 @@ function limit(arr, count) {
 }
 
 class CaptureTag extends Tag {
-    constructor(tagToken, remainTokens, liquid) {
+    constructor(tagToken, remainTokens, liquid, parser) {
         super(tagToken, remainTokens, liquid);
         this.templates = [];
         this.variable = this.readVariableName();
@@ -3234,7 +3456,7 @@ class CaptureTag extends Tag {
             const token = remainTokens.shift();
             if (isTagToken(token) && token.name === 'endcapture')
                 return;
-            this.templates.push(liquid.parser.parseToken(token, remainTokens));
+            this.templates.push(parser.parseToken(token, remainTokens));
         }
         throw new Error(`tag ${tagToken.getText()} not closed`);
     }
@@ -3255,7 +3477,7 @@ class CaptureTag extends Tag {
 }
 
 class CaseTag extends Tag {
-    constructor(tagToken, remainTokens, liquid) {
+    constructor(tagToken, remainTokens, liquid, parser) {
         super(tagToken, remainTokens, liquid);
         this.branches = [];
         this.elseTemplates = [];
@@ -3263,7 +3485,7 @@ class CaseTag extends Tag {
         this.elseTemplates = [];
         let p = [];
         let elseCount = 0;
-        const stream = this.liquid.parser.parseStream(remainTokens)
+        const stream = parser.parseStream(remainTokens)
             .on('tag:when', (token) => {
             if (elseCount > 0) {
                 return;
@@ -3334,10 +3556,10 @@ class CommentTag extends Tag {
 }
 
 class RenderTag extends Tag {
-    constructor(token, remainTokens, liquid) {
+    constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
         const 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();
@@ -3371,13 +3593,13 @@ class RenderTag extends Tag {
             tokenizer.p = begin;
             break;
         }
-        this.hash = new Hash(tokenizer.remaining());
+        this.hash = new Hash(tokenizer.remaining(), liquid.options.keyValueSeparator);
     }
     *render(ctx, emitter) {
         const { liquid, hash } = this;
         const filepath = (yield renderFilePath(this['file'], ctx, liquid));
         assert(filepath, () => `illegal file path "${filepath}"`);
-        const childCtx = new Context({}, ctx.opts, { sync: ctx.sync, globals: ctx.globals, strictVariables: ctx.strictVariables });
+        const childCtx = ctx.spawn();
         const scope = childCtx.bottom();
         __assign(scope, yield hash.render(ctx));
         if (this['with']) {
@@ -3407,7 +3629,7 @@ class RenderTag extends Tag {
  * @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) {
         const file = tokenizer.readValue();
         tokenizer.assert(file, 'illegal file path');
@@ -3415,13 +3637,13 @@ function parseFilePath(tokenizer, liquid) {
             return;
         if (isQuotedToken(file)) {
             // for filenames like "files/{{file}}", eval as liquid template
-            const templates = liquid.parse(evalQuotedToken(file));
+            const templates = parser.parse(evalQuotedToken(file));
             return optimize(templates);
         }
         return file;
     }
     const tokens = [...tokenizer.readFileNameTemplate(liquid.options)];
-    const templates = optimize(liquid.parser.parseTokens(tokens));
+    const templates = optimize(parser.parseTokens(tokens));
     return templates === 'none' ? undefined : templates;
 }
 function optimize(templates) {
@@ -3439,10 +3661,10 @@ function* renderFilePath(file, ctx, liquid) {
 }
 
 class IncludeTag extends Tag {
-    constructor(token, remainTokens, liquid) {
+    constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
         const { tokenizer } = token;
-        this['file'] = parseFilePath(tokenizer, this.liquid);
+        this['file'] = parseFilePath(tokenizer, this.liquid, parser);
         this['currentFile'] = token.file;
         const begin = tokenizer.p;
         const withStr = tokenizer.readIdentifier();
@@ -3456,7 +3678,7 @@ class IncludeTag extends Tag {
         }
         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);
     }
     *render(ctx, emitter) {
         const { liquid, hash, withVar } = this;
@@ -3529,37 +3751,29 @@ class CycleTag extends Tag {
 }
 
 class IfTag extends Tag {
-    constructor(tagToken, remainTokens, liquid) {
+    constructor(tagToken, remainTokens, liquid, parser) {
         super(tagToken, remainTokens, liquid);
         this.branches = [];
-        this.elseTemplates = [];
         let p = [];
-        let elseCount = 0;
-        liquid.parser.parseStream(remainTokens)
+        parser.parseStream(remainTokens)
             .on('start', () => this.branches.push({
             value: new Value(tagToken.args, this.liquid),
             templates: (p = [])
         }))
             .on('tag:elsif', (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', () => {
-            elseCount++;
-            p = this.elseTemplates;
-        })
-            .on('tag:endif', function () { this.stop(); })
-            .on('template', (tpl) => {
-            if (p !== this.elseTemplates || elseCount === 1) {
-                p.push(tpl);
-            }
+            .on('tag:else', tag => {
+            assertEmpty(tag.args);
+            assert(!this.elseTemplates, 'duplicated else');
+            p = this.elseTemplates = [];
         })
+            .on('tag:endif', function (tag) { assertEmpty(tag.args); this.stop(); })
+            .on('template', (tpl) => p.push(tpl))
             .on('end', () => { throw new Error(`tag ${tagToken.getText()} not closed`); })
             .start();
     }
@@ -3572,7 +3786,7 @@ class IfTag extends Tag {
                 return;
             }
         }
-        yield r.renderTemplates(this.elseTemplates, ctx, emitter);
+        yield r.renderTemplates(this.elseTemplates || [], ctx, emitter);
     }
 }
 
@@ -3593,12 +3807,12 @@ class IncrementTag extends Tag {
 }
 
 class LayoutTag extends Tag {
-    constructor(token, remainTokens, liquid) {
+    constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
-        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);
     }
     *render(ctx, emitter) {
         const { liquid, args, file } = this;
@@ -3627,7 +3841,7 @@ class LayoutTag extends Tag {
 }
 
 class BlockTag extends Tag {
-    constructor(token, remainTokens, liquid) {
+    constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
         this.templates = [];
         const match = /\w+/.exec(token.args);
@@ -3636,7 +3850,7 @@ class BlockTag extends Tag {
             const token = remainTokens.shift();
             if (isTagToken(token) && token.name === 'endblock')
                 return;
-            const template = liquid.parser.parseToken(token, remainTokens);
+            const template = parser.parseToken(token, remainTokens);
             this.templates.push(template);
         }
         throw new Error(`tag ${token.getText()} not closed`);
@@ -3706,7 +3920,7 @@ class TablerowloopDrop extends ForloopDrop {
 }
 
 class TablerowTag extends Tag {
-    constructor(tagToken, remainTokens, liquid) {
+    constructor(tagToken, remainTokens, liquid, parser) {
         super(tagToken, remainTokens, liquid);
         const variable = this.tokenizer.readIdentifier();
         this.tokenizer.skipBlank();
@@ -3717,10 +3931,10 @@ class TablerowTag extends Tag {
         }
         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 = [];
         let p;
-        const stream = this.liquid.parser.parseStream(remainTokens)
+        const stream = parser.parseStream(remainTokens)
             .on('start', () => (p = this.templates))
             .on('tag:endtablerow', () => stream.stop())
             .on('template', (tpl) => p.push(tpl))
@@ -3758,13 +3972,13 @@ class TablerowTag extends Tag {
 }
 
 class UnlessTag extends Tag {
-    constructor(tagToken, remainTokens, liquid) {
+    constructor(tagToken, remainTokens, liquid, parser) {
         super(tagToken, remainTokens, liquid);
         this.branches = [];
         this.elseTemplates = [];
         let p = [];
         let elseCount = 0;
-        this.liquid.parser.parseStream(remainTokens)
+        parser.parseStream(remainTokens)
             .on('start', () => this.branches.push({
             value: new Value(tagToken.args, this.liquid),
             test: isFalsy,
@@ -3836,10 +4050,10 @@ class EchoTag extends Tag {
 }
 
 class LiquidTag extends Tag {
-    constructor(token, remainTokens, liquid) {
+    constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
         const tokens = this.tokenizer.readLiquidTagTokens(this.liquid.options);
-        this.templates = this.liquid.parser.parseTokens(tokens);
+        this.templates = parser.parseTokens(tokens);
     }
     *render(ctx, emitter) {
         yield this.liquid.renderer.renderTemplates(this.templates, ctx, emitter);
@@ -3886,12 +4100,14 @@ class Liquid {
         this.filters = {};
         this.tags = {};
         this.options = normalize(opts);
+        // eslint-disable-next-line deprecation/deprecation
         this.parser = new Parser(this);
         forOwn(tags, (conf, name) => this.registerTag(name, conf));
         forOwn(filters, (handler, name) => this.registerFilter(name, handler));
     }
     parse(html, filepath) {
-        return this.parser.parse(html, filepath);
+        const parser = new Parser(this);
+        return parser.parse(html, filepath);
     }
     _render(tpl, scope, renderOptions) {
         const ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions);
@@ -3922,21 +4138,21 @@ class Liquid {
         return toValueSync(this._parseAndRender(html, scope, Object.assign(Object.assign({}, renderOptions), { sync: true })));
     }
     _parsePartialFile(file, sync, currentFile) {
-        return this.parser.parseFile(file, sync, LookupType.Partials, currentFile);
+        return new Parser(this).parseFile(file, sync, LookupType.Partials, currentFile);
     }
     _parseLayoutFile(file, sync, currentFile) {
-        return this.parser.parseFile(file, sync, LookupType.Layouts, currentFile);
+        return new Parser(this).parseFile(file, sync, LookupType.Layouts, currentFile);
     }
     _parseFile(file, sync, lookupType, currentFile) {
-        return this.parser.parseFile(file, sync, lookupType, currentFile);
+        return new Parser(this).parseFile(file, sync, lookupType, currentFile);
     }
     parseFile(file, lookupType) {
         return __awaiter(this, void 0, void 0, function* () {
-            return toPromise(this.parser.parseFile(file, false, lookupType));
+            return toPromise(new Parser(this).parseFile(file, false, lookupType));
         });
     }
     parseFileSync(file, lookupType) {
-        return toValueSync(this.parser.parseFile(file, true, lookupType));
+        return toValueSync(new Parser(this).parseFile(file, true, lookupType));
     }
     *_renderFile(file, ctx, renderFileOptions) {
         const templates = (yield this._parseFile(file, renderFileOptions.sync, renderFileOptions.lookupType));
@@ -3995,6 +4211,6 @@ class Liquid {
 }
 
 /* istanbul ignore file */
-const version = '10.13.0';
+const version = '[VI]{version}[/VI]';
 
-export { AssertionError, AssignTag, BlockTag, BreakTag, CaptureTag, CaseTag, CommentTag, Context, ContinueTag, CycleTag, DecrementTag, Drop, EchoTag, Expression, Filter, ForTag, Hash, IfTag, IncludeTag, IncrementTag, InlineCommentTag, LayoutTag, Liquid, LiquidError, LiquidTag, Output, ParseError, ParseStream, RawTag, RenderError, RenderTag, TablerowTag, Tag, TagToken, TimezoneDate, Token, TokenKind, TokenizationError, Tokenizer, typeGuards as TypeGuards, UndefinedVariableError, UnlessTag, Value, assert, createTrie, defaultOperators, defaultOptions, evalQuotedToken, evalToken, filters, isFalsy, isTruthy, tags, toPromise, toValue, toValueSync, version };
+export { AssertionError, AssignTag, BlockTag, BreakTag, CaptureTag, CaseTag, CommentTag, Context, ContinueTag, CycleTag, DecrementTag, Drop, EchoTag, Expression, Filter, ForTag, Hash, IfTag, IncludeTag, IncrementTag, InlineCommentTag, LayoutTag, Liquid, LiquidError, LiquidTag, Output, ParseError, ParseStream, RawTag, RenderError, RenderTag, TablerowTag, Tag, TagToken, Token, TokenKind, TokenizationError, Tokenizer, typeGuards as TypeGuards, UndefinedVariableError, UnlessTag, Value, assert, createTrie, defaultOperators, defaultOptions, evalQuotedToken, evalToken, filters, isFalsy, isTruthy, tags, toPromise, toValue, toValueSync, version };