@skeptools/skep-organization-project 0.0.17 → 0.0.19

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

@@ -1,6 +1,6 @@
 /*
- * liquidjs@10.20.1, https://github.com/harttle/liquidjs
- * (c) 2016-2025 harttle
+ * liquidjs@10.30.1, https://github.com/harttle/liquidjs
+ * (c) 2016-2026 harttle
  * Released under the MIT License.
  */
 'use strict';
@@ -10,6 +10,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var stream = require('stream');
 var path = require('path');
 var fs$1 = require('fs');
+var crypto = require('crypto');
 
 class Token {
     constructor(kind, input, begin, end, file) {
@@ -40,7 +41,7 @@ class Token {
 }
 
 class Drop {
-    liquidMethodMissing(key) {
+    liquidMethodMissing(key, context) {
         return undefined;
     }
 }
@@ -61,9 +62,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) => {
@@ -83,6 +81,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))
@@ -107,8 +124,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';
@@ -152,9 +168,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(''))
@@ -180,10 +193,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;
@@ -195,13 +208,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);
@@ -214,8 +240,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) {
@@ -381,8 +407,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;
@@ -402,10 +428,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))
@@ -433,14 +459,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;
@@ -480,6 +506,50 @@ class ForloopDrop extends Drop {
     }
 }
 
+class SimpleEmitter {
+    constructor() {
+        this.buffer = '';
+    }
+    write(html) {
+        this.buffer += stringify(html);
+    }
+}
+
+class StreamedEmitter {
+    constructor() {
+        this.buffer = '';
+        this.stream = new stream.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
@@ -491,8 +561,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;
     }
 }
 
@@ -515,7 +587,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;
@@ -530,9 +611,16 @@ function createTrie(input) {
         node.data = data;
         node.end = true;
     }
+    trieCache.set(input, trie);
     return trie;
 }
 
+function toLiquidAsync(asyncFn, syncFn) {
+    const syncImpl = syncFn || asyncFn;
+    return (sync, ...args) => {
+        return sync ? syncImpl(...args) : asyncFn(...args);
+    };
+}
 // convert an async iterator to a Promise
 async function toPromise(val) {
     if (!isIterator(val))
@@ -542,7 +630,7 @@ async function toPromise(val) {
     let next = 'next';
     do {
         const state = val[next](value);
-        done = state.done;
+        done = !!state.done;
         value = state.value;
         next = 'next';
         try {
@@ -567,7 +655,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)) {
@@ -597,12 +685,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();
@@ -620,10 +705,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,
@@ -636,7 +722,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) {
@@ -667,13 +755,14 @@ const formatCodes = {
     M: (d) => d.getMinutes(),
     N: (d, opts) => {
         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);
+        opts.memoryLimit?.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),
@@ -681,7 +770,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),
@@ -690,18 +779,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)
@@ -709,9 +798,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['#'])
@@ -722,6 +811,9 @@ function format(d, match) {
         padChar = '0';
     if (flags['-'])
         padWidth = 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);
 }
 
@@ -770,6 +862,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();
     }
@@ -877,13 +978,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);
+        }
     }
 }
 
@@ -914,13 +1017,11 @@ class TagToken extends DelimitedToken {
         const { trimTagLeft, trimTagRight, tagDelimiterLeft, tagDelimiterRight } = options;
         const [valueBegin, valueEnd] = [begin + tagDelimiterLeft.length, end - tagDelimiterRight.length];
         super(exports.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]);
     }
 }
 
@@ -1015,8 +1116,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;
     }
 }
 
@@ -1130,7 +1230,7 @@ class RangeToken extends Token {
 class LiquidTagToken extends DelimitedToken {
     constructor(input, begin, end, options, file) {
         super(exports.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();
@@ -1166,50 +1266,6 @@ function getPerformance() {
         polyfill;
 }
 
-class SimpleEmitter {
-    constructor() {
-        this.buffer = '';
-    }
-    write(html) {
-        this.buffer += stringify(html);
-    }
-}
-
-class StreamedEmitter {
-    constructor() {
-        this.buffer = '';
-        this.stream = new stream.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();
@@ -1221,6 +1277,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());
@@ -1247,6 +1304,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?.handler) ? options.handler : identify);
+        this.raw = !isFunction(options) && !!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)];
@@ -1277,6 +1361,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;
@@ -1286,11 +1375,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) {
@@ -1311,8 +1421,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);
 }
@@ -1347,67 +1457,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?.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 {
@@ -1510,10 +1628,28 @@ function fallback(file) {
 function dirname(filepath) {
     return path.dirname(filepath);
 }
-function contains(root, file) {
-    root = path.resolve(root);
-    root = root.endsWith(path.sep) ? root : root + path.sep;
-    return file.startsWith(root);
+const realpathAsync = promisify(fs$1.realpath);
+async function contains(root, file) {
+    try {
+        const realRoot = await realpathAsync(root);
+        const realFile = await realpathAsync(file);
+        const prefix = realRoot.endsWith(path.sep) ? realRoot : realRoot + path.sep;
+        return realFile.startsWith(prefix);
+    }
+    catch {
+        return false;
+    }
+}
+function containsSync(root, file) {
+    try {
+        const realRoot = fs$1.realpathSync(root);
+        const realFile = fs$1.realpathSync(file);
+        const prefix = realRoot.endsWith(path.sep) ? realRoot : realRoot + path.sep;
+        return realFile.startsWith(prefix);
+    }
+    catch {
+        return false;
+    }
 }
 
 var fs = /*#__PURE__*/Object.freeze({
@@ -1526,9 +1662,24 @@ var fs = /*#__PURE__*/Object.freeze({
   fallback: fallback,
   dirname: dirname,
   contains: contains,
+  containsSync: containsSync,
   sep: path.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))
@@ -1538,19 +1689,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);
 }
@@ -1605,10 +1766,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({
@@ -1695,6 +1879,7 @@ const defaultOptions = {
     globals: {},
     keepOutputType: false,
     operators: defaultOperators,
+    groupedExpressions: false,
     memoryLimit: Infinity,
     parseLimit: Infinity,
     renderLimit: Infinity
@@ -1790,7 +1975,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;
@@ -1798,6 +1983,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());
@@ -1859,6 +2045,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()) {
@@ -1873,10 +2061,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');
         }
@@ -2082,7 +2270,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;
@@ -2161,17 +2352,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();
@@ -2198,7 +2402,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())) {
@@ -2325,33 +2529,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?.handler) ? options.handler : identify);
-        this.raw = !isFunction(options) && !!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
@@ -2359,7 +2536,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));
@@ -2382,7 +2559,7 @@ class Value {
 class Output extends TemplateImpl {
     constructor(token, liquid) {
         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;
@@ -2392,7 +2569,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() {
@@ -2667,10 +2844,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.
@@ -2739,52 +2937,53 @@ function segmentsString(segments, bracketedRoot = false) {
     return buf.join('');
 }
 
-var LookupType;
 (function (LookupType) {
     LookupType["Partials"] = "partials";
     LookupType["Layouts"] = "layouts";
     LookupType["Root"] = "root";
-})(LookupType || (LookupType = {}));
+})(exports.LookupType || (exports.LookupType = {}));
 class Loader {
     constructor(options) {
         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(fs.contains?.bind(fs) || (async () => true), fs.containsSync?.bind(fs) || (() => true));
+        this.exists = toLiquidAsync(fs.exists?.bind(fs) || (async () => false), fs.existsSync?.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);
@@ -2813,11 +3012,12 @@ class Parser {
         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(this.fs.readFile?.bind(this.fs) || (async () => { throw new Error('readFile not implemented'); }), this.fs.readFileSync?.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);
     }
@@ -2861,7 +3061,7 @@ class Parser {
     parseStream(tokens) {
         return new ParseStream(tokens, (token, tokens) => this.parseToken(token, tokens));
     }
-    *_parseFileCached(file, sync, type = LookupType.Root, currentFile) {
+    *_parseFileCached(file, sync, type = exports.LookupType.Root, currentFile) {
         const cache = this.cache;
         const key = this.loader.shouldLoadRelative(file) ? currentFile + ',' + file : type + ':' + file;
         const tpls = yield cache.read(key);
@@ -2881,9 +3081,9 @@ class Parser {
             throw err;
         }
     }
-    *_parseFile(file, sync, type = LookupType.Root, currentFile) {
+    *_parseFile(file, sync, type = exports.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);
     }
 }
 
@@ -2901,6 +3101,7 @@ class Parser {
     TokenKind[TokenKind["Quoted"] = 1024] = "Quoted";
     TokenKind[TokenKind["Operator"] = 2048] = "Operator";
     TokenKind[TokenKind["FilteredValue"] = 4096] = "FilteredValue";
+    TokenKind[TokenKind["GroupedExpression"] = 8192] = "GroupedExpression";
     TokenKind[TokenKind["Delimited"] = 12] = "Delimited";
 })(exports.TokenKind || (exports.TokenKind = {}));
 
@@ -2937,9 +3138,12 @@ function isWordToken(val) {
 function isRangeToken(val) {
     return getKind(val) === exports.TokenKind.Range;
 }
+function isFilteredValueToken(val) {
+    return getKind(val) === exports.TokenKind.FilteredValue;
+}
 function isValueToken(val) {
-    // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range
-    return (getKind(val) & 1667) > 0;
+    // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range | TokenKind.FilteredValue
+    return (getKind(val) & 5763) > 0;
 }
 function getKind(val) {
     return val ? val.kind : -1;
@@ -2958,6 +3162,7 @@ var typeGuards = /*#__PURE__*/Object.freeze({
   isPropertyAccessToken: isPropertyAccessToken,
   isWordToken: isWordToken,
   isRangeToken: isRangeToken,
+  isFilteredValueToken: isFilteredValueToken,
   isValueToken: isValueToken
 });
 
@@ -2987,13 +3192,20 @@ var __assign = function() {
     return __assign.apply(this, arguments);
 };
 
+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 } = {}) {
         /**
          * 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;
@@ -3005,9 +3217,10 @@ class Context {
         this.ownPropertyOnly = renderOptions.ownPropertyOnly ?? opts.ownPropertyOnly;
         this.memoryLimit = memoryLimit ?? new Limiter('memory alloc', renderOptions.memoryLimit ?? opts.memoryLimit);
         this.renderLimit = renderLimit ?? new Limiter('template render', getPerformance().now() + (renderOptions.renderLimit ?? 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);
@@ -3045,7 +3258,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('.'));
             }
@@ -3065,10 +3278,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) {
@@ -3081,41 +3296,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)
@@ -3134,25 +3349,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({
@@ -3164,13 +3382,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, '+')
@@ -3228,18 +3446,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);
@@ -3249,20 +3473,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) {
@@ -3286,13 +3503,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]);
@@ -3305,7 +3522,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;
 }
@@ -3322,39 +3541,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);
@@ -3374,31 +3619,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);
@@ -3410,7 +3683,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];
@@ -3420,7 +3693,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,
@@ -3436,9 +3709,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,
@@ -3446,20 +3725,24 @@ var arrayFilters = /*#__PURE__*/Object.freeze({
 });
 
 function date(v, format, timezoneOffset) {
-    const size = (v?.length ?? 0) + (format?.length ?? 0) + (timezoneOffset?.length ?? 0);
+    const size = (v?.length ?? 0) + (timezoneOffset?.length ?? 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);
@@ -3471,20 +3754,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 ?? 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)) {
@@ -3538,14 +3824,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);
@@ -3559,18 +3865,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;
@@ -3580,10 +3888,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);
@@ -3599,10 +3908,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();
 }
@@ -3611,6 +3920,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);
@@ -3618,35 +3932,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(' ');
@@ -3679,8 +4001,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 '';
@@ -3707,6 +4034,7 @@ var stringFilters = /*#__PURE__*/Object.freeze({
   split: split,
   strip: strip,
   strip_newlines: strip_newlines,
+  squish: squish,
   capitalize: capitalize,
   replace: replace,
   replace_first: replace_first,
@@ -3718,6 +4046,76 @@ var stringFilters = /*#__PURE__*/Object.freeze({
   array_to_sentence_string: array_to_sentence_string
 });
 
+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 crypto.createHash('sha256').update(str, 'utf8').digest('hex');
+}
+function hmacSha256(str, key) {
+    return crypto.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 = {
     ...htmlFilters,
     ...mathFilters,
@@ -3725,6 +4123,8 @@ const filters = {
     ...arrayFilters,
     ...dateFilters,
     ...stringFilters,
+    ...base64Filters,
+    ...cryptoFilters,
     ...misc
 };
 
@@ -3782,8 +4182,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))
@@ -3796,7 +4196,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;
@@ -3922,12 +4322,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;
@@ -3988,7 +4388,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();
@@ -4006,42 +4410,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]);
                 }
@@ -4049,8 +4453,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]);
                 }
@@ -4058,7 +4462,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() {
@@ -4067,14 +4471,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;
             }
@@ -4122,8 +4526,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') {
@@ -4141,28 +4545,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'];
@@ -4170,16 +4574,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;
@@ -4209,6 +4613,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) {
@@ -4217,28 +4622,32 @@ 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) {
         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 && !candidate.filters[candidate.filters.length - 1]?.raw) {
+            val = yield outputEscape.call({ context: ctx, token: this.token, liquid: this.liquid }, val);
+        }
+        return val;
     }
     *arguments() {
         yield* this.candidates;
@@ -4278,7 +4687,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;
@@ -4322,7 +4731,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);
     }
@@ -4336,24 +4745,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;
     }
@@ -4392,23 +4801,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() {
@@ -4492,7 +4906,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];
@@ -4565,7 +4979,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;
@@ -4608,7 +5022,11 @@ class EchoTag extends Tag {
     *render(ctx, emitter) {
         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 && !this.value.filters[this.value.filters.length - 1]?.raw) {
+            val = yield outputEscape.call({ context: ctx, token: this.token, liquid: this.liquid }, val);
+        }
         emitter.write(val);
     }
     *arguments() {
@@ -4669,8 +5087,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);
@@ -4682,7 +5100,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);
     }
     async render(tpl, scope, renderOptions) {
@@ -4692,7 +5110,7 @@ class Liquid {
         return toValueSync(this._render(tpl, scope, { ...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) {
@@ -4706,10 +5124,10 @@ class Liquid {
         return toValueSync(this._parseAndRender(html, scope, { ...renderOptions, sync: true }));
     }
     _parsePartialFile(file, sync, currentFile) {
-        return new Parser(this).parseFile(file, sync, LookupType.Partials, currentFile);
+        return new Parser(this).parseFile(file, sync, exports.LookupType.Partials, currentFile);
     }
     _parseLayoutFile(file, sync, currentFile) {
-        return new Parser(this).parseFile(file, sync, LookupType.Layouts, currentFile);
+        return new Parser(this).parseFile(file, sync, exports.LookupType.Layouts, currentFile);
     }
     _parseFile(file, sync, lookupType, currentFile) {
         return new Parser(this).parseFile(file, sync, lookupType, currentFile);
@@ -4736,7 +5154,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);
     }
     async evalValue(str, scope) {
@@ -4748,6 +5166,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);
     }
@@ -4843,7 +5264,7 @@ class Liquid {
 }
 
 /* istanbul ignore file */
-const version = '10.20.1';
+const version = '10.30.1';
 
 exports.AssertionError = AssertionError;
 exports.AssignTag = AssignTag;
@@ -4896,6 +5317,7 @@ exports.defaultOperators = defaultOperators;
 exports.defaultOptions = defaultOptions;
 exports.evalQuotedToken = evalQuotedToken;
 exports.evalToken = evalToken;
+exports.evalTokenValue = evalTokenValue;
 exports.filters = filters;
 exports.isFalsy = isFalsy;
 exports.isTruthy = isTruthy;