@skeptools/skep-organization-project 0.0.0

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

@@ -0,0 +1,3540 @@
+/*
+ * liquidjs@9.43.0, https://github.com/harttle/liquidjs
+ * (c) 2016-2022 harttle
+ * Released under the MIT License.
+ */
+import { extname, resolve as resolve$1, dirname as dirname$1, sep } from 'path';
+import { statSync, readFileSync as readFileSync$1, readFile as readFile$1, stat } from 'fs';
+import { createRequire } from 'module';
+import { PassThrough } from 'stream';
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+class Drop {
+    liquidMethodMissing(key) {
+        return undefined;
+    }
+}
+
+const toString$1 = Object.prototype.toString;
+const toLowerCase = String.prototype.toLowerCase;
+const hasOwnProperty = Object.hasOwnProperty;
+function isString(value) {
+    return typeof value === 'string';
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isFunction(value) {
+    return typeof value === 'function';
+}
+function isPromise(val) {
+    return val && isFunction(val.then);
+}
+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) => {
+            fn(...args, (err, result) => {
+                err ? reject(err) : resolve(result);
+            });
+        });
+    };
+}
+function stringify(value) {
+    value = toValue(value);
+    if (isString(value))
+        return value;
+    if (isNil(value))
+        return '';
+    if (isArray(value))
+        return value.map(x => stringify(x)).join('');
+    return String(value);
+}
+function toValue(value) {
+    return (value instanceof Drop && isFunction(value.valueOf)) ? value.valueOf() : value;
+}
+function isNumber(value) {
+    return typeof value === 'number';
+}
+function toLiquid(value) {
+    if (value && isFunction(value.toLiquid))
+        return toLiquid(value.toLiquid());
+    return value;
+}
+function isNil(value) {
+    return value == null;
+}
+function isArray(value) {
+    // be compatible with IE 8
+    return toString$1.call(value) === '[object Array]';
+}
+function isIterable(value) {
+    return isObject(value) && Symbol.iterator in value;
+}
+/*
+ * Iterates over own enumerable string keyed properties of an object and invokes iteratee for each property.
+ * The iteratee is invoked with three arguments: (value, key, object).
+ * Iteratee functions may exit iteration early by explicitly returning false.
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @return {Object} Returns object.
+ */
+function forOwn(obj, iteratee) {
+    obj = obj || {};
+    for (const k in obj) {
+        if (hasOwnProperty.call(obj, k)) {
+            if (iteratee(obj[k], k, obj) === false)
+                break;
+        }
+    }
+    return obj;
+}
+function last$1(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(''))
+ * @param {any} value The value to check.
+ * @return {Boolean} Returns true if value is an object, else false.
+ */
+function isObject(value) {
+    const type = typeof value;
+    return value !== null && (type === 'object' || type === 'function');
+}
+function range(start, stop, step = 1) {
+    const arr = [];
+    for (let i = start; i < stop; i += step) {
+        arr.push(i);
+    }
+    return arr;
+}
+function padStart(str, length, ch = ' ') {
+    return pad(str, length, ch, (str, ch) => ch + str);
+}
+function padEnd(str, length, ch = ' ') {
+    return pad(str, length, ch, (str, ch) => str + ch);
+}
+function pad(str, length, ch, add) {
+    str = String(str);
+    let n = length - str.length;
+    while (n-- > 0)
+        str = add(str, ch);
+    return str;
+}
+function identify(val) {
+    return val;
+}
+function snakeCase(str) {
+    return str.replace(/(\w?)([A-Z])/g, (_, a, b) => (a ? a + '_' : '') + b.toLowerCase());
+}
+function changeCase(str) {
+    const hasLowerCase = [...str].some(ch => ch >= 'a' && ch <= 'z');
+    return hasLowerCase ? str.toUpperCase() : str.toLowerCase();
+}
+function ellipsis(str, N) {
+    return str.length > N ? str.slice(0, N - 3) + '...' : str;
+}
+// compare string in case-insensitive way, undefined values to the tail
+function caseInsensitiveCompare(a, b) {
+    if (a == null && b == null)
+        return 0;
+    if (a == null)
+        return 1;
+    if (b == null)
+        return -1;
+    a = toLowerCase.call(a);
+    b = toLowerCase.call(b);
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function argumentsToValue(fn) {
+    return (...args) => fn(...args.map(toValue));
+}
+function escapeRegExp(text) {
+    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+}
+
+class Node {
+    constructor(key, value, next, prev) {
+        this.key = key;
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+class LRU {
+    constructor(limit, size = 0) {
+        this.limit = limit;
+        this.size = size;
+        this.cache = {};
+        this.head = new Node('HEAD', null, null, null);
+        this.tail = new Node('TAIL', null, null, null);
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+    write(key, value) {
+        if (this.cache[key]) {
+            this.cache[key].value = value;
+        }
+        else {
+            const node = new Node(key, value, this.head.next, this.head);
+            this.head.next.prev = node;
+            this.head.next = node;
+            this.cache[key] = node;
+            this.size++;
+            this.ensureLimit();
+        }
+    }
+    read(key) {
+        if (!this.cache[key])
+            return;
+        const { value } = this.cache[key];
+        this.remove(key);
+        this.write(key, value);
+        return value;
+    }
+    remove(key) {
+        const node = this.cache[key];
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+        delete this.cache[key];
+        this.size--;
+    }
+    clear() {
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+        this.size = 0;
+        this.cache = {};
+    }
+    ensureLimit() {
+        if (this.size > this.limit)
+            this.remove(this.tail.prev.key);
+    }
+}
+
+function requireResolve (file) {
+  /**
+   * createRequire() can throw,
+   * when import.meta.url not begin with "file://".
+   */
+  const require = createRequire(import.meta.url);
+  return require.resolve(file)
+}
+
+const statAsync = promisify(stat);
+const readFileAsync = promisify(readFile$1);
+function exists(filepath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield statAsync(filepath);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    });
+}
+function readFile(filepath) {
+    return readFileAsync(filepath, 'utf8');
+}
+function existsSync(filepath) {
+    try {
+        statSync(filepath);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+function readFileSync(filepath) {
+    return readFileSync$1(filepath, 'utf8');
+}
+function resolve(root, file, ext) {
+    if (!extname(file))
+        file += ext;
+    return resolve$1(root, file);
+}
+function fallback(file) {
+    try {
+        return requireResolve(file);
+    }
+    catch (e) { }
+}
+function dirname(filepath) {
+    return dirname$1(filepath);
+}
+function contains(root, file) {
+    root = resolve$1(root);
+    root = root.endsWith(sep) ? root : root + sep;
+    return file.startsWith(root);
+}
+
+var fs = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    exists: exists,
+    readFile: readFile,
+    existsSync: existsSync,
+    readFileSync: readFileSync,
+    resolve: resolve,
+    fallback: fallback,
+    dirname: dirname,
+    contains: contains,
+    sep: sep
+});
+
+function isComparable(arg) {
+    return arg && isFunction(arg.equals);
+}
+
+function isTruthy(val, ctx) {
+    return !isFalsy(val, ctx);
+}
+function isFalsy(val, ctx) {
+    if (ctx.opts.jsTruthy) {
+        return !val;
+    }
+    else {
+        return val === false || undefined === val || val === null;
+    }
+}
+
+const defaultOperators = {
+    '==': (l, r) => {
+        if (isComparable(l))
+            return l.equals(r);
+        if (isComparable(r))
+            return r.equals(l);
+        return toValue(l) === toValue(r);
+    },
+    '!=': (l, r) => {
+        if (isComparable(l))
+            return !l.equals(r);
+        if (isComparable(r))
+            return !r.equals(l);
+        return toValue(l) !== toValue(r);
+    },
+    '>': (l, r) => {
+        if (isComparable(l))
+            return l.gt(r);
+        if (isComparable(r))
+            return r.lt(l);
+        return toValue(l) > toValue(r);
+    },
+    '<': (l, r) => {
+        if (isComparable(l))
+            return l.lt(r);
+        if (isComparable(r))
+            return r.gt(l);
+        return toValue(l) < toValue(r);
+    },
+    '>=': (l, r) => {
+        if (isComparable(l))
+            return l.geq(r);
+        if (isComparable(r))
+            return r.leq(l);
+        return toValue(l) >= toValue(r);
+    },
+    '<=': (l, r) => {
+        if (isComparable(l))
+            return l.leq(r);
+        if (isComparable(r))
+            return r.geq(l);
+        return toValue(l) <= toValue(r);
+    },
+    'contains': (l, r) => {
+        l = toValue(l);
+        r = toValue(r);
+        return l && isFunction(l.indexOf) ? l.indexOf(r) > -1 : false;
+    },
+    'and': (l, r, ctx) => isTruthy(toValue(l), ctx) && isTruthy(toValue(r), ctx),
+    'or': (l, r, ctx) => isTruthy(toValue(l), ctx) || isTruthy(toValue(r), ctx)
+};
+
+// **DO NOT CHANGE THIS FILE**
+//
+// This file is generated by bin/character-gen.js
+// bitmask character types to boost performance
+const TYPES = [0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 4, 4, 4, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 8, 0, 0, 0, 0, 8, 0, 0, 0, 64, 0, 65, 0, 0, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 0, 0, 2, 2, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
+const IDENTIFIER = 1;
+const BLANK = 4;
+const QUOTE = 8;
+const INLINE_BLANK = 16;
+const NUMBER = 32;
+const SIGN = 64;
+TYPES[160] = TYPES[5760] = TYPES[6158] = TYPES[8192] = TYPES[8193] = TYPES[8194] = TYPES[8195] = TYPES[8196] = TYPES[8197] = TYPES[8198] = TYPES[8199] = TYPES[8200] = TYPES[8201] = TYPES[8202] = TYPES[8232] = TYPES[8233] = TYPES[8239] = TYPES[8287] = TYPES[12288] = BLANK;
+
+function createTrie(operators) {
+    const trie = {};
+    for (const [name, handler] of Object.entries(operators)) {
+        let node = trie;
+        for (let i = 0; i < name.length; i++) {
+            const c = name[i];
+            node[c] = node[c] || {};
+            if (i === name.length - 1 && (TYPES[name.charCodeAt(i)] & IDENTIFIER)) {
+                node[c].needBoundary = true;
+            }
+            node = node[c];
+        }
+        node.handler = handler;
+        node.end = true;
+    }
+    return trie;
+}
+
+const escapeMap = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&#34;',
+    "'": '&#39;'
+};
+const unescapeMap = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&#34;': '"',
+    '&#39;': "'"
+};
+function escape(str) {
+    return stringify(str).replace(/&|<|>|"|'/g, m => escapeMap[m]);
+}
+function unescape(str) {
+    return stringify(str).replace(/&(amp|lt|gt|#34|#39);/g, m => unescapeMap[m]);
+}
+function escapeOnce(str) {
+    return escape(unescape(stringify(str)));
+}
+function newlineToBr(v) {
+    return stringify(v).replace(/\n/g, '<br />\n');
+}
+function stripHtml(v) {
+    return stringify(v).replace(/<script.*?<\/script>|<!--.*?-->|<style.*?<\/style>|<.*?>/g, '');
+}
+
+const abs = argumentsToValue(Math.abs);
+const atLeast = argumentsToValue(Math.max);
+const atMost = argumentsToValue(Math.min);
+const ceil = argumentsToValue(Math.ceil);
+const dividedBy = 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;
+}
+function plus(v, arg) {
+    v = toValue(v);
+    arg = toValue(arg);
+    return Number(v) + Number(arg);
+}
+
+const urlDecode = (x) => stringify(x).split('+').map(decodeURIComponent).join(' ');
+const urlEncode = (x) => stringify(x).split(' ').map(encodeURIComponent).join('+');
+
+function toEnumerable(val) {
+    val = toValue(val);
+    if (isArray(val))
+        return val;
+    if (isString(val) && val.length > 0)
+        return [val];
+    if (isIterable(val))
+        return Array.from(val);
+    if (isObject(val))
+        return Object.keys(val).map((key) => [key, val[key]]);
+    return [];
+}
+function toArray(val) {
+    if (isNil(val))
+        return [];
+    if (isArray(val))
+        return val;
+    return [val];
+}
+
+const join = argumentsToValue((v, arg) => toArray(v).join(arg === undefined ? ' ' : arg));
+const last = argumentsToValue((v) => isArray(v) ? last$1(v) : '');
+const first = argumentsToValue((v) => isArray(v) ? v[0] : '');
+const reverse = argumentsToValue((v) => [...toArray(v)].reverse());
+function* sort(arr, property) {
+    const values = [];
+    for (const item of toArray(toValue(arr))) {
+        values.push([
+            item,
+            property ? yield this.context._getFromScope(item, stringify(property).split('.')) : 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 sortNatural(input, property) {
+    input = toValue(input);
+    const propertyString = stringify(property);
+    const compare = property === undefined
+        ? caseInsensitiveCompare
+        : (lhs, rhs) => caseInsensitiveCompare(lhs[propertyString], rhs[propertyString]);
+    return [...toArray(input)].sort(compare);
+}
+const size = (v) => (v && v.length) || 0;
+function* map(arr, property) {
+    const results = [];
+    for (const item of toArray(toValue(arr))) {
+        results.push(yield this.context._getFromScope(item, stringify(property).split('.')));
+    }
+    return results;
+}
+function compact(arr) {
+    arr = toValue(arr);
+    return toArray(arr).filter(x => !isNil(toValue(x)));
+}
+function concat(v, arg = []) {
+    v = toValue(v);
+    arg = toArray(arg).map(v => toValue(v));
+    return toArray(v).concat(arg);
+}
+function slice(v, begin, length = 1) {
+    v = toValue(v);
+    if (isNil(v))
+        return [];
+    if (!isArray(v))
+        v = stringify(v);
+    begin = begin < 0 ? v.length + begin : begin;
+    return v.slice(begin, begin + length);
+}
+function* where(arr, property, expected) {
+    const values = [];
+    arr = toArray(toValue(arr));
+    for (const item of arr) {
+        values.push(yield this.context._getFromScope(item, stringify(property).split('.')));
+    }
+    return arr.filter((_, i) => {
+        if (expected === undefined)
+            return isTruthy(values[i], this.context);
+        if (isComparable(expected))
+            return expected.equals(values[i]);
+        return values[i] === expected;
+    });
+}
+function uniq(arr) {
+    arr = toValue(arr);
+    const u = {};
+    return (arr || []).filter(val => {
+        if (hasOwnProperty.call(u, String(val)))
+            return false;
+        u[String(val)] = true;
+        return true;
+    });
+}
+
+const rFormat = /%([-_0^#:]+)?(\d+)?([EO])?(.)/;
+const monthNames = [
+    'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
+    'September', 'October', 'November', 'December'
+];
+const dayNames = [
+    'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'
+];
+const monthNamesShort = monthNames.map(abbr);
+const dayNamesShort = dayNames.map(abbr);
+const suffixes = {
+    1: 'st',
+    2: 'nd',
+    3: 'rd',
+    'default': 'th'
+};
+function abbr(str) {
+    return str.slice(0, 3);
+}
+// prototype extensions
+function daysInMonth(d) {
+    const feb = isLeapYear(d) ? 29 : 28;
+    return [31, feb, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+}
+function getDayOfYear(d) {
+    let num = 0;
+    for (let i = 0; i < d.getMonth(); ++i) {
+        num += daysInMonth(d)[i];
+    }
+    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);
+}
+function isLeapYear(d) {
+    const year = d.getFullYear();
+    return !!((year & 3) === 0 && (year % 100 || (year % 400 === 0 && year)));
+}
+function getSuffix(d) {
+    const str = d.getDate().toString();
+    const index = parseInt(str.slice(-1));
+    return suffixes[index] || suffixes['default'];
+}
+function century(d) {
+    return parseInt(d.getFullYear().toString().substring(0, 2), 10);
+}
+// default to 0
+const padWidths = {
+    d: 2,
+    e: 2,
+    H: 2,
+    I: 2,
+    j: 3,
+    k: 2,
+    l: 2,
+    L: 3,
+    m: 2,
+    M: 2,
+    S: 2,
+    U: 2,
+    W: 2
+};
+// default to '0'
+const padChars = {
+    a: ' ',
+    A: ' ',
+    b: ' ',
+    B: ' ',
+    c: ' ',
+    e: ' ',
+    k: ' ',
+    l: ' ',
+    p: ' ',
+    P: ' '
+};
+const formatCodes = {
+    a: (d) => dayNamesShort[d.getDay()],
+    A: (d) => dayNames[d.getDay()],
+    b: (d) => monthNamesShort[d.getMonth()],
+    B: (d) => monthNames[d.getMonth()],
+    c: (d) => d.toLocaleString(),
+    C: (d) => century(d),
+    d: (d) => d.getDate(),
+    e: (d) => d.getDate(),
+    H: (d) => d.getHours(),
+    I: (d) => String(d.getHours() % 12 || 12),
+    j: (d) => getDayOfYear(d),
+    k: (d) => d.getHours(),
+    l: (d) => String(d.getHours() % 12 || 12),
+    L: (d) => d.getMilliseconds(),
+    m: (d) => d.getMonth() + 1,
+    M: (d) => d.getMinutes(),
+    N: (d, opts) => {
+        const width = Number(opts.width) || 9;
+        const str = String(d.getMilliseconds()).slice(0, width);
+        return padEnd(str, width, '0');
+    },
+    p: (d) => (d.getHours() < 12 ? 'AM' : 'PM'),
+    P: (d) => (d.getHours() < 12 ? 'am' : 'pm'),
+    q: (d) => getSuffix(d),
+    s: (d) => Math.round(d.getTime() / 1000),
+    S: (d) => d.getSeconds(),
+    u: (d) => d.getDay() || 7,
+    U: (d) => getWeekOfYear(d, 0),
+    w: (d) => d.getDay(),
+    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(),
+    z: (d, opts) => {
+        const nOffset = Math.abs(d.getTimezoneOffset());
+        const h = Math.floor(nOffset / 60);
+        const m = nOffset % 60;
+        return (d.getTimezoneOffset() > 0 ? '-' : '+') +
+            padStart(h, 2, '0') +
+            (opts.flags[':'] ? ':' : '') +
+            padStart(m, 2, '0');
+    },
+    't': () => '\t',
+    'n': () => '\n',
+    '%': () => '%'
+};
+formatCodes.h = formatCodes.b;
+function strftime (d, formatStr) {
+    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);
+    }
+    return output + remaining;
+}
+function format(d, match) {
+    const [input, flagStr = '', width, modifier, conversion] = match;
+    const convert = formatCodes[conversion];
+    if (!convert)
+        return input;
+    const flags = {};
+    for (const flag of flagStr)
+        flags[flag] = true;
+    let ret = String(convert(d, { flags, width, modifier }));
+    let padChar = padChars[conversion] || '0';
+    let padWidth = width || padWidths[conversion] || 0;
+    if (flags['^'])
+        ret = ret.toUpperCase();
+    else if (flags['#'])
+        ret = changeCase(ret);
+    if (flags['_'])
+        padChar = ' ';
+    else if (flags['0'])
+        padChar = '0';
+    if (flags['-'])
+        padWidth = 0;
+    return padStart(ret, padWidth, padChar);
+}
+
+// one minute in milliseconds
+const OneMinute = 60000;
+const hostTimezoneOffset = new Date().getTimezoneOffset();
+const ISO8601_TIMEZONE_PATTERN = /([zZ]|([+-])(\d{2}):(\d{2}))$/;
+/**
+ * A date implementation with timezone info, just like Ruby date
+ *
+ * Implementation:
+ * - create a Date offset by it's timezone difference, avoiding overriding a bunch of methods
+ * - rewrite getTimezoneOffset() to trick strftime
+ */
+class TimezoneDate {
+    constructor(init, timezoneOffset) {
+        if (init instanceof TimezoneDate) {
+            this.date = init.date;
+            timezoneOffset = init.timezoneOffset;
+        }
+        else {
+            const diff = (hostTimezoneOffset - timezoneOffset) * OneMinute;
+            const time = new Date(init).getTime() + diff;
+            this.date = new Date(time);
+        }
+        this.timezoneOffset = timezoneOffset;
+    }
+    getTime() {
+        return this.date.getTime();
+    }
+    getMilliseconds() {
+        return this.date.getMilliseconds();
+    }
+    getSeconds() {
+        return this.date.getSeconds();
+    }
+    getMinutes() {
+        return this.date.getMinutes();
+    }
+    getHours() {
+        return this.date.getHours();
+    }
+    getDay() {
+        return this.date.getDay();
+    }
+    getDate() {
+        return this.date.getDate();
+    }
+    getMonth() {
+        return this.date.getMonth();
+    }
+    getFullYear() {
+        return this.date.getFullYear();
+    }
+    toLocaleTimeString(locale) {
+        return this.date.toLocaleTimeString(locale);
+    }
+    toLocaleDateString(locale) {
+        return this.date.toLocaleDateString(locale);
+    }
+    getTimezoneOffset() {
+        return this.timezoneOffset;
+    }
+    /**
+     * Create a Date object fixed to it's declared Timezone. Both
+     * - 2021-08-06T02:29:00.000Z and
+     * - 2021-08-06T02:29:00.000+08:00
+     * will always be displayed as
+     * - 2021-08-06 02:29:00
+     * regardless timezoneOffset in JavaScript realm
+     *
+     * The implementation hack:
+     * Instead of calling `.getMonth()`/`.getUTCMonth()` respect to `preserveTimezones`,
+     * we create a different Date to trick strftime, it's both simpler and more performant.
+     * Given that a template is expected to be parsed fewer times than rendered.
+     */
+    static createDateFixedToTimezone(dateString) {
+        const m = dateString.match(ISO8601_TIMEZONE_PATTERN);
+        // representing a UTC timestamp
+        if (m && m[1] === 'Z') {
+            return new TimezoneDate(+new Date(dateString), 0);
+        }
+        // has a timezone specified
+        if (m && m[2] && m[3] && m[4]) {
+            const [, , sign, hours, minutes] = m;
+            const delta = (sign === '+' ? -1 : 1) * (parseInt(hours, 10) * 60 + parseInt(minutes, 10));
+            return new TimezoneDate(+new Date(dateString), delta);
+        }
+        return new Date(dateString);
+    }
+}
+
+function date(v, format, timeZoneOffset) {
+    const opts = this.context.opts;
+    let date;
+    v = toValue(v);
+    format = stringify(format);
+    if (v === 'now' || v === 'today') {
+        date = new Date();
+    }
+    else if (isNumber(v)) {
+        date = new Date(v * 1000);
+    }
+    else if (isString(v)) {
+        if (/^\d+$/.test(v)) {
+            date = new Date(+v * 1000);
+        }
+        else if (opts.preserveTimezones) {
+            date = TimezoneDate.createDateFixedToTimezone(v);
+        }
+        else {
+            date = new Date(v);
+        }
+    }
+    else {
+        date = v;
+    }
+    if (!isValidDate(date))
+        return v;
+    if (timeZoneOffset !== undefined) {
+        date = new TimezoneDate(date, timeZoneOffset);
+    }
+    else if (opts.timezoneOffset !== undefined) {
+        date = new TimezoneDate(date, opts.timezoneOffset);
+    }
+    return strftime(date, format);
+}
+function isValidDate(date) {
+    return (date instanceof Date || date instanceof TimezoneDate) && !isNaN(date.getTime());
+}
+
+function Default(value, defaultValue, ...args) {
+    value = toValue(value);
+    if (isArray(value) || isString(value))
+        return value.length ? value : defaultValue;
+    if (value === false && (new Map(args)).get('allow_false'))
+        return false;
+    return isFalsy(value, this.context) ? defaultValue : value;
+}
+function json(value) {
+    return JSON.stringify(value);
+}
+const raw$1 = identify;
+
+class LiquidError extends Error {
+    constructor(err, token) {
+        super(err.message);
+        this.originalError = err;
+        this.token = token;
+        this.context = '';
+    }
+    update() {
+        const err = this.originalError;
+        this.context = mkContext(this.token);
+        this.message = mkMessage(err.message, this.token);
+        this.stack = this.message + '\n' + this.context +
+            '\n' + this.stack + '\nFrom ' + err.stack;
+    }
+}
+class TokenizationError extends LiquidError {
+    constructor(message, token) {
+        super(new Error(message), token);
+        this.name = 'TokenizationError';
+        super.update();
+    }
+}
+class ParseError extends LiquidError {
+    constructor(err, token) {
+        super(err, token);
+        this.name = 'ParseError';
+        this.message = err.message;
+        super.update();
+    }
+}
+class RenderError extends LiquidError {
+    constructor(err, tpl) {
+        super(err, tpl.token);
+        this.name = 'RenderError';
+        this.message = err.message;
+        super.update();
+    }
+    static is(obj) {
+        return obj.name === 'RenderError';
+    }
+}
+class UndefinedVariableError extends LiquidError {
+    constructor(err, token) {
+        super(err, token);
+        this.name = 'UndefinedVariableError';
+        this.message = err.message;
+        super.update();
+    }
+}
+// only used internally; raised where we don't have token information,
+// so it can't be an UndefinedVariableError.
+class InternalUndefinedVariableError extends Error {
+    constructor(variableName) {
+        super(`undefined variable: ${variableName}`);
+        this.name = 'InternalUndefinedVariableError';
+        this.variableName = variableName;
+    }
+}
+class AssertionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AssertionError';
+        this.message = message + '';
+    }
+}
+function mkContext(token) {
+    const [line] = token.getPosition();
+    const lines = token.input.split('\n');
+    const begin = Math.max(line - 2, 1);
+    const end = Math.min(line + 3, lines.length);
+    const context = range(begin, end + 1)
+        .map(lineNumber => {
+        const indicator = (lineNumber === line) ? '>> ' : '   ';
+        const num = padStart(String(lineNumber), String(end).length);
+        const text = lines[lineNumber - 1];
+        return `${indicator}${num}| ${text}`;
+    })
+        .join('\n');
+    return context;
+}
+function mkMessage(msg, token) {
+    if (token.file)
+        msg += `, file:${token.file}`;
+    const [line, col] = token.getPosition();
+    msg += `, line:${line}, col:${col}`;
+    return msg;
+}
+
+function assert(predicate, message) {
+    if (!predicate) {
+        const msg = typeof message === 'function'
+            ? message()
+            : (message || `expect ${predicate} to be true`);
+        throw new AssertionError(msg);
+    }
+}
+
+/**
+ * String related filters
+ *
+ * * prefer stringify() to String() since `undefined`, `null` should eval ''
+ */
+function append(v, arg) {
+    assert(arguments.length === 2, 'append expect 2 arguments');
+    return stringify(v) + stringify(arg);
+}
+function prepend(v, arg) {
+    assert(arguments.length === 2, 'prepend expect 2 arguments');
+    return stringify(arg) + stringify(v);
+}
+function lstrip(v, chars) {
+    if (chars) {
+        chars = escapeRegExp(stringify(chars));
+        return stringify(v).replace(new RegExp(`^[${chars}]+`, 'g'), '');
+    }
+    return stringify(v).replace(/^\s+/, '');
+}
+function downcase(v) {
+    return stringify(v).toLowerCase();
+}
+function upcase(str) {
+    return stringify(str).toUpperCase();
+}
+function remove(v, arg) {
+    return stringify(v).split(String(arg)).join('');
+}
+function removeFirst(v, l) {
+    return stringify(v).replace(String(l), '');
+}
+function rstrip(str, chars) {
+    if (chars) {
+        chars = escapeRegExp(stringify(chars));
+        return stringify(str).replace(new RegExp(`[${chars}]+$`, 'g'), '');
+    }
+    return stringify(str).replace(/\s+$/, '');
+}
+function split(v, arg) {
+    const arr = stringify(v).split(String(arg));
+    // align to ruby split, which is the behavior of shopify/liquid
+    // see: https://ruby-doc.org/core-2.4.0/String.html#method-i-split
+    while (arr.length && arr[arr.length - 1] === '')
+        arr.pop();
+    return arr;
+}
+function strip(v, chars) {
+    if (chars) {
+        chars = escapeRegExp(stringify(chars));
+        return stringify(v)
+            .replace(new RegExp(`^[${chars}]+`, 'g'), '')
+            .replace(new RegExp(`[${chars}]+$`, 'g'), '');
+    }
+    return stringify(v).trim();
+}
+function stripNewlines(v) {
+    return stringify(v).replace(/\n/g, '');
+}
+function capitalize(str) {
+    str = stringify(str);
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function replace(v, pattern, replacement) {
+    return stringify(v).split(String(pattern)).join(replacement);
+}
+function replaceFirst(v, arg1, arg2) {
+    return stringify(v).replace(String(arg1), arg2);
+}
+function truncate(v, l = 50, o = '...') {
+    v = stringify(v);
+    if (v.length <= l)
+        return v;
+    return v.substring(0, l - o.length) + o;
+}
+function truncatewords(v, words = 15, o = '...') {
+    const arr = stringify(v).split(/\s+/);
+    if (words <= 0)
+        words = 1;
+    let ret = arr.slice(0, words).join(' ');
+    if (arr.length >= words)
+        ret += o;
+    return ret;
+}
+
+var builtinFilters = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    escape: escape,
+    escapeOnce: escapeOnce,
+    newlineToBr: newlineToBr,
+    stripHtml: stripHtml,
+    abs: abs,
+    atLeast: atLeast,
+    atMost: atMost,
+    ceil: ceil,
+    dividedBy: dividedBy,
+    floor: floor,
+    minus: minus,
+    modulo: modulo,
+    times: times,
+    round: round,
+    plus: plus,
+    urlDecode: urlDecode,
+    urlEncode: urlEncode,
+    join: join,
+    last: last,
+    first: first,
+    reverse: reverse,
+    sort: sort,
+    sortNatural: sortNatural,
+    size: size,
+    map: map,
+    compact: compact,
+    concat: concat,
+    slice: slice,
+    where: where,
+    uniq: uniq,
+    date: date,
+    Default: Default,
+    json: json,
+    raw: raw$1,
+    append: append,
+    prepend: prepend,
+    lstrip: lstrip,
+    downcase: downcase,
+    upcase: upcase,
+    remove: remove,
+    removeFirst: removeFirst,
+    rstrip: rstrip,
+    split: split,
+    strip: strip,
+    stripNewlines: stripNewlines,
+    capitalize: capitalize,
+    replace: replace,
+    replaceFirst: replaceFirst,
+    truncate: truncate,
+    truncatewords: truncatewords
+});
+
+var TokenKind;
+(function (TokenKind) {
+    TokenKind[TokenKind["Number"] = 1] = "Number";
+    TokenKind[TokenKind["Literal"] = 2] = "Literal";
+    TokenKind[TokenKind["Tag"] = 4] = "Tag";
+    TokenKind[TokenKind["Output"] = 8] = "Output";
+    TokenKind[TokenKind["HTML"] = 16] = "HTML";
+    TokenKind[TokenKind["Filter"] = 32] = "Filter";
+    TokenKind[TokenKind["Hash"] = 64] = "Hash";
+    TokenKind[TokenKind["PropertyAccess"] = 128] = "PropertyAccess";
+    TokenKind[TokenKind["Word"] = 256] = "Word";
+    TokenKind[TokenKind["Range"] = 512] = "Range";
+    TokenKind[TokenKind["Quoted"] = 1024] = "Quoted";
+    TokenKind[TokenKind["Operator"] = 2048] = "Operator";
+    TokenKind[TokenKind["Delimited"] = 12] = "Delimited";
+})(TokenKind || (TokenKind = {}));
+
+function isDelimitedToken(val) {
+    return !!(getKind(val) & TokenKind.Delimited);
+}
+function isOperatorToken(val) {
+    return getKind(val) === TokenKind.Operator;
+}
+function isHTMLToken(val) {
+    return getKind(val) === TokenKind.HTML;
+}
+function isOutputToken(val) {
+    return getKind(val) === TokenKind.Output;
+}
+function isTagToken(val) {
+    return getKind(val) === TokenKind.Tag;
+}
+function isQuotedToken(val) {
+    return getKind(val) === TokenKind.Quoted;
+}
+function isLiteralToken(val) {
+    return getKind(val) === TokenKind.Literal;
+}
+function isNumberToken(val) {
+    return getKind(val) === TokenKind.Number;
+}
+function isPropertyAccessToken(val) {
+    return getKind(val) === TokenKind.PropertyAccess;
+}
+function isWordToken(val) {
+    return getKind(val) === TokenKind.Word;
+}
+function isRangeToken(val) {
+    return getKind(val) === TokenKind.Range;
+}
+function getKind(val) {
+    return val ? val.kind : -1;
+}
+
+var typeGuards = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isDelimitedToken: isDelimitedToken,
+    isOperatorToken: isOperatorToken,
+    isHTMLToken: isHTMLToken,
+    isOutputToken: isOutputToken,
+    isTagToken: isTagToken,
+    isQuotedToken: isQuotedToken,
+    isLiteralToken: isLiteralToken,
+    isNumberToken: isNumberToken,
+    isPropertyAccessToken: isPropertyAccessToken,
+    isWordToken: isWordToken,
+    isRangeToken: isRangeToken
+});
+
+class NullDrop extends Drop {
+    equals(value) {
+        return isNil(toValue(value));
+    }
+    gt() {
+        return false;
+    }
+    geq() {
+        return false;
+    }
+    lt() {
+        return false;
+    }
+    leq() {
+        return false;
+    }
+    valueOf() {
+        return null;
+    }
+}
+
+class EmptyDrop extends Drop {
+    equals(value) {
+        if (value instanceof EmptyDrop)
+            return false;
+        value = toValue(value);
+        if (isString(value) || isArray(value))
+            return value.length === 0;
+        if (isObject(value))
+            return Object.keys(value).length === 0;
+        return false;
+    }
+    gt() {
+        return false;
+    }
+    geq() {
+        return false;
+    }
+    lt() {
+        return false;
+    }
+    leq() {
+        return false;
+    }
+    valueOf() {
+        return '';
+    }
+}
+
+class BlankDrop extends EmptyDrop {
+    equals(value) {
+        if (value === false)
+            return true;
+        if (isNil(toValue(value)))
+            return true;
+        if (isString(value))
+            return /^\s*$/.test(value);
+        return super.equals(value);
+    }
+}
+
+const nil = new NullDrop();
+const literalValues = {
+    'true': true,
+    'false': false,
+    'nil': nil,
+    'null': nil,
+    'empty': new EmptyDrop(),
+    'blank': new BlankDrop()
+};
+
+const rHex = /[\da-fA-F]/;
+const rOct = /[0-7]/;
+const escapeChar = {
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    v: '\x0B'
+};
+function hexVal(c) {
+    const code = c.charCodeAt(0);
+    if (code >= 97)
+        return code - 87;
+    if (code >= 65)
+        return code - 55;
+    return code - 48;
+}
+function parseStringLiteral(str) {
+    let ret = '';
+    for (let i = 1; i < str.length - 1; i++) {
+        if (str[i] !== '\\') {
+            ret += str[i];
+            continue;
+        }
+        if (escapeChar[str[i + 1]] !== undefined) {
+            ret += escapeChar[str[++i]];
+        }
+        else if (str[i + 1] === 'u') {
+            let val = 0;
+            let j = i + 2;
+            while (j <= i + 5 && rHex.test(str[j])) {
+                val = val * 16 + hexVal(str[j++]);
+            }
+            i = j - 1;
+            ret += String.fromCharCode(val);
+        }
+        else if (!rOct.test(str[i + 1])) {
+            ret += str[++i];
+        }
+        else {
+            let j = i + 1;
+            let val = 0;
+            while (j <= i + 3 && rOct.test(str[j])) {
+                val = val * 8 + hexVal(str[j++]);
+            }
+            i = j - 1;
+            ret += String.fromCharCode(val);
+        }
+    }
+    return ret;
+}
+
+// convert an async iterator to a Promise
+function toPromise(val) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!isIterator(val))
+            return val;
+        let value;
+        let done = false;
+        let next = 'next';
+        do {
+            const state = val[next](value);
+            done = state.done;
+            value = state.value;
+            next = 'next';
+            try {
+                if (isIterator(value))
+                    value = toPromise(value);
+                if (isPromise(value))
+                    value = yield value;
+            }
+            catch (err) {
+                next = 'throw';
+                value = err;
+            }
+        } while (!done);
+        return value;
+    });
+}
+// convert an async iterator to a value in a synchronous manner
+function toValueSync(val) {
+    if (!isIterator(val))
+        return val;
+    let value;
+    let done = false;
+    let next = 'next';
+    do {
+        const state = val[next](value);
+        done = state.done;
+        value = state.value;
+        next = 'next';
+        if (isIterator(value)) {
+            try {
+                value = toValueSync(value);
+            }
+            catch (err) {
+                next = 'throw';
+                value = err;
+            }
+        }
+    } while (!done);
+    return value;
+}
+const toThenable = toPromise;
+
+class Expression {
+    constructor(tokens) {
+        this.postfix = [...toPostfix(tokens)];
+    }
+    *evaluate(ctx, lenient) {
+        assert(ctx, 'unable to evaluate: context not defined');
+        const operands = [];
+        for (const token of this.postfix) {
+            if (isOperatorToken(token)) {
+                const r = operands.pop();
+                const l = operands.pop();
+                const result = yield evalOperatorToken(ctx.opts.operators, token, l, r, ctx);
+                operands.push(result);
+            }
+            else {
+                operands.push(yield _evalToken(token, ctx, lenient && this.postfix.length === 1));
+            }
+        }
+        return operands[0];
+    }
+}
+/**
+ * @deprecated use `_evalToken` instead
+ */
+function* evalToken(token, ctx, lenient = false) {
+    return toValueSync(_evalToken(token, ctx, lenient));
+}
+function* _evalToken(token, ctx, lenient = false) {
+    if (isPropertyAccessToken(token))
+        return yield evalPropertyAccessToken(token, ctx, lenient);
+    if (isRangeToken(token))
+        return yield evalRangeToken(token, ctx);
+    if (isLiteralToken(token))
+        return evalLiteralToken(token);
+    if (isNumberToken(token))
+        return evalNumberToken(token);
+    if (isWordToken(token))
+        return token.getText();
+    if (isQuotedToken(token))
+        return evalQuotedToken(token);
+}
+function* evalPropertyAccessToken(token, ctx, lenient) {
+    const props = [];
+    for (const prop of token.props) {
+        props.push((yield _evalToken(prop, ctx, false)));
+    }
+    try {
+        return yield ctx._get([token.propertyName, ...props]);
+    }
+    catch (e) {
+        if (lenient && e.name === 'InternalUndefinedVariableError')
+            return null;
+        throw (new UndefinedVariableError(e, token));
+    }
+}
+function evalNumberToken(token) {
+    const str = token.whole.content + '.' + (token.decimal ? token.decimal.content : '');
+    return Number(str);
+}
+function evalQuotedToken(token) {
+    return parseStringLiteral(token.getText());
+}
+function evalOperatorToken(operators, token, lhs, rhs, ctx) {
+    const impl = operators[token.operator];
+    return impl(lhs, rhs, ctx);
+}
+function evalLiteralToken(token) {
+    return literalValues[token.literal];
+}
+function* evalRangeToken(token, ctx) {
+    const low = yield _evalToken(token.lhs, ctx);
+    const high = yield _evalToken(token.rhs, ctx);
+    return range(+low, +high + 1);
+}
+function* toPostfix(tokens) {
+    const ops = [];
+    for (const token of tokens) {
+        if (isOperatorToken(token)) {
+            while (ops.length && ops[ops.length - 1].getPrecedence() > token.getPrecedence()) {
+                yield ops.pop();
+            }
+            ops.push(token);
+        }
+        else
+            yield token;
+    }
+    while (ops.length) {
+        yield ops.pop();
+    }
+}
+
+class Token {
+    constructor(kind, input, begin, end, file) {
+        this.kind = kind;
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.file = file;
+    }
+    getText() {
+        return this.input.slice(this.begin, this.end);
+    }
+    getPosition() {
+        let [row, col] = [1, 1];
+        for (let i = 0; i < this.begin; i++) {
+            if (this.input[i] === '\n') {
+                row++;
+                col = 1;
+            }
+            else
+                col++;
+        }
+        return [row, col];
+    }
+    size() {
+        return this.end - this.begin;
+    }
+}
+
+class DelimitedToken extends Token {
+    constructor(kind, content, input, begin, end, trimLeft, trimRight, file) {
+        super(kind, input, begin, end, file);
+        this.trimLeft = false;
+        this.trimRight = false;
+        this.content = this.getText();
+        const tl = content[0] === '-';
+        const tr = last$1(content) === '-';
+        this.content = content
+            .slice(tl ? 1 : 0, tr ? -1 : content.length)
+            .trim();
+        this.trimLeft = tl || trimLeft;
+        this.trimRight = tr || trimRight;
+    }
+}
+
+function whiteSpaceCtrl(tokens, options) {
+    let inRaw = false;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!isDelimitedToken(token))
+            continue;
+        if (!inRaw && token.trimLeft) {
+            trimLeft(tokens[i - 1], options.greedy);
+        }
+        if (isTagToken(token)) {
+            if (token.name === 'raw')
+                inRaw = true;
+            else if (token.name === 'endraw')
+                inRaw = false;
+        }
+        if (!inRaw && token.trimRight) {
+            trimRight(tokens[i + 1], options.greedy);
+        }
+    }
+}
+function trimLeft(token, greedy) {
+    if (!token || !isHTMLToken(token))
+        return;
+    const mask = greedy ? BLANK : INLINE_BLANK;
+    while (TYPES[token.input.charCodeAt(token.end - 1 - token.trimRight)] & mask)
+        token.trimRight++;
+}
+function trimRight(token, greedy) {
+    if (!token || !isHTMLToken(token))
+        return;
+    const mask = greedy ? BLANK : INLINE_BLANK;
+    while (TYPES[token.input.charCodeAt(token.begin + token.trimLeft)] & mask)
+        token.trimLeft++;
+    if (token.input.charAt(token.begin + token.trimLeft) === '\n')
+        token.trimLeft++;
+}
+
+class NumberToken extends Token {
+    constructor(whole, decimal) {
+        super(TokenKind.Number, whole.input, whole.begin, decimal ? decimal.end : whole.end, whole.file);
+        this.whole = whole;
+        this.decimal = decimal;
+    }
+}
+
+class IdentifierToken extends Token {
+    constructor(input, begin, end, file) {
+        super(TokenKind.Word, input, begin, end, file);
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.file = file;
+        this.content = this.getText();
+    }
+    isNumber(allowSign = false) {
+        const begin = allowSign && TYPES[this.input.charCodeAt(this.begin)] & SIGN
+            ? this.begin + 1
+            : this.begin;
+        for (let i = begin; i < this.end; i++) {
+            if (!(TYPES[this.input.charCodeAt(i)] & NUMBER))
+                return false;
+        }
+        return true;
+    }
+}
+
+class LiteralToken extends Token {
+    constructor(input, begin, end, file) {
+        super(TokenKind.Literal, input, begin, end, file);
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.file = file;
+        this.literal = this.getText();
+    }
+}
+
+const precedence = {
+    '==': 1,
+    '!=': 1,
+    '>': 1,
+    '<': 1,
+    '>=': 1,
+    '<=': 1,
+    'contains': 1,
+    'and': 0,
+    'or': 0
+};
+class OperatorToken extends Token {
+    constructor(input, begin, end, file) {
+        super(TokenKind.Operator, input, begin, end, file);
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.file = file;
+        this.operator = this.getText();
+    }
+    getPrecedence() {
+        const key = this.getText();
+        return key in precedence ? precedence[key] : 1;
+    }
+}
+
+class PropertyAccessToken extends Token {
+    constructor(variable, props, end) {
+        super(TokenKind.PropertyAccess, variable.input, variable.begin, end, variable.file);
+        this.variable = variable;
+        this.props = props;
+        this.propertyName = this.variable instanceof IdentifierToken
+            ? this.variable.getText()
+            : parseStringLiteral(this.variable.getText());
+    }
+}
+
+class FilterToken extends Token {
+    constructor(name, args, input, begin, end, file) {
+        super(TokenKind.Filter, input, begin, end, file);
+        this.name = name;
+        this.args = args;
+    }
+}
+
+class HashToken extends Token {
+    constructor(input, begin, end, name, value, file) {
+        super(TokenKind.Hash, input, begin, end, file);
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.name = name;
+        this.value = value;
+        this.file = file;
+    }
+}
+
+class QuotedToken extends Token {
+    constructor(input, begin, end, file) {
+        super(TokenKind.Quoted, input, begin, end, file);
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.file = file;
+    }
+}
+
+class HTMLToken extends Token {
+    constructor(input, begin, end, file) {
+        super(TokenKind.HTML, input, begin, end, file);
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.file = file;
+        this.trimLeft = 0;
+        this.trimRight = 0;
+    }
+    getContent() {
+        return this.input.slice(this.begin + this.trimLeft, this.end - this.trimRight);
+    }
+}
+
+class RangeToken extends Token {
+    constructor(input, begin, end, lhs, rhs, file) {
+        super(TokenKind.Range, input, begin, end, file);
+        this.input = input;
+        this.begin = begin;
+        this.end = end;
+        this.lhs = lhs;
+        this.rhs = rhs;
+        this.file = file;
+    }
+}
+
+class OutputToken extends DelimitedToken {
+    constructor(input, begin, end, options, file) {
+        const { trimOutputLeft, trimOutputRight, outputDelimiterLeft, outputDelimiterRight } = options;
+        const value = input.slice(begin + outputDelimiterLeft.length, end - outputDelimiterRight.length);
+        super(TokenKind.Output, value, input, begin, end, trimOutputLeft, trimOutputRight, file);
+    }
+}
+
+function matchOperator(str, begin, trie, end = str.length) {
+    let node = trie;
+    let i = begin;
+    let info;
+    while (node[str[i]] && i < end) {
+        node = node[str[i++]];
+        if (node['end'])
+            info = node;
+    }
+    if (!info)
+        return -1;
+    if (info['needBoundary'] && (TYPES[str.charCodeAt(i)] & IDENTIFIER))
+        return -1;
+    return i;
+}
+
+class LiquidTagToken extends DelimitedToken {
+    constructor(input, begin, end, options, file) {
+        const value = input.slice(begin, end);
+        super(TokenKind.Tag, value, input, begin, end, false, false, file);
+        if (!/\S/.test(value)) {
+            // A line that contains only whitespace.
+            this.name = '';
+            this.args = '';
+        }
+        else {
+            const tokenizer = new Tokenizer(this.content, options.operatorsTrie);
+            this.name = tokenizer.readTagName();
+            if (!this.name)
+                throw new TokenizationError(`illegal liquid tag syntax`, this);
+            tokenizer.skipBlank();
+            this.args = tokenizer.remaining();
+        }
+    }
+}
+
+class Tokenizer {
+    constructor(input, trie = defaultOptions.operatorsTrie, file = '') {
+        this.input = input;
+        this.trie = trie;
+        this.file = file;
+        this.p = 0;
+        this.rawBeginAt = -1;
+        this.N = input.length;
+    }
+    readExpression() {
+        return new Expression(this.readExpressionTokens());
+    }
+    *readExpressionTokens() {
+        const operand = this.readValue();
+        if (!operand)
+            return;
+        yield operand;
+        while (this.p < this.N) {
+            const operator = this.readOperator();
+            if (!operator)
+                return;
+            const operand = this.readValue();
+            if (!operand)
+                return;
+            yield operator;
+            yield operand;
+        }
+    }
+    readOperator() {
+        this.skipBlank();
+        const end = matchOperator(this.input, this.p, this.trie);
+        if (end === -1)
+            return;
+        return new OperatorToken(this.input, this.p, (this.p = end), this.file);
+    }
+    readFilters() {
+        const filters = [];
+        while (true) {
+            const filter = this.readFilter();
+            if (!filter)
+                return filters;
+            filters.push(filter);
+        }
+    }
+    readFilter() {
+        this.skipBlank();
+        if (this.end())
+            return null;
+        assert(this.peek() === '|', () => `unexpected token at ${this.snapshot()}`);
+        this.p++;
+        const begin = this.p;
+        const name = this.readIdentifier();
+        if (!name.size())
+            return null;
+        const args = [];
+        this.skipBlank();
+        if (this.peek() === ':') {
+            do {
+                ++this.p;
+                const arg = this.readFilterArg();
+                arg && args.push(arg);
+                this.skipBlank();
+                assert(this.end() || this.peek() === ',' || this.peek() === '|', () => `unexpected character ${this.snapshot()}`);
+            } while (this.peek() === ',');
+        }
+        return new FilterToken(name.getText(), args, this.input, begin, this.p, this.file);
+    }
+    readFilterArg() {
+        const key = this.readValue();
+        if (!key)
+            return;
+        this.skipBlank();
+        if (this.peek() !== ':')
+            return key;
+        ++this.p;
+        const value = this.readValue();
+        return [key.getText(), value];
+    }
+    readTopLevelTokens(options = defaultOptions) {
+        const tokens = [];
+        while (this.p < this.N) {
+            const token = this.readTopLevelToken(options);
+            tokens.push(token);
+        }
+        whiteSpaceCtrl(tokens, options);
+        return tokens;
+    }
+    readTopLevelToken(options) {
+        const { tagDelimiterLeft, outputDelimiterLeft } = options;
+        if (this.rawBeginAt > -1)
+            return this.readEndrawOrRawContent(options);
+        if (this.match(tagDelimiterLeft))
+            return this.readTagToken(options);
+        if (this.match(outputDelimiterLeft))
+            return this.readOutputToken(options);
+        return this.readHTMLToken([tagDelimiterLeft, outputDelimiterLeft]);
+    }
+    readHTMLToken(stopStrings) {
+        const begin = this.p;
+        while (this.p < this.N) {
+            if (stopStrings.some(str => this.match(str)))
+                break;
+            ++this.p;
+        }
+        return new HTMLToken(this.input, begin, this.p, this.file);
+    }
+    readTagToken(options = defaultOptions) {
+        const { file, input } = this;
+        const begin = this.p;
+        if (this.readToDelimiter(options.tagDelimiterRight) === -1) {
+            throw this.mkError(`tag ${this.snapshot(begin)} not closed`, begin);
+        }
+        const token = new TagToken(input, begin, this.p, options, file);
+        if (token.name === 'raw')
+            this.rawBeginAt = begin;
+        return token;
+    }
+    readToDelimiter(delimiter) {
+        while (this.p < this.N) {
+            if ((this.peekType() & QUOTE)) {
+                this.readQuoted();
+                continue;
+            }
+            ++this.p;
+            if (this.rmatch(delimiter))
+                return this.p;
+        }
+        return -1;
+    }
+    readOutputToken(options = defaultOptions) {
+        const { file, input } = this;
+        const { outputDelimiterRight } = options;
+        const begin = this.p;
+        if (this.readToDelimiter(outputDelimiterRight) === -1) {
+            throw this.mkError(`output ${this.snapshot(begin)} not closed`, begin);
+        }
+        return new OutputToken(input, begin, this.p, options, file);
+    }
+    readEndrawOrRawContent(options) {
+        const { tagDelimiterLeft, tagDelimiterRight } = options;
+        const begin = this.p;
+        let leftPos = this.readTo(tagDelimiterLeft) - tagDelimiterLeft.length;
+        while (this.p < this.N) {
+            if (this.readIdentifier().getText() !== 'endraw') {
+                leftPos = this.readTo(tagDelimiterLeft) - tagDelimiterLeft.length;
+                continue;
+            }
+            while (this.p <= this.N) {
+                if (this.rmatch(tagDelimiterRight)) {
+                    const end = this.p;
+                    if (begin === leftPos) {
+                        this.rawBeginAt = -1;
+                        return new TagToken(this.input, begin, end, options, this.file);
+                    }
+                    else {
+                        this.p = leftPos;
+                        return new HTMLToken(this.input, begin, leftPos, this.file);
+                    }
+                }
+                if (this.rmatch(tagDelimiterLeft))
+                    break;
+                this.p++;
+            }
+        }
+        throw this.mkError(`raw ${this.snapshot(this.rawBeginAt)} not closed`, begin);
+    }
+    readLiquidTagTokens(options = defaultOptions) {
+        const tokens = [];
+        while (this.p < this.N) {
+            const token = this.readLiquidTagToken(options);
+            if (token.name)
+                tokens.push(token);
+        }
+        return tokens;
+    }
+    readLiquidTagToken(options) {
+        const { file, input } = this;
+        const begin = this.p;
+        let end = this.N;
+        if (this.readToDelimiter('\n') !== -1)
+            end = this.p;
+        return new LiquidTagToken(input, begin, end, options, file);
+    }
+    mkError(msg, begin) {
+        return new TokenizationError(msg, new IdentifierToken(this.input, begin, this.N, this.file));
+    }
+    snapshot(begin = this.p) {
+        return JSON.stringify(ellipsis(this.input.slice(begin), 16));
+    }
+    /**
+     * @deprecated
+     */
+    readWord() {
+        console.warn('Tokenizer#readWord() will be removed, use #readIdentifier instead');
+        return this.readIdentifier();
+    }
+    readIdentifier() {
+        this.skipBlank();
+        const begin = this.p;
+        while (this.peekType() & IDENTIFIER)
+            ++this.p;
+        return new IdentifierToken(this.input, begin, this.p, this.file);
+    }
+    readTagName() {
+        this.skipBlank();
+        // Handle inline comment tags
+        if (this.input[this.p] === '#')
+            return this.input.slice(this.p, ++this.p);
+        return this.readIdentifier().getText();
+    }
+    readHashes(jekyllStyle) {
+        const hashes = [];
+        while (true) {
+            const hash = this.readHash(jekyllStyle);
+            if (!hash)
+                return hashes;
+            hashes.push(hash);
+        }
+    }
+    readHash(jekyllStyle) {
+        this.skipBlank();
+        if (this.peek() === ',')
+            ++this.p;
+        const begin = this.p;
+        const name = this.readIdentifier();
+        if (!name.size())
+            return;
+        let value;
+        this.skipBlank();
+        const sep = jekyllStyle ? '=' : ':';
+        if (this.peek() === sep) {
+            ++this.p;
+            value = this.readValue();
+        }
+        return new HashToken(this.input, begin, this.p, name, value, this.file);
+    }
+    remaining() {
+        return this.input.slice(this.p);
+    }
+    advance(i = 1) {
+        this.p += i;
+    }
+    end() {
+        return this.p >= this.N;
+    }
+    readTo(end) {
+        while (this.p < this.N) {
+            ++this.p;
+            if (this.rmatch(end))
+                return this.p;
+        }
+        return -1;
+    }
+    readValue() {
+        const value = this.readQuoted() || this.readRange();
+        if (value)
+            return value;
+        if (this.peek() === '[') {
+            this.p++;
+            const prop = this.readQuoted();
+            if (!prop)
+                return;
+            if (this.peek() !== ']')
+                return;
+            this.p++;
+            return new PropertyAccessToken(prop, [], this.p);
+        }
+        const variable = this.readIdentifier();
+        if (!variable.size())
+            return;
+        let isNumber = variable.isNumber(true);
+        const props = [];
+        while (true) {
+            if (this.peek() === '[') {
+                isNumber = false;
+                this.p++;
+                const prop = this.readValue() || new IdentifierToken(this.input, this.p, this.p, this.file);
+                this.readTo(']');
+                props.push(prop);
+            }
+            else if (this.peek() === '.' && this.peek(1) !== '.') { // skip range syntax
+                this.p++;
+                const prop = this.readIdentifier();
+                if (!prop.size())
+                    break;
+                if (!prop.isNumber())
+                    isNumber = false;
+                props.push(prop);
+            }
+            else
+                break;
+        }
+        if (!props.length && literalValues.hasOwnProperty(variable.content)) {
+            return new LiteralToken(this.input, variable.begin, variable.end, this.file);
+        }
+        if (isNumber)
+            return new NumberToken(variable, props[0]);
+        return new PropertyAccessToken(variable, props, this.p);
+    }
+    readRange() {
+        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);
+    }
+    readValueOrThrow() {
+        const value = this.readValue();
+        assert(value, () => `unexpected token ${this.snapshot()}, value expected`);
+        return value;
+    }
+    readQuoted() {
+        this.skipBlank();
+        const begin = this.p;
+        if (!(this.peekType() & QUOTE))
+            return;
+        ++this.p;
+        let escaped = false;
+        while (this.p < this.N) {
+            ++this.p;
+            if (this.input[this.p - 1] === this.input[begin] && !escaped)
+                break;
+            if (escaped)
+                escaped = false;
+            else if (this.input[this.p - 1] === '\\')
+                escaped = true;
+        }
+        return new QuotedToken(this.input, begin, this.p, this.file);
+    }
+    *readFileNameTemplate(options) {
+        const { outputDelimiterLeft } = options;
+        const htmlStopStrings = [',', ' ', outputDelimiterLeft];
+        const htmlStopStringSet = new Set(htmlStopStrings);
+        // break on ',' and ' ', outputDelimiterLeft only stops HTML token
+        while (this.p < this.N && !htmlStopStringSet.has(this.peek())) {
+            yield this.match(outputDelimiterLeft)
+                ? this.readOutputToken(options)
+                : this.readHTMLToken(htmlStopStrings);
+        }
+    }
+    match(word) {
+        for (let i = 0; i < word.length; i++) {
+            if (word[i] !== this.input[this.p + i])
+                return false;
+        }
+        return true;
+    }
+    rmatch(pattern) {
+        for (let i = 0; i < pattern.length; i++) {
+            if (pattern[pattern.length - 1 - i] !== this.input[this.p - 1 - i])
+                return false;
+        }
+        return true;
+    }
+    peekType(n = 0) {
+        return TYPES[this.input.charCodeAt(this.p + n)];
+    }
+    peek(n = 0) {
+        return this.input[this.p + n];
+    }
+    skipBlank() {
+        while (this.peekType() & BLANK)
+            ++this.p;
+    }
+}
+
+class TagToken extends DelimitedToken {
+    constructor(input, begin, end, options, file) {
+        const { trimTagLeft, trimTagRight, tagDelimiterLeft, tagDelimiterRight } = options;
+        const value = input.slice(begin + tagDelimiterLeft.length, end - tagDelimiterRight.length);
+        super(TokenKind.Tag, value, input, begin, end, trimTagLeft, trimTagRight, file);
+        const tokenizer = new Tokenizer(this.content, options.operatorsTrie);
+        this.name = tokenizer.readTagName();
+        if (!this.name)
+            throw new TokenizationError(`illegal tag syntax`, this);
+        tokenizer.skipBlank();
+        this.args = tokenizer.remaining();
+    }
+}
+
+class ParseStream {
+    constructor(tokens, parseToken) {
+        this.handlers = {};
+        this.stopRequested = false;
+        this.tokens = tokens;
+        this.parseToken = parseToken;
+    }
+    on(name, cb) {
+        this.handlers[name] = cb;
+        return this;
+    }
+    trigger(event, arg) {
+        const h = this.handlers[event];
+        return h ? (h.call(this, arg), true) : false;
+    }
+    start() {
+        this.trigger('start');
+        let token;
+        while (!this.stopRequested && (token = this.tokens.shift())) {
+            if (this.trigger('token', token))
+                continue;
+            if (isTagToken(token) && this.trigger(`tag:${token.name}`, token)) {
+                continue;
+            }
+            const template = this.parseToken(token, this.tokens);
+            this.trigger('template', template);
+        }
+        if (!this.stopRequested)
+            this.trigger('end');
+        return this;
+    }
+    stop() {
+        this.stopRequested = true;
+        return this;
+    }
+}
+
+/**
+ * Key-Value Pairs Representing Tag Arguments
+ * Example:
+ *    For the markup `, foo:'bar', coo:2 reversed %}`,
+ *    hash['foo'] === 'bar'
+ *    hash['coo'] === 2
+ *    hash['reversed'] === undefined
+ */
+class Hash {
+    constructor(markup, jekyllStyle) {
+        this.hash = {};
+        const tokenizer = new Tokenizer(markup, {});
+        for (const hash of tokenizer.readHashes(jekyllStyle)) {
+            this.hash[hash.name.content] = hash.value;
+        }
+    }
+    *render(ctx) {
+        const hash = {};
+        for (const key of Object.keys(this.hash)) {
+            hash[key] = this.hash[key] === undefined ? true : yield _evalToken(this.hash[key], ctx);
+        }
+        return hash;
+    }
+}
+
+function isKeyValuePair(arr) {
+    return isArray(arr);
+}
+
+class Filter {
+    constructor(name, impl, args, liquid) {
+        this.name = name;
+        this.impl = impl || identify;
+        this.args = 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 this.impl.apply({ context, liquid: this.liquid }, [value, ...argv]);
+    }
+}
+
+class Value {
+    /**
+     * @param str the value to be valuated, eg.: "foobar" | truncate: 3
+     */
+    constructor(str, liquid) {
+        this.filters = [];
+        const tokenizer = new Tokenizer(str, liquid.options.operatorsTrie);
+        this.initial = tokenizer.readExpression();
+        this.filters = tokenizer.readFilters().map(({ name, args }) => new Filter(name, liquid.filters.get(name), args, liquid));
+    }
+    *value(ctx, lenient) {
+        lenient = lenient || (ctx.opts.lenientIf && this.filters.length > 0 && this.filters[0].name === 'default');
+        let val = yield this.initial.evaluate(ctx, lenient);
+        for (const filter of this.filters) {
+            val = yield filter.render(val, ctx);
+        }
+        return val;
+    }
+}
+
+var assign = {
+    parse: function (token) {
+        const tokenizer = new Tokenizer(token.args, this.liquid.options.operatorsTrie);
+        this.key = tokenizer.readIdentifier().content;
+        tokenizer.skipBlank();
+        assert(tokenizer.peek() === '=', () => `illegal token ${token.getText()}`);
+        tokenizer.advance();
+        this.value = new Value(tokenizer.remaining(), this.liquid);
+    },
+    render: function* (ctx) {
+        ctx.bottom()[this.key] = yield this.value.value(ctx, this.liquid.options.lenientIf);
+    }
+};
+
+class ForloopDrop extends Drop {
+    constructor(length, collection, variable) {
+        super();
+        this.i = 0;
+        this.length = length;
+        this.name = `${variable}-${collection}`;
+    }
+    next() {
+        this.i++;
+    }
+    index0() {
+        return this.i;
+    }
+    index() {
+        return this.i + 1;
+    }
+    first() {
+        return this.i === 0;
+    }
+    last() {
+        return this.i === this.length - 1;
+    }
+    rindex() {
+        return this.length - this.i;
+    }
+    rindex0() {
+        return this.length - this.i - 1;
+    }
+    valueOf() {
+        return JSON.stringify(this);
+    }
+}
+
+const MODIFIERS = ['offset', 'limit', 'reversed'];
+var For = {
+    type: 'block',
+    parse: function (token, remainTokens) {
+        const tokenizer = new Tokenizer(token.args, this.liquid.options.operatorsTrie);
+        const variable = tokenizer.readIdentifier();
+        const inStr = tokenizer.readIdentifier();
+        const collection = tokenizer.readValue();
+        assert(variable.size() && inStr.content === 'in' && collection, () => `illegal tag: ${token.getText()}`);
+        this.variable = variable.content;
+        this.collection = collection;
+        this.hash = new Hash(tokenizer.remaining());
+        this.templates = [];
+        this.elseTemplates = [];
+        let p;
+        const stream = this.liquid.parser.parseStream(remainTokens)
+            .on('start', () => (p = this.templates))
+            .on('tag:else', () => (p = this.elseTemplates))
+            .on('tag:endfor', () => stream.stop())
+            .on('template', (tpl) => p.push(tpl))
+            .on('end', () => {
+            throw new Error(`tag ${token.getText()} not closed`);
+        });
+        stream.start();
+    },
+    render: function* (ctx, emitter) {
+        const r = this.liquid.renderer;
+        let collection = toEnumerable(yield _evalToken(this.collection, ctx));
+        if (!collection.length) {
+            yield r.renderTemplates(this.elseTemplates, ctx, emitter);
+            return;
+        }
+        const continueKey = 'continue-' + this.variable + '-' + this.collection.getText();
+        ctx.push({ 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))
+            : MODIFIERS.filter(x => hash[x] !== undefined);
+        collection = modifiers.reduce((collection, modifier) => {
+            if (modifier === 'offset')
+                return offset(collection, hash['offset']);
+            if (modifier === 'limit')
+                return limit(collection, hash['limit']);
+            return reversed(collection);
+        }, collection);
+        ctx.setRegister(continueKey, (hash['offset'] || 0) + collection.length);
+        const scope = { forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) };
+        ctx.push(scope);
+        for (const item of collection) {
+            scope[this.variable] = item;
+            yield r.renderTemplates(this.templates, ctx, emitter);
+            if (emitter['break']) {
+                emitter['break'] = false;
+                break;
+            }
+            emitter['continue'] = false;
+            scope.forloop.next();
+        }
+        ctx.pop();
+    }
+};
+function reversed(arr) {
+    return [...arr].reverse();
+}
+function offset(arr, count) {
+    return arr.slice(count);
+}
+function limit(arr, count) {
+    return arr.slice(0, count);
+}
+
+var capture = {
+    parse: function (tagToken, remainTokens) {
+        const tokenizer = new Tokenizer(tagToken.args, this.liquid.options.operatorsTrie);
+        this.variable = readVariableName(tokenizer);
+        assert(this.variable, () => `${tagToken.args} not valid identifier`);
+        this.templates = [];
+        const stream = this.liquid.parser.parseStream(remainTokens);
+        stream.on('tag:endcapture', () => stream.stop())
+            .on('template', (tpl) => this.templates.push(tpl))
+            .on('end', () => {
+            throw new Error(`tag ${tagToken.getText()} not closed`);
+        });
+        stream.start();
+    },
+    render: function* (ctx) {
+        const r = this.liquid.renderer;
+        const html = yield r.renderTemplates(this.templates, ctx);
+        ctx.bottom()[this.variable] = html;
+    }
+};
+function readVariableName(tokenizer) {
+    const word = tokenizer.readIdentifier().content;
+    if (word)
+        return word;
+    const quoted = tokenizer.readQuoted();
+    if (quoted)
+        return evalQuotedToken(quoted);
+}
+
+var Case = {
+    parse: function (tagToken, remainTokens) {
+        this.cond = new Value(tagToken.args, this.liquid);
+        this.cases = [];
+        this.elseTemplates = [];
+        let p = [];
+        const stream = this.liquid.parser.parseStream(remainTokens)
+            .on('tag:when', (token) => {
+            p = [];
+            const tokenizer = new Tokenizer(token.args, this.liquid.options.operatorsTrie);
+            while (!tokenizer.end()) {
+                const value = tokenizer.readValue();
+                this.cases.push({
+                    val: value,
+                    templates: p
+                });
+                tokenizer.readTo(',');
+            }
+        })
+            .on('tag:else', () => (p = this.elseTemplates))
+            .on('tag:endcase', () => stream.stop())
+            .on('template', (tpl) => p.push(tpl))
+            .on('end', () => {
+            throw new Error(`tag ${tagToken.getText()} not closed`);
+        });
+        stream.start();
+    },
+    render: function* (ctx, emitter) {
+        const r = this.liquid.renderer;
+        const cond = toValue(yield this.cond.value(ctx, ctx.opts.lenientIf));
+        for (const branch of this.cases) {
+            const val = yield _evalToken(branch.val, ctx, ctx.opts.lenientIf);
+            if (val === cond) {
+                yield r.renderTemplates(branch.templates, ctx, emitter);
+                return;
+            }
+        }
+        yield r.renderTemplates(this.elseTemplates, ctx, emitter);
+    }
+};
+
+var comment = {
+    parse: function (tagToken, remainTokens) {
+        const stream = this.liquid.parser.parseStream(remainTokens);
+        stream
+            .on('token', (token) => {
+            if (token.name === 'endcomment')
+                stream.stop();
+        })
+            .on('end', () => {
+            throw new Error(`tag ${tagToken.getText()} not closed`);
+        });
+        stream.start();
+    }
+};
+
+var BlockMode;
+(function (BlockMode) {
+    /* store rendered html into blocks */
+    BlockMode[BlockMode["OUTPUT"] = 0] = "OUTPUT";
+    /* output rendered html directly */
+    BlockMode[BlockMode["STORE"] = 1] = "STORE";
+})(BlockMode || (BlockMode = {}));
+var BlockMode$1 = BlockMode;
+
+var render = {
+    parseFilePath,
+    renderFilePath,
+    parse: function (token) {
+        const args = token.args;
+        const tokenizer = new Tokenizer(args, this.liquid.options.operatorsTrie);
+        this['file'] = this.parseFilePath(tokenizer, this.liquid);
+        this['currentFile'] = token.file;
+        while (!tokenizer.end()) {
+            tokenizer.skipBlank();
+            const begin = tokenizer.p;
+            const keyword = tokenizer.readIdentifier();
+            if (keyword.content === 'with' || keyword.content === 'for') {
+                tokenizer.skipBlank();
+                // can be normal key/value pair, like "with: true"
+                if (tokenizer.peek() !== ':') {
+                    const value = tokenizer.readValue();
+                    // can be normal key, like "with,"
+                    if (value) {
+                        const beforeAs = tokenizer.p;
+                        const asStr = tokenizer.readIdentifier();
+                        let alias;
+                        if (asStr.content === 'as')
+                            alias = tokenizer.readIdentifier();
+                        else
+                            tokenizer.p = beforeAs;
+                        this[keyword.content] = { value, alias: alias && alias.content };
+                        tokenizer.skipBlank();
+                        if (tokenizer.peek() === ',')
+                            tokenizer.advance();
+                        // matched!
+                        continue;
+                    }
+                }
+            }
+            /**
+             * restore cursor if with/for not matched
+             */
+            tokenizer.p = begin;
+            break;
+        }
+        this.hash = new Hash(tokenizer.remaining());
+    },
+    render: function* (ctx, emitter) {
+        const { liquid, hash } = this;
+        const filepath = yield this.renderFilePath(this['file'], ctx, liquid);
+        assert(filepath, () => `illegal filename "${filepath}"`);
+        const childCtx = new Context({}, ctx.opts, { sync: ctx.sync, globals: ctx.globals, strictVariables: ctx.strictVariables });
+        const scope = childCtx.bottom();
+        __assign(scope, yield hash.render(ctx));
+        if (this['with']) {
+            const { value, alias } = this['with'];
+            scope[alias || filepath] = yield _evalToken(value, ctx);
+        }
+        if (this['for']) {
+            const { value, alias } = this['for'];
+            let collection = yield _evalToken(value, ctx);
+            collection = toEnumerable(collection);
+            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']);
+                yield liquid.renderer.renderTemplates(templates, childCtx, emitter);
+                scope['forloop'].next();
+            }
+        }
+        else {
+            const templates = yield liquid._parsePartialFile(filepath, childCtx.sync, this['currentFile']);
+            yield liquid.renderer.renderTemplates(templates, childCtx, emitter);
+        }
+    }
+};
+/**
+ * @return null for "none",
+ * @return Template[] for quoted with tags and/or filters
+ * @return Token for expression (not quoted)
+ * @throws TypeError if cannot read next token
+ */
+function parseFilePath(tokenizer, liquid) {
+    if (liquid.options.dynamicPartials) {
+        const file = tokenizer.readValue();
+        if (file === undefined)
+            throw new TypeError(`illegal argument "${tokenizer.input}"`);
+        if (file.getText() === 'none')
+            return null;
+        if (isQuotedToken(file)) {
+            // for filenames like "files/{{file}}", eval as liquid template
+            const templates = liquid.parse(evalQuotedToken(file));
+            return optimize(templates);
+        }
+        return file;
+    }
+    const tokens = [...tokenizer.readFileNameTemplate(liquid.options)];
+    const templates = optimize(liquid.parser.parseTokens(tokens));
+    return templates === 'none' ? null : templates;
+}
+function optimize(templates) {
+    // for filenames like "files/file.liquid", extract the string directly
+    if (templates.length === 1 && isHTMLToken(templates[0].token))
+        return templates[0].token.getContent();
+    return templates;
+}
+function* renderFilePath(file, ctx, liquid) {
+    if (typeof file === 'string')
+        return file;
+    if (Array.isArray(file))
+        return liquid.renderer.renderTemplates(file, ctx);
+    return yield _evalToken(file, ctx);
+}
+
+var include = {
+    parseFilePath,
+    renderFilePath,
+    parse: function (token) {
+        const args = token.args;
+        const tokenizer = new Tokenizer(args, this.liquid.options.operatorsTrie);
+        this['file'] = this.parseFilePath(tokenizer, this.liquid);
+        this['currentFile'] = token.file;
+        const begin = tokenizer.p;
+        const withStr = tokenizer.readIdentifier();
+        if (withStr.content === 'with') {
+            tokenizer.skipBlank();
+            if (tokenizer.peek() !== ':') {
+                this.withVar = tokenizer.readValue();
+            }
+            else
+                tokenizer.p = begin;
+        }
+        else
+            tokenizer.p = begin;
+        this.hash = new Hash(tokenizer.remaining(), this.liquid.options.jekyllInclude);
+    },
+    render: function* (ctx, emitter) {
+        const { liquid, hash, withVar } = this;
+        const { renderer } = liquid;
+        const filepath = yield this.renderFilePath(this['file'], ctx, liquid);
+        assert(filepath, () => `illegal filename "${filepath}"`);
+        const saved = ctx.saveRegister('blocks', 'blockMode');
+        ctx.setRegister('blocks', {});
+        ctx.setRegister('blockMode', BlockMode$1.OUTPUT);
+        const scope = 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);
+        yield renderer.renderTemplates(templates, ctx, emitter);
+        ctx.pop();
+        ctx.restoreRegister(saved);
+    }
+};
+
+var decrement = {
+    parse: function (token) {
+        const tokenizer = new Tokenizer(token.args, this.liquid.options.operatorsTrie);
+        this.variable = tokenizer.readIdentifier().content;
+    },
+    render: function (context, emitter) {
+        const scope = context.environments;
+        if (!isNumber(scope[this.variable])) {
+            scope[this.variable] = 0;
+        }
+        emitter.write(stringify(--scope[this.variable]));
+    }
+};
+
+var cycle = {
+    parse: function (tagToken) {
+        const tokenizer = new Tokenizer(tagToken.args, this.liquid.options.operatorsTrie);
+        const group = tokenizer.readValue();
+        tokenizer.skipBlank();
+        this.candidates = [];
+        if (group) {
+            if (tokenizer.peek() === ':') {
+                this.group = group;
+                tokenizer.advance();
+            }
+            else
+                this.candidates.push(group);
+        }
+        while (!tokenizer.end()) {
+            const value = tokenizer.readValue();
+            if (value)
+                this.candidates.push(value);
+            tokenizer.readTo(',');
+        }
+        assert(this.candidates.length, () => `empty candidates: ${tagToken.getText()}`);
+    },
+    render: function* (ctx, emitter) {
+        const group = yield _evalToken(this.group, ctx);
+        const fingerprint = `cycle:${group}:` + this.candidates.join(',');
+        const groups = ctx.getRegister('cycle');
+        let idx = groups[fingerprint];
+        if (idx === undefined) {
+            idx = groups[fingerprint] = 0;
+        }
+        const candidate = this.candidates[idx];
+        idx = (idx + 1) % this.candidates.length;
+        groups[fingerprint] = idx;
+        const html = yield _evalToken(candidate, ctx);
+        emitter.write(html);
+    }
+};
+
+var If = {
+    parse: function (tagToken, remainTokens) {
+        this.branches = [];
+        this.elseTemplates = [];
+        let p;
+        this.liquid.parser.parseStream(remainTokens)
+            .on('start', () => this.branches.push({
+            predicate: new Value(tagToken.args, this.liquid),
+            templates: (p = [])
+        }))
+            .on('tag:elsif', (token) => this.branches.push({
+            predicate: new Value(token.args, this.liquid),
+            templates: (p = [])
+        }))
+            .on('tag:else', () => (p = this.elseTemplates))
+            .on('tag:endif', function () { this.stop(); })
+            .on('template', (tpl) => p.push(tpl))
+            .on('end', () => { throw new Error(`tag ${tagToken.getText()} not closed`); })
+            .start();
+    },
+    render: function* (ctx, emitter) {
+        const r = this.liquid.renderer;
+        for (const { predicate, templates } of this.branches) {
+            const value = yield predicate.value(ctx, ctx.opts.lenientIf);
+            if (isTruthy(value, ctx)) {
+                yield r.renderTemplates(templates, ctx, emitter);
+                return;
+            }
+        }
+        yield r.renderTemplates(this.elseTemplates, ctx, emitter);
+    }
+};
+
+var increment = {
+    parse: function (token) {
+        const tokenizer = new Tokenizer(token.args, this.liquid.options.operatorsTrie);
+        this.variable = tokenizer.readIdentifier().content;
+    },
+    render: function (context, emitter) {
+        const scope = context.environments;
+        if (!isNumber(scope[this.variable])) {
+            scope[this.variable] = 0;
+        }
+        const val = scope[this.variable];
+        scope[this.variable]++;
+        emitter.write(stringify(val));
+    }
+};
+
+var layout = {
+    parseFilePath,
+    renderFilePath,
+    parse: function (token, remainTokens) {
+        const tokenizer = new Tokenizer(token.args, this.liquid.options.operatorsTrie);
+        this['file'] = this.parseFilePath(tokenizer, this.liquid);
+        this['currentFile'] = token.file;
+        this.hash = new Hash(tokenizer.remaining());
+        this.tpls = this.liquid.parser.parseTokens(remainTokens);
+    },
+    render: function* (ctx, emitter) {
+        const { liquid, hash, file } = this;
+        const { renderer } = liquid;
+        if (file === null) {
+            ctx.setRegister('blockMode', BlockMode$1.OUTPUT);
+            yield renderer.renderTemplates(this.tpls, ctx, emitter);
+            return;
+        }
+        const filepath = yield this.renderFilePath(this['file'], ctx, liquid);
+        assert(filepath, () => `illegal filename "${filepath}"`);
+        const templates = yield liquid._parseLayoutFile(filepath, ctx.sync, this['currentFile']);
+        // render remaining contents and store rendered results
+        ctx.setRegister('blockMode', BlockMode$1.STORE);
+        const html = yield renderer.renderTemplates(this.tpls, ctx);
+        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$1.OUTPUT);
+        // render the layout file use stored blocks
+        ctx.push(yield hash.render(ctx));
+        yield renderer.renderTemplates(templates, ctx, emitter);
+        ctx.pop();
+    }
+};
+
+class BlockDrop extends Drop {
+    constructor(
+    // the block render from layout template
+    superBlockRender = () => '') {
+        super();
+        this.superBlockRender = superBlockRender;
+    }
+    /**
+     * Provide parent access in child block by
+     * {{ block.super }}
+     */
+    super() {
+        return this.superBlockRender();
+    }
+}
+
+var block = {
+    parse(token, remainTokens) {
+        const match = /\w+/.exec(token.args);
+        this.block = match ? match[0] : '';
+        this.tpls = [];
+        this.liquid.parser.parseStream(remainTokens)
+            .on('tag:endblock', function () { this.stop(); })
+            .on('template', (tpl) => this.tpls.push(tpl))
+            .on('end', () => { throw new Error(`tag ${token.getText()} not closed`); })
+            .start();
+    },
+    *render(ctx, emitter) {
+        const blockRender = this.getBlockRender(ctx);
+        if (ctx.getRegister('blockMode') === BlockMode$1.STORE) {
+            ctx.getRegister('blocks')[this.block] = blockRender;
+        }
+        else {
+            yield blockRender(new BlockDrop(), emitter);
+        }
+    },
+    getBlockRender(ctx) {
+        const { liquid, tpls } = this;
+        const renderChild = ctx.getRegister('blocks')[this.block];
+        const renderCurrent = function* (superBlock, emitter) {
+            // add {{ block.super }} support when rendering
+            ctx.push({ block: superBlock });
+            yield liquid.renderer.renderTemplates(tpls, ctx, emitter);
+            ctx.pop();
+        };
+        return renderChild
+            ? (superBlock, emitter) => renderChild(new BlockDrop(() => renderCurrent(superBlock, emitter)), emitter)
+            : renderCurrent;
+    }
+};
+
+var raw = {
+    parse: function (tagToken, remainTokens) {
+        this.tokens = [];
+        const stream = this.liquid.parser.parseStream(remainTokens);
+        stream
+            .on('token', (token) => {
+            if (token.name === 'endraw')
+                stream.stop();
+            else
+                this.tokens.push(token);
+        })
+            .on('end', () => {
+            throw new Error(`tag ${tagToken.getText()} not closed`);
+        });
+        stream.start();
+    },
+    render: function () {
+        return this.tokens.map((token) => token.getText()).join('');
+    }
+};
+
+class TablerowloopDrop extends ForloopDrop {
+    constructor(length, cols, collection, variable) {
+        super(length, collection, variable);
+        this.length = length;
+        this.cols = cols;
+    }
+    row() {
+        return Math.floor(this.i / this.cols) + 1;
+    }
+    col0() {
+        return (this.i % this.cols);
+    }
+    col() {
+        return this.col0() + 1;
+    }
+    col_first() {
+        return this.col0() === 0;
+    }
+    col_last() {
+        return this.col() === this.cols;
+    }
+}
+
+var tablerow = {
+    parse: function (tagToken, remainTokens) {
+        const tokenizer = new Tokenizer(tagToken.args, this.liquid.options.operatorsTrie);
+        const variable = tokenizer.readIdentifier();
+        tokenizer.skipBlank();
+        const tmp = tokenizer.readIdentifier();
+        assert(tmp && tmp.content === 'in', () => `illegal tag: ${tagToken.getText()}`);
+        this.variable = variable.content;
+        this.collection = tokenizer.readValue();
+        this.hash = new Hash(tokenizer.remaining());
+        this.templates = [];
+        let p;
+        const stream = this.liquid.parser.parseStream(remainTokens)
+            .on('start', () => (p = this.templates))
+            .on('tag:endtablerow', () => stream.stop())
+            .on('template', (tpl) => p.push(tpl))
+            .on('end', () => {
+            throw new Error(`tag ${tagToken.getText()} not closed`);
+        });
+        stream.start();
+    },
+    render: function* (ctx, emitter) {
+        let collection = toEnumerable(yield _evalToken(this.collection, ctx));
+        const hash = yield this.hash.render(ctx);
+        const offset = hash.offset || 0;
+        const limit = (hash.limit === undefined) ? collection.length : hash.limit;
+        collection = collection.slice(offset, offset + limit);
+        const cols = hash.cols || collection.length;
+        const r = this.liquid.renderer;
+        const tablerowloop = new TablerowloopDrop(collection.length, cols, this.collection.getText(), this.variable);
+        const scope = { tablerowloop };
+        ctx.push(scope);
+        for (let idx = 0; idx < collection.length; idx++, tablerowloop.next()) {
+            scope[this.variable] = collection[idx];
+            if (tablerowloop.col0() === 0) {
+                if (tablerowloop.row() !== 1)
+                    emitter.write('</tr>');
+                emitter.write(`<tr class="row${tablerowloop.row()}">`);
+            }
+            emitter.write(`<td class="col${tablerowloop.col()}">`);
+            yield r.renderTemplates(this.templates, ctx, emitter);
+            emitter.write('</td>');
+        }
+        if (collection.length)
+            emitter.write('</tr>');
+        ctx.pop();
+    }
+};
+
+var unless = {
+    parse: function (tagToken, remainTokens) {
+        this.branches = [];
+        this.elseTemplates = [];
+        let p;
+        this.liquid.parser.parseStream(remainTokens)
+            .on('start', () => this.branches.push({
+            predicate: new Value(tagToken.args, this.liquid),
+            test: isFalsy,
+            templates: (p = [])
+        }))
+            .on('tag:elsif', (token) => this.branches.push({
+            predicate: new Value(token.args, this.liquid),
+            test: isTruthy,
+            templates: (p = [])
+        }))
+            .on('tag:else', () => (p = this.elseTemplates))
+            .on('tag:endunless', function () { this.stop(); })
+            .on('template', (tpl) => p.push(tpl))
+            .on('end', () => { throw new Error(`tag ${tagToken.getText()} not closed`); })
+            .start();
+    },
+    render: function* (ctx, emitter) {
+        const r = this.liquid.renderer;
+        for (const { predicate, test, templates } of this.branches) {
+            const value = yield predicate.value(ctx, ctx.opts.lenientIf);
+            if (test(value, ctx)) {
+                yield r.renderTemplates(templates, ctx, emitter);
+                return;
+            }
+        }
+        yield r.renderTemplates(this.elseTemplates, ctx, emitter);
+    }
+};
+
+var Break = {
+    render: function (ctx, emitter) {
+        emitter['break'] = true;
+    }
+};
+
+var Continue = {
+    render: function (ctx, emitter) {
+        emitter['continue'] = true;
+    }
+};
+
+var echo = {
+    parse: function (token) {
+        this.value = new Value(token.args, this.liquid);
+    },
+    render: function* (ctx, emitter) {
+        const val = yield this.value.value(ctx, false);
+        emitter.write(val);
+    }
+};
+
+var liquid = {
+    parse: function (token) {
+        const tokenizer = new Tokenizer(token.args, this.liquid.options.operatorsTrie);
+        const tokens = tokenizer.readLiquidTagTokens(this.liquid.options);
+        this.tpls = this.liquid.parser.parseTokens(tokens);
+    },
+    render: function* (ctx, emitter) {
+        yield this.liquid.renderer.renderTemplates(this.tpls, ctx, emitter);
+    }
+};
+
+var inlineComment = {
+    parse: function (tagToken, remainTokens) {
+        if (tagToken.args.search(/\n\s*[^#\s]/g) !== -1) {
+            throw new Error('every line of an inline comment must start with a \'#\' character');
+        }
+    }
+};
+
+const tags = {
+    assign, 'for': For, capture, 'case': Case, comment, include, render, decrement, increment, cycle, 'if': If, layout, block, raw, tablerow, unless, 'break': Break, 'continue': Continue, echo, liquid, '#': inlineComment
+};
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    'default': tags
+});
+
+const filters = new Map();
+forOwn(builtinFilters, (conf, name) => {
+    filters.set(snakeCase(name), conf);
+});
+const defaultOptions = {
+    root: ['.'],
+    layouts: ['.'],
+    partials: ['.'],
+    relativeReference: true,
+    jekyllInclude: false,
+    cache: undefined,
+    extname: '',
+    fs: fs,
+    dynamicPartials: true,
+    jsTruthy: false,
+    trimTagRight: false,
+    trimTagLeft: false,
+    trimOutputRight: false,
+    trimOutputLeft: false,
+    greedy: true,
+    tagDelimiterLeft: '{%',
+    tagDelimiterRight: '%}',
+    outputDelimiterLeft: '{{',
+    outputDelimiterRight: '}}',
+    preserveTimezones: false,
+    strictFilters: false,
+    strictVariables: false,
+    ownPropertyOnly: false,
+    lenientIf: false,
+    globals: {},
+    keepOutputType: false,
+    operators: defaultOperators,
+    operatorsTrie: createTrie(defaultOperators)
+};
+function normalize(options) {
+    if (options.hasOwnProperty('operators')) {
+        options.operatorsTrie = createTrie(options.operators);
+    }
+    if (options.hasOwnProperty('root')) {
+        if (!options.hasOwnProperty('partials'))
+            options.partials = options.root;
+        if (!options.hasOwnProperty('layouts'))
+            options.layouts = options.root;
+    }
+    if (options.hasOwnProperty('cache')) {
+        let cache;
+        if (typeof options.cache === 'number')
+            cache = options.cache > 0 ? new LRU(options.cache) : undefined;
+        else if (typeof options.cache === 'object')
+            cache = options.cache;
+        else
+            cache = options.cache ? new LRU(1024) : undefined;
+        options.cache = cache;
+    }
+    options = Object.assign(Object.assign(Object.assign({}, defaultOptions), (options.jekyllInclude ? { dynamicPartials: false } : {})), options);
+    if (!options.fs.dirname && options.relativeReference) {
+        console.warn('[LiquidJS] `fs.dirname` is required for relativeReference, set relativeReference to `false` to suppress this warning, or provide implementation for `fs.dirname`');
+        options.relativeReference = false;
+    }
+    options.root = normalizeDirectoryList(options.root);
+    options.partials = normalizeDirectoryList(options.partials);
+    options.layouts = normalizeDirectoryList(options.layouts);
+    options.outputEscape = options.outputEscape && getOutputEscapeFunction(options.outputEscape);
+    return options;
+}
+function getOutputEscapeFunction(nameOrFunction) {
+    if (isString(nameOrFunction)) {
+        const filterImpl = filters.get(nameOrFunction);
+        assert(isFunction(filterImpl), `filter "${nameOrFunction}" not found`);
+        return filterImpl;
+    }
+    else {
+        assert(isFunction(nameOrFunction), '`outputEscape` need to be of type string or function');
+        return nameOrFunction;
+    }
+}
+function normalizeDirectoryList(value) {
+    let list = [];
+    if (isArray(value))
+        list = value;
+    if (isString(value))
+        list = [value];
+    return list;
+}
+
+class Context {
+    constructor(env = {}, opts = defaultOptions, renderOptions = {}) {
+        var _a, _b;
+        /**
+         * insert a Context-level empty scope,
+         * for tags like `{% capture %}` `{% assign %}` to operate
+         */
+        this.scopes = [{}];
+        this.registers = {};
+        this.sync = !!renderOptions.sync;
+        this.opts = opts;
+        this.globals = (_a = renderOptions.globals) !== null && _a !== void 0 ? _a : opts.globals;
+        this.environments = env;
+        this.strictVariables = (_b = renderOptions.strictVariables) !== null && _b !== void 0 ? _b : this.opts.strictVariables;
+    }
+    getRegister(key) {
+        return (this.registers[key] = this.registers[key] || {});
+    }
+    setRegister(key, value) {
+        return (this.registers[key] = value);
+    }
+    saveRegister(...keys) {
+        return keys.map(key => [key, this.getRegister(key)]);
+    }
+    restoreRegister(keyValues) {
+        return keyValues.forEach(([key, value]) => this.setRegister(key, value));
+    }
+    getAll() {
+        return [this.globals, this.environments, ...this.scopes]
+            .reduce((ctx, val) => __assign(ctx, val), {});
+    }
+    /**
+     * @deprecated use `_get()` instead
+     */
+    get(paths) {
+        return toValueSync(this._get(paths));
+    }
+    *_get(paths) {
+        const scope = this.findScope(paths[0]);
+        return yield this._getFromScope(scope, paths);
+    }
+    /**
+     * @deprecated use `_get()` instead
+     */
+    getFromScope(scope, paths) {
+        return toValueSync(this._getFromScope(scope, paths));
+    }
+    *_getFromScope(scope, paths) {
+        if (isString(paths))
+            paths = paths.split('.');
+        for (let i = 0; i < paths.length; i++) {
+            scope = yield readProperty(scope, paths[i], this.opts.ownPropertyOnly);
+            if (isNil(scope) && this.strictVariables) {
+                throw new InternalUndefinedVariableError(paths.slice(0, i + 1).join('.'));
+            }
+        }
+        return scope;
+    }
+    push(ctx) {
+        return this.scopes.push(ctx);
+    }
+    pop() {
+        return this.scopes.pop();
+    }
+    bottom() {
+        return this.scopes[0];
+    }
+    findScope(key) {
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+            const candidate = this.scopes[i];
+            if (key in candidate)
+                return candidate;
+        }
+        if (key in this.environments)
+            return this.environments;
+        return this.globals;
+    }
+}
+function readProperty(obj, key, ownPropertyOnly) {
+    if (isNil(obj))
+        return obj;
+    obj = toLiquid(obj);
+    if (isArray(obj) && key < 0)
+        return obj[obj.length + +key];
+    const jsProperty = readJSProperty(obj, key, ownPropertyOnly);
+    if (jsProperty === undefined && obj instanceof Drop)
+        return obj.liquidMethodMissing(key);
+    if (isFunction(jsProperty))
+        return jsProperty.call(obj);
+    if (key === 'size')
+        return readSize(obj);
+    else if (key === 'first')
+        return readFirst(obj);
+    else if (key === 'last')
+        return readLast(obj);
+    return jsProperty;
+}
+function readJSProperty(obj, key, ownPropertyOnly) {
+    if (ownPropertyOnly && !Object.hasOwnProperty.call(obj, key))
+        return undefined;
+    return obj[key];
+}
+function readFirst(obj) {
+    if (isArray(obj))
+        return obj[0];
+    return obj['first'];
+}
+function readLast(obj) {
+    if (isArray(obj))
+        return obj[obj.length - 1];
+    return obj['last'];
+}
+function readSize(obj) {
+    if (obj.hasOwnProperty('size') || obj['size'] !== undefined)
+        return obj['size'];
+    if (isArray(obj) || isString(obj))
+        return obj.length;
+    if (typeof obj === 'object')
+        return Object.keys(obj).length;
+}
+
+var LookupType;
+(function (LookupType) {
+    LookupType["Partials"] = "partials";
+    LookupType["Layouts"] = "layouts";
+    LookupType["Root"] = "root";
+})(LookupType || (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);
+        }
+        else {
+            this.shouldLoadRelative = (referencedFile) => false;
+        }
+        this.contains = this.options.fs.contains || (() => true);
+    }
+    *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))
+                return filepath;
+        }
+        throw this.lookupError(file, dirs);
+    }
+    *candidates(file, dirs, currentFile, enforceRoot) {
+        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;
+                }
+            }
+        }
+        for (const dir of dirs) {
+            const referenced = fs.resolve(dir, file, extname);
+            if (!enforceRoot || this.contains(dir, referenced)) {
+                yield referenced;
+            }
+        }
+        if (fs.fallback !== undefined) {
+            const filepath = fs.fallback(file);
+            if (filepath !== undefined)
+                yield filepath;
+        }
+    }
+    dirname(path) {
+        const fs = this.options.fs;
+        assert(fs.dirname, '`fs.dirname` is required for relative reference');
+        return fs.dirname(path);
+    }
+    lookupError(file, roots) {
+        const err = new Error('ENOENT');
+        err.message = `ENOENT: Failed to lookup "${file}" in "${roots}"`;
+        err.code = 'ENOENT';
+        return err;
+    }
+}
+
+class SimpleEmitter {
+    constructor() {
+        this.buffer = '';
+    }
+    write(html) {
+        this.buffer += stringify(html);
+    }
+}
+
+class StreamedEmitter {
+    constructor() {
+        this.buffer = '';
+        this.stream = new PassThrough();
+    }
+    write(html) {
+        this.stream.write(stringify(html));
+    }
+    error(err) {
+        this.stream.emit('error', err);
+    }
+    end() {
+        this.stream.end();
+    }
+}
+
+class KeepingTypeEmitter {
+    constructor() {
+        this.buffer = '';
+    }
+    write(html) {
+        html = toValue(html);
+        // This will only preserve the type if the value is isolated.
+        // I.E:
+        // {{ my-port }} -> 42
+        // {{ my-host }}:{{ my-port }} -> 'host:42'
+        if (typeof html !== 'string' && this.buffer === '') {
+            this.buffer = html;
+        }
+        else {
+            this.buffer = stringify(this.buffer) + stringify(html);
+        }
+    }
+}
+
+class Render {
+    renderTemplatesToNodeStream(templates, ctx) {
+        const emitter = new StreamedEmitter();
+        Promise.resolve().then(() => toPromise(this.renderTemplates(templates, ctx, emitter)))
+            .then(() => emitter.end(), err => emitter.error(err));
+        return emitter.stream;
+    }
+    *renderTemplates(templates, ctx, emitter) {
+        if (!emitter) {
+            emitter = ctx.opts.keepOutputType ? new KeepingTypeEmitter() : new SimpleEmitter();
+        }
+        for (const tpl of templates) {
+            try {
+                // if tpl.render supports emitter, it'll return empty `html`
+                const html = yield tpl.render(ctx, emitter);
+                // if not, it'll return an `html`, write to the emitter for it
+                html && emitter.write(html);
+                if (emitter['break'] || emitter['continue'])
+                    break;
+            }
+            catch (e) {
+                const err = RenderError.is(e) ? e : new RenderError(e, tpl);
+                throw err;
+            }
+        }
+        return emitter.buffer;
+    }
+}
+
+class TemplateImpl {
+    constructor(token) {
+        this.token = token;
+    }
+}
+
+class Tag extends TemplateImpl {
+    constructor(token, tokens, liquid) {
+        super(token);
+        this.name = token.name;
+        const impl = liquid.tags.get(token.name);
+        this.impl = Object.create(impl);
+        this.impl.liquid = liquid;
+        if (this.impl.parse) {
+            this.impl.parse(token, tokens);
+        }
+    }
+    *render(ctx, emitter) {
+        const hash = (yield new Hash(this.token.args).render(ctx));
+        const impl = this.impl;
+        if (isFunction(impl.render))
+            return yield impl.render(ctx, emitter, hash);
+    }
+}
+
+class Output extends TemplateImpl {
+    constructor(token, liquid) {
+        super(token);
+        this.value = new Value(token.content, liquid);
+        const filters = this.value.filters;
+        const outputEscape = liquid.options.outputEscape;
+        if (filters.length && filters[filters.length - 1].name === 'raw') {
+            filters.pop();
+        }
+        else if (outputEscape) {
+            filters.push(new Filter(toString.call(outputEscape), outputEscape, [], liquid));
+        }
+    }
+    *render(ctx, emitter) {
+        const val = yield this.value.value(ctx, false);
+        emitter.write(val);
+    }
+}
+
+class HTML extends TemplateImpl {
+    constructor(token) {
+        super(token);
+        this.str = token.getContent();
+    }
+    *render(ctx, emitter) {
+        emitter.write(this.str);
+    }
+}
+
+class Parser {
+    constructor(liquid) {
+        this.liquid = liquid;
+        this.cache = this.liquid.options.cache;
+        this.fs = this.liquid.options.fs;
+        this.parseFile = this.cache ? this._parseFileCached : this._parseFile;
+        this.loader = new Loader(this.liquid.options);
+    }
+    parse(html, filepath) {
+        const tokenizer = new Tokenizer(html, this.liquid.options.operatorsTrie, filepath);
+        const tokens = tokenizer.readTopLevelTokens(this.liquid.options);
+        return this.parseTokens(tokens);
+    }
+    parseTokens(tokens) {
+        let token;
+        const templates = [];
+        while ((token = tokens.shift())) {
+            templates.push(this.parseToken(token, tokens));
+        }
+        return templates;
+    }
+    parseToken(token, remainTokens) {
+        try {
+            if (isTagToken(token)) {
+                return new Tag(token, remainTokens, this.liquid);
+            }
+            if (isOutputToken(token)) {
+                return new Output(token, this.liquid);
+            }
+            return new HTML(token);
+        }
+        catch (e) {
+            throw new ParseError(e, token);
+        }
+    }
+    parseStream(tokens) {
+        return new ParseStream(tokens, (token, tokens) => this.parseToken(token, tokens));
+    }
+    *_parseFileCached(file, sync, type = LookupType.Root, currentFile) {
+        const cache = this.cache;
+        const key = this.loader.shouldLoadRelative(file) ? currentFile + ',' + file : type + ':' + file;
+        const tpls = yield cache.read(key);
+        if (tpls)
+            return tpls;
+        const task = this._parseFile(file, sync, type, currentFile);
+        // sync mode: exec the task and cache the result
+        // async mode: cache the task before exec
+        const taskOrTpl = sync ? yield task : toPromise(task);
+        cache.write(key, taskOrTpl);
+        // note: concurrent tasks will be reused, cache for failed task is removed until its end
+        try {
+            return yield taskOrTpl;
+        }
+        catch (err) {
+            cache.remove(key);
+            throw err;
+        }
+    }
+    *_parseFile(file, sync, type = LookupType.Root, currentFile) {
+        const filepath = yield this.loader.lookup(file, type, sync, currentFile);
+        return this.liquid.parse(sync ? this.fs.readFileSync(filepath) : yield this.fs.readFile(filepath), filepath);
+    }
+}
+
+class TagMap {
+    constructor() {
+        this.impls = {};
+    }
+    get(name) {
+        const impl = this.impls[name];
+        assert(impl, () => `tag "${name}" not found`);
+        return impl;
+    }
+    set(name, impl) {
+        this.impls[name] = impl;
+    }
+}
+
+class FilterMap {
+    constructor(strictFilters, liquid) {
+        this.strictFilters = strictFilters;
+        this.liquid = liquid;
+        this.impls = {};
+    }
+    get(name) {
+        const impl = this.impls[name];
+        assert(impl || !this.strictFilters, () => `undefined filter: ${name}`);
+        return impl;
+    }
+    set(name, impl) {
+        this.impls[name] = impl;
+    }
+    create(name, args) {
+        return new Filter(name, this.get(name), args, this.liquid);
+    }
+}
+
+const version = '9.43.0';
+class Liquid {
+    constructor(opts = {}) {
+        this.options = normalize(opts);
+        this.parser = new Parser(this);
+        this.renderer = new Render();
+        this.filters = new FilterMap(this.options.strictFilters, this);
+        this.tags = new TagMap();
+        forOwn(tags, (conf, name) => this.registerTag(snakeCase(name), conf));
+        forOwn(builtinFilters, (handler, name) => this.registerFilter(snakeCase(name), handler));
+    }
+    parse(html, filepath) {
+        return this.parser.parse(html, filepath);
+    }
+    _render(tpl, scope, renderOptions) {
+        const ctx = new Context(scope, this.options, renderOptions);
+        return this.renderer.renderTemplates(tpl, ctx);
+    }
+    render(tpl, scope, renderOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return toPromise(this._render(tpl, scope, Object.assign(Object.assign({}, renderOptions), { sync: false })));
+        });
+    }
+    renderSync(tpl, scope, renderOptions) {
+        return toValueSync(this._render(tpl, scope, Object.assign(Object.assign({}, renderOptions), { sync: true })));
+    }
+    renderToNodeStream(tpl, scope, renderOptions = {}) {
+        const ctx = new Context(scope, this.options, renderOptions);
+        return this.renderer.renderTemplatesToNodeStream(tpl, ctx);
+    }
+    _parseAndRender(html, scope, renderOptions) {
+        const tpl = this.parse(html);
+        return this._render(tpl, scope, renderOptions);
+    }
+    parseAndRender(html, scope, renderOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return toPromise(this._parseAndRender(html, scope, Object.assign(Object.assign({}, renderOptions), { sync: false })));
+        });
+    }
+    parseAndRenderSync(html, scope, renderOptions) {
+        return toValueSync(this._parseAndRender(html, scope, Object.assign(Object.assign({}, renderOptions), { sync: true })));
+    }
+    _parsePartialFile(file, sync, currentFile) {
+        return this.parser.parseFile(file, sync, LookupType.Partials, currentFile);
+    }
+    _parseLayoutFile(file, sync, currentFile) {
+        return this.parser.parseFile(file, sync, LookupType.Layouts, currentFile);
+    }
+    parseFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return toPromise(this.parser.parseFile(file, false));
+        });
+    }
+    parseFileSync(file) {
+        return toValueSync(this.parser.parseFile(file, true));
+    }
+    renderFile(file, ctx, renderOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const templates = yield this.parseFile(file);
+            return this.render(templates, ctx, renderOptions);
+        });
+    }
+    renderFileSync(file, ctx, renderOptions) {
+        const templates = this.parseFileSync(file);
+        return this.renderSync(templates, ctx, renderOptions);
+    }
+    renderFileToNodeStream(file, scope, renderOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const templates = yield this.parseFile(file);
+            return this.renderToNodeStream(templates, scope, renderOptions);
+        });
+    }
+    _evalValue(str, scopeOrContext) {
+        const value = new Value(str, this);
+        const ctx = scopeOrContext instanceof Context ? scopeOrContext : new Context(scopeOrContext, this.options);
+        return value.value(ctx, false);
+    }
+    evalValue(str, scopeOrContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return toPromise(this._evalValue(str, scopeOrContext));
+        });
+    }
+    evalValueSync(str, scopeOrContext) {
+        return toValueSync(this._evalValue(str, scopeOrContext));
+    }
+    registerFilter(name, filter) {
+        this.filters.set(name, filter);
+    }
+    registerTag(name, tag) {
+        this.tags.set(name, tag);
+    }
+    plugin(plugin) {
+        return plugin.call(this, Liquid);
+    }
+    express() {
+        const self = this; // eslint-disable-line
+        let firstCall = true;
+        return function (filePath, ctx, callback) {
+            if (firstCall) {
+                firstCall = false;
+                const dirs = normalizeDirectoryList(this.root);
+                self.options.root.unshift(...dirs);
+                self.options.layouts.unshift(...dirs);
+                self.options.partials.unshift(...dirs);
+            }
+            self.renderFile(filePath, ctx).then(html => callback(null, html), callback);
+        };
+    }
+}
+
+export { AssertionError, Context, Drop, Expression, Hash, InternalUndefinedVariableError, Liquid, LiquidError, ParseError, ParseStream, RenderError, TagToken, TimezoneDate, Token, TokenKind, TokenizationError, Tokenizer, typeGuards as TypeGuards, UndefinedVariableError, Value, _evalToken, assert, createTrie, defaultOperators, defaultOptions, evalQuotedToken, evalToken, builtinFilters as filters, isFalsy, isTruthy, index as tags, toPromise, toThenable, toValue, toValueSync, version };