@skeptools/skep-organization-project 0.0.17 → 0.0.19

package/node_modules/liquidjs/dist/liquid.node.mjs

@@ -1,12 +1,13 @@
 /*
- * liquidjs@10.20.1, https://github.com/harttle/liquidjs
- * (c) 2016-2025 harttle
+ * liquidjs@10.30.1, https://github.com/harttle/liquidjs
+ * (c) 2016-2026 harttle
  * Released under the MIT License.
  */
 import { PassThrough } from 'stream';
 import { sep, extname, resolve as resolve$1, dirname as dirname$1 } from 'path';
-import { statSync, readFileSync as readFileSync$1, stat, readFile as readFile$1 } from 'fs';
+import { statSync, readFileSync as readFileSync$1, realpathSync, stat, readFile as readFile$1, realpath } from 'fs';
 import { createRequire } from 'module';
+import { createHash, createHmac } from 'crypto';
 
 class Token {
     constructor(kind, input, begin, end, file) {
@@ -37,7 +38,7 @@ class Token {
 }
 
 class Drop {
-    liquidMethodMissing(key) {
+    liquidMethodMissing(key, context) {
         return undefined;
     }
 }
@@ -58,9 +59,6 @@ function isPromise(val) {
 function isIterator(val) {
     return val && isFunction(val.next) && isFunction(val.throw) && isFunction(val.return);
 }
-function escapeRegex(str) {
-    return str.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
 function promisify(fn) {
     return function (...args) {
         return new Promise((resolve, reject) => {
@@ -80,6 +78,25 @@ function stringify(value) {
         return value.map(x => stringify(x)).join('');
     return String(value);
 }
+function advanceCodePoints(str, from, count) {
+    let index = from;
+    for (let i = 0; i < count && index < str.length; i++)
+        index += str.codePointAt(index) > 0xFFFF ? 2 : 1;
+    return index;
+}
+function codePointLength(str) {
+    let length = 0;
+    for (let index = 0; index < str.length; index = advanceCodePoints(str, index, 1))
+        length++;
+    return length;
+}
+function readArrayElement(arr, index, ownPropertyOnly) {
+    if (index < 0)
+        index = arr.length + index;
+    if (ownPropertyOnly && !hasOwnProperty.call(arr, index))
+        return undefined;
+    return arr[index];
+}
 function toEnumerable(val) {
     val = toValue(val);
     if (isArray(val))
@@ -104,8 +121,7 @@ function toValue(value) {
     return (value instanceof Drop && isFunction(value.valueOf)) ? value.valueOf() : value;
 }
 function toNumber(value) {
-    value = Number(value);
-    return isNaN(value) ? 0 : value;
+    return +toValue(value) || 0;
 }
 function isNumber(value) {
     return typeof value === 'number';
@@ -149,9 +165,6 @@ function forOwn(obj, iteratee) {
     }
     return obj;
 }
-function last(arr) {
-    return arr[arr.length - 1];
-}
 /*
  * Checks if value is the language type of Object.
  * (e.g. arrays, functions, objects, regexes, new Number(0), and new String(''))
@@ -177,10 +190,10 @@ function padEnd(str, length, ch = ' ') {
 }
 function pad(str, length, ch, add) {
     str = String(str);
-    let n = length - str.length;
-    while (n-- > 0)
-        str = add(str, ch);
-    return str;
+    const n = length - str.length;
+    if (n <= 0)
+        return str;
+    return add(str, ch.repeat(n));
 }
 function identify(val) {
     return val;
@@ -192,13 +205,26 @@ function changeCase(str) {
 function ellipsis(str, N) {
     return str.length > N ? str.slice(0, N - 3) + '...' : str;
 }
+function orderedCompare(a, b) {
+    if (isNil(a) && isNil(b))
+        return 0;
+    if (isNil(a))
+        return 1;
+    if (isNil(b))
+        return -1;
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
 // compare string in case-insensitive way, undefined values to the tail
 function caseInsensitiveCompare(a, b) {
-    if (a == null && b == null)
+    if (isNil(a) && isNil(b))
         return 0;
-    if (a == null)
+    if (isNil(a))
         return 1;
-    if (b == null)
+    if (isNil(b))
         return -1;
     a = toLowerCase.call(a);
     b = toLowerCase.call(b);
@@ -211,8 +237,8 @@ function caseInsensitiveCompare(a, b) {
 function argumentsToValue(fn) {
     return function (...args) { return fn.call(this, ...args.map(toValue)); };
 }
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+function argumentsToNumber(fn) {
+    return function (...args) { return fn.call(this, ...args.map(toNumber)); };
 }
 /** Return an array containing unique elements from _array_. Works with nested arrays and objects. */
 function* strictUniq(array) {
@@ -378,8 +404,8 @@ function assertEmpty(predicate, message = `unexpected ${JSON.stringify(predicate
 }
 
 class NullDrop extends Drop {
-    equals(value) {
-        return isNil(toValue(value));
+    *equals(value) {
+        return isNil(yield toValue(value));
     }
     gt() {
         return false;
@@ -399,10 +425,10 @@ class NullDrop extends Drop {
 }
 
 class EmptyDrop extends Drop {
-    equals(value) {
+    *equals(value) {
         if (value instanceof EmptyDrop)
             return false;
-        value = toValue(value);
+        value = yield toValue(value);
         if (isString(value) || isArray(value))
             return value.length === 0;
         if (isObject(value))
@@ -430,14 +456,14 @@ class EmptyDrop extends Drop {
 }
 
 class BlankDrop extends EmptyDrop {
-    equals(value) {
+    *equals(value) {
         if (value === false)
             return true;
-        if (isNil(toValue(value)))
+        if (isNil(yield toValue(value)))
             return true;
         if (isString(value))
             return /^\s*$/.test(value);
-        return super.equals(value);
+        return yield super.equals(value);
     }
     static is(value) {
         return value instanceof BlankDrop;
@@ -477,6 +503,50 @@ class ForloopDrop extends Drop {
     }
 }
 
+class SimpleEmitter {
+    constructor() {
+        this.buffer = '';
+    }
+    write(html) {
+        this.buffer += stringify(html);
+    }
+}
+
+class StreamedEmitter {
+    constructor() {
+        this.buffer = '';
+        this.stream = new PassThrough();
+    }
+    write(html) {
+        this.stream.write(stringify(html));
+    }
+    error(err) {
+        this.stream.emit('error', err);
+    }
+    end() {
+        this.stream.end();
+    }
+}
+
+class KeepingTypeEmitter {
+    constructor() {
+        this.buffer = '';
+    }
+    write(html) {
+        html = toValue(html);
+        // This will only preserve the type if the value is isolated.
+        // I.E:
+        // {{ my-port }} -> 42
+        // {{ my-host }}:{{ my-port }} -> 'host:42'
+        if (typeof html !== 'string' && this.buffer === '') {
+            this.buffer = html;
+        }
+        else {
+            this.buffer = stringify(this.buffer) + stringify(html);
+        }
+    }
+}
+
 class BlockDrop extends Drop {
     constructor(
     // the block render from layout template
@@ -488,8 +558,10 @@ class BlockDrop extends Drop {
      * Provide parent access in child block by
      * {{ block.super }}
      */
-    super() {
-        return this.superBlockRender();
+    *super() {
+        const emitter = new SimpleEmitter();
+        yield this.superBlockRender(emitter);
+        return emitter.buffer;
     }
 }
 
@@ -512,7 +584,16 @@ const literalValues = {
     'blank': new BlankDrop()
 };
 
+// Tries are built once per input object and reused: the Tokenizer rebuilds them
+// on every instantiation, but `input` (operators/literalValues) is a stable
+// reference. WeakMap-keying by `input` lets short-lived operator objects (and
+// their tries) be garbage collected. The returned trie is treated as read-only
+// by callers (matchTrie only reads it); do not mutate it.
+const trieCache = new WeakMap();
 function createTrie(input) {
+    const cached = trieCache.get(input);
+    if (cached)
+        return cached;
     const trie = {};
     for (const [name, data] of Object.entries(input)) {
         let node = trie;
@@ -527,6 +608,7 @@ function createTrie(input) {
         node.data = data;
         node.end = true;
     }
+    trieCache.set(input, trie);
     return trie;
 }
 
@@ -566,6 +648,12 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+function toLiquidAsync(asyncFn, syncFn) {
+    const syncImpl = syncFn || asyncFn;
+    return (sync, ...args) => {
+        return sync ? syncImpl(...args) : asyncFn(...args);
+    };
+}
 // convert an async iterator to a Promise
 function toPromise(val) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -576,7 +664,7 @@ function toPromise(val) {
         let next = 'next';
         do {
             const state = val[next](value);
-            done = state.done;
+            done = !!state.done;
             value = state.value;
             next = 'next';
             try {
@@ -602,7 +690,7 @@ function toValueSync(val) {
     let next = 'next';
     do {
         const state = val[next](value);
-        done = state.done;
+        done = !!state.done;
         value = state.value;
         next = 'next';
         if (isIterator(value)) {
@@ -632,12 +720,9 @@ function getDayOfYear(d) {
     return num + d.getDate();
 }
 function getWeekOfYear(d, startDay) {
-    // Skip to startDay of this week
-    const now = getDayOfYear(d) + (startDay - d.getDay());
-    // Find the first startDay of the year
-    const jan1 = new Date(d.getFullYear(), 0, 1);
-    const then = (7 - jan1.getDay() + startDay);
-    return String(Math.floor((now - then) / 7) + 1);
+    // Days before the first startDay of the year belong to week 0
+    const daysSinceStartDay = (d.getDay() - startDay + 7) % 7;
+    return String(Math.floor((getDayOfYear(d) - 1 - daysSinceStartDay + 7) / 7));
 }
 function isLeapYear(d) {
     const year = d.getFullYear();
@@ -655,10 +740,11 @@ function ordinal(d) {
     }
 }
 function century(d) {
-    return parseInt(d.getFullYear().toString().substring(0, 2), 10);
+    return Math.floor(d.getFullYear() / 100);
 }
 // default to 0
 const padWidths = {
+    C: 2,
     d: 2,
     e: 2,
     H: 2,
@@ -671,7 +757,9 @@ const padWidths = {
     M: 2,
     S: 2,
     U: 2,
-    W: 2
+    W: 2,
+    y: 2,
+    Y: 4
 };
 const padSpaceChars = new Set('aAbBceklpP');
 function getTimezoneOffset(d, opts) {
@@ -701,14 +789,16 @@ const formatCodes = {
     m: (d) => d.getMonth() + 1,
     M: (d) => d.getMinutes(),
     N: (d, opts) => {
+        var _a;
         const width = Number(opts.width) || 9;
-        const str = String(d.getMilliseconds()).slice(0, width);
+        const str = padStart(String(d.getMilliseconds()), 3, '0').slice(0, width);
+        (_a = opts.memoryLimit) === null || _a === void 0 ? void 0 : _a.use(width - str.length);
         return padEnd(str, width, '0');
     },
     p: (d) => (d.getHours() < 12 ? 'AM' : 'PM'),
     P: (d) => (d.getHours() < 12 ? 'am' : 'pm'),
     q: (d) => ordinal(d),
-    s: (d) => Math.round(d.getTime() / 1000),
+    s: (d) => Math.floor(d.dateValue() / 1000),
     S: (d) => d.getSeconds(),
     u: (d) => d.getDay() || 7,
     U: (d) => getWeekOfYear(d, 0),
@@ -716,7 +806,7 @@ const formatCodes = {
     W: (d) => getWeekOfYear(d, 1),
     x: (d) => d.toLocaleDateString(),
     X: (d) => d.toLocaleTimeString(),
-    y: (d) => d.getFullYear().toString().slice(2, 4),
+    y: (d) => (d.getFullYear() % 100 + 100) % 100,
     Y: (d) => d.getFullYear(),
     z: getTimezoneOffset,
     Z: (d, opts) => d.getTimeZoneName() || getTimezoneOffset(d, opts),
@@ -725,18 +815,18 @@ const formatCodes = {
     '%': () => '%'
 };
 formatCodes.h = formatCodes.b;
-function strftime(d, formatStr) {
+function strftime(d, formatStr, memoryLimit) {
     let output = '';
     let remaining = formatStr;
     let match;
     while ((match = rFormat.exec(remaining))) {
         output += remaining.slice(0, match.index);
         remaining = remaining.slice(match.index + match[0].length);
-        output += format(d, match);
+        output += format(d, match, memoryLimit);
     }
     return output + remaining;
 }
-function format(d, match) {
+function format(d, match, memoryLimit) {
     const [input, flagStr = '', width, modifier, conversion] = match;
     const convert = formatCodes[conversion];
     if (!convert)
@@ -744,9 +834,9 @@ function format(d, match) {
     const flags = {};
     for (const flag of flagStr)
         flags[flag] = true;
-    let ret = String(convert(d, { flags, width, modifier }));
+    let ret = String(convert(d, { flags, width, modifier, memoryLimit }));
     let padChar = padSpaceChars.has(conversion) ? ' ' : '0';
-    let padWidth = width || padWidths[conversion] || 0;
+    let padWidth = Number(width) || padWidths[conversion] || 0;
     if (flags['^'])
         ret = ret.toUpperCase();
     else if (flags['#'])
@@ -757,6 +847,9 @@ function format(d, match) {
         padChar = '0';
     if (flags['-'])
         padWidth = 0;
+    memoryLimit === null || memoryLimit === void 0 ? void 0 : memoryLimit.use(Number(padWidth) - ret.length);
+    if (padChar === '0' && ret[0] === '-')
+        return '-' + padStart(ret.slice(1), padWidth - 1, padChar);
     return padStart(ret, padWidth, padChar);
 }
 
@@ -805,6 +898,15 @@ class LiquidDate {
     getTime() {
         return this.displayDate.getTime();
     }
+    /**
+     * The underlying UTC timestamp in milliseconds, unaffected by the display
+     * timezone. Use this (not `getTime()`) for timezone-invariant values like
+     * `%s`: `getTime()` reads `displayDate`, which is deliberately shifted by
+     * the display timezone offset so wall-clock getters can delegate to Date.
+     */
+    dateValue() {
+        return this.date.getTime();
+    }
     getMilliseconds() {
         return this.displayDate.getMilliseconds();
     }
@@ -916,13 +1018,15 @@ class Limiter {
         this.limit = limit;
     }
     use(count) {
-        count = toNumber(count);
-        assert(this.base + count <= this.limit, this.message);
-        this.base += count;
+        if (+count > 0) {
+            assert(this.base + +count <= this.limit, this.message);
+            this.base += +count;
+        }
     }
     check(count) {
-        count = toNumber(count);
-        assert(count <= this.limit, this.message);
+        if (+count > 0) {
+            assert(+count <= this.limit, this.message);
+        }
     }
 }
 
@@ -953,13 +1057,11 @@ class TagToken extends DelimitedToken {
         const { trimTagLeft, trimTagRight, tagDelimiterLeft, tagDelimiterRight } = options;
         const [valueBegin, valueEnd] = [begin + tagDelimiterLeft.length, end - tagDelimiterRight.length];
         super(TokenKind.Tag, [valueBegin, valueEnd], input, begin, end, trimTagLeft, trimTagRight, file);
-        this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange);
+        this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange, options.groupedExpressions);
         this.name = this.tokenizer.readTagName();
         this.tokenizer.assert(this.name, `illegal tag syntax, tag name expected`);
         this.tokenizer.skipBlank();
-    }
-    get args() {
-        return this.tokenizer.input.slice(this.tokenizer.p, this.contentRange[1]);
+        this.args = this.tokenizer.input.slice(this.tokenizer.p, this.contentRange[1]);
     }
 }
 
@@ -1054,8 +1156,7 @@ class OperatorToken extends Token {
         this.operator = this.getText();
     }
     getPrecedence() {
-        const key = this.getText();
-        return key in operatorPrecedences ? operatorPrecedences[key] : 1;
+        return this.operator in operatorPrecedences ? operatorPrecedences[this.operator] : 1;
     }
 }
 
@@ -1169,7 +1270,7 @@ class RangeToken extends Token {
 class LiquidTagToken extends DelimitedToken {
     constructor(input, begin, end, options, file) {
         super(TokenKind.Tag, [begin, end], input, begin, end, false, false, file);
-        this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange);
+        this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange, options.groupedExpressions);
         this.name = this.tokenizer.readTagName();
         this.tokenizer.assert(this.name, 'illegal liquid tag syntax');
         this.tokenizer.skipBlank();
@@ -1205,50 +1306,6 @@ function getPerformance() {
         polyfill;
 }
 
-class SimpleEmitter {
-    constructor() {
-        this.buffer = '';
-    }
-    write(html) {
-        this.buffer += stringify(html);
-    }
-}
-
-class StreamedEmitter {
-    constructor() {
-        this.buffer = '';
-        this.stream = new PassThrough();
-    }
-    write(html) {
-        this.stream.write(stringify(html));
-    }
-    error(err) {
-        this.stream.emit('error', err);
-    }
-    end() {
-        this.stream.end();
-    }
-}
-
-class KeepingTypeEmitter {
-    constructor() {
-        this.buffer = '';
-    }
-    write(html) {
-        html = toValue(html);
-        // This will only preserve the type if the value is isolated.
-        // I.E:
-        // {{ my-port }} -> 42
-        // {{ my-host }}:{{ my-port }} -> 'host:42'
-        if (typeof html !== 'string' && this.buffer === '') {
-            this.buffer = html;
-        }
-        else {
-            this.buffer = stringify(this.buffer) + stringify(html);
-        }
-    }
-}
-
 class Render {
     renderTemplatesToNodeStream(templates, ctx) {
         const emitter = new StreamedEmitter();
@@ -1260,6 +1317,7 @@ class Render {
         if (!emitter) {
             emitter = ctx.opts.keepOutputType ? new KeepingTypeEmitter() : new SimpleEmitter();
         }
+        ctx.renderLimit.check(getPerformance().now());
         const errors = [];
         for (const tpl of templates) {
             ctx.renderLimit.check(getPerformance().now());
@@ -1286,6 +1344,33 @@ class Render {
     }
 }
 
+function isKeyValuePair(arr) {
+    return isArray(arr);
+}
+
+class Filter {
+    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 = token.args;
+        this.liquid = liquid;
+    }
+    *render(value, context) {
+        const argv = [];
+        for (const arg of this.args) {
+            if (isKeyValuePair(arg))
+                argv.push([arg[0], yield evalToken(arg[1], context)]);
+            else
+                argv.push(yield evalToken(arg, context));
+        }
+        return yield this.handler.apply({ context, token: this.token, liquid: this.liquid }, [value, ...argv]);
+    }
+}
+
 class Expression {
     constructor(tokens) {
         this.postfix = [...toPostfix(tokens)];
@@ -1316,6 +1401,11 @@ class Expression {
         return !!this.postfix.length;
     }
 }
+/**
+ * Evaluate `token`, preserving Drops.
+ * Operators use this so `Comparable` drops (`empty`, `nil`, `blank`) and custom drops
+ * are compared as drops rather than as their `valueOf()` result.
+ */
 function* evalToken(token, ctx, lenient = false) {
     if (!token)
         return;
@@ -1325,11 +1415,32 @@ function* evalToken(token, ctx, lenient = false) {
         return yield evalPropertyAccessToken(token, ctx, lenient);
     if (isRangeToken(token))
         return yield evalRangeToken(token, ctx);
+    if (isFilteredValueToken(token))
+        return yield evalFilteredValueToken(token, ctx, lenient);
+}
+function* evalFilteredValueToken(token, ctx, lenient) {
+    assert(ctx.liquid, 'FilteredValueToken evaluation requires liquid instance in context');
+    lenient = lenient || (ctx.opts.lenientIf && token.filters.length > 0 && token.filters[0].name === 'default');
+    let val = yield token.initial.evaluate(ctx, lenient);
+    for (const filterToken of token.filters) {
+        const filterImpl = ctx.liquid.filters[filterToken.name];
+        assert(filterImpl || !ctx.liquid.options.strictFilters, () => `undefined filter: ${filterToken.name}`);
+        const filter = new Filter(filterToken, filterImpl, ctx.liquid);
+        val = yield filter.render(val, ctx);
+    }
+    return val;
+}
+/**
+ * Evaluate `token` to the value filters and tags consume.
+ * Awaits a promise returned by `Drop.valueOf()`.
+ */
+function* evalTokenValue(token, ctx, lenient = false) {
+    return yield toValue(yield evalToken(token, ctx, lenient));
 }
 function* evalPropertyAccessToken(token, ctx, lenient) {
     const props = [];
     for (const prop of token.props) {
-        props.push((yield evalToken(prop, ctx, false)));
+        props.push((yield evalTokenValue(prop, ctx, false)));
     }
     try {
         if (token.variable) {
@@ -1350,8 +1461,8 @@ function evalQuotedToken(token) {
     return token.content;
 }
 function* evalRangeToken(token, ctx) {
-    const low = yield evalToken(token.lhs, ctx);
-    const high = yield evalToken(token.rhs, ctx);
+    const low = (yield evalTokenValue(token.lhs, ctx));
+    const high = (yield evalTokenValue(token.rhs, ctx));
     ctx.memoryLimit.use(high - low + 1);
     return range(+low, +high + 1);
 }
@@ -1386,67 +1497,75 @@ function isFalsy(val, ctx) {
 }
 
 const defaultOperators = {
-    '==': equals,
-    '!=': (l, r) => !equals(l, r),
-    '>': (l, r) => {
+    '==': function* (l, r) { return yield equals(l, r); },
+    '!=': function* (l, r) { return !(yield equals(l, r)); },
+    '>': function* (l, r) {
         if (isComparable(l))
-            return l.gt(r);
+            return yield l.gt(r);
         if (isComparable(r))
-            return r.lt(l);
-        return toValue(l) > toValue(r);
+            return yield r.lt(l);
+        return (yield toValue(l)) > (yield toValue(r));
     },
-    '<': (l, r) => {
+    '<': function* (l, r) {
         if (isComparable(l))
-            return l.lt(r);
+            return yield l.lt(r);
         if (isComparable(r))
-            return r.gt(l);
-        return toValue(l) < toValue(r);
+            return yield r.gt(l);
+        return (yield toValue(l)) < (yield toValue(r));
     },
-    '>=': (l, r) => {
+    '>=': function* (l, r) {
         if (isComparable(l))
-            return l.geq(r);
+            return yield l.geq(r);
         if (isComparable(r))
-            return r.leq(l);
-        return toValue(l) >= toValue(r);
+            return yield r.leq(l);
+        return (yield toValue(l)) >= (yield toValue(r));
     },
-    '<=': (l, r) => {
+    '<=': function* (l, r) {
         if (isComparable(l))
-            return l.leq(r);
+            return yield l.leq(r);
         if (isComparable(r))
-            return r.geq(l);
-        return toValue(l) <= toValue(r);
+            return yield r.geq(l);
+        return (yield toValue(l)) <= (yield toValue(r));
     },
-    'contains': (l, r) => {
-        l = toValue(l);
+    'contains': function* (l, r) {
+        l = yield toValue(l);
         if (isArray(l))
-            return l.some((i) => equals(i, r));
+            return yield arrayIncludes(l, r);
         if (isFunction(l === null || l === void 0 ? void 0 : l.indexOf))
-            return l.indexOf(toValue(r)) > -1;
+            return l.indexOf(yield toValue(r)) > -1;
         return false;
     },
-    'not': (v, ctx) => isFalsy(toValue(v), ctx),
-    'and': (l, r, ctx) => isTruthy(toValue(l), ctx) && isTruthy(toValue(r), ctx),
-    'or': (l, r, ctx) => isTruthy(toValue(l), ctx) || isTruthy(toValue(r), ctx)
+    'not': function* (v, ctx) { return isFalsy(yield toValue(v), ctx); },
+    'and': function* (l, r, ctx) { return isTruthy(yield toValue(l), ctx) && isTruthy(yield toValue(r), ctx); },
+    'or': function* (l, r, ctx) { return isTruthy(yield toValue(l), ctx) || isTruthy(yield toValue(r), ctx); }
 };
-function equals(lhs, rhs) {
+function* equals(lhs, rhs) {
     if (isComparable(lhs))
-        return lhs.equals(rhs);
+        return yield lhs.equals(rhs);
     if (isComparable(rhs))
-        return rhs.equals(lhs);
-    lhs = toValue(lhs);
-    rhs = toValue(rhs);
+        return yield rhs.equals(lhs);
+    lhs = yield toValue(lhs);
+    rhs = yield toValue(rhs);
     if (isArray(lhs)) {
-        return isArray(rhs) && arrayEquals(lhs, rhs);
+        return isArray(rhs) && (yield arrayEquals(lhs, rhs));
     }
     return lhs === rhs;
 }
-function arrayEquals(lhs, rhs) {
+function* arrayEquals(lhs, rhs) {
     if (lhs.length !== rhs.length)
         return false;
-    return !lhs.some((value, i) => !equals(value, rhs[i]));
+    for (let i = 0; i < lhs.length; i++) {
+        if (!(yield equals(lhs[i], rhs[i])))
+            return false;
+    }
+    return true;
 }
-function arrayIncludes(arr, item) {
-    return arr.some(value => equals(value, item));
+function* arrayIncludes(arr, item) {
+    for (const value of arr) {
+        if (yield equals(value, item))
+            return true;
+    }
+    return false;
 }
 
 class Node {
@@ -1554,10 +1673,30 @@ function fallback(file) {
 function dirname(filepath) {
     return dirname$1(filepath);
 }
+const realpathAsync = promisify(realpath);
 function contains(root, file) {
-    root = resolve$1(root);
-    root = root.endsWith(sep) ? root : root + sep;
-    return file.startsWith(root);
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const realRoot = yield realpathAsync(root);
+            const realFile = yield realpathAsync(file);
+            const prefix = realRoot.endsWith(sep) ? realRoot : realRoot + sep;
+            return realFile.startsWith(prefix);
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function containsSync(root, file) {
+    try {
+        const realRoot = realpathSync(root);
+        const realFile = realpathSync(file);
+        const prefix = realRoot.endsWith(sep) ? realRoot : realRoot + sep;
+        return realFile.startsWith(prefix);
+    }
+    catch (_a) {
+        return false;
+    }
 }
 
 var fs = /*#__PURE__*/Object.freeze({
@@ -1570,9 +1709,24 @@ var fs = /*#__PURE__*/Object.freeze({
   fallback: fallback,
   dirname: dirname,
   contains: contains,
+  containsSync: containsSync,
   sep: sep
 });
 
+function chargeJsonReplacerValue(memoryLimit, val) {
+    if (typeof val === 'string') {
+        memoryLimit.use(val.length);
+    }
+    else if (val === null || typeof val === 'number' || typeof val === 'boolean') {
+        memoryLimit.use(JSON.stringify(val).length);
+    }
+    else if (Array.isArray(val)) {
+        memoryLimit.use(val.length + 1);
+    }
+    else if (typeof val === 'object') {
+        memoryLimit.use(2);
+    }
+}
 function defaultFilter(value, defaultValue, ...args) {
     value = toValue(value);
     if (isArray(value) || isString(value))
@@ -1582,19 +1736,29 @@ function defaultFilter(value, defaultValue, ...args) {
     return isFalsy(value, this.context) ? defaultValue : value;
 }
 function json(value, space = 0) {
-    return JSON.stringify(value, null, space);
+    const memoryLimit = this.context.memoryLimit;
+    return JSON.stringify(value, (_key, val) => {
+        chargeJsonReplacerValue(memoryLimit, val);
+        return val;
+    }, space);
 }
 function inspect(value, space = 0) {
+    const memoryLimit = this.context.memoryLimit;
     const ancestors = [];
     return JSON.stringify(value, function (_key, value) {
-        if (typeof value !== 'object' || value === null)
+        if (typeof value !== 'object' || value === null) {
+            chargeJsonReplacerValue(memoryLimit, value);
             return value;
+        }
         // `this` is the object that value is contained in, i.e., its direct parent.
         while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this)
             ancestors.pop();
-        if (ancestors.includes(value))
+        if (ancestors.includes(value)) {
+            memoryLimit.use('[Circular]'.length);
             return '[Circular]';
+        }
         ancestors.push(value);
+        chargeJsonReplacerValue(memoryLimit, value);
         return value;
     }, space);
 }
@@ -1649,10 +1813,33 @@ function newline_to_br(v) {
     this.context.memoryLimit.use(str.length);
     return str.replace(/\r?\n/gm, '<br />\n');
 }
+// Raw-text blocks (HTML5) plus '<...>' as the catch-all kind; a regex
+// equivalent is O(n^2) in V8 on unclosed openers.
 function strip_html(v) {
     const str = stringify(v);
     this.context.memoryLimit.use(str.length);
-    return str.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<.*?>|<!--[\s\S]*?-->/g, '');
+    const blocks = new Map([['<script', '</script>'], ['<style', '</style>'], ['<!--', '-->'], ['<', '>']]);
+    let out = '';
+    let i = 0;
+    while (i < str.length) {
+        const lt = str.indexOf('<', i);
+        if (lt < 0)
+            return out + str.slice(i);
+        out += str.slice(i, lt);
+        for (const [opener, closer] of blocks) {
+            if (!str.startsWith(opener, lt))
+                continue;
+            const e = str.indexOf(closer, lt + opener.length);
+            if (e >= 0) {
+                i = e + closer.length;
+                break;
+            }
+            blocks.delete(opener);
+        }
+        if (i <= lt)
+            return out + str.slice(lt);
+    }
+    return out;
 }
 
 var htmlFilters = /*#__PURE__*/Object.freeze({
@@ -1743,6 +1930,7 @@ const defaultOptions = {
     globals: {},
     keepOutputType: false,
     operators: defaultOperators,
+    groupedExpressions: false,
     memoryLimit: Infinity,
     parseLimit: Infinity,
     renderLimit: Infinity
@@ -1839,7 +2027,7 @@ function trimRight(token, greedy) {
 }
 
 class Tokenizer {
-    constructor(input, operators = defaultOptions.operators, file, range) {
+    constructor(input, operators = defaultOptions.operators, file, range, groupedExpressions = false) {
         this.input = input;
         this.file = file;
         this.rawBeginAt = -1;
@@ -1847,6 +2035,7 @@ class Tokenizer {
         this.N = range ? range[1] : input.length;
         this.opTrie = createTrie(operators);
         this.literalTrie = createTrie(literalValues);
+        this.groupedExpressions = groupedExpressions;
     }
     readExpression() {
         return new Expression(this.readExpressionTokens());
@@ -1908,6 +2097,8 @@ class Tokenizer {
         this.skipBlank();
         if (this.end())
             return null;
+        if (this.peek() === ')' || this.peek() === ',')
+            return null;
         this.assert(this.read() === '|', `expected "|" before filter`);
         const name = this.readIdentifier();
         if (!name.size()) {
@@ -1922,10 +2113,10 @@ class Tokenizer {
                 const arg = this.readFilterArg();
                 arg && args.push(arg);
                 this.skipBlank();
-                this.assert(this.end() || this.peek() === ',' || this.peek() === '|', () => `unexpected character ${this.snapshot()}`);
+                this.assert(this.end() || this.peek() === ',' || this.peek() === '|' || this.peek() === ')', () => `unexpected character ${this.snapshot()}`);
             } while (this.peek() === ',');
         }
-        else if (this.peek() === '|' || this.end()) ;
+        else if (this.peek() === '|' || this.peek() === ')' || this.peek() === ',' || this.end()) ;
         else {
             throw this.error('expected ":" after filter name');
         }
@@ -2131,7 +2322,10 @@ class Tokenizer {
     readValue() {
         this.skipBlank();
         const begin = this.p;
-        const variable = this.readLiteral() || this.readQuoted() || this.readRange() || this.readNumber();
+        let variable = this.readLiteral() || this.readQuoted() || this.readNumber();
+        if (!variable && this.peek() === '(') {
+            variable = this.readGroupOrRange();
+        }
         const props = this.readProperties(!variable);
         if (!props.length)
             return variable;
@@ -2210,17 +2404,30 @@ class Tokenizer {
         this.p = end;
         return literal;
     }
-    readRange() {
+    readGroupOrRange() {
         this.skipBlank();
         const begin = this.p;
         if (this.peek() !== '(')
             return;
         ++this.p;
         const lhs = this.readValueOrThrow();
-        this.p += 2;
-        const rhs = this.readValueOrThrow();
-        ++this.p;
-        return new RangeToken(this.input, begin, this.p, lhs, rhs, this.file);
+        this.skipBlank();
+        if (this.peek() === '.' && this.peek(1) === '.') {
+            this.p += 2;
+            const rhs = this.readValueOrThrow();
+            this.skipBlank();
+            this.assert(this.read() === ')', 'invalid range syntax');
+            return new RangeToken(this.input, begin, this.p, lhs, rhs, this.file);
+        }
+        if (this.groupedExpressions) {
+            const initial = new Expression([lhs, ...this.readExpressionTokens()]);
+            this.assert(initial.valid(), () => `invalid value expression: ${this.snapshot()}`);
+            const filters = this.readFilters();
+            this.skipBlank();
+            this.assert(this.read() === ')', 'unbalanced parentheses');
+            return new FilteredValueToken(initial, filters, this.input, begin, this.p, this.file);
+        }
+        throw this.error('invalid range syntax');
     }
     readValueOrThrow() {
         const value = this.readValue();
@@ -2247,7 +2454,7 @@ class Tokenizer {
     }
     *readFileNameTemplate(options) {
         const { outputDelimiterLeft } = options;
-        const htmlStopStrings = [',', ' ', outputDelimiterLeft];
+        const htmlStopStrings = [',', ' ', '\r', '\n', '\t', outputDelimiterLeft];
         const htmlStopStringSet = new Set(htmlStopStrings);
         // break on ',' and ' ', outputDelimiterLeft only stops HTML token
         while (this.p < this.N && !htmlStopStringSet.has(this.peek())) {
@@ -2374,33 +2581,6 @@ function createTagClass(options) {
     };
 }
 
-function isKeyValuePair(arr) {
-    return isArray(arr);
-}
-
-class Filter {
-    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 = token.args;
-        this.liquid = liquid;
-    }
-    *render(value, context) {
-        const argv = [];
-        for (const arg of this.args) {
-            if (isKeyValuePair(arg))
-                argv.push([arg[0], yield evalToken(arg[1], context)]);
-            else
-                argv.push(yield evalToken(arg, context));
-        }
-        return yield this.handler.apply({ context, token: this.token, liquid: this.liquid }, [value, ...argv]);
-    }
-}
-
 class Value {
     /**
      * @param str the value to be valuated, eg.: "foobar" | truncate: 3
@@ -2408,7 +2588,7 @@ class Value {
     constructor(input, liquid) {
         this.filters = [];
         const token = typeof input === 'string'
-            ? new Tokenizer(input, liquid.options.operators).readFilteredValue()
+            ? new Tokenizer(input, liquid.options.operators, undefined, undefined, liquid.options.groupedExpressions).readFilteredValue()
             : input;
         this.initial = token.initial;
         this.filters = token.filters.map(token => new Filter(token, this.getFilter(liquid, token.name), liquid));
@@ -2432,7 +2612,7 @@ class Output extends TemplateImpl {
     constructor(token, liquid) {
         var _a;
         super(token);
-        const tokenizer = new Tokenizer(token.input, liquid.options.operators, token.file, token.contentRange);
+        const tokenizer = new Tokenizer(token.input, liquid.options.operators, token.file, token.contentRange, liquid.options.groupedExpressions);
         this.value = new Value(tokenizer.readFilteredValue(), liquid);
         const filters = this.value.filters;
         const outputEscape = liquid.options.outputEscape;
@@ -2442,7 +2622,7 @@ class Output extends TemplateImpl {
         }
     }
     *render(ctx, emitter) {
-        const val = yield this.value.value(ctx, false);
+        const val = yield toValue(yield this.value.value(ctx, false));
         emitter.write(val);
     }
     *arguments() {
@@ -2718,10 +2898,31 @@ function* extractValueTokenVariables(token) {
         yield* extractValueTokenVariables(token.lhs);
         yield* extractValueTokenVariables(token.rhs);
     }
+    else if (isFilteredValueToken(token)) {
+        yield* extractGroupedExpressionTokenVariables(token);
+    }
     else if (isPropertyAccessToken(token)) {
         yield extractPropertyAccessVariable(token);
     }
 }
+function* extractGroupedExpressionTokenVariables(token) {
+    if (!isFilteredValueToken(token))
+        return;
+    for (const t of token.initial.postfix) {
+        if (isValueToken(t))
+            yield* extractValueTokenVariables(t);
+    }
+    for (const filter of token.filters) {
+        for (const arg of filter.args) {
+            if (isKeyValuePair(arg) && arg[1]) {
+                yield* extractValueTokenVariables(arg[1]);
+            }
+            else if (isValueToken(arg)) {
+                yield* extractValueTokenVariables(arg);
+            }
+        }
+    }
+}
 function extractPropertyAccessVariable(token) {
     const segments = [];
     // token is not guaranteed to have `file` set. We'll try to get it from a prop if not.
@@ -2798,44 +2999,47 @@ var LookupType;
 })(LookupType || (LookupType = {}));
 class Loader {
     constructor(options) {
+        var _a, _b, _c, _d;
         this.options = options;
         if (options.relativeReference) {
             const sep = options.fs.sep;
             assert(sep, '`fs.sep` is required for relative reference');
-            const rRelativePath = new RegExp(['.' + sep, '..' + sep, './', '../'].map(prefix => escapeRegex(prefix)).join('|'));
-            this.shouldLoadRelative = (referencedFile) => rRelativePath.test(referencedFile);
+            const prefixes = ['.' + sep, '..' + sep, './', '../'];
+            this.shouldLoadRelative = (referencedFile) => prefixes.some(prefix => referencedFile.startsWith(prefix));
         }
         else {
             this.shouldLoadRelative = (_referencedFile) => false;
         }
-        this.contains = this.options.fs.contains || (() => true);
+        const fs = options.fs;
+        this.contains = toLiquidAsync(((_a = fs.contains) === null || _a === void 0 ? void 0 : _a.bind(fs)) || (() => __awaiter(this, void 0, void 0, function* () { return true; })), ((_b = fs.containsSync) === null || _b === void 0 ? void 0 : _b.bind(fs)) || (() => true));
+        this.exists = toLiquidAsync(((_c = fs.exists) === null || _c === void 0 ? void 0 : _c.bind(fs)) || (() => __awaiter(this, void 0, void 0, function* () { return false; })), (_d = fs.existsSync) === null || _d === void 0 ? void 0 : _d.bind(fs));
     }
     *lookup(file, type, sync, currentFile) {
-        const { fs } = this.options;
         const dirs = this.options[type];
-        for (const filepath of this.candidates(file, dirs, currentFile, type !== LookupType.Root)) {
-            if (sync ? fs.existsSync(filepath) : yield fs.exists(filepath))
+        for (const filepath of this.candidates(file, dirs, currentFile)) {
+            let allowed = false;
+            for (const dir of dirs) {
+                if (yield this.contains(!!sync, dir, filepath)) {
+                    allowed = true;
+                    break;
+                }
+            }
+            if (!allowed)
+                continue;
+            if (yield this.exists(!!sync, filepath))
                 return filepath;
         }
         throw this.lookupError(file, dirs);
     }
-    *candidates(file, dirs, currentFile, enforceRoot) {
+    *candidates(file, dirs, currentFile) {
         const { fs, extname } = this.options;
         if (this.shouldLoadRelative(file) && currentFile) {
             const referenced = fs.resolve(this.dirname(currentFile), file, extname);
-            for (const dir of dirs) {
-                if (!enforceRoot || this.contains(dir, referenced)) {
-                    // the relatively referenced file is within one of root dirs
-                    yield referenced;
-                    break;
-                }
-            }
+            yield referenced;
         }
         for (const dir of dirs) {
             const referenced = fs.resolve(dir, file, extname);
-            if (!enforceRoot || this.contains(dir, referenced)) {
-                yield referenced;
-            }
+            yield referenced;
         }
         if (fs.fallback !== undefined) {
             const filepath = fs.fallback(file);
@@ -2858,17 +3062,19 @@ class Loader {
 
 class Parser {
     constructor(liquid) {
+        var _a, _b;
         this.liquid = liquid;
         this.cache = this.liquid.options.cache;
         this.fs = this.liquid.options.fs;
         this.parseFile = this.cache ? this._parseFileCached : this._parseFile;
         this.loader = new Loader(this.liquid.options);
         this.parseLimit = new Limiter('parse length', liquid.options.parseLimit);
+        this.readFile = toLiquidAsync(((_a = this.fs.readFile) === null || _a === void 0 ? void 0 : _a.bind(this.fs)) || (() => __awaiter(this, void 0, void 0, function* () { throw new Error('readFile not implemented'); })), (_b = this.fs.readFileSync) === null || _b === void 0 ? void 0 : _b.bind(this.fs));
     }
     parse(html, filepath) {
         html = String(html);
         this.parseLimit.use(html.length);
-        const tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath);
+        const tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath, undefined, this.liquid.options.groupedExpressions);
         const tokens = tokenizer.readTopLevelTokens(this.liquid.options);
         return this.parseTokens(tokens);
     }
@@ -2934,7 +3140,7 @@ class Parser {
     }
     *_parseFile(file, sync, type = LookupType.Root, currentFile) {
         const filepath = yield this.loader.lookup(file, type, sync, currentFile);
-        return this.parse(sync ? this.fs.readFileSync(filepath) : yield this.fs.readFile(filepath), filepath);
+        return this.parse(yield this.readFile(!!sync, filepath), filepath);
     }
 }
 
@@ -2953,6 +3159,7 @@ var TokenKind;
     TokenKind[TokenKind["Quoted"] = 1024] = "Quoted";
     TokenKind[TokenKind["Operator"] = 2048] = "Operator";
     TokenKind[TokenKind["FilteredValue"] = 4096] = "FilteredValue";
+    TokenKind[TokenKind["GroupedExpression"] = 8192] = "GroupedExpression";
     TokenKind[TokenKind["Delimited"] = 12] = "Delimited";
 })(TokenKind || (TokenKind = {}));
 
@@ -2989,9 +3196,12 @@ function isWordToken(val) {
 function isRangeToken(val) {
     return getKind(val) === TokenKind.Range;
 }
+function isFilteredValueToken(val) {
+    return getKind(val) === TokenKind.FilteredValue;
+}
 function isValueToken(val) {
-    // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range
-    return (getKind(val) & 1667) > 0;
+    // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range | TokenKind.FilteredValue
+    return (getKind(val) & 5763) > 0;
 }
 function getKind(val) {
     return val ? val.kind : -1;
@@ -3010,17 +3220,25 @@ var typeGuards = /*#__PURE__*/Object.freeze({
   isPropertyAccessToken: isPropertyAccessToken,
   isWordToken: isWordToken,
   isRangeToken: isRangeToken,
+  isFilteredValueToken: isFilteredValueToken,
   isValueToken: isValueToken
 });
 
+function createScope(from) {
+    const scope = Object.create(null);
+    if (from)
+        Object.assign(scope, from);
+    return scope;
+}
+
 class Context {
-    constructor(env = {}, opts = defaultOptions, renderOptions = {}, { memoryLimit, renderLimit } = {}) {
+    constructor(env = {}, opts = defaultOptions, renderOptions = {}, { memoryLimit, renderLimit, liquid } = {}) {
         var _a, _b, _c, _d, _e;
         /**
          * insert a Context-level empty scope,
          * for tags like `{% capture %}` `{% assign %}` to operate
          */
-        this.scopes = [{}];
+        this.scopes = [createScope()];
         this.registers = {};
         this.breakCalled = false;
         this.continueCalled = false;
@@ -3032,9 +3250,10 @@ class Context {
         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));
+        this.liquid = liquid;
     }
-    getRegister(key) {
-        return (this.registers[key] = this.registers[key] || {});
+    getRegister(key, defaultValue = undefined) {
+        return (this.registers[key] = this.registers[key] || defaultValue);
     }
     setRegister(key, value) {
         return (this.registers[key] = value);
@@ -3072,7 +3291,7 @@ class Context {
         if (isString(paths))
             paths = paths.split('.');
         for (let i = 0; i < paths.length; i++) {
-            scope = yield readProperty(scope, paths[i], this.ownPropertyOnly);
+            scope = yield this.readProperty(scope, paths[i]);
             if (strictVariables && isUndefined(scope)) {
                 throw new InternalUndefinedVariableError(paths.slice(0, i + 1).join('.'));
             }
@@ -3092,10 +3311,12 @@ class Context {
         return new Context(scope, this.opts, {
             sync: this.sync,
             globals: this.globals,
-            strictVariables: this.strictVariables
+            strictVariables: this.strictVariables,
+            ownPropertyOnly: this.ownPropertyOnly
         }, {
             renderLimit: this.renderLimit,
-            memoryLimit: this.memoryLimit
+            memoryLimit: this.memoryLimit,
+            liquid: this.liquid
         });
     }
     findScope(key) {
@@ -3108,41 +3329,41 @@ class Context {
             return this.environments;
         return this.globals;
     }
-}
-function readProperty(obj, key, ownPropertyOnly) {
-    obj = toLiquid(obj);
-    key = toValue(key);
-    if (isNil(obj))
-        return obj;
-    if (isArray(obj) && key < 0)
-        return obj[obj.length + +key];
-    const value = readJSProperty(obj, key, ownPropertyOnly);
-    if (value === undefined && obj instanceof Drop)
-        return obj.liquidMethodMissing(key);
-    if (isFunction(value))
-        return value.call(obj);
-    if (key === 'size')
-        return readSize(obj);
-    else if (key === 'first')
-        return readFirst(obj);
-    else if (key === 'last')
-        return readLast(obj);
-    return value;
+    readProperty(obj, key) {
+        obj = toLiquid(obj);
+        key = toValue(key);
+        if (isNil(obj))
+            return obj;
+        if (isArray(obj) && isNumber(key))
+            return readArrayElement(obj, key, this.ownPropertyOnly);
+        const value = readJSProperty(obj, key, this.ownPropertyOnly);
+        if (value === undefined && obj instanceof Drop)
+            return obj.liquidMethodMissing(key, this);
+        if (isFunction(value))
+            return value.call(obj);
+        if (key === 'size')
+            return readSize(obj);
+        else if (key === 'first')
+            return readFirst(obj, this.ownPropertyOnly);
+        else if (key === 'last')
+            return readLast(obj, this.ownPropertyOnly);
+        return value;
+    }
 }
 function readJSProperty(obj, key, ownPropertyOnly) {
     if (ownPropertyOnly && !hasOwnProperty.call(obj, key) && !(obj instanceof Drop))
         return undefined;
     return obj[key];
 }
-function readFirst(obj) {
+function readFirst(obj, ownPropertyOnly) {
     if (isArray(obj))
-        return obj[0];
-    return obj['first'];
+        return readArrayElement(obj, 0, ownPropertyOnly);
+    return readJSProperty(obj, 'first', ownPropertyOnly);
 }
-function readLast(obj) {
+function readLast(obj, ownPropertyOnly) {
     if (isArray(obj))
-        return obj[obj.length - 1];
-    return obj['last'];
+        return readArrayElement(obj, -1, ownPropertyOnly);
+    return readJSProperty(obj, 'last', ownPropertyOnly);
 }
 function readSize(obj) {
     if (hasOwnProperty.call(obj, 'size') || obj['size'] !== undefined)
@@ -3161,25 +3382,28 @@ var BlockMode;
     BlockMode[BlockMode["STORE"] = 1] = "STORE";
 })(BlockMode || (BlockMode = {}));
 
-const abs = argumentsToValue(Math.abs);
-const at_least = argumentsToValue(Math.max);
-const at_most = argumentsToValue(Math.min);
-const ceil = argumentsToValue(Math.ceil);
-const divided_by = argumentsToValue((dividend, divisor, integerArithmetic = false) => integerArithmetic ? Math.floor(dividend / divisor) : dividend / divisor);
-const floor = argumentsToValue(Math.floor);
-const minus = argumentsToValue((v, arg) => v - arg);
-const modulo = argumentsToValue((v, arg) => v % arg);
-const times = argumentsToValue((v, arg) => v * arg);
-function round(v, arg = 0) {
-    v = toValue(v);
-    arg = toValue(arg);
-    const amp = Math.pow(10, arg);
-    return Math.round(v * amp) / amp;
+const abs = argumentsToNumber(Math.abs);
+const at_least = argumentsToNumber(Math.max);
+const at_most = argumentsToNumber(Math.min);
+const ceil = argumentsToNumber(Math.ceil);
+const divided_by = argumentsToNumber((dividend, divisor, integerArithmetic = false) => integerArithmetic ? Math.floor(dividend / divisor) : dividend / divisor);
+const floor = argumentsToNumber(Math.floor);
+const minus = argumentsToNumber((v, arg) => v - arg);
+const plus = argumentsToNumber((lhs, rhs) => lhs + rhs);
+const modulo = argumentsToNumber((v, arg) => ((v % arg) + arg) % arg);
+const times = argumentsToNumber((v, arg) => v * arg);
+function shiftDecimal(n, exponent) {
+    const [mantissa, power = '0'] = String(n).split('e');
+    return Number(`${mantissa}e${Number(power) + exponent}`);
 }
-function plus(v, arg) {
-    v = toValue(v);
-    arg = toValue(arg);
-    return Number(v) + Number(arg);
+function round(v, arg = 0) {
+    v = toNumber(v);
+    arg = toNumber(arg);
+    const scaled = shiftDecimal(Math.abs(v), arg);
+    if (!(scaled <= Number.MAX_SAFE_INTEGER))
+        return v;
+    const rounded = shiftDecimal(Math.round(scaled), -arg);
+    return v < 0 ? -rounded : rounded;
 }
 
 var mathFilters = /*#__PURE__*/Object.freeze({
@@ -3191,13 +3415,13 @@ var mathFilters = /*#__PURE__*/Object.freeze({
   divided_by: divided_by,
   floor: floor,
   minus: minus,
+  plus: plus,
   modulo: modulo,
   times: times,
-  round: round,
-  plus: plus
+  round: round
 });
 
-const url_decode = (x) => decodeURIComponent(stringify(x)).replace(/\+/g, ' ');
+const url_decode = (x) => decodeURIComponent(stringify(x).replace(/\+/g, ' '));
 const url_encode = (x) => encodeURIComponent(stringify(x)).replace(/%20/g, '+');
 const cgi_escape = (x) => encodeURIComponent(stringify(x))
     .replace(/%20/g, '+')
@@ -3255,18 +3479,24 @@ var urlFilters = /*#__PURE__*/Object.freeze({
 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);
+    let outputSize = sep.length * Math.max(array.length - 1, 0);
+    for (let i = 0; i < array.length; i++)
+        outputSize += String(array[i]).length;
+    this.context.memoryLimit.use(outputSize);
+    return Array.prototype.join.call(array, sep);
+});
+const last = argumentsToValue(function (v) {
+    return isArrayLike(v) ? readArrayElement(v, -1, this.context.ownPropertyOnly) : '';
+});
+const first = argumentsToValue(function (v) {
+    return isArrayLike(v) ? readArrayElement(v, 0, this.context.ownPropertyOnly) : '';
 });
-const last$1 = argumentsToValue((v) => isArrayLike(v) ? last(v) : '');
-const first = argumentsToValue((v) => isArrayLike(v) ? v[0] : '');
 const reverse = argumentsToValue(function (v) {
     const array = toArray(v);
     this.context.memoryLimit.use(array.length);
     return [...array].reverse();
 });
-function* sort(arr, property) {
+function* sortBy(arr, property, comparator) {
     const values = [];
     const array = toArray(arr);
     this.context.memoryLimit.use(array.length);
@@ -3276,20 +3506,13 @@ function* sort(arr, property) {
             property ? yield this.context._getFromScope(item, stringify(property).split('.'), false) : item
         ]);
     }
-    return values.sort((lhs, rhs) => {
-        const lvalue = lhs[1];
-        const rvalue = rhs[1];
-        return lvalue < rvalue ? -1 : (lvalue > rvalue ? 1 : 0);
-    }).map(tuple => tuple[0]);
-}
-function sort_natural(input, property) {
-    const propertyString = stringify(property);
-    const compare = property === undefined
-        ? caseInsensitiveCompare
-        : (lhs, rhs) => caseInsensitiveCompare(lhs[propertyString], rhs[propertyString]);
-    const array = toArray(input);
-    this.context.memoryLimit.use(array.length);
-    return [...array].sort(compare);
+    return values.sort((lhs, rhs) => comparator(lhs[1], rhs[1])).map(tuple => tuple[0]);
+}
+function* sort(arr, property) {
+    return yield* sortBy.call(this, arr, property, orderedCompare);
+}
+function* sort_natural(arr, property) {
+    return yield* sortBy.call(this, arr, property, caseInsensitiveCompare);
 }
 const size = (v) => (v && v.length) || 0;
 function* map(arr, property) {
@@ -3313,13 +3536,13 @@ function* sum(arr, property) {
 function compact(arr) {
     const array = toArray(arr);
     this.context.memoryLimit.use(array.length);
-    return array.filter(x => !isNil(toValue(x)));
+    return Array.prototype.filter.call(array, x => !isNil(toValue(x)));
 }
 function concat(v, arg = []) {
     const lhs = toArray(v);
     const rhs = toArray(arg);
     this.context.memoryLimit.use(lhs.length + rhs.length);
-    return lhs.concat(rhs);
+    return Array.prototype.concat.call(lhs, rhs);
 }
 function push(v, arg) {
     return concat.call(this, v, [arg]);
@@ -3332,7 +3555,9 @@ function unshift(v, arg) {
     return clone;
 }
 function pop(v) {
-    const clone = [...toArray(v)];
+    const array = toArray(v);
+    this.context.memoryLimit.use(array.length);
+    const clone = [...array];
     clone.pop();
     return clone;
 }
@@ -3349,39 +3574,65 @@ function slice(v, begin, length = 1) {
         return [];
     if (!isArray(v))
         v = stringify(v);
-    begin = begin < 0 ? v.length + begin : begin;
+    begin = begin < 0 ? (isArray(v) ? v.length : codePointLength(v)) + begin : begin;
+    if (begin < 0 || length < 0)
+        return isArray(v) ? [] : '';
     this.context.memoryLimit.use(length);
-    return v.slice(begin, begin + length);
-}
-function* where(arr, property, expected) {
-    const values = [];
+    if (isArray(v))
+        return Array.prototype.slice.call(v, begin, begin + length);
+    const start = advanceCodePoints(v, 0, begin);
+    return v.slice(start, advanceCodePoints(v, start, length));
+}
+function* matches(value, expected) {
+    if (this.context.opts.jekyllWhere) {
+        if (EmptyDrop.is(expected))
+            return yield equals(value, expected);
+        if (isArray(value))
+            return yield arrayIncludes(value, expected);
+        return yield equals(value, expected);
+    }
+    if (expected === undefined)
+        return isTruthy(value, this.context);
+    return yield equals(value, expected);
+}
+function* filter(include, arr, property, expected) {
     arr = toArray(arr);
     this.context.memoryLimit.use(arr.length);
     const token = new Tokenizer(stringify(property)).readScopeValue();
+    const result = [];
     for (const item of arr) {
-        values.push(yield evalToken(token, this.context.spawn(item)));
-    }
-    const matcher = this.context.opts.jekyllWhere
-        ? (v) => EmptyDrop.is(expected) ? equals(v, expected) : (isArray(v) ? arrayIncludes(v, expected) : equals(v, expected))
-        : (v) => equals(v, expected);
-    return arr.filter((_, i) => {
-        if (expected === undefined)
-            return isTruthy(values[i], this.context);
-        return matcher(values[i]);
-    });
+        const value = yield evalToken(token, this.context.spawn(item));
+        if ((yield matches.call(this, value, expected)) === include)
+            result.push(item);
+    }
+    return result;
 }
-function* where_exp(arr, itemName, exp) {
+function* filter_exp(include, arr, itemName, exp) {
     const filtered = [];
     const keyTemplate = new Value(stringify(exp), this.liquid);
     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)
+        this.context.push({ [itemName]: item });
+        const value = yield keyTemplate.value(this.context);
+        this.context.pop();
+        if (value === include)
             filtered.push(item);
     }
     return filtered;
 }
+function* where(arr, property, expected) {
+    return yield* filter.call(this, true, arr, property, expected);
+}
+function* reject(arr, property, expected) {
+    return yield* filter.call(this, false, arr, property, expected);
+}
+function* where_exp(arr, itemName, exp) {
+    return yield* filter_exp.call(this, true, arr, itemName, exp);
+}
+function* reject_exp(arr, itemName, exp) {
+    return yield* filter_exp.call(this, false, arr, itemName, exp);
+}
 function* group_by(arr, property) {
     const map = new Map();
     arr = toEnumerable(arr);
@@ -3401,31 +3652,59 @@ function* group_by_exp(arr, itemName, exp) {
     arr = toEnumerable(arr);
     this.context.memoryLimit.use(arr.length);
     for (const item of arr) {
-        const key = yield keyTemplate.value(this.context.spawn({ [itemName]: item }));
+        this.context.push({ [itemName]: item });
+        const key = yield keyTemplate.value(this.context);
+        this.context.pop();
         if (!map.has(key))
             map.set(key, []);
         map.get(key).push(item);
     }
     return [...map.entries()].map(([name, items]) => ({ name, items }));
 }
-function* find(arr, property, expected) {
+function* search(arr, property, expected) {
     const token = new Tokenizer(stringify(property)).readScopeValue();
     const array = toArray(arr);
-    for (const item of array) {
-        const value = yield evalToken(token, this.context.spawn(item));
-        if (equals(value, expected))
-            return item;
+    for (let index = 0; index < array.length; index++) {
+        const value = yield evalToken(token, this.context.spawn(array[index]));
+        if (yield matches.call(this, value, expected))
+            return [index, array[index]];
     }
 }
-function* find_exp(arr, itemName, exp) {
+function* search_exp(arr, itemName, exp) {
     const predicate = new Value(stringify(exp), this.liquid);
     const array = toArray(arr);
-    for (const item of array) {
-        const value = yield predicate.value(this.context.spawn({ [itemName]: item }));
+    for (let index = 0; index < array.length; index++) {
+        this.context.push({ [itemName]: array[index] });
+        const value = yield predicate.value(this.context);
+        this.context.pop();
         if (value)
-            return item;
+            return [index, array[index]];
     }
 }
+function* has(arr, property, expected) {
+    const result = yield* search.call(this, arr, property, expected);
+    return !!result;
+}
+function* has_exp(arr, itemName, exp) {
+    const result = yield* search_exp.call(this, arr, itemName, exp);
+    return !!result;
+}
+function* find_index(arr, property, expected) {
+    const result = yield* search.call(this, arr, property, expected);
+    return result ? result[0] : undefined;
+}
+function* find_index_exp(arr, itemName, exp) {
+    const result = yield* search_exp.call(this, arr, itemName, exp);
+    return result ? result[0] : undefined;
+}
+function* find(arr, property, expected) {
+    const result = yield* search.call(this, arr, property, expected);
+    return result ? result[1] : undefined;
+}
+function* find_exp(arr, itemName, exp) {
+    const result = yield* search_exp.call(this, arr, itemName, exp);
+    return result ? result[1] : undefined;
+}
 function uniq(arr) {
     arr = toArray(arr);
     this.context.memoryLimit.use(arr.length);
@@ -3437,7 +3716,7 @@ function sample(v, count = 1) {
         return [];
     if (!isArray(v))
         v = stringify(v);
-    this.context.memoryLimit.use(count);
+    this.context.memoryLimit.use(v.length);
     const shuffled = [...v].sort(() => Math.random() - 0.5);
     if (count === 1)
         return shuffled[0];
@@ -3447,7 +3726,7 @@ function sample(v, count = 1) {
 var arrayFilters = /*#__PURE__*/Object.freeze({
   __proto__: null,
   join: join,
-  last: last$1,
+  last: last,
   first: first,
   reverse: reverse,
   sort: sort,
@@ -3463,9 +3742,15 @@ var arrayFilters = /*#__PURE__*/Object.freeze({
   shift: shift,
   slice: slice,
   where: where,
+  reject: reject,
   where_exp: where_exp,
+  reject_exp: reject_exp,
   group_by: group_by,
   group_by_exp: group_by_exp,
+  has: has,
+  has_exp: has_exp,
+  find_index: find_index,
+  find_index_exp: find_index_exp,
   find: find,
   find_exp: find_exp,
   uniq: uniq,
@@ -3473,21 +3758,25 @@ 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);
+    var _a, _b;
+    const size = ((_a = v === null || v === void 0 ? void 0 : v.length) !== null && _a !== void 0 ? _a : 0) + ((_b = timezoneOffset === null || timezoneOffset === void 0 ? void 0 : timezoneOffset.length) !== null && _b !== void 0 ? _b : 0);
     this.context.memoryLimit.use(size);
     const date = parseDate(v, this.context.opts, timezoneOffset);
     if (!date)
         return v;
     format = toValue(format);
     format = isNil(format) ? this.context.opts.dateFormat : stringify(format);
-    return strftime(date, format);
+    this.context.memoryLimit.use(format.length);
+    return strftime(date, format, this.context.memoryLimit);
 }
 function date_to_xmlschema(v) {
     return date.call(this, v, '%Y-%m-%dT%H:%M:%S%:z');
 }
 function date_to_rfc822(v) {
-    return date.call(this, v, '%a, %d %b %Y %H:%M:%S %z');
+    const date = parseDate(v, this.context.opts, undefined, 'en-US');
+    if (!date)
+        return v;
+    return strftime(date, '%a, %d %b %Y %H:%M:%S %z', this.context.memoryLimit);
 }
 function date_to_string(v, type, style) {
     return stringify_date.call(this, v, '%b', type, style);
@@ -3499,20 +3788,23 @@ function stringify_date(v, month_type, type, style) {
     const date = parseDate(v, this.context.opts);
     if (!date)
         return v;
+    const ml = this.context.memoryLimit;
     if (type === 'ordinal') {
         const d = date.getDate();
         return style === 'US'
-            ? strftime(date, `${month_type} ${d}%q, %Y`)
-            : strftime(date, `${d}%q ${month_type} %Y`);
+            ? strftime(date, `${month_type} ${d}%q, %Y`, ml)
+            : strftime(date, `${d}%q ${month_type} %Y`, ml);
     }
-    return strftime(date, `%d ${month_type} %Y`);
+    return strftime(date, `%d ${month_type} %Y`, ml);
 }
-function parseDate(v, opts, timezoneOffset) {
+function parseDate(v, opts, timezoneOffset, locale = opts.locale) {
     let date;
     const defaultTimezoneOffset = timezoneOffset !== null && timezoneOffset !== void 0 ? timezoneOffset : opts.timezoneOffset;
-    const locale = opts.locale;
     v = toValue(v);
-    if (v === 'now' || v === 'today') {
+    if (isNil(v)) {
+        return undefined;
+    }
+    else if (v === 'now' || v === 'today') {
         date = new LiquidDate(Date.now(), locale, defaultTimezoneOffset);
     }
     else if (isNumber(v)) {
@@ -3566,14 +3858,34 @@ function prepend(v, arg) {
     this.context.memoryLimit.use(lhs.length + rhs.length);
     return rhs + lhs;
 }
+function getTrimStart(str, chars) {
+    let start = 0;
+    for (const char of str) {
+        if (!chars.has(char))
+            break;
+        start += char.length;
+    }
+    return start;
+}
+function getTrimEnd(str, chars, start = 0) {
+    let end = str.length;
+    while (end > start) {
+        const size = end - start >= 2 && str.codePointAt(end - 2) > 0xFFFF ? 2 : 1;
+        if (!chars.has(str.slice(end - size, end)))
+            break;
+        end -= size;
+    }
+    return end;
+}
 function lstrip(v, chars) {
     const str = stringify(v);
     this.context.memoryLimit.use(str.length);
     if (chars) {
-        chars = escapeRegExp(stringify(chars));
-        return str.replace(new RegExp(`^[${chars}]+`, 'g'), '');
+        chars = stringify(chars);
+        this.context.memoryLimit.use(chars.length);
+        return str.slice(getTrimStart(str, new Set(chars)));
     }
-    return str.replace(/^\s+/, '');
+    return str.trimStart();
 }
 function downcase(v) {
     const str = stringify(v);
@@ -3587,18 +3899,20 @@ function upcase(v) {
 }
 function remove(v, arg) {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
-    return str.split(stringify(arg)).join('');
+    arg = stringify(arg);
+    this.context.memoryLimit.use(str.length + arg.length);
+    return str.split(arg).join('');
 }
 function remove_first(v, l) {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
-    return str.replace(stringify(l), '');
+    l = stringify(l);
+    this.context.memoryLimit.use(str.length + l.length);
+    return str.replace(l, '');
 }
 function remove_last(v, l) {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
     const pattern = stringify(l);
+    this.context.memoryLimit.use(str.length + pattern.length);
     const index = str.lastIndexOf(pattern);
     if (index === -1)
         return str;
@@ -3608,10 +3922,11 @@ function rstrip(str, chars) {
     str = stringify(str);
     this.context.memoryLimit.use(str.length);
     if (chars) {
-        chars = escapeRegExp(stringify(chars));
-        return str.replace(new RegExp(`[${chars}]+$`, 'g'), '');
+        chars = stringify(chars);
+        this.context.memoryLimit.use(chars.length);
+        return str.slice(0, getTrimEnd(str, new Set(chars)));
     }
-    return str.replace(/\s+$/, '');
+    return str.trimEnd();
 }
 function split(v, arg) {
     const str = stringify(v);
@@ -3627,10 +3942,10 @@ function strip(v, chars) {
     const str = stringify(v);
     this.context.memoryLimit.use(str.length);
     if (chars) {
-        chars = escapeRegExp(stringify(chars));
-        return str
-            .replace(new RegExp(`^[${chars}]+`, 'g'), '')
-            .replace(new RegExp(`[${chars}]+$`, 'g'), '');
+        const set = new Set(stringify(chars));
+        this.context.memoryLimit.use(set.size);
+        const start = getTrimStart(str, set);
+        return str.slice(start, getTrimEnd(str, set, start));
     }
     return str.trim();
 }
@@ -3639,6 +3954,11 @@ function strip_newlines(v) {
     this.context.memoryLimit.use(str.length);
     return str.replace(/\r?\n/gm, '');
 }
+function squish(v) {
+    const str = stringify(v);
+    this.context.memoryLimit.use(str.length);
+    return str.replace(/\s+/g, ' ').trim();
+}
 function capitalize(str) {
     str = stringify(str);
     this.context.memoryLimit.use(str.length);
@@ -3646,35 +3966,43 @@ function capitalize(str) {
 }
 function replace(v, pattern, replacement) {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
-    return str.split(stringify(pattern)).join(replacement);
+    pattern = stringify(pattern);
+    replacement = stringify(replacement);
+    const parts = str.split(pattern);
+    const outputSize = str.length + (parts.length - 1) * (replacement.length - pattern.length);
+    this.context.memoryLimit.use(outputSize);
+    return parts.join(replacement);
 }
 function replace_first(v, arg1, arg2) {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
-    return str.replace(stringify(arg1), arg2);
+    arg1 = stringify(arg1);
+    arg2 = stringify(arg2);
+    this.context.memoryLimit.use(str.length + arg1.length + arg2.length);
+    return str.replace(arg1, () => arg2);
 }
 function replace_last(v, arg1, arg2) {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
     const pattern = stringify(arg1);
+    const replacement = stringify(arg2);
+    this.context.memoryLimit.use(str.length + pattern.length + replacement.length);
     const index = str.lastIndexOf(pattern);
     if (index === -1)
         return str;
-    const replacement = stringify(arg2);
     return str.substring(0, index) + replacement + str.substring(index + pattern.length);
 }
 function truncate(v, l = 50, o = '...') {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
-    if (str.length <= l)
+    o = stringify(o);
+    this.context.memoryLimit.use(str.length + o.length);
+    if (str.length <= l || advanceCodePoints(str, 0, l) >= str.length)
         return v;
-    return str.substring(0, l - o.length) + o;
+    return str.slice(0, advanceCodePoints(str, 0, Math.max(l - codePointLength(o), 0))) + o;
 }
 function truncatewords(v, words = 15, o = '...') {
     const str = stringify(v);
-    this.context.memoryLimit.use(str.length);
-    const arr = str.split(/\s+/);
+    o = stringify(o);
+    this.context.memoryLimit.use(str.length + o.length);
+    const arr = str.trimStart().split(/\s+/);
     if (words <= 0)
         words = 1;
     let ret = arr.slice(0, words).join(' ');
@@ -3707,8 +4035,13 @@ function number_of_words(input, mode) {
             return input.split(/\s+/).length;
     }
 }
-function array_to_sentence_string(array, connector = 'and') {
-    this.context.memoryLimit.use(array.length);
+function array_to_sentence_string(input, connector = 'and') {
+    const array = toArray(input);
+    connector = stringify(connector);
+    let outputSize = connector.length + array.length * 2;
+    for (let i = 0; i < array.length; i++)
+        outputSize += stringify(array[i]).length;
+    this.context.memoryLimit.use(outputSize);
     switch (array.length) {
         case 0:
             return '';
@@ -3735,6 +4068,7 @@ var stringFilters = /*#__PURE__*/Object.freeze({
   split: split,
   strip: strip,
   strip_newlines: strip_newlines,
+  squish: squish,
   capitalize: capitalize,
   replace: replace,
   replace_first: replace_first,
@@ -3746,7 +4080,77 @@ var stringFilters = /*#__PURE__*/Object.freeze({
   array_to_sentence_string: array_to_sentence_string
 });
 
-const filters = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, htmlFilters), mathFilters), urlFilters), arrayFilters), dateFilters), stringFilters), misc);
+function base64Encode(str) {
+    return Buffer.from(str, 'utf8').toString('base64');
+}
+function base64Decode(str) {
+    return Buffer.from(str, 'base64').toString('utf8');
+}
+
+/**
+ * Base64 related filters
+ *
+ * Implements base64_encode and base64_decode filters for Shopify compatibility
+ */
+function base64_encode(value) {
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+        this.context.memoryLimit.use(value.byteLength);
+        return value.toString('base64');
+    }
+    const str = stringify(value);
+    this.context.memoryLimit.use(str.length);
+    return base64Encode(str);
+}
+function base64_decode(value) {
+    const str = stringify(value);
+    this.context.memoryLimit.use(str.length);
+    assert(isBase64(str), 'invalid base64 provided to base64_decode');
+    return base64Decode(str);
+}
+function isBase64(str) {
+    str = str.replace(/[\t\n\f\r ]/g, '');
+    if (str.length % 4 === 0)
+        str = str.replace(/==?$/, '');
+    return str.length % 4 !== 1 && /^[A-Za-z0-9+/]*$/.test(str);
+}
+
+var base64Filters = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  base64_encode: base64_encode,
+  base64_decode: base64_decode
+});
+
+function sha256(str) {
+    return createHash('sha256').update(str, 'utf8').digest('hex');
+}
+function hmacSha256(str, key) {
+    return createHmac('sha256', key).update(str, 'utf8').digest('hex');
+}
+
+/**
+ * Crypto related filters
+ *
+ * Implements sha256 and hmac_sha256 filters for Shopify compatibility
+ */
+function sha256$1(value) {
+    const str = stringify(value);
+    this.context.memoryLimit.use(str.length);
+    return sha256(str);
+}
+function hmac_sha256(value, key) {
+    const str = stringify(value);
+    const keyStr = stringify(key);
+    this.context.memoryLimit.use(str.length + keyStr.length);
+    return hmacSha256(str, keyStr);
+}
+
+var cryptoFilters = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  sha256: sha256$1,
+  hmac_sha256: hmac_sha256
+});
+
+const filters = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, htmlFilters), mathFilters), urlFilters), arrayFilters), dateFilters), stringFilters), base64Filters), cryptoFilters), misc);
 
 class AssignTag extends Tag {
     constructor(token, remainTokens, liquid) {
@@ -3802,8 +4206,8 @@ class ForTag extends Tag {
             return;
         }
         const continueKey = 'continue-' + this.variable + '-' + this.collection.getText();
-        ctx.push({ continue: ctx.getRegister(continueKey) });
-        const hash = yield this.hash.render(ctx);
+        ctx.push(createScope({ continue: ctx.getRegister(continueKey, {}) }));
+        const hash = (yield this.hash.render(ctx));
         ctx.pop();
         const modifiers = this.liquid.options.orderedFilterParameters
             ? Object.keys(hash).filter(x => MODIFIERS.includes(x))
@@ -3816,7 +4220,7 @@ class ForTag extends Tag {
             return reversed(collection);
         }, collection);
         ctx.setRegister(continueKey, (hash['offset'] || 0) + collection.length);
-        const scope = { forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) };
+        const scope = createScope({ forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) });
         ctx.push(scope);
         for (const item of collection) {
             scope[this.variable] = item;
@@ -3942,12 +4346,12 @@ class CaseTag extends Tag {
     }
     *render(ctx, emitter) {
         const r = this.liquid.renderer;
-        const target = toValue(yield this.value.value(ctx, ctx.opts.lenientIf));
+        const target = yield toValue(yield this.value.value(ctx, ctx.opts.lenientIf));
         let branchHit = false;
         for (const branch of this.branches) {
             for (const valueToken of branch.values) {
                 const value = yield evalToken(valueToken, ctx, ctx.opts.lenientIf);
-                if (equals(target, value)) {
+                if (yield equals(target, value)) {
                     yield r.renderTemplates(branch.templates, ctx, emitter);
                     branchHit = true;
                     break;
@@ -4008,7 +4412,11 @@ class RenderTag extends Tag {
                             alias = tokenizer.readIdentifier();
                         else
                             tokenizer.p = beforeAs;
-                        this[keyword.content] = { value, alias: alias && alias.content };
+                        const binding = { value, alias: alias && alias.content };
+                        if (keyword.content === 'with')
+                            this.with = binding;
+                        else
+                            this.forBinding = binding;
                         tokenizer.skipBlank();
                         if (tokenizer.peek() === ',')
                             tokenizer.advance();
@@ -4026,42 +4434,42 @@ class RenderTag extends Tag {
     }
     *render(ctx, emitter) {
         const { liquid, hash } = this;
-        const filepath = (yield renderFilePath(this['file'], ctx, liquid));
+        const filepath = (yield renderFilePath(this.file, ctx, liquid));
         assert(filepath, () => `illegal file path "${filepath}"`);
         const childCtx = ctx.spawn();
         const scope = childCtx.bottom();
         __assign(scope, yield hash.render(ctx));
-        if (this['with']) {
-            const { value, alias } = this['with'];
+        if (this.with) {
+            const { value, alias } = this.with;
             scope[alias || filepath] = yield evalToken(value, ctx);
         }
-        if (this['for']) {
-            const { value, alias } = this['for'];
+        if (this.forBinding) {
+            const { value, alias } = this.forBinding;
             const collection = toEnumerable(yield evalToken(value, ctx));
             scope['forloop'] = new ForloopDrop(collection.length, value.getText(), alias);
             for (const item of collection) {
                 scope[alias] = item;
-                const templates = (yield liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile']));
+                const templates = (yield liquid._parsePartialFile(filepath, childCtx.sync, this.currentFile));
                 yield liquid.renderer.renderTemplates(templates, childCtx, emitter);
                 scope['forloop'].next();
             }
         }
         else {
-            const templates = (yield liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile']));
+            const templates = (yield liquid._parsePartialFile(filepath, childCtx.sync, this.currentFile));
             yield liquid.renderer.renderTemplates(templates, childCtx, emitter);
         }
     }
     *children(partials, sync) {
-        if (partials && isString(this['file'])) {
-            return (yield this.liquid._parsePartialFile(this['file'], sync, this['currentFile']));
+        if (partials && isString(this.file)) {
+            return (yield this.liquid._parsePartialFile(this.file, sync, this.currentFile));
         }
         return [];
     }
     partialScope() {
-        if (isString(this['file'])) {
+        if (isString(this.file)) {
             const names = Object.keys(this.hash.hash);
-            if (this['with']) {
-                const { value, alias } = this['with'];
+            if (this.with) {
+                const { value, alias } = this.with;
                 if (isString(alias)) {
                     names.push([alias, value]);
                 }
@@ -4069,8 +4477,8 @@ class RenderTag extends Tag {
                     names.push([this.file, value]);
                 }
             }
-            if (this['for']) {
-                const { value, alias } = this['for'];
+            if (this.forBinding) {
+                const { value, alias } = this.forBinding;
                 if (isString(alias)) {
                     names.push([alias, value]);
                 }
@@ -4078,7 +4486,7 @@ class RenderTag extends Tag {
                     names.push([this.file, value]);
                 }
             }
-            return { name: this['file'], isolated: true, scope: names };
+            return { name: this.file, isolated: true, scope: names };
         }
     }
     *arguments() {
@@ -4087,14 +4495,14 @@ class RenderTag extends Tag {
                 yield v;
             }
         }
-        if (this['with']) {
-            const { value } = this['with'];
+        if (this.with) {
+            const { value } = this.with;
             if (isValueToken(value)) {
                 yield value;
             }
         }
-        if (this['for']) {
-            const { value } = this['for'];
+        if (this.forBinding) {
+            const { value } = this.forBinding;
             if (isValueToken(value)) {
                 yield value;
             }
@@ -4142,8 +4550,8 @@ class IncludeTag extends Tag {
     constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
         const { tokenizer } = token;
-        this['file'] = parseFilePath(tokenizer, this.liquid, parser);
-        this['currentFile'] = token.file;
+        this.file = parseFilePath(tokenizer, this.liquid, parser);
+        this.currentFile = token.file;
         const begin = tokenizer.p;
         const withStr = tokenizer.readIdentifier();
         if (withStr.content === 'with') {
@@ -4161,28 +4569,28 @@ class IncludeTag extends Tag {
     *render(ctx, emitter) {
         const { liquid, hash, withVar } = this;
         const { renderer } = liquid;
-        const filepath = (yield renderFilePath(this['file'], ctx, liquid));
+        const filepath = (yield renderFilePath(this.file, ctx, liquid));
         assert(filepath, () => `illegal file path "${filepath}"`);
         const saved = ctx.saveRegister('blocks', 'blockMode');
         ctx.setRegister('blocks', {});
         ctx.setRegister('blockMode', BlockMode.OUTPUT);
-        const scope = (yield hash.render(ctx));
+        const scope = createScope((yield hash.render(ctx)));
         if (withVar)
             scope[filepath] = yield evalToken(withVar, ctx);
-        const templates = (yield liquid._parsePartialFile(filepath, ctx.sync, this['currentFile']));
-        ctx.push(ctx.opts.jekyllInclude ? { include: scope } : scope);
+        const templates = (yield liquid._parsePartialFile(filepath, ctx.sync, this.currentFile));
+        ctx.push(ctx.opts.jekyllInclude ? createScope({ include: scope }) : scope);
         yield renderer.renderTemplates(templates, ctx, emitter);
         ctx.pop();
         ctx.restoreRegister(saved);
     }
     *children(partials, sync) {
-        if (partials && isString(this['file'])) {
-            return (yield this.liquid._parsePartialFile(this['file'], sync, this['currentFile']));
+        if (partials && isString(this.file)) {
+            return (yield this.liquid._parsePartialFile(this.file, sync, this.currentFile));
         }
         return [];
     }
     partialScope() {
-        if (isString(this['file'])) {
+        if (isString(this.file)) {
             let names;
             if (this.liquid.options.jekyllInclude) {
                 names = ['include'];
@@ -4190,16 +4598,16 @@ class IncludeTag extends Tag {
             else {
                 names = Object.keys(this.hash.hash);
                 if (this.withVar) {
-                    names.push([this['file'], this.withVar]);
+                    names.push([this.file, this.withVar]);
                 }
             }
-            return { name: this['file'], isolated: false, scope: names };
+            return { name: this.file, isolated: false, scope: names };
         }
     }
     *arguments() {
         yield* Object.values(this.hash.hash).filter(isValueToken);
-        if (isValueToken(this['file'])) {
-            yield this['file'];
+        if (isValueToken(this.file)) {
+            yield this.file;
         }
         if (isValueToken(this.withVar)) {
             yield this.withVar;
@@ -4229,6 +4637,7 @@ class CycleTag extends Tag {
     constructor(token, remainTokens, liquid) {
         super(token, remainTokens, liquid);
         this.candidates = [];
+        const begin = this.tokenizer.p;
         const group = this.tokenizer.readValue();
         this.tokenizer.skipBlank();
         if (group) {
@@ -4237,28 +4646,33 @@ class CycleTag extends Tag {
                 this.tokenizer.advance();
             }
             else
-                this.candidates.push(group);
+                this.tokenizer.p = begin;
         }
         while (!this.tokenizer.end()) {
-            const value = this.tokenizer.readValue();
-            if (value)
-                this.candidates.push(value);
+            const value = this.tokenizer.readFilteredValue();
+            this.candidates.push(value);
             this.tokenizer.readTo(',');
         }
         this.tokenizer.assert(this.candidates.length, () => `empty candidates: "${token.getText()}"`);
     }
     *render(ctx, emitter) {
+        var _a;
         const group = (yield evalToken(this.group, ctx));
-        const fingerprint = `cycle:${group}:` + this.candidates.join(',');
-        const groups = ctx.getRegister('cycle');
+        const fingerprint = `cycle:${group}:` + this.candidates.map(c => c.getText()).join(',');
+        const groups = ctx.getRegister('cycle', {});
         let idx = groups[fingerprint];
         if (idx === undefined) {
             idx = groups[fingerprint] = 0;
         }
-        const candidate = this.candidates[idx];
+        const candidate = new Value(this.candidates[idx], this.liquid);
         idx = (idx + 1) % this.candidates.length;
         groups[fingerprint] = idx;
-        return yield evalToken(candidate, ctx);
+        let val = yield toValue(yield candidate.value(ctx, false));
+        const outputEscape = this.liquid.options.outputEscape;
+        if (outputEscape && !((_a = candidate.filters[candidate.filters.length - 1]) === null || _a === void 0 ? void 0 : _a.raw)) {
+            val = yield outputEscape.call({ context: ctx, token: this.token, liquid: this.liquid }, val);
+        }
+        return val;
     }
     *arguments() {
         yield* this.candidates;
@@ -4298,7 +4712,7 @@ class IfTag extends Tag {
     *render(ctx, emitter) {
         const r = this.liquid.renderer;
         for (const { value, templates } of this.branches) {
-            const v = yield value.value(ctx, ctx.opts.lenientIf);
+            const v = yield toValue(yield value.value(ctx, ctx.opts.lenientIf));
             if (isTruthy(v, ctx)) {
                 yield r.renderTemplates(templates, ctx, emitter);
                 return;
@@ -4342,7 +4756,7 @@ class LayoutTag extends Tag {
     constructor(token, remainTokens, liquid, parser) {
         super(token, remainTokens, liquid);
         this.file = parseFilePath(this.tokenizer, this.liquid, parser);
-        this['currentFile'] = token.file;
+        this.currentFile = token.file;
         this.args = new Hash(this.tokenizer, liquid.options.keyValueSeparator);
         this.templates = parser.parseTokens(remainTokens);
     }
@@ -4356,24 +4770,24 @@ class LayoutTag extends Tag {
         }
         const filepath = (yield renderFilePath(this.file, ctx, liquid));
         assert(filepath, () => `illegal file path "${filepath}"`);
-        const templates = (yield liquid._parseLayoutFile(filepath, ctx.sync, this['currentFile']));
+        const templates = (yield liquid._parseLayoutFile(filepath, ctx.sync, this.currentFile));
         // render remaining contents and store rendered results
         ctx.setRegister('blockMode', BlockMode.STORE);
         const html = yield renderer.renderTemplates(this.templates, ctx);
-        const blocks = ctx.getRegister('blocks');
+        const blocks = ctx.getRegister('blocks', {});
         // set whole content to anonymous block if anonymous doesn't specified
         if (blocks[''] === undefined)
             blocks[''] = (parent, emitter) => emitter.write(html);
         ctx.setRegister('blockMode', BlockMode.OUTPUT);
         // render the layout file use stored blocks
-        ctx.push((yield args.render(ctx)));
+        ctx.push(createScope((yield args.render(ctx))));
         yield renderer.renderTemplates(templates, ctx, emitter);
         ctx.pop();
     }
     *children(partials) {
         const templates = this.templates.slice();
         if (partials && isString(this.file)) {
-            templates.push(...(yield this.liquid._parsePartialFile(this.file, true, this['currentFile'])));
+            templates.push(...(yield this.liquid._parsePartialFile(this.file, true, this.currentFile)));
         }
         return templates;
     }
@@ -4412,23 +4826,28 @@ class BlockTag extends Tag {
     *render(ctx, emitter) {
         const blockRender = this.getBlockRender(ctx);
         if (ctx.getRegister('blockMode') === BlockMode.STORE) {
-            ctx.getRegister('blocks')[this.block] = blockRender;
+            ctx.getRegister('blocks', {})[this.block] = blockRender;
         }
         else {
             yield blockRender(new BlockDrop(), emitter);
         }
     }
     getBlockRender(ctx) {
+        const self = this;
         const { liquid, templates } = this;
-        const renderChild = ctx.getRegister('blocks')[this.block];
+        const renderChild = ctx.getRegister('blocks', {})[this.block];
         const renderCurrent = function* (superBlock, emitter) {
-            // add {{ block.super }} support when rendering
-            ctx.push({ block: superBlock });
+            const stack = ctx.getRegister('blockStack', []);
+            if (stack.includes(self))
+                throw new Error('block tag cannot be nested');
+            stack.push(self);
+            ctx.push(createScope({ block: superBlock }));
             yield liquid.renderer.renderTemplates(templates, ctx, emitter);
             ctx.pop();
+            stack.pop();
         };
         return renderChild
-            ? (superBlock, emitter) => renderChild(new BlockDrop(() => renderCurrent(superBlock, emitter)), emitter)
+            ? (superBlock, emitter) => renderChild(new BlockDrop((emitter) => renderCurrent(superBlock, emitter)), emitter)
             : renderCurrent;
     }
     *children() {
@@ -4512,7 +4931,7 @@ class TablerowTag extends Tag {
         const cols = args.cols || collection.length;
         const r = this.liquid.renderer;
         const tablerowloop = new TablerowloopDrop(collection.length, cols, this.collection.getText(), this.variable);
-        const scope = { tablerowloop };
+        const scope = createScope({ tablerowloop });
         ctx.push(scope);
         for (let idx = 0; idx < collection.length; idx++, tablerowloop.next()) {
             scope[this.variable] = collection[idx];
@@ -4585,7 +5004,7 @@ class UnlessTag extends Tag {
     *render(ctx, emitter) {
         const r = this.liquid.renderer;
         for (const { value, test, templates } of this.branches) {
-            const v = yield value.value(ctx, ctx.opts.lenientIf);
+            const v = yield toValue(yield value.value(ctx, ctx.opts.lenientIf));
             if (test(v, ctx)) {
                 yield r.renderTemplates(templates, ctx, emitter);
                 return;
@@ -4626,9 +5045,14 @@ class EchoTag extends Tag {
         }
     }
     *render(ctx, emitter) {
+        var _a;
         if (!this.value)
             return;
-        const val = yield this.value.value(ctx, false);
+        let val = yield toValue(yield this.value.value(ctx, false));
+        const outputEscape = this.liquid.options.outputEscape;
+        if (outputEscape && !((_a = this.value.filters[this.value.filters.length - 1]) === null || _a === void 0 ? void 0 : _a.raw)) {
+            val = yield outputEscape.call({ context: ctx, token: this.token, liquid: this.liquid }, val);
+        }
         emitter.write(val);
     }
     *arguments() {
@@ -4689,8 +5113,8 @@ const tags = {
 class Liquid {
     constructor(opts = {}) {
         this.renderer = new Render();
-        this.filters = {};
-        this.tags = {};
+        this.filters = Object.create(null);
+        this.tags = Object.create(null);
         this.options = normalize(opts);
         // eslint-disable-next-line deprecation/deprecation
         this.parser = new Parser(this);
@@ -4702,7 +5126,7 @@ class Liquid {
         return parser.parse(html, filepath);
     }
     _render(tpl, scope, renderOptions) {
-        const ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions);
+        const ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions, { liquid: this });
         return this.renderer.renderTemplates(tpl, ctx);
     }
     render(tpl, scope, renderOptions) {
@@ -4714,7 +5138,7 @@ class Liquid {
         return toValueSync(this._render(tpl, scope, Object.assign(Object.assign({}, renderOptions), { sync: true })));
     }
     renderToNodeStream(tpl, scope, renderOptions = {}) {
-        const ctx = new Context(scope, this.options, renderOptions);
+        const ctx = new Context(scope, this.options, renderOptions, { liquid: this });
         return this.renderer.renderTemplatesToNodeStream(tpl, ctx);
     }
     _parseAndRender(html, scope, renderOptions) {
@@ -4766,7 +5190,7 @@ class Liquid {
     }
     _evalValue(str, scope) {
         const value = new Value(str, this);
-        const ctx = scope instanceof Context ? scope : new Context(scope, this.options);
+        const ctx = scope instanceof Context ? scope : new Context(scope, this.options, {}, { liquid: this });
         return value.value(ctx);
     }
     evalValue(str, scope) {
@@ -4780,6 +5204,9 @@ class Liquid {
     registerFilter(name, filter) {
         this.filters[name] = filter;
     }
+    unregisterFilter(name) {
+        delete this.filters[name];
+    }
     registerTag(name, tag) {
         this.tags[name] = isFunction(tag) ? tag : createTagClass(tag);
     }
@@ -4893,4 +5320,4 @@ class Liquid {
 /* istanbul ignore file */
 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, Parser, RawTag, RenderError, RenderTag, TablerowTag, Tag, TagToken, Token, TokenKind, TokenizationError, Tokenizer, typeGuards as TypeGuards, UndefinedVariableError, UnlessTag, Value, Variable, analyze, analyzeSync, 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, LookupType, Output, ParseError, ParseStream, Parser, RawTag, RenderError, RenderTag, TablerowTag, Tag, TagToken, Token, TokenKind, TokenizationError, Tokenizer, typeGuards as TypeGuards, UndefinedVariableError, UnlessTag, Value, Variable, analyze, analyzeSync, assert, createTrie, defaultOperators, defaultOptions, evalQuotedToken, evalToken, evalTokenValue, filters, isFalsy, isTruthy, tags, toPromise, toValue, toValueSync, version };