From 77930e2d20294a8e51146a895761b3f3537dd59e Mon Sep 17 00:00:00 2001
From: harttle <yangjvn@126.com>
Date: Tue, 4 Oct 2016 22:31:28 +0800
Subject: [PATCH] enhancement: decrease dist size

---
 README.md                  |    2 +-
 demo/browser/index.html    |    8 +-
 dist/liquid.js             | 2251 +++++++++++++++++++++
 dist/liquid.min.js         |    2 +
 dist/shopify-liquid.js     | 3858 ------------------------------------
 dist/shopify-liquid.min.js |    4 -
 filters.js                 |    6 +-
 index.js                   |   25 +-
 makefile                   |    4 +-
 package.json               |    5 +-
 src/error.js               |   11 +-
 src/express.js             |    8 +-
 src/expression.js          |    2 -
 src/parser.js              |    3 +-
 src/render.js              |    6 +-
 src/scope.js               |    2 -
 src/strftime.js            |  404 ++++
 src/tag.js                 |    3 +-
 tags/assign.js             |    2 +-
 tags/case.js               |    1 -
 tags/comment.js            |    4 -
 tags/decrement.js          |    1 -
 tags/if.js                 |    1 -
 tags/include.js            |    1 -
 tags/layout.js             |   15 -
 tags/raw.js                |    3 -
 tags/tablerow.js           |    4 +-
 tags/unless.js             |    1 -
 test/filters.js            |    2 +-
 test/liquid.js             |   19 +-
 30 files changed, 2724 insertions(+), 3934 deletions(-)
 create mode 100644 dist/liquid.js
 create mode 100644 dist/liquid.min.js
 delete mode 100644 dist/shopify-liquid.js
 delete mode 100644 dist/shopify-liquid.min.js
 create mode 100644 src/strftime.js
diff --git a/README.md b/README.md
index d61c3c347..5357a21f6 100644
--- a/README.md
+++ b/README.md
@@ -101,7 +101,7 @@ And `window.Liquid` is what you want.
 ```html
 <html lang="en">
 <head>
-  <script src="shopify-liquid.min.js"></script>
+  <script src="dist/liquid.min.js"></script>
 </head>
 <body>
   <script>
diff --git a/demo/browser/index.html b/demo/browser/index.html
index e9d228149..06a2bc227 100644
--- a/demo/browser/index.html
+++ b/demo/browser/index.html
@@ -4,7 +4,7 @@
 <head>
   <meta charset="UTF-8">
   <title></title>
-  <script src="../../dist/shopify-liquid.min.js"></script>
+  <script src="../../dist/liquid.js"></script>
 </head>
 
 <body>
@@ -12,9 +12,11 @@
   <script>
     var engine = window.Liquid();
 
-    var src = '{{ name | capitalize}}';
+    var src = 'Welcome to {{ name | capitalize}}, ' +
+      'access time: {{date|date: "%Y-%m-%d %H:%M:%S"}}';
     var ctx = {
-      name: 'welcome to Shopify Liquid'
+      name: 'Liquid',
+      date: new Date()
     };
     engine.parseAndRender(src, ctx)
       .then(function(html) {
diff --git a/dist/liquid.js b/dist/liquid.js
new file mode 100644
index 000000000..76e9bc97b
--- /dev/null
+++ b/dist/liquid.js
@@ -0,0 +1,2251 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Liquid = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+'use strict';
+
+//const strftime = require('strftime').timezone(-(new Date()).getTimezoneOffset());
+var strftime = require('./src/strftime.js');
+
+module.exports = function (liquid) {
+    liquid.registerFilter('abs', function (v) {
+        return Math.abs(v);
+    });
+    liquid.registerFilter('append', function (v, arg) {
+        return v + arg;
+    });
+    liquid.registerFilter('capitalize', function (str) {
+        return (str || '').charAt(0).toUpperCase() + str.slice(1);
+    });
+    liquid.registerFilter('ceil', function (v) {
+        return Math.ceil(v);
+    });
+
+    //liquid.registerFilter('date', (v, arg) => strftime(arg, v));
+    liquid.registerFilter('date', function (v, arg) {
+        return strftime(v, arg);
+    });
+
+    liquid.registerFilter('default', function (v, arg) {
+        return arg || v;
+    });
+    liquid.registerFilter('divided_by', function (v, arg) {
+        return Math.floor(v / arg);
+    });
+    liquid.registerFilter('downcase', function (v) {
+        return v.toLowerCase();
+    });
+
+    var escapeMap = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&#34;',
+        "'": '&#39;'
+    };
+
+    function escape(str) {
+        return (str || '').replace(/&|<|>|"|'/g, function (m) {
+            return escapeMap[m];
+        });
+    }
+    liquid.registerFilter('escape', escape);
+
+    var unescapeMap = {
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&#34;': '"',
+        '&#39;': "'"
+    };
+
+    function unescape(str) {
+        return (str || '').replace(/&(amp|lt|gt|#34|#39);/g, function (m) {
+            return unescapeMap[m];
+        });
+    }
+    liquid.registerFilter('escape_once', function (str) {
+        return escape(unescape(str));
+    });
+    liquid.registerFilter('first', function (v) {
+        return v[0];
+    });
+    liquid.registerFilter('floor', function (v) {
+        return Math.floor(v);
+    });
+    liquid.registerFilter('join', function (v, arg) {
+        return v.join(arg);
+    });
+    liquid.registerFilter('last', function (v) {
+        return v[v.length - 1];
+    });
+    liquid.registerFilter('lstrip', function (v) {
+        return (v || '').replace(/^\s+/, '');
+    });
+    liquid.registerFilter('map', function (arr, arg) {
+        return arr.map(function (v) {
+            return v[arg];
+        });
+    });
+    liquid.registerFilter('minus', bindFixed(function (v, arg) {
+        return v - arg;
+    }));
+    liquid.registerFilter('modulo', bindFixed(function (v, arg) {
+        return v % arg;
+    }));
+    liquid.registerFilter('newline_to_br', function (v) {
+        return v.replace(/\n/g, '<br />');
+    });
+    liquid.registerFilter('plus', bindFixed(function (v, arg) {
+        return v + arg;
+    }));
+    liquid.registerFilter('prepend', function (v, arg) {
+        return arg + v;
+    });
+    liquid.registerFilter('remove', function (v, arg) {
+        return v.split(arg).join('');
+    });
+    liquid.registerFilter('remove_first', function (v, l) {
+        return v.replace(l, '');
+    });
+    liquid.registerFilter('replace', function (v, pattern, replacement) {
+        return (v || '').split(pattern).join(replacement);
+    });
+    liquid.registerFilter('replace_first', function (v, arg1, arg2) {
+        return (v || '').replace(arg1, arg2);
+    });
+    liquid.registerFilter('reverse', function (v) {
+        return (v || '').reverse();
+    });
+    liquid.registerFilter('round', function (v, arg) {
+        var amp = Math.pow(10, arg || 0);
+        return Math.round(v * amp, arg) / amp;
+    });
+    liquid.registerFilter('rstrip', function (str) {
+        return (str || '').replace(/\s+$/, '');
+    });
+    liquid.registerFilter('size', function (v) {
+        return v.length;
+    });
+    liquid.registerFilter('slice', function (v, begin, length) {
+        return v.substr(begin, length === undefined ? 1 : length);
+    });
+    liquid.registerFilter('sort', function (v, arg) {
+        return (v || '').sort(arg);
+    });
+    liquid.registerFilter('split', function (v, arg) {
+        return (v || '').split(arg);
+    });
+    liquid.registerFilter('strip', function (v) {
+        return (v || '').trim();
+    });
+    liquid.registerFilter('strip_html', function (v) {
+        return (v || '').replace(/<\/?\s*\w+\s*\/?>/g, '');
+    });
+    liquid.registerFilter('strip_newlines', function (v) {
+        return (v || '').replace(/\n/g, '');
+    });
+    liquid.registerFilter('times', function (v, arg) {
+        return v * arg;
+    });
+    liquid.registerFilter('truncate', function (v, l, o) {
+        v = v || '';
+        o = o === undefined ? '...' : o;
+        l = l || 16;
+        if (v.length <= l) return v;
+        return v.substr(0, l - o.length) + o;
+    });
+    liquid.registerFilter('truncatewords', function (v, l, o) {
+        if (o === undefined) o = '...';
+        var arr = v.split(' ');
+        var ret = arr.slice(0, l).join(' ');
+        if (arr.length > l) ret += o;
+        return ret;
+    });
+    liquid.registerFilter('uniq', function (arr) {
+        var u = {};
+        return (arr || []).filter(function (val) {
+            if (u.hasOwnProperty(val)) {
+                return false;
+            }
+            u[val] = true;
+            return true;
+        });
+    });
+    liquid.registerFilter('upcase', function (str) {
+        return (str || '').toUpperCase();
+    });
+    liquid.registerFilter('url_encode', encodeURIComponent);
+};
+
+function getFixed(v) {
+    var p = (v + "").split(".");
+    return p.length > 1 ? p[1].length : 0;
+}
+
+function getMaxFixed(l, r) {
+    return Math.max(getFixed(l), getFixed(r));
+}
+
+function bindFixed(cb) {
+    return function (l, r) {
+        var f = getMaxFixed(l, r);
+        return cb(l, r).toFixed(f);
+    };
+}
+
+},{"./src/strftime.js":14}],2:[function(require,module,exports){
+'use strict';
+
+var Scope = require('./src/scope');
+var tokenizer = require('./src/tokenizer.js');
+var fs = require('fs');
+var Render = require('./src/render.js');
+var lexical = require('./src/lexical.js');
+var Tag = require('./src/tag.js');
+var Filter = require('./src/filter.js');
+var Template = require('./src/parser');
+var Expression = require('./src/expression.js');
+var tags = require('./tags');
+var filters = require('./filters');
+var Promise = require('any-promise');
+
+var _engine = {
+    init: function init(tag, filter, options) {
+        if (options.cache) {
+            this.cache = {};
+        }
+        this.options = options;
+        this.tag = tag;
+        this.filter = filter;
+        this.parser = Template(tag, filter);
+        this.renderer = Render();
+
+        tags(this);
+        filters(this);
+
+        return this;
+    },
+    parse: function parse(html) {
+        var tokens = tokenizer.parse(html);
+        return this.parser.parse(tokens);
+    },
+    render: function render(tpl, ctx, opts) {
+        opts = opts || {};
+        opts.strict_variables = opts.strict_variables || false;
+        opts.strict_filters = opts.strict_filters || false;
+
+        this.renderer.resetRegisters();
+        var scope = Scope.factory(ctx, {
+            strict: opts.strict_variables
+        });
+        return this.renderer.renderTemplates(tpl, scope, opts);
+    },
+    parseAndRender: function parseAndRender(html, ctx, opts) {
+        try {
+            var tpl = this.parse(html);
+            return this.render(tpl, ctx, opts);
+        } catch (error) {
+            // A throw inside of a then or catch of a Promise automatically rejects, but since we mix a sync call
+            //  with an async call, we need to do this in case the sync call throws.
+            return Promise.reject(error);
+        }
+    },
+    renderFile: function renderFile(filepath, ctx, opts) {
+        var _this = this;
+
+        return this.handleCache(filepath).then(function (templates) {
+            return _this.render(templates, ctx, opts);
+        }).catch(function (e) {
+            e.file = filepath;
+            throw e;
+        });
+    },
+    evalOutput: function evalOutput(str, scope) {
+        var tpl = this.parser.parseOutput(str.trim());
+        return this.renderer.evalOutput(tpl, scope);
+    },
+    registerFilter: function registerFilter(name, filter) {
+        return this.filter.register(name, filter);
+    },
+    registerTag: function registerTag(name, tag) {
+        return this.tag.register(name, tag);
+    },
+    handleCache: function handleCache(filepath) {
+        var _this2 = this;
+
+        if (!filepath) throw new Error('filepath cannot be null');
+
+        filepath = resolvePath(this.options.root, filepath);
+
+        if (!filepath.match(/\.\w+$/)) {
+            filepath += this.options.extname;
+        }
+
+        return this.getTemplate(filepath).then(function (html) {
+            var tpl = _this2.options.cache && _this2.cache[filepath] || _this2.parse(html);
+            return _this2.options.cache ? _this2.cache[filepath] = tpl : tpl;
+        });
+    },
+    getTemplate: function getTemplate(filepath) {
+        return new Promise(function (resolve, reject) {
+            fs.readFile(filepath, 'utf8', function (err, html) {
+                err ? reject(err) : resolve(html);
+            });
+        });
+    },
+    express: function express(renderingOptions) {
+        var _this3 = this;
+
+        return function (filePath, options, callback) {
+            _this3.renderFile(filePath, options, renderingOptions).then(function (html) {
+                return callback(null, html);
+            }).catch(function (e) {
+                return callback(e);
+            });
+        };
+    }
+};
+
+function factory(options) {
+    options = options || {};
+    options.root = options.root || '';
+    options.extname = options.extname || '.liquid';
+
+    var engine = Object.create(_engine);
+
+    engine.init(Tag(), Filter(), options);
+    return engine;
+}
+
+function resolvePath(root, path) {
+    if (path[0] == '/') return path;
+
+    var arr = root.split('/').concat(path.split('/'));
+    var result = [];
+    arr.forEach(function (slug) {
+        if (slug == '..') result.pop();else if (!slug || slug == '.') ;else result.push(slug);
+    });
+    return '/' + result.join('/');
+}
+
+factory.lexical = lexical;
+factory.isTruthy = Expression.isTruthy;
+factory.isFalsy = Expression.isFalsy;
+factory.evalExp = Expression.evalExp;
+factory.evalValue = Expression.evalValue;
+
+module.exports = factory;
+
+},{"./filters":1,"./src/expression.js":8,"./src/filter.js":9,"./src/lexical.js":10,"./src/parser":11,"./src/render.js":12,"./src/scope":13,"./src/tag.js":16,"./src/tokenizer.js":17,"./tags":28,"any-promise":3,"fs":6}],3:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./register')().Promise;
+
+},{"./register":5}],4:[function(require,module,exports){
+"use strict";
+// global key for user preferred registration
+
+var REGISTRATION_KEY = '@@any-promise/REGISTRATION',
+
+// Prior registration (preferred or detected)
+registered = null;
+
+/**
+ * Registers the given implementation.  An implementation must
+ * be registered prior to any call to `require("any-promise")`,
+ * typically on application load.
+ *
+ * If called with no arguments, will return registration in
+ * following priority:
+ *
+ * For Node.js:
+ *
+ * 1. Previous registration
+ * 2. global.Promise if node.js version >= 0.12
+ * 3. Auto detected promise based on first sucessful require of
+ *    known promise libraries. Note this is a last resort, as the
+ *    loaded library is non-deterministic. node.js >= 0.12 will
+ *    always use global.Promise over this priority list.
+ * 4. Throws error.
+ *
+ * For Browser:
+ *
+ * 1. Previous registration
+ * 2. window.Promise
+ * 3. Throws error.
+ *
+ * Options:
+ *
+ * Promise: Desired Promise constructor
+ * global: Boolean - Should the registration be cached in a global variable to
+ * allow cross dependency/bundle registration?  (default true)
+ */
+module.exports = function (root, loadImplementation) {
+  return function register(implementation, opts) {
+    implementation = implementation || null;
+    opts = opts || {};
+    // global registration unless explicitly  {global: false} in options (default true)
+    var registerGlobal = opts.global !== false;
+
+    // load any previous global registration
+    if (registered === null && registerGlobal) {
+      registered = root[REGISTRATION_KEY] || null;
+    }
+
+    if (registered !== null && implementation !== null && registered.implementation !== implementation) {
+      // Throw error if attempting to redefine implementation
+      throw new Error('any-promise already defined as "' + registered.implementation + '".  You can only register an implementation before the first ' + ' call to require("any-promise") and an implementation cannot be changed');
+    }
+
+    if (registered === null) {
+      // use provided implementation
+      if (implementation !== null && typeof opts.Promise !== 'undefined') {
+        registered = {
+          Promise: opts.Promise,
+          implementation: implementation
+        };
+      } else {
+        // require implementation if implementation is specified but not provided
+        registered = loadImplementation(implementation);
+      }
+
+      if (registerGlobal) {
+        // register preference globally in case multiple installations
+        root[REGISTRATION_KEY] = registered;
+      }
+    }
+
+    return registered;
+  };
+};
+
+},{}],5:[function(require,module,exports){
+"use strict";
+
+module.exports = require('./loader')(window, loadImplementation);
+
+/**
+ * Browser specific loadImplementation.  Always uses `window.Promise`
+ *
+ * To register a custom implementation, must register with `Promise` option.
+ */
+function loadImplementation() {
+  if (typeof window.Promise === 'undefined') {
+    throw new Error("any-promise browser requires a polyfill or explicit registration" + " e.g: require('any-promise/register/bluebird')");
+  }
+  return {
+    Promise: window.Promise,
+    implementation: 'window.Promise'
+  };
+}
+
+},{"./loader":4}],6:[function(require,module,exports){
+"use strict";
+
+},{}],7:[function(require,module,exports){
+"use strict";
+
+function TokenizationError(message, input, line) {
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+
+    this.message = message || "";
+    this.input = input;
+    this.line = line;
+}
+TokenizationError.prototype = Object.create(Error.prototype);
+TokenizationError.prototype.constructor = TokenizationError;
+
+function ParseError(message, input, line, e) {
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.originalError = e;
+
+    this.message = message || "";
+    this.input = input;
+    this.line = line;
+}
+ParseError.prototype = Object.create(Error.prototype);
+ParseError.prototype.constructor = ParseError;
+
+module.exports = {
+    TokenizationError: TokenizationError, ParseError: ParseError
+};
+
+},{}],8:[function(require,module,exports){
+'use strict';
+
+var syntax = require('./syntax.js');
+var lexical = require('./lexical.js');
+
+function evalExp(exp, scope) {
+    if (!scope) throw new Error('unable to evalExp: scope undefined');
+    var operatorREs = lexical.operators,
+        match;
+    for (var i = 0; i < operatorREs.length; i++) {
+        var operatorRE = operatorREs[i];
+        var expRE = new RegExp('^(' + lexical.quoteBalanced.source + ')(' + operatorRE.source + ')(' + lexical.quoteBalanced.source + ')$');
+        if (match = exp.match(expRE)) {
+            var l = evalExp(match[1], scope);
+            var op = syntax.operators[match[2].trim()];
+            var r = evalExp(match[3], scope);
+            return op(l, r);
+        }
+    }
+
+    if (match = exp.match(lexical.rangeLine)) {
+        var low = evalValue(match[1], scope),
+            high = evalValue(match[2], scope);
+        var range = [];
+        for (var j = low; j <= high; j++) {
+            range.push(j);
+        }
+        return range;
+    }
+
+    return evalValue(exp, scope);
+}
+
+function evalValue(str, scope) {
+    str = str && str.trim();
+    if (!str) return undefined;
+
+    if (lexical.isLiteral(str)) {
+        return lexical.parseLiteral(str);
+    }
+    if (lexical.isVariable(str)) {
+        return scope.get(str);
+    }
+}
+
+function isTruthy(val) {
+    if (val instanceof Array) return !!val.length;
+    return !!val;
+}
+
+function isFalsy(val) {
+    return !isTruthy(val);
+}
+
+module.exports = {
+    evalExp: evalExp, evalValue: evalValue, isTruthy: isTruthy, isFalsy: isFalsy
+};
+
+},{"./lexical.js":10,"./syntax.js":15}],9:[function(require,module,exports){
+'use strict';
+
+var lexical = require('./lexical.js');
+var Exp = require('./expression.js');
+
+var valueRE = new RegExp('' + lexical.value.source, 'g');
+
+module.exports = function () {
+    var filters = {};
+
+    var _filterInstance = {
+        render: function render(output, scope) {
+            var args = this.args.map(function (arg) {
+                return Exp.evalValue(arg, scope);
+            });
+            args.unshift(output);
+            return this.filter.apply(null, args);
+        },
+        parse: function parse(str) {
+            var match = lexical.filterLine.exec(str);
+            if (!match) throw new Error('illegal filter: ' + str);
+
+            var name = match[1],
+                argList = match[2] || '',
+                filter = filters[name];
+            if (typeof filter !== 'function') {
+                return {
+                    name: name,
+                    error: new Error('undefined filter: ' + name)
+                };
+            }
+
+            var args = [];
+            while (match = valueRE.exec(argList.trim())) {
+                args.push(match[0]);
+            }
+
+            this.name = name;
+            this.filter = filter;
+            this.args = args;
+
+            return this;
+        }
+    };
+
+    function construct(str) {
+        var instance = Object.create(_filterInstance);
+        return instance.parse(str);
+    }
+
+    function register(name, filter) {
+        filters[name] = filter;
+    }
+
+    function clear() {
+        filters = {};
+    }
+
+    return {
+        construct: construct, register: register, clear: clear
+    };
+};
+
+},{"./expression.js":8,"./lexical.js":10}],10:[function(require,module,exports){
+'use strict';
+
+// quote related
+var singleQuoted = /'[^']*'/;
+var doubleQuoted = /"[^"]*"/;
+var quoteBalanced = new RegExp('(?:' + singleQuoted.source + '|' + doubleQuoted.source + '|[^\'"])*');
+
+var number = /(?:-?\d+\.?\d*|\.?\d+)/;
+var bool = /true|false/;
+var identifier = /[a-zA-Z_$][a-zA-Z_$0-9]*/;
+var subscript = /\[\d+\]/;
+
+var quoted = new RegExp('(?:' + singleQuoted.source + '|' + doubleQuoted.source + ')');
+var literal = new RegExp('(?:' + quoted.source + '|' + bool.source + '|' + number.source + ')');
+var variable = new RegExp(identifier.source + '(?:\\.' + identifier.source + '|' + subscript.source + ')*');
+
+// range related
+var rangeLimit = new RegExp('(?:' + variable.source + '|' + number.source + ')');
+var range = new RegExp('\\(' + rangeLimit.source + '\\.\\.' + rangeLimit.source + '\\)');
+var rangeCapture = new RegExp('\\((' + rangeLimit.source + ')\\.\\.(' + rangeLimit.source + ')\\)');
+
+var value = new RegExp('(?:' + literal.source + '|' + variable.source + '|' + range.source + ')');
+
+// hash related
+var hash = new RegExp('(?:' + identifier.source + ')\\s*:\\s*(?:' + value.source + ')');
+var hashCapture = new RegExp('(' + identifier.source + ')\\s*:\\s*(' + value.source + ')', 'g');
+
+var tagLine = new RegExp('^\\s*(' + identifier.source + ')\\s*(.*)\\s*$');
+var literalLine = new RegExp('^' + literal.source + '$', 'i');
+var variableLine = new RegExp('^' + variable.source + '$');
+var numberLine = new RegExp('^' + number.source + '$');
+var boolLine = new RegExp('^' + bool.source + '$', 'i');
+var quotedLine = new RegExp('^' + quoted.source + '$');
+var rangeLine = new RegExp('^' + rangeCapture.source + '$');
+
+// filter related
+var valueList = new RegExp(value.source + '(\\s*,\\s*' + value.source + ')*');
+var filter = new RegExp(identifier.source + '(?:\\s*:\\s*' + valueList.source + ')?', 'g');
+var filterCapture = new RegExp('(' + identifier.source + ')(?:\\s*:\\s*(' + valueList.source + '))?');
+var filterLine = new RegExp('^' + filterCapture.source + '$');
+
+var operators = [/\s+or\s+/, /\s+and\s+/, /==|!=|<=|>=|<|>|\s+contains\s+/];
+
+function isLiteral(str) {
+    return literalLine.test(str);
+}
+
+function isRange(str) {
+    return rangeLine.test(str);
+}
+
+function isVariable(str) {
+    return variableLine.test(str);
+}
+
+function parseLiteral(str) {
+    var res;
+    if (res = str.match(numberLine)) {
+        return Number(str);
+    }
+    if (res = str.match(boolLine)) {
+        return str.toLowerCase() === 'true';
+    }
+    if (res = str.match(quotedLine)) {
+        return str.slice(1, -1);
+    }
+}
+
+module.exports = {
+    quoted: quoted, number: number, bool: bool, literal: literal, filter: filter,
+    hash: hash, hashCapture: hashCapture,
+    range: range, rangeCapture: rangeCapture,
+    identifier: identifier, value: value, quoteBalanced: quoteBalanced, operators: operators,
+    quotedLine: quotedLine, numberLine: numberLine, boolLine: boolLine, rangeLine: rangeLine, literalLine: literalLine, filterLine: filterLine, tagLine: tagLine,
+    isLiteral: isLiteral, isVariable: isVariable, parseLiteral: parseLiteral, isRange: isRange
+};
+
+},{}],11:[function(require,module,exports){
+'use strict';
+
+var lexical = require('./lexical.js');
+var ParseError = require('./error.js').ParseError;
+
+module.exports = function (Tag, Filter) {
+
+    var stream = {
+        init: function init(tokens) {
+            this.tokens = tokens;
+            this.handlers = {};
+            return this;
+        },
+        on: function on(name, cb) {
+            this.handlers[name] = cb;
+            return this;
+        },
+        trigger: function trigger(event, arg) {
+            var h = this.handlers[event];
+            if (typeof h === 'function') {
+                h(arg);
+                return true;
+            }
+        },
+        start: function start() {
+            this.trigger('start');
+            var token;
+            while (!this.stopRequested && (token = this.tokens.shift())) {
+                if (this.trigger('token', token)) continue;
+                if (token.type == 'tag' && this.trigger('tag:' + token.name, token)) {
+                    continue;
+                }
+                var template = parseToken(token, this.tokens);
+                this.trigger('template', template);
+            }
+            if (!this.stopRequested) this.trigger('end');
+            return this;
+        },
+        stop: function stop() {
+            this.stopRequested = true;
+            return this;
+        }
+    };
+
+    function parse(tokens) {
+        var token,
+            templates = [];
+        while (token = tokens.shift()) {
+            templates.push(parseToken(token, tokens));
+        }
+        return templates;
+    }
+
+    function parseToken(token, tokens) {
+        try {
+            switch (token.type) {
+                case 'tag':
+                    return parseTag(token, tokens);
+                case 'output':
+                    return parseOutput(token.value);
+                case 'html':
+                    return token;
+            }
+        } catch (e) {
+            throw new ParseError(e.message, token.input, token.line, e);
+        }
+    }
+
+    function parseTag(token, tokens) {
+        if (token.name === 'continue' || token.name === 'break') return token;
+        return Tag.construct(token, tokens);
+    }
+
+    function parseOutput(str) {
+        var match = lexical.value.exec(str);
+        if (!match) throw new Error('illegal output string: ' + str);
+
+        var initial = match[0];
+        str = str.substr(match.index + match[0].length);
+
+        var filters = [];
+        while (match = lexical.filter.exec(str)) {
+            filters.push([match[0].trim()]);
+        }
+
+        return {
+            type: 'output',
+            initial: initial,
+            filters: filters.map(function (str) {
+                return Filter.construct(str);
+            })
+        };
+    }
+
+    function parseStream(tokens) {
+        var s = Object.create(stream);
+        return s.init(tokens);
+    }
+
+    return {
+        parse: parse, parseTag: parseTag, parseStream: parseStream, parseOutput: parseOutput
+    };
+};
+
+},{"./error.js":7,"./lexical.js":10}],12:[function(require,module,exports){
+'use strict';
+
+var Exp = require('./expression.js');
+var Promise = require('any-promise');
+
+var render = {
+
+    renderTemplates: function renderTemplates(templates, scope, opts) {
+        var _this = this;
+
+        if (!scope) throw new Error('unable to evalTemplates: scope undefined');
+        opts = opts || {};
+        opts.strict_filters = opts.strict_filters || false;
+
+        var html = '';
+
+        // This executes an array of promises sequentially for every template in the templates array - http://webcache.googleusercontent.com/search?q=cache:rNbMUn9TPtkJ:joost.vunderink.net/blog/2014/12/15/processing-an-array-of-promises-sequentially-in-node-js/+&cd=5&hl=en&ct=clnk&gl=us
+        // It's fundamentally equivalent to the following...
+        //  emptyPromise.then(renderTag(template0).then(renderTag(template1).then(renderTag(template2)...
+        var lastPromise = templates.reduce(function (promise, template) {
+            return promise.then(function (partial) {
+                if (scope.safeGet('forloop.skip')) {
+                    return Promise.resolve('');
+                }
+                if (scope.safeGet('forloop.stop')) {
+                    throw new Error('forloop.stop'); // this will stop/break the sequential promise chain and go to the catch
+                }
+
+                var promiseLink = Promise.resolve('');
+                switch (template.type) {
+                    case 'tag':
+                        // Add Promises to the chain
+                        promiseLink = _this.renderTag(template, scope, _this.register).then(function (partial) {
+                            if (partial === undefined) {
+                                return true; // basically a noop (do nothing)
+                            }
+                            return html += partial;
+                        });
+                        break;
+                    case 'html':
+                        promiseLink = Promise.resolve(template.value).then(function (partial) {
+                            return html += partial;
+                        });
+                        break;
+                    case 'output':
+                        var val = _this.evalOutput(template, scope, opts);
+                        promiseLink = Promise.resolve(val === undefined ? '' : stringify(val)).then(function (partial) {
+                            return html += partial;
+                        });
+                        break;
+                }
+
+                return promiseLink;
+            }).catch(function (error) {
+                if (error.message === 'forloop.skip') {
+                    // the error is a controlled, purposeful stop. so just return the html that we have up to this point
+                    return html;
+                } else {
+                    // rethrow actual error
+                    throw error;
+                }
+            });
+        }, Promise.resolve('')); // start the reduce chain with a resolved Promise. After first run, the "promise" argument
+        //  in our reduce callback will be the returned promise from our "then" above.  In this
+        //  case, that's the promise returned from this.renderTag or a resolved promise with raw html.
+
+        return lastPromise.then(function (renderedHtml) {
+            return renderedHtml;
+        }).catch(function (error) {
+            throw error;
+        });
+    },
+
+    renderTag: function renderTag(template, scope, register) {
+        if (template.name === 'continue') {
+            scope.set('forloop.skip', true);
+            return Promise.resolve('');
+        }
+        if (template.name === 'break') {
+            scope.set('forloop.stop', true);
+            scope.set('forloop.skip', true);
+            return Promise.reject(new Error('forloop.stop')); // this will stop the sequential promise chain
+        }
+        return template.render(scope, register);
+    },
+
+    evalOutput: function evalOutput(template, scope, opts) {
+        if (!scope) throw new Error('unable to evalOutput: scope undefined');
+        var val = Exp.evalExp(template.initial, scope);
+        template.filters.some(function (filter) {
+            if (filter.error) {
+                if (opts.strict_filters) {
+                    throw filter.error;
+                } else {
+                    // render as null
+                    val = '';
+                    return true;
+                }
+            }
+            val = filter.render(val, scope);
+        });
+        return val;
+    },
+
+    resetRegisters: function resetRegisters() {
+        return this.register = {};
+    }
+};
+
+function factory() {
+    var instance = Object.create(render);
+    instance.register = {};
+    return instance;
+}
+
+function stringify(val) {
+    if (typeof val === 'string') return val;
+    return JSON.stringify(val);
+}
+
+module.exports = factory;
+
+},{"./expression.js":8,"any-promise":3}],13:[function(require,module,exports){
+'use strict';
+
+var Scope = {
+    safeGet: function safeGet(str) {
+        var i;
+        // get all
+        if (str === undefined) {
+            var ctx = {};
+            for (i = this.scopes.length - 1; i >= 0; i--) {
+                var scp = this.scopes[i];
+                for (var k in scp) {
+                    if (scp.hasOwnProperty(k)) {
+                        ctx[k] = scp[k];
+                    }
+                }
+            }
+            return ctx;
+        }
+        // get one path
+        for (i = this.scopes.length - 1; i >= 0; i--) {
+            var v = getPropertyByPath(this.scopes[i], str);
+            if (v !== undefined) return v;
+        }
+    },
+    get: function get(str) {
+        var val = this.safeGet(str);
+        if (val === undefined && this.opts.strict) {
+            throw new Error('[strict_variables] undefined variable: ' + str);
+        }
+        return val;
+    },
+    set: function set(k, v) {
+        setPropertyByPath(this.scopes[this.scopes.length - 1], k, v);
+        return this;
+    },
+    push: function push(ctx) {
+        if (!ctx) throw new Error('trying to push ' + ctx + ' into scopes');
+        return this.scopes.push(ctx);
+    },
+    pop: function pop() {
+        return this.scopes.pop();
+    }
+};
+
+function setPropertyByPath(obj, path, val) {
+    if (path instanceof String || typeof path === 'string') {
+        var paths = path.replace(/\[/g, '.').replace(/\]/g, '').split('.');
+        for (var i = 0; i < paths.length; i++) {
+            var key = paths[i];
+            if (i === paths.length - 1) {
+                return obj[key] = val;
+            }
+            if (undefined === obj[key]) obj[key] = {};
+            // case for readonly objects
+            obj = obj[key] || {};
+        }
+        return obj;
+    }
+    return obj[path] = val;
+}
+
+function getPropertyByPath(obj, path) {
+    if (path instanceof String || typeof path === 'string') {
+        var paths = path.replace(/\[/g, '.').replace(/\]/g, '').split('.');
+        paths.forEach(function (p) {
+            return obj = obj && obj[p];
+        });
+        return obj;
+    }
+    return obj[path];
+}
+
+exports.factory = function (_ctx, opts) {
+    opts = opts || {};
+    opts.strict = opts.strict || false;
+
+    var scope = Object.create(Scope);
+    scope.opts = opts;
+    scope.scopes = [_ctx || {}];
+    return scope;
+};
+
+},{}],14:[function(require,module,exports){
+"use strict";
+
+var monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var monthNamesShort = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var dayNamesShort = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var suffixes = {
+    1: 'st',
+    2: 'nd',
+    3: 'rd',
+    'default': 'th'
+};
+
+// prototype extensions
+var _date = {
+    daysInMonth: function daysInMonth(d) {
+        var feb = _date.isLeapYear(d) ? 29 : 28;
+        return [31, feb, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    },
+
+    getTimezone: function getTimezone(d) {
+        return d.toString().replace(/^.*? ([A-Z]{3}) [0-9]{4}.*$/, "$1").replace(/^.*?\(([A-Z])[a-z]+ ([A-Z])[a-z]+ ([A-Z])[a-z]+\)$/, "$1$2$3");
+    },
+
+    getGMTOffset: function getGMTOffset(d) {
+        return (d.getTimezoneOffset() > 0 ? "-" : "+") + _number.pad(Math.floor(d.getTimezoneOffset() / 60), 2) + _number.pad(d.getTimezoneOffset() % 60, 2);
+    },
+
+    getDayOfYear: function getDayOfYear(d) {
+        var num = 0;
+        for (var i = 0; i < d.getMonth(); ++i) {
+            num += _date.daysInMonth(d)[i];
+        }
+        return num + d.getDate();
+    },
+
+    // Startday is an integer of which day to start the week measuring from
+    // TODO: that comment was retarted. fix it.
+    getWeekOfYear: function getWeekOfYear(d, startDay) {
+        // Skip to startDay of this week
+        var now = this.getDayOfYear(d) + (startDay - d.getDay());
+        // Find the first startDay of the year
+        var jan1 = new Date(d.getFullYear(), 0, 1);
+        var then = 7 - jan1.getDay() + startDay;
+        return _number.pad(Math.floor((now - then) / 7) + 1, 2);
+    },
+
+    isLeapYear: function isLeapYear(d) {
+        var year = d.getFullYear();
+        return !!((year & 3) === 0 && (year % 100 || year % 400 === 0 && year));
+    },
+
+    getFirstDayOfMonth: function getFirstDayOfMonth(d) {
+        var day = (d.getDay() - (d.getDate() - 1)) % 7;
+        return day < 0 ? day + 7 : day;
+    },
+
+    getLastDayOfMonth: function getLastDayOfMonth(d) {
+        var day = (d.getDay() + (_date.daysInMonth(d)[d.getMonth()] - d.getDate())) % 7;
+        return day < 0 ? day + 7 : day;
+    },
+
+    getSuffix: function getSuffix(d) {
+        var str = d.getDate().toString();
+        var index = parseInt(str.slice(-1));
+        return suffixes[index] || suffixes['default'];
+    },
+
+    applyOffset: function applyOffset(date, offset_seconds) {
+        date.setTime(date.valueOf() - offset_seconds * 1000);
+        return date;
+    },
+
+    century: function century(d) {
+        return parseInt(d.getFullYear().toString().substring(0, 2), 10);
+    }
+};
+
+var _obj = {
+    values_of: function values_of(obj) {
+        var values = [];
+        for (var k in obj) {
+            if (obj.hasOwnProperty(k)) {
+                values.push(obj[k]);
+            }
+        }
+        return values;
+    }
+};
+
+var _number = {
+    pad: function pad(value, size, ch) {
+        if (!ch) ch = '0';
+        var result = value.toString();
+        var pad = size - result.length;
+
+        while (pad-- > 0) {
+            result = ch + result;
+        }
+
+        return result;
+    }
+};
+
+var format_codes = {
+    a: function a(d) {
+        return dayNamesShort[d.getDay()];
+    },
+    A: function A(d) {
+        return dayNames[d.getDay()];
+    },
+    b: function b(d) {
+        return monthNamesShort[d.getMonth()];
+    },
+    B: function B(d) {
+        return monthNames[d.getMonth()];
+    },
+    c: function c(d) {
+        return d.toLocaleString();
+    },
+    C: function C(d) {
+        return _date.century(d);
+    },
+    d: function d(_d) {
+        return _number.pad(_d.getDate(), 2);
+    },
+    e: function e(d) {
+        return _number.pad(d.getDate(), 2, ' ');
+    },
+    H: function H(d) {
+        return _number.pad(d.getHours(), 2);
+    },
+    I: function I(d) {
+        return _number.pad(d.getHours() % 12 || 12, 2);
+    },
+    j: function j(d) {
+        return _number.pad(_date.getDayOfYear(d), 3);
+    },
+    k: function k(d) {
+        return _number.pad(d.getHours(), 2, ' ');
+    },
+    l: function l(d) {
+        return _number.pad(d.getHours() % 12 || 12, 2, ' ');
+    },
+    L: function L(d) {
+        return _number.pad(d.getMilliseconds(), 3);
+    },
+    m: function m(d) {
+        return _number.pad(d.getMonth() + 1, 2);
+    },
+    M: function M(d) {
+        return _number.pad(d.getMinutes(), 2);
+    },
+    p: function p(d) {
+        return d.getHours() < 12 ? 'AM' : 'PM';
+    },
+    P: function P(d) {
+        return d.getHours() < 12 ? 'am' : 'pm';
+    },
+    q: function q(d) {
+        return _date.getSuffix(d);
+    },
+    s: function s(d) {
+        return Math.round(d.valueOf() / 1000);
+    },
+    S: function S(d) {
+        return _number.pad(d.getSeconds(), 2);
+    },
+    u: function u(d) {
+        return d.getDay() || 7;
+    },
+    U: function U(d) {
+        return _date.getWeekOfYear(d, 0);
+    },
+    w: function w(d) {
+        return d.getDay();
+    },
+    W: function W(d) {
+        return _date.getWeekOfYear(d, 1);
+    },
+    x: function x(d) {
+        return d.toLocaleDateString();
+    },
+    X: function X(d) {
+        return d.toLocaleTimeString();
+    },
+    y: function y(d) {
+        return d.getFullYear().toString().substring(2, 4);
+    },
+    Y: function Y(d) {
+        return d.getFullYear();
+    },
+    // TODO: guessing the pad function won't work with negative numbers?
+    // TODO: getTimezoneOffset returns a positive number for GMT-7. Verify my
+    // assumption that it will return negative for GMT+x
+    z: function z(d) {
+        var tz = d.getTimezoneOffset() / 60 * 100;
+        return (tz > 0 ? '-' : '+') + _number.pad(tz, 4);
+    },
+    "%": function _() {
+        return '%';
+    }
+};
+format_codes.h = format_codes.b;
+format_codes.N = format_codes.L;
+
+// * r stands for regex, p stands for parser
+// * all parseInt calls have to have the base supplied as the second
+//   parameter, otherwise they will default to octal when parsing numbers
+//   with leading zeros. This is most evident when parsing a date with 08 as
+//   the minutes / year as 08 is an invalid octal number, and so returns 0
+var parse_codes = {
+    a: {
+        r: "(?:" + dayNamesShort.join("|") + ")"
+    },
+    A: {
+        r: "(?:" + dayNames.join("|") + ")"
+    },
+    b: {
+        r: "(" + monthNamesShort.join("|") + ")",
+        p: function p(data) {
+            this.month = $.inArray(data, monthNamesShort);
+        }
+    },
+    B: {
+        r: "(" + monthNames.join("|") + ")",
+        p: function p(data) {
+            this.month = $.inArray(data, monthNames);
+        }
+    },
+    C: {
+        r: "(\\d{1,2})",
+        p: function p(d) {
+            this.century = parseInt(d, 10);
+        }
+    },
+    d: {
+        r: "(\\d{1,2})",
+        p: function p(d) {
+            this.day = parseInt(d, 10);
+        }
+    },
+    H: {
+        r: "(\\d{1,2})",
+        p: function p(d) {
+            this.hour = parseInt(d, 10);
+        }
+    },
+    // This gives only the day. Parsing of the month happens at the end because
+    // we also need the year
+    j: {
+        r: "(\\d{1,3})",
+        p: function p(d) {
+            this.day = parseInt(d, 10);
+        }
+    },
+    L: {
+        r: "(\\d{3})",
+        p: function p(d) {
+            this.milliseconds = parseInt(d, 10);
+        }
+    },
+    m: {
+        r: "(\\d{1,2})",
+        p: function p(d) {
+            this.month = parseInt(d, 10) - 1;
+        }
+    },
+    M: {
+        r: "(\\d{2})",
+        p: function p(d) {
+            this.minute = parseInt(d, 10);
+        }
+    },
+    p: {
+        r: "(AM|PM)",
+        p: function p(d) {
+            if (d == 'AM') {
+                if (this.hour == 12) {
+                    this.hour = 0;
+                }
+            } else {
+                if (this.hour < 12) {
+                    this.hour += 12;
+                }
+            }
+        }
+    },
+    P: {
+        r: "(am|pm)",
+        p: function p(d) {
+            if (d == 'am') {
+                if (this.hour == 12) {
+                    this.hour = 0;
+                }
+            } else {
+                if (this.hour < 12) {
+                    this.hour += 12;
+                }
+            }
+        }
+    },
+    q: {
+        r: "(?:" + _obj.values_of(suffixes).join('|') + ")"
+    },
+    S: {
+        r: "(\\d{2})",
+        p: function p(d) {
+            this.second = parseInt(d, 10);
+        }
+    },
+    y: {
+        r: "(\\d{1,2})",
+        p: function p(d) {
+            this.year = parseInt(d, 10);
+        }
+    },
+    Y: {
+        r: "(\\d{4})",
+        p: function p(d) {
+            this.century = Math.floor(parseInt(d, 10) / 100);
+            this.year = parseInt(d, 10) % 100;
+        }
+    },
+    z: { // "Z", "+05:00", "+0500" all acceptable.
+        r: "(Z|[+-]\\d{2}:?\\d{2})",
+        p: function p(d) {
+            // UTC, no offset.
+            if (d == "Z") {
+                this.zone = 0;
+                return;
+            }
+
+            var seconds = parseInt(d[0] + d[1] + d[2], 10) * 3600; // e.g., "+05" or "-08"
+            if (d[3] == ":") {
+                // "+HH:MM" is preferred iso8601 format
+                seconds += parseInt(d[4] + d[5], 10) * 60;
+            } else {
+                // "+HHMM" is frequently used, though.
+                seconds += parseInt(d[3] + d[4], 10) * 60;
+            }
+            this.zone = seconds;
+        }
+    }
+};
+parse_codes.e = parse_codes.d;
+parse_codes.h = parse_codes.b;
+parse_codes.I = parse_codes.H;
+parse_codes.k = parse_codes.H;
+parse_codes.l = parse_codes.H;
+
+var strftime = function strftime(d, format) {
+    // I used to use string split with a regex and a capturing block here,
+    // which I thought was really clever, but apparently this exact feature is
+    // fucked in IE. In every other browser (and languages), the captured
+    // blocks are present in the output. E.g.
+    // var pairs = "hello%athere".split(/(%.)/);
+    // => ['hello', '%a', 'there']
+    // IE however, just treats it the same as if no capturing block is present
+    // => ['hello', 'there']
+    // An alternate implementation of split is available here
+    // http://blog.stevenlevithan.com/archives/cross-browser-split
+    // Because that's a large amount of code for this one specific use case,
+    // I've just decided to loop through a regex instead.
+
+    var output = '';
+    var remaining = format;
+
+    while (true) {
+        var r = /%./g;
+        var results = r.exec(remaining);
+
+        // No more format codes. Add the remaining text and return
+        if (!results) {
+            return output + remaining;
+        }
+
+        // Add the preceding text
+        output += remaining.slice(0, r.lastIndex - 2);
+        remaining = remaining.slice(r.lastIndex);
+
+        // Add the format code
+        var ch = results[0].charAt(1);
+        var func = format_codes[ch];
+        output += func ? func.call(this, d) : '%' + ch;
+    }
+};
+
+module.exports = strftime;
+
+},{}],15:[function(require,module,exports){
+'use strict';
+
+var operators = {
+    '==': function _(l, r) {
+        return l == r;
+    },
+    '!=': function _(l, r) {
+        return l != r;
+    },
+    '>': function _(l, r) {
+        return l > r;
+    },
+    '<': function _(l, r) {
+        return l < r;
+    },
+    '>=': function _(l, r) {
+        return l >= r;
+    },
+    '<=': function _(l, r) {
+        return l <= r;
+    },
+    'contains': function contains(l, r) {
+        return l.indexOf(r) > -1;
+    },
+    'and': function and(l, r) {
+        return l && r;
+    },
+    'or': function or(l, r) {
+        return l || r;
+    }
+};
+
+exports.operators = operators;
+
+},{}],16:[function(require,module,exports){
+'use strict';
+
+var lexical = require('./lexical.js');
+var Promise = require('any-promise');
+var Exp = require('./expression.js');
+
+function hash(markup, scope) {
+    var obj = {},
+        match;
+    lexical.hashCapture.lastIndex = 0;
+    while (match = lexical.hashCapture.exec(markup)) {
+        var k = match[1],
+            v = match[2];
+        obj[k] = Exp.evalValue(v, scope);
+    }
+    return obj;
+}
+
+module.exports = function () {
+    var tagImpls = {};
+
+    var _tagInstance = {
+        render: function render(scope, register) {
+            var reg = register[this.name];
+            if (!reg) reg = register[this.name] = {};
+            var obj = hash(this.token.args, scope);
+            return this.tagImpl.render && this.tagImpl.render(scope, obj, reg) || Promise.resolve('');
+        },
+        parse: function parse(token, tokens) {
+            this.type = 'tag';
+            this.token = token;
+            this.name = token.name;
+
+            var tagImpl = tagImpls[this.name];
+            if (!tagImpl) throw new Error('tag ' + this.name + ' not found');
+            this.tagImpl = Object.create(tagImpl);
+            if (this.tagImpl.parse) {
+                this.tagImpl.parse(token, tokens);
+            }
+        }
+    };
+
+    function register(name, tag) {
+        tagImpls[name] = tag;
+    }
+
+    function construct(token, tokens) {
+        var instance = Object.create(_tagInstance);
+        instance.parse(token, tokens);
+        return instance;
+    }
+
+    function clear() {
+        tagImpls = {};
+    }
+
+    return {
+        construct: construct, register: register, clear: clear
+    };
+};
+
+},{"./expression.js":8,"./lexical.js":10,"any-promise":3}],17:[function(require,module,exports){
+'use strict';
+
+var lexical = require('./lexical.js');
+var TokenizationError = require('./error.js').TokenizationError;
+
+function parse(html) {
+    var tokens = [];
+    if (!html) return tokens;
+
+    var syntax = /({%(.*?)%})|({{(.*?)}})/g;
+    var result, htmlFragment, token;
+    var lastMatchEnd = 0,
+        lastMatchBegin = -1,
+        parsedLinesCount = 0;
+
+    while ((result = syntax.exec(html)) !== null) {
+        // passed html fragments
+        if (result.index > lastMatchEnd) {
+            htmlFragment = html.slice(lastMatchEnd, result.index);
+            tokens.push({
+                type: 'html',
+                raw: htmlFragment,
+                value: htmlFragment
+            });
+        }
+        // tag appeared
+        if (result[1]) {
+            token = factory('tag', 1, result);
+
+            var match = token.value.match(lexical.tagLine);
+            if (!match) {
+                throw new TokenizationError('illegal tag: ' + token.raw, token.input, token.line);
+            }
+            token.name = match[1];
+            token.args = match[2];
+
+            tokens.push(token);
+        }
+        // output
+        else {
+                token = factory('output', 3, result);
+                tokens.push(token);
+            }
+        lastMatchEnd = syntax.lastIndex;
+    }
+
+    // remaining html
+    if (html.length > lastMatchEnd) {
+        htmlFragment = html.slice(lastMatchEnd, html.length);
+        tokens.push({
+            type: 'html',
+            raw: htmlFragment,
+            value: htmlFragment
+        });
+    }
+    return tokens;
+
+    function factory(type, offset, match) {
+        return {
+            type: type,
+            raw: match[offset],
+            value: match[offset + 1].trim(),
+            line: getLineNum(match),
+            input: getLineContent(match)
+        };
+    }
+
+    function getLineContent(match) {
+        var idx1 = match.input.lastIndexOf('\n', match.index);
+        var idx2 = match.input.indexOf('\n', match.index);
+        if (idx2 === -1) idx2 = match.input.length;
+        return match.input.slice(idx1 + 1, idx2);
+    }
+
+    function getLineNum(match) {
+        var lines = match.input.slice(lastMatchBegin + 1, match.index).split('\n');
+        parsedLinesCount += lines.length - 1;
+        lastMatchBegin = match.index;
+        return parsedLinesCount + 1;
+    }
+}
+
+exports.parse = parse;
+
+},{"./error.js":7,"./lexical.js":10}],18:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var lexical = Liquid.lexical;
+var Promise = require('any-promise');
+var re = new RegExp('(' + lexical.identifier.source + ')\\s*=(.*)');
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('assign', {
+        parse: function parse(token) {
+            var match = token.args.match(re);
+            if (!match) throw new Error('illegal token ' + token.raw);
+            this.key = match[1];
+            this.value = match[2];
+        },
+        render: function render(scope, hash) {
+            scope.set(this.key, liquid.evalOutput(this.value, scope));
+            return Promise.resolve('');
+        }
+    });
+};
+
+},{"..":2,"any-promise":3}],19:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var lexical = Liquid.lexical;
+var re = new RegExp('(' + lexical.identifier.source + ')');
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('capture', {
+        parse: function parse(tagToken, remainTokens) {
+            var _this = this;
+
+            var match = tagToken.args.match(re);
+            if (!match) throw new Error(tagToken.args + ' not valid identifier');
+
+            this.variable = match[1];
+            this.templates = [];
+
+            var stream = liquid.parser.parseStream(remainTokens);
+            stream.on('tag:endcapture', function (token) {
+                return stream.stop();
+            }).on('template', function (tpl) {
+                return _this.templates.push(tpl);
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+            stream.start();
+        },
+        render: function render(scope, hash) {
+            var _this2 = this;
+
+            return liquid.renderer.renderTemplates(this.templates, scope).then(function (html) {
+                scope.set(_this2.variable, html);
+            });
+        }
+    });
+};
+
+},{"..":2}],20:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+
+module.exports = function (liquid) {
+    liquid.registerTag('case', {
+
+        parse: function parse(tagToken, remainTokens) {
+            var _this = this;
+
+            this.cond = tagToken.args;
+            this.cases = [];
+            this.elseTemplates = [];
+
+            var p = [],
+                stream = liquid.parser.parseStream(remainTokens).on('tag:when', function (token) {
+                if (!_this.cases[token.args]) {
+                    _this.cases.push({
+                        val: token.args,
+                        templates: p = []
+                    });
+                }
+            }).on('tag:else', function (token) {
+                return p = _this.elseTemplates;
+            }).on('tag:endcase', function (token) {
+                return stream.stop();
+            }).on('template', function (tpl) {
+                return p.push(tpl);
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+
+            stream.start();
+        },
+
+        render: function render(scope, hash) {
+            for (var i = 0; i < this.cases.length; i++) {
+                var branch = this.cases[i];
+                var val = Liquid.evalExp(branch.val, scope);
+                var cond = Liquid.evalExp(this.cond, scope);
+                if (val === cond) {
+                    return liquid.renderer.renderTemplates(branch.templates, scope);
+                }
+            }
+            return liquid.renderer.renderTemplates(this.elseTemplates, scope);
+        }
+
+    });
+};
+
+},{"..":2}],21:[function(require,module,exports){
+'use strict';
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('comment', {
+        parse: function parse(tagToken, remainTokens) {
+            var stream = liquid.parser.parseStream(remainTokens);
+            stream.on('token', function (token) {
+                if (token.name === 'endcomment') stream.stop();
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+            stream.start();
+        }
+    });
+};
+
+},{}],22:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var Promise = require('any-promise');
+var lexical = Liquid.lexical;
+var groupRE = new RegExp('^(?:(' + lexical.value.source + ')\\s*:\\s*)?(.*)$');
+var candidatesRE = new RegExp(lexical.value.source, 'g');
+
+module.exports = function (liquid) {
+    liquid.registerTag('cycle', {
+
+        parse: function parse(tagToken, remainTokens) {
+            var match = groupRE.exec(tagToken.args);
+            if (!match) throw new Error('illegal tag: ' + tagToken.raw);
+
+            this.group = match[1] || '';
+            var candidates = match[2];
+
+            this.candidates = [];
+
+            while (match = candidatesRE.exec(candidates)) {
+                this.candidates.push(match[0]);
+            }
+
+            if (!this.candidates.length) {
+                throw new Error('empty candidates: ' + tagToken.raw);
+            }
+        },
+
+        render: function render(scope, hash, register) {
+            var fingerprint = Liquid.evalValue(this.group, scope) + ':' + this.candidates.join(',');
+            var idx = register[fingerprint];
+
+            if (idx === undefined) {
+                idx = register[fingerprint] = 0;
+            }
+
+            var candidate = this.candidates[idx];
+            idx = (idx + 1) % this.candidates.length;
+            register[fingerprint] = idx;
+
+            return Promise.resolve(Liquid.evalValue(candidate, scope));
+        }
+    });
+};
+
+},{"..":2,"any-promise":3}],23:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var lexical = Liquid.lexical;
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('decrement', {
+        parse: function parse(token) {
+            var match = token.args.match(lexical.identifier);
+            if (!match) throw new Error('illegal identifier ' + token.args);
+            this.variable = match[0];
+        },
+        render: function render(scope, hash) {
+            var v = scope.get(this.variable);
+            if (typeof v !== 'number') v = 0;
+            scope.set(this.variable, v - 1);
+        }
+    });
+};
+
+},{"..":2}],24:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var Promise = require('any-promise');
+var lexical = Liquid.lexical;
+var re = new RegExp('^(' + lexical.identifier.source + ')\\s+in\\s+' + ('(' + lexical.value.source + ')') + ('(?:\\s+' + lexical.hash.source + ')*') + '(?:\\s+(reversed))?$');
+
+module.exports = function (liquid) {
+    liquid.registerTag('for', {
+
+        parse: function parse(tagToken, remainTokens) {
+            var _this = this;
+
+            var match = re.exec(tagToken.args);
+            if (!match) throw new Error('illegal tag: ' + tagToken.raw);
+            this.variable = match[1];
+            this.collection = match[2];
+            this.reversed = !!match[3];
+
+            this.templates = [];
+            this.elseTemplates = [];
+
+            var p,
+                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
+                return p = _this.templates;
+            }).on('tag:else', function (token) {
+                return p = _this.elseTemplates;
+            }).on('tag:endfor', function (token) {
+                return stream.stop();
+            }).on('template', function (tpl) {
+                return p.push(tpl);
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+
+            stream.start();
+        },
+
+        render: function render(scope, hash) {
+            var _this2 = this;
+
+            var collection = Liquid.evalExp(this.collection, scope);
+            if (Liquid.isFalsy(collection)) {
+                return liquid.renderer.renderTemplates(this.elseTemplates, scope);
+            }
+
+            var html = '';
+            var length = collection.length;
+            var offset = hash.offset || 0;
+            var limit = hash.limit === undefined ? collection.length : hash.limit;
+
+            collection = collection.slice(offset, offset + limit);
+            if (this.reversed) collection.reverse();
+
+            // for needs to execute the promises sequentially, not just resolve them sequentially, due to break and continue.
+            // We can't just loop through executing everything then resolve them all sequentially like we do for render.renderTemplates
+            // First, we build the array of parameters we are going to use for each call to renderTemplates
+            var contexts = [];
+            collection.some(function (item, i) {
+                var ctx = {};
+                ctx[_this2.variable] = item;
+                ctx.forloop = {
+                    first: i === 0,
+                    index: i + 1,
+                    index0: i,
+                    last: i === length - 1,
+                    length: length,
+                    rindex: length - i,
+                    rindex0: length - i - 1,
+                    stop: false,
+                    skip: false
+                };
+                // We are just putting together an array of the arguments we will be passing to our sequential promises
+                contexts.push(ctx);
+            });
+
+            // This is some pretty tricksy javascript, at least to me.
+            // This executes an array of promises sequentially for every argument in the contexts array - http://webcache.googleusercontent.com/search?q=cache:rNbMUn9TPtkJ:joost.vunderink.net/blog/2014/12/15/processing-an-array-of-promises-sequentially-in-node-js/+&cd=5&hl=en&ct=clnk&gl=us
+            // It's fundamentally equivalent to the following...
+            //  emptyPromise.then(renderTemplates(args0).then(renderTemplates(args1).then(renderTemplates(args2)...
+            var lastPromise = contexts.reduce(function (promise, context) {
+                return promise.then(function (partial) {
+                    if (scope.get('forloop.stop')) {
+                        throw new Error('forloop.stop'); // this will stop the sequential promise chain
+                    }
+
+                    return html += partial;
+                }).then(function (partial) {
+                    // todo: Make sure our scope management is sound here.  Create some tests that revolve around loops
+                    //  with sections that take differing amounts of time to complete.  Make sure the order is maintained
+                    //  and scope doesn't bleed over into other renderTemplate calls.
+                    scope.push(context);
+                    return liquid.renderer.renderTemplates(_this2.templates, scope);
+                }).then(function (partial) {
+                    scope.pop(context);
+                    return partial;
+                });
+            }, Promise.resolve('')); // start the reduce chain with a resolved Promise. After first run, the "promise" argument
+            //  in our reduce callback will be the returned promise from our "then" above.  In this
+            //  case, the promise returned from liquid.renderer.renderTemplates.
+
+            return lastPromise.then(function (partial) {
+                return html += partial;
+            }).catch(function (error) {
+                if (error.message === 'forloop.stop') {
+                    // the error is a controlled, purposeful stop. so just return the html that we have up to this point
+                    return html;
+                } else {
+                    // rethrow actual error
+                    throw error;
+                }
+            });
+        }
+    });
+};
+
+},{"..":2,"any-promise":3}],25:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+
+module.exports = function (liquid) {
+    liquid.registerTag('if', {
+
+        parse: function parse(tagToken, remainTokens) {
+            var _this = this;
+
+            this.branches = [];
+            this.elseTemplates = [];
+
+            var p,
+                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
+                return _this.branches.push({
+                    cond: tagToken.args,
+                    templates: p = []
+                });
+            }).on('tag:elsif', function (token) {
+                if (!_this.branches[token.args]) {
+                    _this.branches.push({
+                        cond: token.args,
+                        templates: p = []
+                    });
+                }
+            }).on('tag:else', function (token) {
+                return p = _this.elseTemplates;
+            }).on('tag:endif', function (token) {
+                return stream.stop();
+            }).on('template', function (tpl) {
+                return p.push(tpl);
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+
+            stream.start();
+        },
+
+        render: function render(scope, hash) {
+            for (var i = 0; i < this.branches.length; i++) {
+                var branch = this.branches[i];
+                var cond = Liquid.evalExp(branch.cond, scope);
+                if (Liquid.isTruthy(cond)) {
+                    return liquid.renderer.renderTemplates(branch.templates, scope);
+                }
+            }
+            return liquid.renderer.renderTemplates(this.elseTemplates, scope);
+        }
+
+    });
+};
+
+},{"..":2}],26:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var lexical = Liquid.lexical;
+var withRE = new RegExp('with\\s+(' + lexical.value.source + ')');
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('include', {
+        parse: function parse(token) {
+            var match = lexical.value.exec(token.args);
+            if (!match) throw new Error('illegal token ' + token.raw);
+            this.value = match[0];
+
+            match = withRE.exec(token.args);
+            if (match) {
+                this.with = match[1];
+            }
+        },
+        render: function render(scope, hash) {
+            var filepath = Liquid.evalValue(this.value, scope);
+            if (this.with) {
+                hash[filepath] = Liquid.evalValue(this.with, scope);
+            }
+            return liquid.handleCache(filepath).then(function (templates) {
+                scope.push(hash);
+                return liquid.renderer.renderTemplates(templates, scope);
+            }).then(function (html) {
+                scope.pop();
+                return html;
+            });
+        }
+    });
+};
+
+},{"..":2}],27:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var lexical = Liquid.lexical;
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('increment', {
+        parse: function parse(token) {
+            var match = token.args.match(lexical.identifier);
+            if (!match) throw new Error('illegal identifier ' + token.args);
+            this.variable = match[0];
+        },
+        render: function render(scope, hash) {
+            var v = scope.get(this.variable);
+            if (typeof v !== 'number') v = 0;
+            scope.set(this.variable, v + 1);
+        }
+    });
+};
+
+},{"..":2}],28:[function(require,module,exports){
+"use strict";
+
+module.exports = function (engine) {
+    require("./assign.js")(engine);
+    require("./capture.js")(engine);
+    require("./case.js")(engine);
+    require("./comment.js")(engine);
+    require("./cycle.js")(engine);
+    require("./decrement.js")(engine);
+    require("./for.js")(engine);
+    require("./if.js")(engine);
+    require("./include.js")(engine);
+    require("./increment.js")(engine);
+    require("./layout.js")(engine);
+    require("./raw.js")(engine);
+    require("./tablerow.js")(engine);
+    require("./unless.js")(engine);
+};
+
+},{"./assign.js":18,"./capture.js":19,"./case.js":20,"./comment.js":21,"./cycle.js":22,"./decrement.js":23,"./for.js":24,"./if.js":25,"./include.js":26,"./increment.js":27,"./layout.js":29,"./raw.js":30,"./tablerow.js":31,"./unless.js":32}],29:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var Promise = require('any-promise');
+var lexical = Liquid.lexical;
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('layout', {
+        parse: function parse(token, remainTokens) {
+            var match = lexical.value.exec(token.args);
+            if (!match) throw new Error('illegal token ' + token.raw);
+
+            this.layout = match[0];
+            this.tpls = liquid.parser.parse(remainTokens);
+        },
+        render: function render(scope, hash) {
+            var layout = Liquid.evalValue(this.layout, scope);
+
+            var html = '';
+            scope.push({});
+            // not sure if this first one is needed, since the results are ignored
+            return liquid.renderer.renderTemplates(this.tpls, scope).then(function (partial) {
+                html += partial;
+                return liquid.handleCache(layout);
+            }).then(function (templates) {
+                return liquid.renderer.renderTemplates(templates, scope);
+            }).then(function (partial) {
+                scope.pop();
+                return partial;
+            }).catch(function (e) {
+                e.file = layout;
+                throw e;
+            });
+        }
+    });
+
+    liquid.registerTag('block', {
+        parse: function parse(token, remainTokens) {
+            var _this = this;
+
+            var match = /\w+/.exec(token.args);
+            this.block = match ? match[0] : '';
+
+            this.tpls = [];
+            var p,
+                stream = liquid.parser.parseStream(remainTokens).on('tag:endblock', function (token) {
+                return stream.stop();
+            }).on('template', function (tpl) {
+                return _this.tpls.push(tpl);
+            }).on('end', function (x) {
+                throw new Error('tag ' + token.raw + ' not closed');
+            });
+            stream.start();
+        },
+        render: function render(scope, hash) {
+            var _this2 = this;
+
+            var html = scope.get('_liquid.blocks.' + this.block);
+            var promise = Promise.resolve('');
+            if (html === undefined) {
+                promise = liquid.renderer.renderTemplates(this.tpls, scope).then(function (partial) {
+                    scope.set('_liquid.blocks.' + _this2.block, partial);
+                    return partial;
+                });
+            } else {
+                scope.set('_liquid.blocks.' + this.block, html);
+                promise = Promise.resolve(html);
+            }
+            return promise;
+        }
+    });
+};
+
+},{"..":2,"any-promise":3}],30:[function(require,module,exports){
+'use strict';
+
+var Promise = require('any-promise');
+
+module.exports = function (liquid) {
+
+    liquid.registerTag('raw', {
+        parse: function parse(tagToken, remainTokens) {
+            var _this = this;
+
+            this.tokens = [];
+
+            var stream = liquid.parser.parseStream(remainTokens);
+            stream.on('token', function (token) {
+                if (token.name === 'endraw') stream.stop();else _this.tokens.push(token);
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+            stream.start();
+        },
+        render: function render(scope, hash) {
+            var tokens = this.tokens.map(function (token) {
+                return token.raw;
+            }).join('');
+            return Promise.resolve(tokens);
+        }
+    });
+};
+
+},{"any-promise":3}],31:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+var Promise = require('any-promise');
+var lexical = Liquid.lexical;
+var re = new RegExp('^(' + lexical.identifier.source + ')\\s+in\\s+' + ('(' + lexical.value.source + ')') + ('(?:\\s+' + lexical.hash.source + ')*$'));
+
+module.exports = function (liquid) {
+    liquid.registerTag('tablerow', {
+
+        parse: function parse(tagToken, remainTokens) {
+            var _this = this;
+
+            var match = re.exec(tagToken.args);
+            if (!match) throw new Error('illegal tag: ' + tagToken.raw);
+            this.variable = match[1];
+            this.collection = match[2];
+
+            this.templates = [];
+
+            var p,
+                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
+                return p = _this.templates;
+            }).on('tag:endtablerow', function (token) {
+                return stream.stop();
+            }).on('template', function (tpl) {
+                return p.push(tpl);
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+
+            stream.start();
+        },
+
+        render: function render(scope, hash) {
+            var _this2 = this;
+
+            var collection = Liquid.evalExp(this.collection, scope) || [];
+
+            var html = '<table>';
+            var offset = hash.offset || 0;
+            var limit = hash.limit === undefined ? collection.length : hash.limit;
+
+            var cols = hash.cols,
+                row,
+                col;
+            if (!cols) throw new Error('illegal cols: ' + cols);
+
+            // build array of arguments to pass to sequential promises...
+            collection = collection.slice(offset, offset + limit);
+            var contexts = [];
+            collection.some(function (item, i) {
+                var ctx = {};
+                ctx[_this2.variable] = item;
+                // We are just putting together an array of the arguments we will be passing to our sequential promises
+                contexts.push(ctx);
+            });
+
+            // This executes an array of promises sequentially for every argument in the contexts array - http://webcache.googleusercontent.com/search?q=cache:rNbMUn9TPtkJ:joost.vunderink.net/blog/2014/12/15/processing-an-array-of-promises-sequentially-in-node-js/+&cd=5&hl=en&ct=clnk&gl=us
+            // It's fundamentally equivalent to the following...
+            //  emptyPromise.then(renderTemplates(args0).then(renderTemplates(args1).then(renderTemplates(args2)...
+            var lastPromise = contexts.reduce(function (promise, context, currentIndex) {
+                return promise.then(function (partial) {
+                    row = Math.floor(currentIndex / cols) + 1;
+                    col = currentIndex % cols + 1;
+                    if (col === 1) {
+                        if (row !== 1) {
+                            html += '</tr>';
+                        }
+                        html += '<tr class="row' + row + '">';
+                    }
+
+                    //ctx[this.variable] = context;
+
+                    return html += '<td class="col' + col + '">';
+                }).then(function (partial) {
+                    scope.push(context);
+                    return liquid.renderer.renderTemplates(_this2.templates, scope);
+                }).then(function (partial) {
+                    scope.pop(context);
+                    html += partial;
+                    return html += '</td>';
+                });
+            }, Promise.resolve('')); // start the reduce chain with a resolved Promise. After first run, the "promise" argument
+            //  in our reduce callback will be the returned promise from our "then" above.  In this
+            //  case, the promise returned from liquid.renderer.renderTemplates.
+
+            return lastPromise.then(function () {
+                if (row > 0) {
+                    html += '</tr>';
+                }
+                html += '</table>';
+                return html;
+            }).catch(function (error) {
+                throw error;
+            });
+        }
+    });
+};
+
+},{"..":2,"any-promise":3}],32:[function(require,module,exports){
+'use strict';
+
+var Liquid = require('..');
+
+module.exports = function (liquid) {
+    liquid.registerTag('unless', {
+        parse: function parse(tagToken, remainTokens) {
+            var _this = this;
+
+            this.templates = [];
+            this.elseTemplates = [];
+            var p,
+                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
+                p = _this.templates;
+                _this.cond = tagToken.args;
+            }).on('tag:else', function (token) {
+                return p = _this.elseTemplates;
+            }).on('tag:endunless', function (token) {
+                return stream.stop();
+            }).on('template', function (tpl) {
+                return p.push(tpl);
+            }).on('end', function (x) {
+                throw new Error('tag ' + tagToken.raw + ' not closed');
+            });
+
+            stream.start();
+        },
+
+        render: function render(scope, hash) {
+            var cond = Liquid.evalExp(this.cond, scope);
+            return Liquid.isFalsy(cond) ? liquid.renderer.renderTemplates(this.templates, scope) : liquid.renderer.renderTemplates(this.elseTemplates, scope);
+        }
+    });
+};
+
+},{"..":2}]},{},[2])(2)
+});
\ No newline at end of file
diff --git a/dist/liquid.min.js b/dist/liquid.min.js
new file mode 100644
index 000000000..6c11ea120
--- /dev/null
+++ b/dist/liquid.min.js
@@ -0,0 +1,2 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var r;r="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,r.Liquid=e()}}(function(){return function e(r,t,n){function i(o,a){if(!t[o]){if(!r[o]){var u="function"==typeof require&&require;if(!a&&u)return u(o,!0);if(s)return s(o,!0);var c=new Error("Cannot find module '"+o+"'");throw c.code="MODULE_NOT_FOUND",c}var l=t[o]={exports:{}};r[o][0].call(l.exports,function(e){var t=r[o][1][e];return i(t?t:e)},l,l.exports,e,r,t,n)}return t[o].exports}for(var s="function"==typeof require&&require,o=0;o<n.length;o++)i(n[o]);return i}({1:[function(e,r){"use strict";function t(e){var r=(e+"").split(".");return r.length>1?r[1].length:0}function n(e,r){return Math.max(t(e),t(r))}function i(e){return function(r,t){var i=n(r,t);return e(r,t).toFixed(i)}}var s=e("./src/strftime.js");r.exports=function(e){function r(e){return(e||"").replace(/&|<|>|"|'/g,function(e){return n[e]})}function t(e){return(e||"").replace(/&(amp|lt|gt|#34|#39);/g,function(e){return o[e]})}e.registerFilter("abs",function(e){return Math.abs(e)}),e.registerFilter("append",function(e,r){return e+r}),e.registerFilter("capitalize",function(e){return(e||"").charAt(0).toUpperCase()+e.slice(1)}),e.registerFilter("ceil",function(e){return Math.ceil(e)}),e.registerFilter("date",function(e,r){return s(e,r)}),e.registerFilter("default",function(e,r){return r||e}),e.registerFilter("divided_by",function(e,r){return Math.floor(e/r)}),e.registerFilter("downcase",function(e){return e.toLowerCase()});var n={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&#34;","'":"&#39;"};e.registerFilter("escape",r);var o={"&amp;":"&","&lt;":"<","&gt;":">","&#34;":'"',"&#39;":"'"};e.registerFilter("escape_once",function(e){return r(t(e))}),e.registerFilter("first",function(e){return e[0]}),e.registerFilter("floor",function(e){return Math.floor(e)}),e.registerFilter("join",function(e,r){return e.join(r)}),e.registerFilter("last",function(e){return e[e.length-1]}),e.registerFilter("lstrip",function(e){return(e||"").replace(/^\s+/,"")}),e.registerFilter("map",function(e,r){return e.map(function(e){return e[r]})}),e.registerFilter("minus",i(function(e,r){return e-r})),e.registerFilter("modulo",i(function(e,r){return e%r})),e.registerFilter("newline_to_br",function(e){return e.replace(/\n/g,"<br />")}),e.registerFilter("plus",i(function(e,r){return e+r})),e.registerFilter("prepend",function(e,r){return r+e}),e.registerFilter("remove",function(e,r){return e.split(r).join("")}),e.registerFilter("remove_first",function(e,r){return e.replace(r,"")}),e.registerFilter("replace",function(e,r,t){return(e||"").split(r).join(t)}),e.registerFilter("replace_first",function(e,r,t){return(e||"").replace(r,t)}),e.registerFilter("reverse",function(e){return(e||"").reverse()}),e.registerFilter("round",function(e,r){var t=Math.pow(10,r||0);return Math.round(e*t,r)/t}),e.registerFilter("rstrip",function(e){return(e||"").replace(/\s+$/,"")}),e.registerFilter("size",function(e){return e.length}),e.registerFilter("slice",function(e,r,t){return e.substr(r,void 0===t?1:t)}),e.registerFilter("sort",function(e,r){return(e||"").sort(r)}),e.registerFilter("split",function(e,r){return(e||"").split(r)}),e.registerFilter("strip",function(e){return(e||"").trim()}),e.registerFilter("strip_html",function(e){return(e||"").replace(/<\/?\s*\w+\s*\/?>/g,"")}),e.registerFilter("strip_newlines",function(e){return(e||"").replace(/\n/g,"")}),e.registerFilter("times",function(e,r){return e*r}),e.registerFilter("truncate",function(e,r,t){return e=e||"",t=void 0===t?"...":t,r=r||16,e.length<=r?e:e.substr(0,r-t.length)+t}),e.registerFilter("truncatewords",function(e,r,t){void 0===t&&(t="...");var n=e.split(" "),i=n.slice(0,r).join(" ");return n.length>r&&(i+=t),i}),e.registerFilter("uniq",function(e){var r={};return(e||[]).filter(function(e){return r.hasOwnProperty(e)?!1:(r[e]=!0,!0)})}),e.registerFilter("upcase",function(e){return(e||"").toUpperCase()}),e.registerFilter("url_encode",encodeURIComponent)}},{"./src/strftime.js":14}],2:[function(e,r){"use strict";function t(e){e=e||{},e.root=e.root||"",e.extname=e.extname||".liquid";var r=Object.create(v);return r.init(c(),l(),e),r}function n(e,r){if("/"==r[0])return r;var t=e.split("/").concat(r.split("/")),n=[];return t.forEach(function(e){".."==e?n.pop():e&&"."!=e&&n.push(e)}),"/"+n.join("/")}var i=e("./src/scope"),s=e("./src/tokenizer.js"),o=e("fs"),a=e("./src/render.js"),u=e("./src/lexical.js"),c=e("./src/tag.js"),l=e("./src/filter.js"),f=e("./src/parser"),p=e("./src/expression.js"),h=e("./tags"),g=e("./filters"),d=e("any-promise"),v={init:function(e,r,t){return t.cache&&(this.cache={}),this.options=t,this.tag=e,this.filter=r,this.parser=f(e,r),this.renderer=a(),h(this),g(this),this},parse:function(e){var r=s.parse(e);return this.parser.parse(r)},render:function(e,r,t){t=t||{},t.strict_variables=t.strict_variables||!1,t.strict_filters=t.strict_filters||!1,this.renderer.resetRegisters();var n=i.factory(r,{strict:t.strict_variables});return this.renderer.renderTemplates(e,n,t)},parseAndRender:function(e,r,t){try{var n=this.parse(e);return this.render(n,r,t)}catch(i){return d.reject(i)}},renderFile:function(e,r,t){var n=this;return this.handleCache(e).then(function(e){return n.render(e,r,t)})["catch"](function(r){throw r.file=e,r})},evalOutput:function(e,r){var t=this.parser.parseOutput(e.trim());return this.renderer.evalOutput(t,r)},registerFilter:function(e,r){return this.filter.register(e,r)},registerTag:function(e,r){return this.tag.register(e,r)},handleCache:function(e){var r=this;if(!e)throw new Error("filepath cannot be null");return e=n(this.options.root,e),e.match(/\.\w+$/)||(e+=this.options.extname),this.getTemplate(e).then(function(t){var n=r.options.cache&&r.cache[e]||r.parse(t);return r.options.cache?r.cache[e]=n:n})},getTemplate:function(e){return new d(function(r,t){o.readFile(e,"utf8",function(e,n){e?t(e):r(n)})})},express:function(e){var r=this;return function(t,n,i){r.renderFile(t,n,e).then(function(e){return i(null,e)})["catch"](function(e){return i(e)})}}};t.lexical=u,t.isTruthy=p.isTruthy,t.isFalsy=p.isFalsy,t.evalExp=p.evalExp,t.evalValue=p.evalValue,r.exports=t},{"./filters":1,"./src/expression.js":8,"./src/filter.js":9,"./src/lexical.js":10,"./src/parser":11,"./src/render.js":12,"./src/scope":13,"./src/tag.js":16,"./src/tokenizer.js":17,"./tags":28,"any-promise":3,fs:6}],3:[function(e,r){"use strict";r.exports=e("./register")().Promise},{"./register":5}],4:[function(e,r){"use strict";var t="@@any-promise/REGISTRATION",n=null;r.exports=function(e,r){return function(i,s){i=i||null,s=s||{};var o=s.global!==!1;if(null===n&&o&&(n=e[t]||null),null!==n&&null!==i&&n.implementation!==i)throw new Error('any-promise already defined as "'+n.implementation+'".  You can only register an implementation before the first  call to require("any-promise") and an implementation cannot be changed');return null===n&&(n=null!==i&&"undefined"!=typeof s.Promise?{Promise:s.Promise,implementation:i}:r(i),o&&(e[t]=n)),n}}},{}],5:[function(e,r){"use strict";function t(){if("undefined"==typeof window.Promise)throw new Error("any-promise browser requires a polyfill or explicit registration e.g: require('any-promise/register/bluebird')");return{Promise:window.Promise,implementation:"window.Promise"}}r.exports=e("./loader")(window,t)},{"./loader":4}],6:[function(){"use strict"},{}],7:[function(e,r){"use strict";function t(e,r,t){Error.captureStackTrace(this,this.constructor),this.name=this.constructor.name,this.message=e||"",this.input=r,this.line=t}function n(e,r,t,n){Error.captureStackTrace(this,this.constructor),this.name=this.constructor.name,this.originalError=n,this.message=e||"",this.input=r,this.line=t}t.prototype=Object.create(Error.prototype),t.prototype.constructor=t,n.prototype=Object.create(Error.prototype),n.prototype.constructor=n,r.exports={TokenizationError:t,ParseError:n}},{}],8:[function(e,r){"use strict";function t(e,r){if(!r)throw new Error("unable to evalExp: scope undefined");for(var i,s=a.operators,u=0;u<s.length;u++){var c=s[u],l=new RegExp("^("+a.quoteBalanced.source+")("+c.source+")("+a.quoteBalanced.source+")$");if(i=e.match(l)){var f=t(i[1],r),p=o.operators[i[2].trim()],h=t(i[3],r);return p(f,h)}}if(i=e.match(a.rangeLine)){for(var g=n(i[1],r),d=n(i[2],r),v=[],m=g;d>=m;m++)v.push(m);return v}return n(e,r)}function n(e,r){return e=e&&e.trim(),e?a.isLiteral(e)?a.parseLiteral(e):a.isVariable(e)?r.get(e):void 0:void 0}function i(e){return e instanceof Array?!!e.length:!!e}function s(e){return!i(e)}var o=e("./syntax.js"),a=e("./lexical.js");r.exports={evalExp:t,evalValue:n,isTruthy:i,isFalsy:s}},{"./lexical.js":10,"./syntax.js":15}],9:[function(e,r){"use strict";var t=e("./lexical.js"),n=e("./expression.js"),i=new RegExp(""+t.value.source,"g");r.exports=function(){function e(e){var r=Object.create(a);return r.parse(e)}function r(e,r){o[e]=r}function s(){o={}}var o={},a={render:function(e,r){var t=this.args.map(function(e){return n.evalValue(e,r)});return t.unshift(e),this.filter.apply(null,t)},parse:function(e){var r=t.filterLine.exec(e);if(!r)throw new Error("illegal filter: "+e);var n=r[1],s=r[2]||"",a=o[n];if("function"!=typeof a)return{name:n,error:new Error("undefined filter: "+n)};for(var u=[];r=i.exec(s.trim());)u.push(r[0]);return this.name=n,this.filter=a,this.args=u,this}};return{construct:e,register:r,clear:s}}},{"./expression.js":8,"./lexical.js":10}],10:[function(e,r){"use strict";function t(e){return E.test(e)}function n(e){return R.test(e)}function i(e){return T.test(e)}function s(e){var r;return(r=e.match(F))?Number(e):(r=e.match(O))?"true"===e.toLowerCase():(r=e.match(k))?e.slice(1,-1):void 0}var o=/'[^']*'/,a=/"[^"]*"/,u=new RegExp("(?:"+o.source+"|"+a.source+"|[^'\"])*"),c=/(?:-?\d+\.?\d*|\.?\d+)/,l=/true|false/,f=/[a-zA-Z_$][a-zA-Z_$0-9]*/,p=/\[\d+\]/,h=new RegExp("(?:"+o.source+"|"+a.source+")"),g=new RegExp("(?:"+h.source+"|"+l.source+"|"+c.source+")"),d=new RegExp(f.source+"(?:\\."+f.source+"|"+p.source+")*"),v=new RegExp("(?:"+d.source+"|"+c.source+")"),m=new RegExp("\\("+v.source+"\\.\\."+v.source+"\\)"),w=new RegExp("\\(("+v.source+")\\.\\.("+v.source+")\\)"),x=new RegExp("(?:"+g.source+"|"+d.source+"|"+m.source+")"),y=new RegExp("(?:"+f.source+")\\s*:\\s*(?:"+x.source+")"),b=new RegExp("("+f.source+")\\s*:\\s*("+x.source+")","g"),j=new RegExp("^\\s*("+f.source+")\\s*(.*)\\s*$"),E=new RegExp("^"+g.source+"$","i"),T=new RegExp("^"+d.source+"$"),F=new RegExp("^"+c.source+"$"),O=new RegExp("^"+l.source+"$","i"),k=new RegExp("^"+h.source+"$"),R=new RegExp("^"+w.source+"$"),M=new RegExp(x.source+"(\\s*,\\s*"+x.source+")*"),S=new RegExp(f.source+"(?:\\s*:\\s*"+M.source+")?","g"),I=new RegExp("("+f.source+")(?:\\s*:\\s*("+M.source+"))?"),L=new RegExp("^"+I.source+"$"),_=[/\s+or\s+/,/\s+and\s+/,/==|!=|<=|>=|<|>|\s+contains\s+/];r.exports={quoted:h,number:c,bool:l,literal:g,filter:S,hash:y,hashCapture:b,range:m,rangeCapture:w,identifier:f,value:x,quoteBalanced:u,operators:_,quotedLine:k,numberLine:F,boolLine:O,rangeLine:R,literalLine:E,filterLine:L,tagLine:j,isLiteral:t,isVariable:i,parseLiteral:s,isRange:n}},{}],11:[function(e,r){"use strict";var t=e("./lexical.js"),n=e("./error.js").ParseError;r.exports=function(e,r){function i(e){for(var r,t=[];r=e.shift();)t.push(s(r,e));return t}function s(e,r){try{switch(e.type){case"tag":return o(e,r);case"output":return a(e.value);case"html":return e}}catch(t){throw new n(t.message,e.input,e.line,t)}}function o(r,t){return"continue"===r.name||"break"===r.name?r:e.construct(r,t)}function a(e){var n=t.value.exec(e);if(!n)throw new Error("illegal output string: "+e);var i=n[0];e=e.substr(n.index+n[0].length);for(var s=[];n=t.filter.exec(e);)s.push([n[0].trim()]);return{type:"output",initial:i,filters:s.map(function(e){return r.construct(e)})}}function u(e){var r=Object.create(c);return r.init(e)}var c={init:function(e){return this.tokens=e,this.handlers={},this},on:function(e,r){return this.handlers[e]=r,this},trigger:function(e,r){var t=this.handlers[e];return"function"==typeof t?(t(r),!0):void 0},start:function(){this.trigger("start");for(var e;!this.stopRequested&&(e=this.tokens.shift());)if(!(this.trigger("token",e)||"tag"==e.type&&this.trigger("tag:"+e.name,e))){var r=s(e,this.tokens);this.trigger("template",r)}return this.stopRequested||this.trigger("end"),this},stop:function(){return this.stopRequested=!0,this}};return{parse:i,parseTag:o,parseStream:u,parseOutput:a}}},{"./error.js":7,"./lexical.js":10}],12:[function(e,r){"use strict";function t(){var e=Object.create(o);return e.register={},e}function n(e){return"string"==typeof e?e:JSON.stringify(e)}var i=e("./expression.js"),s=e("any-promise"),o={renderTemplates:function(e,r,t){var i=this;if(!r)throw new Error("unable to evalTemplates: scope undefined");t=t||{},t.strict_filters=t.strict_filters||!1;var o="",a=e.reduce(function(e,a){return e.then(function(){if(r.safeGet("forloop.skip"))return s.resolve("");if(r.safeGet("forloop.stop"))throw new Error("forloop.stop");var e=s.resolve("");switch(a.type){case"tag":e=i.renderTag(a,r,i.register).then(function(e){return void 0===e?!0:o+=e});break;case"html":e=s.resolve(a.value).then(function(e){return o+=e});break;case"output":var u=i.evalOutput(a,r,t);e=s.resolve(void 0===u?"":n(u)).then(function(e){return o+=e})}return e})["catch"](function(e){if("forloop.skip"===e.message)return o;throw e})},s.resolve(""));return a.then(function(e){return e})["catch"](function(e){throw e})},renderTag:function(e,r,t){return"continue"===e.name?(r.set("forloop.skip",!0),s.resolve("")):"break"===e.name?(r.set("forloop.stop",!0),r.set("forloop.skip",!0),s.reject(new Error("forloop.stop"))):e.render(r,t)},evalOutput:function(e,r,t){if(!r)throw new Error("unable to evalOutput: scope undefined");var n=i.evalExp(e.initial,r);return e.filters.some(function(e){if(e.error){if(t.strict_filters)throw e.error;return n="",!0}n=e.render(n,r)}),n},resetRegisters:function(){return this.register={}}};r.exports=t},{"./expression.js":8,"any-promise":3}],13:[function(e,r,t){"use strict";function n(e,r,t){if(r instanceof String||"string"==typeof r){for(var n=r.replace(/\[/g,".").replace(/\]/g,"").split("."),i=0;i<n.length;i++){var s=n[i];if(i===n.length-1)return e[s]=t;void 0===e[s]&&(e[s]={}),e=e[s]||{}}return e}return e[r]=t}function i(e,r){if(r instanceof String||"string"==typeof r){var t=r.replace(/\[/g,".").replace(/\]/g,"").split(".");return t.forEach(function(r){return e=e&&e[r]}),e}return e[r]}var s={safeGet:function(e){var r;if(void 0===e){var t={};for(r=this.scopes.length-1;r>=0;r--){var n=this.scopes[r];for(var s in n)n.hasOwnProperty(s)&&(t[s]=n[s])}return t}for(r=this.scopes.length-1;r>=0;r--){var o=i(this.scopes[r],e);if(void 0!==o)return o}},get:function(e){var r=this.safeGet(e);if(void 0===r&&this.opts.strict)throw new Error("[strict_variables] undefined variable: "+e);return r},set:function(e,r){return n(this.scopes[this.scopes.length-1],e,r),this},push:function(e){if(!e)throw new Error("trying to push "+e+" into scopes");return this.scopes.push(e)},pop:function(){return this.scopes.pop()}};t.factory=function(e,r){r=r||{},r.strict=r.strict||!1;var t=Object.create(s);return t.opts=r,t.scopes=[e||{}],t}},{}],14:[function(e,r){"use strict";var t=["January","February","March","April","May","June","July","August","September","October","November","December"],n=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],i=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],s=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],o={1:"st",2:"nd",3:"rd","default":"th"},a={daysInMonth:function(e){var r=a.isLeapYear(e)?29:28;return[31,r,31,30,31,30,31,31,30,31,30,31]},getTimezone:function(e){return e.toString().replace(/^.*? ([A-Z]{3}) [0-9]{4}.*$/,"$1").replace(/^.*?\(([A-Z])[a-z]+ ([A-Z])[a-z]+ ([A-Z])[a-z]+\)$/,"$1$2$3")},getGMTOffset:function(e){return(e.getTimezoneOffset()>0?"-":"+")+c.pad(Math.floor(e.getTimezoneOffset()/60),2)+c.pad(e.getTimezoneOffset()%60,2)},getDayOfYear:function(e){for(var r=0,t=0;t<e.getMonth();++t)r+=a.daysInMonth(e)[t];return r+e.getDate()},getWeekOfYear:function(e,r){var t=this.getDayOfYear(e)+(r-e.getDay()),n=new Date(e.getFullYear(),0,1),i=7-n.getDay()+r;return c.pad(Math.floor((t-i)/7)+1,2)},isLeapYear:function(e){var r=e.getFullYear();return!(0!==(3&r)||!(r%100||r%400===0&&r))},getFirstDayOfMonth:function(e){var r=(e.getDay()-(e.getDate()-1))%7;return 0>r?r+7:r},getLastDayOfMonth:function(e){var r=(e.getDay()+(a.daysInMonth(e)[e.getMonth()]-e.getDate()))%7;return 0>r?r+7:r},getSuffix:function(e){var r=e.getDate().toString(),t=parseInt(r.slice(-1));return o[t]||o["default"]},applyOffset:function(e,r){return e.setTime(e.valueOf()-1e3*r),e},century:function(e){return parseInt(e.getFullYear().toString().substring(0,2),10)}},u={values_of:function(e){var r=[];for(var t in e)e.hasOwnProperty(t)&&r.push(e[t]);return r}},c={pad:function h(e,r,t){t||(t="0");for(var n=e.toString(),h=r-n.length;h-->0;)n=t+n;return n}},l={a:function(e){return s[e.getDay()]},A:function(e){return i[e.getDay()]},b:function(e){return n[e.getMonth()]},B:function(e){return t[e.getMonth()]},c:function(e){return e.toLocaleString()},C:function(e){return a.century(e)},d:function(e){return c.pad(e.getDate(),2)},e:function(e){return c.pad(e.getDate(),2," ")},H:function(e){return c.pad(e.getHours(),2)},I:function(e){return c.pad(e.getHours()%12||12,2)},j:function(e){return c.pad(a.getDayOfYear(e),3)},k:function(e){return c.pad(e.getHours(),2," ")},l:function(e){return c.pad(e.getHours()%12||12,2," ")},L:function(e){return c.pad(e.getMilliseconds(),3)},m:function(e){return c.pad(e.getMonth()+1,2)},M:function(e){return c.pad(e.getMinutes(),2)},p:function(e){return e.getHours()<12?"AM":"PM"},P:function(e){return e.getHours()<12?"am":"pm"},q:function(e){return a.getSuffix(e)},s:function(e){return Math.round(e.valueOf()/1e3)},S:function(e){return c.pad(e.getSeconds(),2)},u:function(e){return e.getDay()||7},U:function(e){return a.getWeekOfYear(e,0)},w:function(e){return e.getDay()},W:function(e){return a.getWeekOfYear(e,1)},x:function(e){return e.toLocaleDateString()},X:function(e){return e.toLocaleTimeString()},y:function(e){return e.getFullYear().toString().substring(2,4)},Y:function(e){return e.getFullYear()},z:function(e){var r=e.getTimezoneOffset()/60*100;return(r>0?"-":"+")+c.pad(r,4)},"%":function(){return"%"}};l.h=l.b,l.N=l.L;var f={a:{r:"(?:"+s.join("|")+")"},A:{r:"(?:"+i.join("|")+")"},b:{r:"("+n.join("|")+")",p:function(e){this.month=$.inArray(e,n)}},B:{r:"("+t.join("|")+")",p:function(e){this.month=$.inArray(e,t)}},C:{r:"(\\d{1,2})",p:function(e){this.century=parseInt(e,10)}},d:{r:"(\\d{1,2})",p:function(e){this.day=parseInt(e,10)}},H:{r:"(\\d{1,2})",p:function(e){this.hour=parseInt(e,10)}},j:{r:"(\\d{1,3})",p:function(e){this.day=parseInt(e,10)}},L:{r:"(\\d{3})",p:function(e){this.milliseconds=parseInt(e,10)}},m:{r:"(\\d{1,2})",p:function(e){this.month=parseInt(e,10)-1}},M:{r:"(\\d{2})",p:function(e){this.minute=parseInt(e,10)}},p:{r:"(AM|PM)",p:function(e){"AM"==e?12==this.hour&&(this.hour=0):this.hour<12&&(this.hour+=12)}},P:{r:"(am|pm)",p:function(e){"am"==e?12==this.hour&&(this.hour=0):this.hour<12&&(this.hour+=12)}},q:{r:"(?:"+u.values_of(o).join("|")+")"},S:{r:"(\\d{2})",p:function(e){this.second=parseInt(e,10)}},y:{r:"(\\d{1,2})",p:function(e){this.year=parseInt(e,10)}},Y:{r:"(\\d{4})",p:function(e){this.century=Math.floor(parseInt(e,10)/100),this.year=parseInt(e,10)%100}},z:{r:"(Z|[+-]\\d{2}:?\\d{2})",p:function(e){if("Z"==e)return void(this.zone=0);var r=3600*parseInt(e[0]+e[1]+e[2],10);r+=":"==e[3]?60*parseInt(e[4]+e[5],10):60*parseInt(e[3]+e[4],10),this.zone=r}}};f.e=f.d,f.h=f.b,f.I=f.H,f.k=f.H,f.l=f.H;var p=function(e,r){for(var t="",n=r;;){var i=/%./g,s=i.exec(n);if(!s)return t+n;t+=n.slice(0,i.lastIndex-2),n=n.slice(i.lastIndex);var o=s[0].charAt(1),a=l[o];t+=a?a.call(this,e):"%"+o}};r.exports=p},{}],15:[function(e,r,t){"use strict";var n={"==":function(e,r){return e==r},"!=":function(e,r){return e!=r},">":function(e,r){return e>r},"<":function(e,r){return r>e},">=":function(e,r){return e>=r},"<=":function(e,r){return r>=e},contains:function(e,r){return e.indexOf(r)>-1},and:function(e,r){return e&&r},or:function(e,r){return e||r}};t.operators=n},{}],16:[function(e,r){"use strict";function t(e,r){var t,i={};for(n.hashCapture.lastIndex=0;t=n.hashCapture.exec(e);){var o=t[1],a=t[2];i[o]=s.evalValue(a,r)}return i}var n=e("./lexical.js"),i=e("any-promise"),s=e("./expression.js");r.exports=function(){function e(e,r){s[e]=r}function r(e,r){var t=Object.create(o);return t.parse(e,r),t}function n(){s={}}var s={},o={render:function(e,r){var n=r[this.name];n||(n=r[this.name]={});var s=t(this.token.args,e);return this.tagImpl.render&&this.tagImpl.render(e,s,n)||i.resolve("")},parse:function(e,r){this.type="tag",this.token=e,this.name=e.name;var t=s[this.name];if(!t)throw new Error("tag "+this.name+" not found");this.tagImpl=Object.create(t),this.tagImpl.parse&&this.tagImpl.parse(e,r)}};return{construct:r,register:e,clear:n}}},{"./expression.js":8,"./lexical.js":10,"any-promise":3}],17:[function(e,r,t){"use strict";function n(e){function r(e,r,i){return{type:e,raw:i[r],value:i[r+1].trim(),line:n(i),input:t(i)}}function t(e){var r=e.input.lastIndexOf("\n",e.index),t=e.input.indexOf("\n",e.index);return-1===t&&(t=e.input.length),e.input.slice(r+1,t)}function n(e){var r=e.input.slice(p+1,e.index).split("\n");return h+=r.length-1,p=e.index,h+1}var o=[];if(!e)return o;for(var a,u,c,l=/({%(.*?)%})|({{(.*?)}})/g,f=0,p=-1,h=0;null!==(a=l.exec(e));){if(a.index>f&&(u=e.slice(f,a.index),o.push({type:"html",raw:u,value:u})),a[1]){c=r("tag",1,a);var g=c.value.match(i.tagLine);if(!g)throw new s("illegal tag: "+c.raw,c.input,c.line);c.name=g[1],c.args=g[2],o.push(c)}else c=r("output",3,a),o.push(c);f=l.lastIndex}return e.length>f&&(u=e.slice(f,e.length),o.push({type:"html",raw:u,value:u})),o}var i=e("./lexical.js"),s=e("./error.js").TokenizationError;t.parse=n},{"./error.js":7,"./lexical.js":10}],18:[function(e,r){"use strict";var t=e(".."),n=t.lexical,i=e("any-promise"),s=new RegExp("("+n.identifier.source+")\\s*=(.*)");r.exports=function(e){e.registerTag("assign",{parse:function(e){var r=e.args.match(s);if(!r)throw new Error("illegal token "+e.raw);this.key=r[1],this.value=r[2]},render:function(r){return r.set(this.key,e.evalOutput(this.value,r)),i.resolve("")}})}},{"..":2,"any-promise":3}],19:[function(e,r){"use strict";var t=e(".."),n=t.lexical,i=new RegExp("("+n.identifier.source+")");r.exports=function(e){e.registerTag("capture",{parse:function(r,t){var n=this,s=r.args.match(i);if(!s)throw new Error(r.args+" not valid identifier");this.variable=s[1],this.templates=[];var o=e.parser.parseStream(t);o.on("tag:endcapture",function(){return o.stop()}).on("template",function(e){return n.templates.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")}),o.start()},render:function(r){var t=this;return e.renderer.renderTemplates(this.templates,r).then(function(e){r.set(t.variable,e)})}})}},{"..":2}],20:[function(e,r){"use strict";var t=e("..");r.exports=function(e){e.registerTag("case",{parse:function(r,t){var n=this;this.cond=r.args,this.cases=[],this.elseTemplates=[];var i=[],s=e.parser.parseStream(t).on("tag:when",function(e){n.cases[e.args]||n.cases.push({val:e.args,templates:i=[]})}).on("tag:else",function(){return i=n.elseTemplates}).on("tag:endcase",function(){return s.stop()}).on("template",function(e){return i.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")});s.start()},render:function(r){for(var n=0;n<this.cases.length;n++){var i=this.cases[n],s=t.evalExp(i.val,r),o=t.evalExp(this.cond,r);if(s===o)return e.renderer.renderTemplates(i.templates,r)}return e.renderer.renderTemplates(this.elseTemplates,r)}})}},{"..":2}],21:[function(e,r){"use strict";r.exports=function(e){e.registerTag("comment",{parse:function(r,t){var n=e.parser.parseStream(t);n.on("token",function(e){"endcomment"===e.name&&n.stop()}).on("end",function(){throw new Error("tag "+r.raw+" not closed")}),n.start()}})}},{}],22:[function(e,r){"use strict";var t=e(".."),n=e("any-promise"),i=t.lexical,s=new RegExp("^(?:("+i.value.source+")\\s*:\\s*)?(.*)$"),o=new RegExp(i.value.source,"g");r.exports=function(e){e.registerTag("cycle",{parse:function(e){var r=s.exec(e.args);if(!r)throw new Error("illegal tag: "+e.raw);this.group=r[1]||"";var t=r[2];for(this.candidates=[];r=o.exec(t);)this.candidates.push(r[0]);if(!this.candidates.length)throw new Error("empty candidates: "+e.raw)},render:function(e,r,i){var s=t.evalValue(this.group,e)+":"+this.candidates.join(","),o=i[s];void 0===o&&(o=i[s]=0);var a=this.candidates[o];return o=(o+1)%this.candidates.length,i[s]=o,n.resolve(t.evalValue(a,e))}})}},{"..":2,"any-promise":3}],23:[function(e,r){"use strict";var t=e(".."),n=t.lexical;r.exports=function(e){e.registerTag("decrement",{parse:function(e){var r=e.args.match(n.identifier);if(!r)throw new Error("illegal identifier "+e.args);this.variable=r[0]},render:function(e){var r=e.get(this.variable);"number"!=typeof r&&(r=0),e.set(this.variable,r-1)}})}},{"..":2}],24:[function(e,r){"use strict";var t=e(".."),n=e("any-promise"),i=t.lexical,s=new RegExp("^("+i.identifier.source+")\\s+in\\s+"+("("+i.value.source+")")+("(?:\\s+"+i.hash.source+")*")+"(?:\\s+(reversed))?$");r.exports=function(e){e.registerTag("for",{parse:function(r,t){var n=this,i=s.exec(r.args);if(!i)throw new Error("illegal tag: "+r.raw);this.variable=i[1],this.collection=i[2],this.reversed=!!i[3],this.templates=[],this.elseTemplates=[];var o,a=e.parser.parseStream(t).on("start",function(){return o=n.templates}).on("tag:else",function(){return o=n.elseTemplates}).on("tag:endfor",function(){return a.stop()}).on("template",function(e){return o.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")});a.start()},render:function(r,i){var s=this,o=t.evalExp(this.collection,r);if(t.isFalsy(o))return e.renderer.renderTemplates(this.elseTemplates,r);var a="",u=o.length,c=i.offset||0,l=void 0===i.limit?o.length:i.limit;o=o.slice(c,c+l),this.reversed&&o.reverse();var f=[];o.some(function(e,r){var t={};t[s.variable]=e,t.forloop={first:0===r,index:r+1,index0:r,last:r===u-1,length:u,rindex:u-r,rindex0:u-r-1,stop:!1,skip:!1},f.push(t)});var p=f.reduce(function(t,n){return t.then(function(e){if(r.get("forloop.stop"))throw new Error("forloop.stop");return a+=e}).then(function(){return r.push(n),e.renderer.renderTemplates(s.templates,r)}).then(function(e){return r.pop(n),e})},n.resolve(""));return p.then(function(e){return a+=e})["catch"](function(e){if("forloop.stop"===e.message)return a;throw e})}})}},{"..":2,"any-promise":3}],25:[function(e,r){"use strict";var t=e("..");r.exports=function(e){e.registerTag("if",{parse:function(r,t){var n=this;this.branches=[],this.elseTemplates=[];var i,s=e.parser.parseStream(t).on("start",function(){return n.branches.push({cond:r.args,templates:i=[]})}).on("tag:elsif",function(e){n.branches[e.args]||n.branches.push({cond:e.args,templates:i=[]})}).on("tag:else",function(){return i=n.elseTemplates}).on("tag:endif",function(){return s.stop()}).on("template",function(e){return i.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")});s.start()},render:function(r){for(var n=0;n<this.branches.length;n++){var i=this.branches[n],s=t.evalExp(i.cond,r);if(t.isTruthy(s))return e.renderer.renderTemplates(i.templates,r)}return e.renderer.renderTemplates(this.elseTemplates,r)}})}},{"..":2}],26:[function(e,r){"use strict";var t=e(".."),n=t.lexical,i=new RegExp("with\\s+("+n.value.source+")");r.exports=function(e){e.registerTag("include",{parse:function(e){var r=n.value.exec(e.args);if(!r)throw new Error("illegal token "+e.raw);this.value=r[0],r=i.exec(e.args),r&&(this["with"]=r[1])},render:function(r,n){var i=t.evalValue(this.value,r);return this["with"]&&(n[i]=t.evalValue(this["with"],r)),e.handleCache(i).then(function(t){return r.push(n),e.renderer.renderTemplates(t,r)}).then(function(e){return r.pop(),e})}})}},{"..":2}],27:[function(e,r){"use strict";var t=e(".."),n=t.lexical;r.exports=function(e){e.registerTag("increment",{parse:function(e){var r=e.args.match(n.identifier);if(!r)throw new Error("illegal identifier "+e.args);this.variable=r[0]},render:function(e){var r=e.get(this.variable);"number"!=typeof r&&(r=0),e.set(this.variable,r+1)}})}},{"..":2}],28:[function(e,r){"use strict";r.exports=function(r){e("./assign.js")(r),e("./capture.js")(r),e("./case.js")(r),e("./comment.js")(r),e("./cycle.js")(r),e("./decrement.js")(r),e("./for.js")(r),e("./if.js")(r),e("./include.js")(r),e("./increment.js")(r),e("./layout.js")(r),e("./raw.js")(r),e("./tablerow.js")(r),e("./unless.js")(r)}},{"./assign.js":18,"./capture.js":19,"./case.js":20,"./comment.js":21,"./cycle.js":22,"./decrement.js":23,"./for.js":24,"./if.js":25,"./include.js":26,"./increment.js":27,"./layout.js":29,"./raw.js":30,"./tablerow.js":31,"./unless.js":32}],29:[function(e,r){"use strict";var t=e(".."),n=e("any-promise"),i=t.lexical;r.exports=function(e){e.registerTag("layout",{parse:function(r,t){var n=i.value.exec(r.args);if(!n)throw new Error("illegal token "+r.raw);this.layout=n[0],this.tpls=e.parser.parse(t)},render:function(r){var n=t.evalValue(this.layout,r),i="";return r.push({}),e.renderer.renderTemplates(this.tpls,r).then(function(r){return i+=r,e.handleCache(n)}).then(function(t){return e.renderer.renderTemplates(t,r)}).then(function(e){return r.pop(),e})["catch"](function(e){throw e.file=n,e})}}),e.registerTag("block",{parse:function(r,t){var n=this,i=/\w+/.exec(r.args);this.block=i?i[0]:"",this.tpls=[];var s=e.parser.parseStream(t).on("tag:endblock",function(){return s.stop()}).on("template",function(e){return n.tpls.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")});s.start()},render:function(r){var t=this,i=r.get("_liquid.blocks."+this.block),s=n.resolve("");return void 0===i?s=e.renderer.renderTemplates(this.tpls,r).then(function(e){return r.set("_liquid.blocks."+t.block,e),e}):(r.set("_liquid.blocks."+this.block,i),s=n.resolve(i)),s}})}},{"..":2,"any-promise":3}],30:[function(e,r){"use strict";var t=e("any-promise");r.exports=function(e){e.registerTag("raw",{parse:function(r,t){var n=this;this.tokens=[];var i=e.parser.parseStream(t);i.on("token",function(e){"endraw"===e.name?i.stop():n.tokens.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")}),i.start()},render:function(){var e=this.tokens.map(function(e){return e.raw}).join("");return t.resolve(e)}})}},{"any-promise":3}],31:[function(e,r){"use strict";var t=e(".."),n=e("any-promise"),i=t.lexical,s=new RegExp("^("+i.identifier.source+")\\s+in\\s+"+("("+i.value.source+")")+("(?:\\s+"+i.hash.source+")*$"));r.exports=function(e){e.registerTag("tablerow",{parse:function(r,t){var n=this,i=s.exec(r.args);if(!i)throw new Error("illegal tag: "+r.raw);this.variable=i[1],this.collection=i[2],this.templates=[];var o,a=e.parser.parseStream(t).on("start",function(){return o=n.templates}).on("tag:endtablerow",function(){return a.stop()}).on("template",function(e){return o.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")});a.start()},render:function(r,i){var s,o,a=this,u=t.evalExp(this.collection,r)||[],c="<table>",l=i.offset||0,f=void 0===i.limit?u.length:i.limit,p=i.cols;if(!p)throw new Error("illegal cols: "+p);u=u.slice(l,l+f);var h=[];u.some(function(e){var r={};r[a.variable]=e,h.push(r)});var g=h.reduce(function(t,n,i){return t.then(function(){return s=Math.floor(i/p)+1,o=i%p+1,1===o&&(1!==s&&(c+="</tr>"),c+='<tr class="row'+s+'">'),c+='<td class="col'+o+'">'}).then(function(){return r.push(n),e.renderer.renderTemplates(a.templates,r)}).then(function(e){return r.pop(n),c+=e,c+="</td>"})},n.resolve(""));return g.then(function(){
+return s>0&&(c+="</tr>"),c+="</table>"})["catch"](function(e){throw e})}})}},{"..":2,"any-promise":3}],32:[function(e,r){"use strict";var t=e("..");r.exports=function(e){e.registerTag("unless",{parse:function(r,t){var n=this;this.templates=[],this.elseTemplates=[];var i,s=e.parser.parseStream(t).on("start",function(){i=n.templates,n.cond=r.args}).on("tag:else",function(){return i=n.elseTemplates}).on("tag:endunless",function(){return s.stop()}).on("template",function(e){return i.push(e)}).on("end",function(){throw new Error("tag "+r.raw+" not closed")});s.start()},render:function(r){var n=t.evalExp(this.cond,r);return t.isFalsy(n)?e.renderer.renderTemplates(this.templates,r):e.renderer.renderTemplates(this.elseTemplates,r)}})}},{"..":2}]},{},[2])(2)});
\ No newline at end of file
diff --git a/dist/shopify-liquid.js b/dist/shopify-liquid.js
deleted file mode 100644
index 1cddf996c..000000000
--- a/dist/shopify-liquid.js
+++ /dev/null
@@ -1,3858 +0,0 @@
-(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Liquid = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
-'use strict';
-
-var strftime = require('strftime').timezone(-new Date().getTimezoneOffset());
-
-module.exports = function (liquid) {
-    liquid.registerFilter('abs', function (v) {
-        return Math.abs(v);
-    });
-    liquid.registerFilter('append', function (v, arg) {
-        return v + arg;
-    });
-    liquid.registerFilter('capitalize', function (str) {
-        return (str || '').charAt(0).toUpperCase() + str.slice(1);
-    });
-    liquid.registerFilter('ceil', function (v) {
-        return Math.ceil(v);
-    });
-
-    liquid.registerFilter('date', function (v, arg) {
-        return strftime(arg, v);
-    });
-
-    liquid.registerFilter('default', function (v, arg) {
-        return arg || v;
-    });
-    liquid.registerFilter('divided_by', function (v, arg) {
-        return Math.floor(v / arg);
-    });
-    liquid.registerFilter('downcase', function (v) {
-        return v.toLowerCase();
-    });
-
-    var escapeMap = {
-        '&': '&amp;',
-        '<': '&lt;',
-        '>': '&gt;',
-        '"': '&#34;',
-        "'": '&#39;'
-    };
-
-    function escape(str) {
-        return (str || '').replace(/&|<|>|"|'/g, function (m) {
-            return escapeMap[m];
-        });
-    }
-    liquid.registerFilter('escape', escape);
-
-    var unescapeMap = {
-        '&amp;': '&',
-        '&lt;': '<',
-        '&gt;': '>',
-        '&#34;': '"',
-        '&#39;': "'"
-    };
-
-    function unescape(str) {
-        return (str || '').replace(/&(amp|lt|gt|#34|#39);/g, function (m) {
-            return unescapeMap[m];
-        });
-    }
-    liquid.registerFilter('escape_once', function (str) {
-        return escape(unescape(str));
-    });
-    liquid.registerFilter('first', function (v) {
-        return v[0];
-    });
-    liquid.registerFilter('floor', function (v) {
-        return Math.floor(v);
-    });
-    liquid.registerFilter('join', function (v, arg) {
-        return v.join(arg);
-    });
-    liquid.registerFilter('last', function (v) {
-        return v[v.length - 1];
-    });
-    liquid.registerFilter('lstrip', function (v) {
-        return (v || '').replace(/^\s+/, '');
-    });
-    liquid.registerFilter('map', function (arr, arg) {
-        return arr.map(function (v) {
-            return v[arg];
-        });
-    });
-    liquid.registerFilter('minus', bindFixed(function (v, arg) {
-        return v - arg;
-    }));
-    liquid.registerFilter('modulo', bindFixed(function (v, arg) {
-        return v % arg;
-    }));
-    liquid.registerFilter('newline_to_br', function (v) {
-        return v.replace(/\n/g, '<br />');
-    });
-    liquid.registerFilter('plus', bindFixed(function (v, arg) {
-        return v + arg;
-    }));
-    liquid.registerFilter('prepend', function (v, arg) {
-        return arg + v;
-    });
-    liquid.registerFilter('remove', function (v, arg) {
-        return v.split(arg).join('');
-    });
-    liquid.registerFilter('remove_first', function (v, l) {
-        return v.replace(l, '');
-    });
-    liquid.registerFilter('replace', function (v, pattern, replacement) {
-        return (v || '').split(pattern).join(replacement);
-    });
-    liquid.registerFilter('replace_first', function (v, arg1, arg2) {
-        return (v || '').replace(arg1, arg2);
-    });
-    liquid.registerFilter('reverse', function (v) {
-        return (v || '').reverse();
-    });
-    liquid.registerFilter('round', function (v, arg) {
-        var amp = Math.pow(10, arg || 0);
-        return Math.round(v * amp, arg) / amp;
-    });
-    liquid.registerFilter('rstrip', function (str) {
-        return (str || '').replace(/\s+$/, '');
-    });
-    liquid.registerFilter('size', function (v) {
-        return v.length;
-    });
-    liquid.registerFilter('slice', function (v, begin, length) {
-        return v.substr(begin, length === undefined ? 1 : length);
-    });
-    liquid.registerFilter('sort', function (v, arg) {
-        return (v || '').sort(arg);
-    });
-    liquid.registerFilter('split', function (v, arg) {
-        return (v || '').split(arg);
-    });
-    liquid.registerFilter('strip', function (v) {
-        return (v || '').trim();
-    });
-    liquid.registerFilter('strip_html', function (v) {
-        return (v || '').replace(/<\/?\s*\w+\s*\/?>/g, '');
-    });
-    liquid.registerFilter('strip_newlines', function (v) {
-        return (v || '').replace(/\n/g, '');
-    });
-    liquid.registerFilter('times', function (v, arg) {
-        return v * arg;
-    });
-    liquid.registerFilter('truncate', function (v, l, o) {
-        v = v || '';
-        o = o === undefined ? '...' : o;
-        l = l || 16;
-        if (v.length <= l) return v;
-        return v.substr(0, l - o.length) + o;
-    });
-    liquid.registerFilter('truncatewords', function (v, l, o) {
-        if (o === undefined) o = '...';
-        var arr = v.split(' ');
-        var ret = arr.slice(0, l).join(' ');
-        if (arr.length > l) ret += o;
-        return ret;
-    });
-    liquid.registerFilter('uniq', function (arr) {
-        var u = {};
-        return (arr || []).filter(function (val) {
-            if (u.hasOwnProperty(val)) {
-                return false;
-            }
-            u[val] = true;
-            return true;
-        });
-    });
-    liquid.registerFilter('upcase', function (str) {
-        return (str || '').toUpperCase();
-    });
-    liquid.registerFilter('url_encode', encodeURIComponent);
-};
-
-function getFixed(v) {
-    var p = (v + "").split(".");
-    return p.length > 1 ? p[1].length : 0;
-}
-
-function getMaxFixed(l, r) {
-    return Math.max(getFixed(l), getFixed(r));
-}
-
-function bindFixed(cb) {
-    return function (l, r) {
-        var f = getMaxFixed(l, r);
-        return cb(l, r).toFixed(f);
-    };
-}
-
-},{"strftime":10}],2:[function(require,module,exports){
-'use strict';
-
-var Scope = require('./src/scope');
-var assert = require('assert');
-var tokenizer = require('./src/tokenizer.js');
-var Render = require('./src/render.js');
-var lexical = require('./src/lexical.js');
-var path = require("path");
-var fs = require('fs');
-var Tag = require('./src/tag.js');
-var Filter = require('./src/filter.js');
-var Template = require('./src/parser');
-var Expression = require('./src/expression.js');
-var tags = require('./tags');
-var filters = require('./filters');
-var Promise = require('any-promise');
-
-var _engine = {
-    init: function init(tag, filter, options) {
-        if (options.cache) {
-            this.cache = {};
-        }
-        this.options = options;
-        this.tag = tag;
-        this.filter = filter;
-        this.parser = Template(tag, filter);
-        this.renderer = Render();
-
-        tags(this);
-        filters(this);
-
-        return this;
-    },
-    parse: function parse(html) {
-        var tokens = tokenizer.parse(html);
-        return this.parser.parse(tokens);
-    },
-    render: function render(tpl, ctx, opts) {
-        opts = opts || {};
-        opts.strict_variables = opts.strict_variables || false;
-        opts.strict_filters = opts.strict_filters || false;
-
-        this.renderer.resetRegisters();
-        var scope = Scope.factory(ctx, {
-            strict: opts.strict_variables
-        });
-        return this.renderer.renderTemplates(tpl, scope, opts);
-    },
-    parseAndRender: function parseAndRender(html, ctx, opts) {
-        try {
-            var tpl = this.parse(html);
-            return this.render(tpl, ctx, opts);
-        } catch (error) {
-            // A throw inside of a then or catch of a Promise automatically rejects, but since we mix a sync call
-            //  with an async call, we need to do this in case the sync call throws.
-            return Promise.reject(error);
-        }
-    },
-    renderFile: function renderFile(filepath, ctx, opts) {
-        var _this = this;
-
-        return this.handleCache(filepath).then(function (templates) {
-            return _this.render(templates, ctx, opts);
-        }).catch(function (e) {
-            e.file = filepath;
-            throw e;
-        });
-    },
-    evalOutput: function evalOutput(str, scope) {
-        var tpl = this.parser.parseOutput(str.trim());
-        return this.renderer.evalOutput(tpl, scope);
-    },
-    registerFilter: function registerFilter(name, filter) {
-        return this.filter.register(name, filter);
-    },
-    registerTag: function registerTag(name, tag) {
-        return this.tag.register(name, tag);
-    },
-    handleCache: function handleCache(filepath) {
-        var _this2 = this;
-
-        assert(filepath, 'filepath cannot be null');
-        filepath = path.resolve(this.options.root, filepath);
-        if (path.extname(filepath) === '') {
-            filepath += this.options.extname;
-        }
-
-        return this.getTemplate(filepath).then(function (html) {
-            var tpl = _this2.options.cache && _this2.cache[filepath] || _this2.parse(html);
-            return _this2.options.cache ? _this2.cache[filepath] = tpl : tpl;
-        });
-    },
-    getTemplate: function getTemplate(filepath) {
-        return new Promise(function (resolve, reject) {
-            fs.readFile(filepath, 'utf8', function (err, html) {
-                err ? reject(err) : resolve(html);
-            });
-        });
-    },
-    express: function express(renderingOptions) {
-        var _this3 = this;
-
-        return function (filePath, options, callback) {
-            _this3.renderFile(filePath, options, renderingOptions).then(function (html) {
-                return callback(null, html);
-            }).catch(function (e) {
-                return callback(e);
-            });
-        };
-    }
-};
-
-function factory(options) {
-    options = options || {};
-    options.root = options.root || '';
-    options.extname = options.extname || '.liquid';
-
-    var engine = Object.create(_engine);
-
-    engine.init(Tag(), Filter(), options);
-    return engine;
-}
-
-factory.lexical = lexical;
-factory.isTruthy = Expression.isTruthy;
-factory.isFalsy = Expression.isFalsy;
-factory.evalExp = Expression.evalExp;
-factory.evalValue = Expression.evalValue;
-
-module.exports = factory;
-
-},{"./filters":1,"./src/expression.js":15,"./src/filter.js":16,"./src/lexical.js":17,"./src/parser":18,"./src/render.js":19,"./src/scope":20,"./src/tag.js":22,"./src/tokenizer.js":23,"./tags":34,"any-promise":3,"assert":6,"fs":7,"path":8}],3:[function(require,module,exports){
-'use strict';
-
-module.exports = require('./register')().Promise;
-
-},{"./register":5}],4:[function(require,module,exports){
-"use strict";
-// global key for user preferred registration
-
-var REGISTRATION_KEY = '@@any-promise/REGISTRATION',
-
-// Prior registration (preferred or detected)
-registered = null;
-
-/**
- * Registers the given implementation.  An implementation must
- * be registered prior to any call to `require("any-promise")`,
- * typically on application load.
- *
- * If called with no arguments, will return registration in
- * following priority:
- *
- * For Node.js:
- *
- * 1. Previous registration
- * 2. global.Promise if node.js version >= 0.12
- * 3. Auto detected promise based on first sucessful require of
- *    known promise libraries. Note this is a last resort, as the
- *    loaded library is non-deterministic. node.js >= 0.12 will
- *    always use global.Promise over this priority list.
- * 4. Throws error.
- *
- * For Browser:
- *
- * 1. Previous registration
- * 2. window.Promise
- * 3. Throws error.
- *
- * Options:
- *
- * Promise: Desired Promise constructor
- * global: Boolean - Should the registration be cached in a global variable to
- * allow cross dependency/bundle registration?  (default true)
- */
-module.exports = function (root, loadImplementation) {
-  return function register(implementation, opts) {
-    implementation = implementation || null;
-    opts = opts || {};
-    // global registration unless explicitly  {global: false} in options (default true)
-    var registerGlobal = opts.global !== false;
-
-    // load any previous global registration
-    if (registered === null && registerGlobal) {
-      registered = root[REGISTRATION_KEY] || null;
-    }
-
-    if (registered !== null && implementation !== null && registered.implementation !== implementation) {
-      // Throw error if attempting to redefine implementation
-      throw new Error('any-promise already defined as "' + registered.implementation + '".  You can only register an implementation before the first ' + ' call to require("any-promise") and an implementation cannot be changed');
-    }
-
-    if (registered === null) {
-      // use provided implementation
-      if (implementation !== null && typeof opts.Promise !== 'undefined') {
-        registered = {
-          Promise: opts.Promise,
-          implementation: implementation
-        };
-      } else {
-        // require implementation if implementation is specified but not provided
-        registered = loadImplementation(implementation);
-      }
-
-      if (registerGlobal) {
-        // register preference globally in case multiple installations
-        root[REGISTRATION_KEY] = registered;
-      }
-    }
-
-    return registered;
-  };
-};
-
-},{}],5:[function(require,module,exports){
-"use strict";
-
-module.exports = require('./loader')(window, loadImplementation);
-
-/**
- * Browser specific loadImplementation.  Always uses `window.Promise`
- *
- * To register a custom implementation, must register with `Promise` option.
- */
-function loadImplementation() {
-  if (typeof window.Promise === 'undefined') {
-    throw new Error("any-promise browser requires a polyfill or explicit registration" + " e.g: require('any-promise/register/bluebird')");
-  }
-  return {
-    Promise: window.Promise,
-    implementation: 'window.Promise'
-  };
-}
-
-},{"./loader":4}],6:[function(require,module,exports){
-'use strict';
-
-// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
-//
-// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
-//
-// Originally from narwhal.js (http://narwhaljs.org)
-// Copyright (c) 2009 Thomas Robinson <280north.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the 'Software'), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// when used in node, this will actually load the util module we depend on
-// versus loading the builtin util module as happens otherwise
-// this is a bug in node module loading as far as I am concerned
-var util = require('util/');
-
-var pSlice = Array.prototype.slice;
-var hasOwn = Object.prototype.hasOwnProperty;
-
-// 1. The assert module provides functions that throw
-// AssertionError's when particular conditions are not met. The
-// assert module must conform to the following interface.
-
-var assert = module.exports = ok;
-
-// 2. The AssertionError is defined in assert.
-// new assert.AssertionError({ message: message,
-//                             actual: actual,
-//                             expected: expected })
-
-assert.AssertionError = function AssertionError(options) {
-  this.name = 'AssertionError';
-  this.actual = options.actual;
-  this.expected = options.expected;
-  this.operator = options.operator;
-  if (options.message) {
-    this.message = options.message;
-    this.generatedMessage = false;
-  } else {
-    this.message = getMessage(this);
-    this.generatedMessage = true;
-  }
-  var stackStartFunction = options.stackStartFunction || fail;
-
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, stackStartFunction);
-  } else {
-    // non v8 browsers so we can have a stacktrace
-    var err = new Error();
-    if (err.stack) {
-      var out = err.stack;
-
-      // try to strip useless frames
-      var fn_name = stackStartFunction.name;
-      var idx = out.indexOf('\n' + fn_name);
-      if (idx >= 0) {
-        // once we have located the function frame
-        // we need to strip out everything before it (and its line)
-        var next_line = out.indexOf('\n', idx + 1);
-        out = out.substring(next_line + 1);
-      }
-
-      this.stack = out;
-    }
-  }
-};
-
-// assert.AssertionError instanceof Error
-util.inherits(assert.AssertionError, Error);
-
-function replacer(key, value) {
-  if (util.isUndefined(value)) {
-    return '' + value;
-  }
-  if (util.isNumber(value) && !isFinite(value)) {
-    return value.toString();
-  }
-  if (util.isFunction(value) || util.isRegExp(value)) {
-    return value.toString();
-  }
-  return value;
-}
-
-function truncate(s, n) {
-  if (util.isString(s)) {
-    return s.length < n ? s : s.slice(0, n);
-  } else {
-    return s;
-  }
-}
-
-function getMessage(self) {
-  return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' + self.operator + ' ' + truncate(JSON.stringify(self.expected, replacer), 128);
-}
-
-// At present only the three keys mentioned above are used and
-// understood by the spec. Implementations or sub modules can pass
-// other keys to the AssertionError's constructor - they will be
-// ignored.
-
-// 3. All of the following functions must throw an AssertionError
-// when a corresponding condition is not met, with a message that
-// may be undefined if not provided.  All assertion methods provide
-// both the actual and expected values to the assertion error for
-// display purposes.
-
-function fail(actual, expected, message, operator, stackStartFunction) {
-  throw new assert.AssertionError({
-    message: message,
-    actual: actual,
-    expected: expected,
-    operator: operator,
-    stackStartFunction: stackStartFunction
-  });
-}
-
-// EXTENSION! allows for well behaved errors defined elsewhere.
-assert.fail = fail;
-
-// 4. Pure assertion tests whether a value is truthy, as determined
-// by !!guard.
-// assert.ok(guard, message_opt);
-// This statement is equivalent to assert.equal(true, !!guard,
-// message_opt);. To test strictly for the value true, use
-// assert.strictEqual(true, guard, message_opt);.
-
-function ok(value, message) {
-  if (!value) fail(value, true, message, '==', assert.ok);
-}
-assert.ok = ok;
-
-// 5. The equality assertion tests shallow, coercive equality with
-// ==.
-// assert.equal(actual, expected, message_opt);
-
-assert.equal = function equal(actual, expected, message) {
-  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
-};
-
-// 6. The non-equality assertion tests for whether two objects are not equal
-// with != assert.notEqual(actual, expected, message_opt);
-
-assert.notEqual = function notEqual(actual, expected, message) {
-  if (actual == expected) {
-    fail(actual, expected, message, '!=', assert.notEqual);
-  }
-};
-
-// 7. The equivalence assertion tests a deep equality relation.
-// assert.deepEqual(actual, expected, message_opt);
-
-assert.deepEqual = function deepEqual(actual, expected, message) {
-  if (!_deepEqual(actual, expected)) {
-    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
-  }
-};
-
-function _deepEqual(actual, expected) {
-  // 7.1. All identical values are equivalent, as determined by ===.
-  if (actual === expected) {
-    return true;
-  } else if (util.isBuffer(actual) && util.isBuffer(expected)) {
-    if (actual.length != expected.length) return false;
-
-    for (var i = 0; i < actual.length; i++) {
-      if (actual[i] !== expected[i]) return false;
-    }
-
-    return true;
-
-    // 7.2. If the expected value is a Date object, the actual value is
-    // equivalent if it is also a Date object that refers to the same time.
-  } else if (util.isDate(actual) && util.isDate(expected)) {
-    return actual.getTime() === expected.getTime();
-
-    // 7.3 If the expected value is a RegExp object, the actual value is
-    // equivalent if it is also a RegExp object with the same source and
-    // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
-  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
-    return actual.source === expected.source && actual.global === expected.global && actual.multiline === expected.multiline && actual.lastIndex === expected.lastIndex && actual.ignoreCase === expected.ignoreCase;
-
-    // 7.4. Other pairs that do not both pass typeof value == 'object',
-    // equivalence is determined by ==.
-  } else if (!util.isObject(actual) && !util.isObject(expected)) {
-    return actual == expected;
-
-    // 7.5 For all other Object pairs, including Array objects, equivalence is
-    // determined by having the same number of owned properties (as verified
-    // with Object.prototype.hasOwnProperty.call), the same set of keys
-    // (although not necessarily the same order), equivalent values for every
-    // corresponding key, and an identical 'prototype' property. Note: this
-    // accounts for both named and indexed properties on Arrays.
-  } else {
-    return objEquiv(actual, expected);
-  }
-}
-
-function isArguments(object) {
-  return Object.prototype.toString.call(object) == '[object Arguments]';
-}
-
-function objEquiv(a, b) {
-  if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b)) return false;
-  // an identical 'prototype' property.
-  if (a.prototype !== b.prototype) return false;
-  // if one is a primitive, the other must be same
-  if (util.isPrimitive(a) || util.isPrimitive(b)) {
-    return a === b;
-  }
-  var aIsArgs = isArguments(a),
-      bIsArgs = isArguments(b);
-  if (aIsArgs && !bIsArgs || !aIsArgs && bIsArgs) return false;
-  if (aIsArgs) {
-    a = pSlice.call(a);
-    b = pSlice.call(b);
-    return _deepEqual(a, b);
-  }
-  var ka = objectKeys(a),
-      kb = objectKeys(b),
-      key,
-      i;
-  // having the same number of owned properties (keys incorporates
-  // hasOwnProperty)
-  if (ka.length != kb.length) return false;
-  //the same set of keys (although not necessarily the same order),
-  ka.sort();
-  kb.sort();
-  //~~~cheap key test
-  for (i = ka.length - 1; i >= 0; i--) {
-    if (ka[i] != kb[i]) return false;
-  }
-  //equivalent values for every corresponding key, and
-  //~~~possibly expensive deep test
-  for (i = ka.length - 1; i >= 0; i--) {
-    key = ka[i];
-    if (!_deepEqual(a[key], b[key])) return false;
-  }
-  return true;
-}
-
-// 8. The non-equivalence assertion tests for any deep inequality.
-// assert.notDeepEqual(actual, expected, message_opt);
-
-assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
-  if (_deepEqual(actual, expected)) {
-    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
-  }
-};
-
-// 9. The strict equality assertion tests strict equality, as determined by ===.
-// assert.strictEqual(actual, expected, message_opt);
-
-assert.strictEqual = function strictEqual(actual, expected, message) {
-  if (actual !== expected) {
-    fail(actual, expected, message, '===', assert.strictEqual);
-  }
-};
-
-// 10. The strict non-equality assertion tests for strict inequality, as
-// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
-
-assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
-  if (actual === expected) {
-    fail(actual, expected, message, '!==', assert.notStrictEqual);
-  }
-};
-
-function expectedException(actual, expected) {
-  if (!actual || !expected) {
-    return false;
-  }
-
-  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
-    return expected.test(actual);
-  } else if (actual instanceof expected) {
-    return true;
-  } else if (expected.call({}, actual) === true) {
-    return true;
-  }
-
-  return false;
-}
-
-function _throws(shouldThrow, block, expected, message) {
-  var actual;
-
-  if (util.isString(expected)) {
-    message = expected;
-    expected = null;
-  }
-
-  try {
-    block();
-  } catch (e) {
-    actual = e;
-  }
-
-  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + (message ? ' ' + message : '.');
-
-  if (shouldThrow && !actual) {
-    fail(actual, expected, 'Missing expected exception' + message);
-  }
-
-  if (!shouldThrow && expectedException(actual, expected)) {
-    fail(actual, expected, 'Got unwanted exception' + message);
-  }
-
-  if (shouldThrow && actual && expected && !expectedException(actual, expected) || !shouldThrow && actual) {
-    throw actual;
-  }
-}
-
-// 11. Expected to throw an error:
-// assert.throws(block, Error_opt, message_opt);
-
-assert.throws = function (block, /*optional*/error, /*optional*/message) {
-  _throws.apply(this, [true].concat(pSlice.call(arguments)));
-};
-
-// EXTENSION! This is annoying to write outside this module.
-assert.doesNotThrow = function (block, /*optional*/message) {
-  _throws.apply(this, [false].concat(pSlice.call(arguments)));
-};
-
-assert.ifError = function (err) {
-  if (err) {
-    throw err;
-  }
-};
-
-var objectKeys = Object.keys || function (obj) {
-  var keys = [];
-  for (var key in obj) {
-    if (hasOwn.call(obj, key)) keys.push(key);
-  }
-  return keys;
-};
-
-},{"util/":13}],7:[function(require,module,exports){
-"use strict";
-
-},{}],8:[function(require,module,exports){
-(function (process){
-'use strict';
-
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// resolves . and .. elements in a path array with directory names there
-// must be no slashes, empty elements, or device names (c:\) in the array
-// (so also no leading and trailing slashes - it does not distinguish
-// relative and absolute paths)
-function normalizeArray(parts, allowAboveRoot) {
-  // if the path tries to go above the root, `up` ends up > 0
-  var up = 0;
-  for (var i = parts.length - 1; i >= 0; i--) {
-    var last = parts[i];
-    if (last === '.') {
-      parts.splice(i, 1);
-    } else if (last === '..') {
-      parts.splice(i, 1);
-      up++;
-    } else if (up) {
-      parts.splice(i, 1);
-      up--;
-    }
-  }
-
-  // if the path is allowed to go above the root, restore leading ..s
-  if (allowAboveRoot) {
-    for (; up--; up) {
-      parts.unshift('..');
-    }
-  }
-
-  return parts;
-}
-
-// Split a filename into [root, dir, basename, ext], unix version
-// 'root' is just a slash, or nothing.
-var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
-var splitPath = function splitPath(filename) {
-  return splitPathRe.exec(filename).slice(1);
-};
-
-// path.resolve([from ...], to)
-// posix version
-exports.resolve = function () {
-  var resolvedPath = '',
-      resolvedAbsolute = false;
-
-  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    var path = i >= 0 ? arguments[i] : process.cwd();
-
-    // Skip empty and invalid entries
-    if (typeof path !== 'string') {
-      throw new TypeError('Arguments to path.resolve must be strings');
-    } else if (!path) {
-      continue;
-    }
-
-    resolvedPath = path + '/' + resolvedPath;
-    resolvedAbsolute = path.charAt(0) === '/';
-  }
-
-  // At this point the path should be resolved to a full absolute path, but
-  // handle relative paths to be safe (might happen when process.cwd() fails)
-
-  // Normalize the path
-  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function (p) {
-    return !!p;
-  }), !resolvedAbsolute).join('/');
-
-  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
-};
-
-// path.normalize(path)
-// posix version
-exports.normalize = function (path) {
-  var isAbsolute = exports.isAbsolute(path),
-      trailingSlash = substr(path, -1) === '/';
-
-  // Normalize the path
-  path = normalizeArray(filter(path.split('/'), function (p) {
-    return !!p;
-  }), !isAbsolute).join('/');
-
-  if (!path && !isAbsolute) {
-    path = '.';
-  }
-  if (path && trailingSlash) {
-    path += '/';
-  }
-
-  return (isAbsolute ? '/' : '') + path;
-};
-
-// posix version
-exports.isAbsolute = function (path) {
-  return path.charAt(0) === '/';
-};
-
-// posix version
-exports.join = function () {
-  var paths = Array.prototype.slice.call(arguments, 0);
-  return exports.normalize(filter(paths, function (p, index) {
-    if (typeof p !== 'string') {
-      throw new TypeError('Arguments to path.join must be strings');
-    }
-    return p;
-  }).join('/'));
-};
-
-// path.relative(from, to)
-// posix version
-exports.relative = function (from, to) {
-  from = exports.resolve(from).substr(1);
-  to = exports.resolve(to).substr(1);
-
-  function trim(arr) {
-    var start = 0;
-    for (; start < arr.length; start++) {
-      if (arr[start] !== '') break;
-    }
-
-    var end = arr.length - 1;
-    for (; end >= 0; end--) {
-      if (arr[end] !== '') break;
-    }
-
-    if (start > end) return [];
-    return arr.slice(start, end - start + 1);
-  }
-
-  var fromParts = trim(from.split('/'));
-  var toParts = trim(to.split('/'));
-
-  var length = Math.min(fromParts.length, toParts.length);
-  var samePartsLength = length;
-  for (var i = 0; i < length; i++) {
-    if (fromParts[i] !== toParts[i]) {
-      samePartsLength = i;
-      break;
-    }
-  }
-
-  var outputParts = [];
-  for (var i = samePartsLength; i < fromParts.length; i++) {
-    outputParts.push('..');
-  }
-
-  outputParts = outputParts.concat(toParts.slice(samePartsLength));
-
-  return outputParts.join('/');
-};
-
-exports.sep = '/';
-exports.delimiter = ':';
-
-exports.dirname = function (path) {
-  var result = splitPath(path),
-      root = result[0],
-      dir = result[1];
-
-  if (!root && !dir) {
-    // No dirname whatsoever
-    return '.';
-  }
-
-  if (dir) {
-    // It has a dirname, strip trailing slash
-    dir = dir.substr(0, dir.length - 1);
-  }
-
-  return root + dir;
-};
-
-exports.basename = function (path, ext) {
-  var f = splitPath(path)[2];
-  // TODO: make this comparison case-insensitive on windows?
-  if (ext && f.substr(-1 * ext.length) === ext) {
-    f = f.substr(0, f.length - ext.length);
-  }
-  return f;
-};
-
-exports.extname = function (path) {
-  return splitPath(path)[3];
-};
-
-function filter(xs, f) {
-  if (xs.filter) return xs.filter(f);
-  var res = [];
-  for (var i = 0; i < xs.length; i++) {
-    if (f(xs[i], i, xs)) res.push(xs[i]);
-  }
-  return res;
-}
-
-// String.prototype.substr - negative index don't work in IE8
-var substr = 'ab'.substr(-1) === 'b' ? function (str, start, len) {
-  return str.substr(start, len);
-} : function (str, start, len) {
-  if (start < 0) start = str.length + start;
-  return str.substr(start, len);
-};
-
-}).call(this,require('_process'))
-},{"_process":9}],9:[function(require,module,exports){
-'use strict';
-
-// shim for using process in browser
-var process = module.exports = {};
-
-// cached from whatever global is present so that test runners that stub it
-// don't break things.  But we need to wrap it in a try catch in case it is
-// wrapped in strict mode code which doesn't define any globals.  It's inside a
-// function because try/catches deoptimize in certain engines.
-
-var cachedSetTimeout;
-var cachedClearTimeout;
-
-function defaultSetTimout() {
-    throw new Error('setTimeout has not been defined');
-}
-function defaultClearTimeout() {
-    throw new Error('clearTimeout has not been defined');
-}
-(function () {
-    try {
-        if (typeof setTimeout === 'function') {
-            cachedSetTimeout = setTimeout;
-        } else {
-            cachedSetTimeout = defaultSetTimout;
-        }
-    } catch (e) {
-        cachedSetTimeout = defaultSetTimout;
-    }
-    try {
-        if (typeof clearTimeout === 'function') {
-            cachedClearTimeout = clearTimeout;
-        } else {
-            cachedClearTimeout = defaultClearTimeout;
-        }
-    } catch (e) {
-        cachedClearTimeout = defaultClearTimeout;
-    }
-})();
-function runTimeout(fun) {
-    if (cachedSetTimeout === setTimeout) {
-        //normal enviroments in sane situations
-        return setTimeout(fun, 0);
-    }
-    // if setTimeout wasn't available but was latter defined
-    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-        cachedSetTimeout = setTimeout;
-        return setTimeout(fun, 0);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedSetTimeout(fun, 0);
-    } catch (e) {
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
-            return cachedSetTimeout.call(null, fun, 0);
-        } catch (e) {
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
-            return cachedSetTimeout.call(this, fun, 0);
-        }
-    }
-}
-function runClearTimeout(marker) {
-    if (cachedClearTimeout === clearTimeout) {
-        //normal enviroments in sane situations
-        return clearTimeout(marker);
-    }
-    // if clearTimeout wasn't available but was latter defined
-    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-        cachedClearTimeout = clearTimeout;
-        return clearTimeout(marker);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedClearTimeout(marker);
-    } catch (e) {
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
-            return cachedClearTimeout.call(null, marker);
-        } catch (e) {
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
-            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
-            return cachedClearTimeout.call(this, marker);
-        }
-    }
-}
-var queue = [];
-var draining = false;
-var currentQueue;
-var queueIndex = -1;
-
-function cleanUpNextTick() {
-    if (!draining || !currentQueue) {
-        return;
-    }
-    draining = false;
-    if (currentQueue.length) {
-        queue = currentQueue.concat(queue);
-    } else {
-        queueIndex = -1;
-    }
-    if (queue.length) {
-        drainQueue();
-    }
-}
-
-function drainQueue() {
-    if (draining) {
-        return;
-    }
-    var timeout = runTimeout(cleanUpNextTick);
-    draining = true;
-
-    var len = queue.length;
-    while (len) {
-        currentQueue = queue;
-        queue = [];
-        while (++queueIndex < len) {
-            if (currentQueue) {
-                currentQueue[queueIndex].run();
-            }
-        }
-        queueIndex = -1;
-        len = queue.length;
-    }
-    currentQueue = null;
-    draining = false;
-    runClearTimeout(timeout);
-}
-
-process.nextTick = function (fun) {
-    var args = new Array(arguments.length - 1);
-    if (arguments.length > 1) {
-        for (var i = 1; i < arguments.length; i++) {
-            args[i - 1] = arguments[i];
-        }
-    }
-    queue.push(new Item(fun, args));
-    if (queue.length === 1 && !draining) {
-        runTimeout(drainQueue);
-    }
-};
-
-// v8 likes predictible objects
-function Item(fun, array) {
-    this.fun = fun;
-    this.array = array;
-}
-Item.prototype.run = function () {
-    this.fun.apply(null, this.array);
-};
-process.title = 'browser';
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = ''; // empty string to avoid regexp issues
-process.versions = {};
-
-function noop() {}
-
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-
-process.binding = function (name) {
-    throw new Error('process.binding is not supported');
-};
-
-process.cwd = function () {
-    return '/';
-};
-process.chdir = function (dir) {
-    throw new Error('process.chdir is not supported');
-};
-process.umask = function () {
-    return 0;
-};
-
-},{}],10:[function(require,module,exports){
-'use strict';
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
-
-//
-// strftime
-// github.com/samsonjs/strftime
-// @_sjs
-//
-// Copyright 2010 - 2015 Sami Samhuri <sami@samhuri.net>
-//
-// MIT License
-// http://sjs.mit-license.org
-//
-
-;(function () {
-
-    var DefaultLocale = {
-        days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
-        shortDays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
-        months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
-        shortMonths: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
-        AM: 'AM',
-        PM: 'PM',
-        am: 'am',
-        pm: 'pm',
-        formats: {
-            D: '%m/%d/%y',
-            F: '%Y-%m-%d',
-            R: '%H:%M',
-            T: '%H:%M:%S',
-            X: '%T',
-            c: '%a %b %d %X %Y',
-            r: '%I:%M:%S %p',
-            v: '%e-%b-%Y',
-            x: '%D'
-        }
-    },
-        defaultStrftime = new Strftime(DefaultLocale, 0, false),
-        isCommonJS = typeof module !== 'undefined',
-        namespace;
-
-    // CommonJS / Node module
-    if (isCommonJS) {
-        namespace = module.exports = adaptedStrftime;
-        namespace.strftime = deprecatedStrftime;
-    }
-    // Browsers and other environments
-    else {
-            // Get the global object. Works in ES3, ES5, and ES5 strict mode.
-            namespace = function () {
-                return this || (1, eval)('this');
-            }();
-            namespace.strftime = adaptedStrftime;
-        }
-
-    // Deprecated API, to be removed in v1.0
-    var _require = isCommonJS ? "require('strftime')" : "strftime";
-    var _deprecationWarnings = {};
-    function deprecationWarning(name, instead) {
-        if (!_deprecationWarnings[name]) {
-            if (typeof console !== 'undefined' && typeof console.warn == 'function') {
-                console.warn("[WARNING] " + name + " is deprecated and will be removed in version 1.0. Instead, use `" + instead + "`.");
-            }
-            _deprecationWarnings[name] = true;
-        }
-    }
-
-    namespace.strftimeTZ = deprecatedStrftimeTZ;
-    namespace.strftimeUTC = deprecatedStrftimeUTC;
-    namespace.localizedStrftime = deprecatedStrftimeLocalized;
-
-    // Adapt the old API while preserving the new API.
-    function adaptForwards(fn) {
-        fn.localize = defaultStrftime.localize.bind(defaultStrftime);
-        fn.timezone = defaultStrftime.timezone.bind(defaultStrftime);
-        fn.utc = defaultStrftime.utc.bind(defaultStrftime);
-    }
-
-    adaptForwards(adaptedStrftime);
-    function adaptedStrftime(fmt, d, locale) {
-        // d and locale are optional, check if this is (format, locale)
-        if (d && d.days) {
-            locale = d;
-            d = undefined;
-        }
-        if (locale) {
-            deprecationWarning("`" + _require + "(format, [date], [locale])`", "var s = " + _require + ".localize(locale); s(format, [date])");
-        }
-        var strftime = locale ? defaultStrftime.localize(locale) : defaultStrftime;
-        return strftime(fmt, d);
-    }
-
-    adaptForwards(deprecatedStrftime);
-    function deprecatedStrftime(fmt, d, locale) {
-        if (locale) {
-            deprecationWarning("`" + _require + ".strftime(format, [date], [locale])`", "var s = " + _require + ".localize(locale); s(format, [date])");
-        } else {
-            deprecationWarning("`" + _require + ".strftime(format, [date])`", _require + "(format, [date])");
-        }
-        var strftime = locale ? defaultStrftime.localize(locale) : defaultStrftime;
-        return strftime(fmt, d);
-    }
-
-    function deprecatedStrftimeTZ(fmt, d, locale, timezone) {
-        // locale is optional, check if this is (format, date, timezone)
-        if ((typeof locale == 'number' || typeof locale == 'string') && timezone == null) {
-            timezone = locale;
-            locale = undefined;
-        }
-
-        if (locale) {
-            deprecationWarning("`" + _require + ".strftimeTZ(format, date, locale, tz)`", "var s = " + _require + ".localize(locale).timezone(tz); s(format, [date])` or `var s = " + _require + ".localize(locale); s.timezone(tz)(format, [date])");
-        } else {
-            deprecationWarning("`" + _require + ".strftimeTZ(format, date, tz)`", "var s = " + _require + ".timezone(tz); s(format, [date])` or `" + _require + ".timezone(tz)(format, [date])");
-        }
-
-        var strftime = (locale ? defaultStrftime.localize(locale) : defaultStrftime).timezone(timezone);
-        return strftime(fmt, d);
-    }
-
-    var utcStrftime = defaultStrftime.utc();
-    function deprecatedStrftimeUTC(fmt, d, locale) {
-        if (locale) {
-            deprecationWarning("`" + _require + ".strftimeUTC(format, date, locale)`", "var s = " + _require + ".localize(locale).utc(); s(format, [date])");
-        } else {
-            deprecationWarning("`" + _require + ".strftimeUTC(format, [date])`", "var s = " + _require + ".utc(); s(format, [date])");
-        }
-        var strftime = locale ? utcStrftime.localize(locale) : utcStrftime;
-        return strftime(fmt, d);
-    }
-
-    function deprecatedStrftimeLocalized(locale) {
-        deprecationWarning("`" + _require + ".localizedStrftime(locale)`", _require + ".localize(locale)");
-        return defaultStrftime.localize(locale);
-    }
-    // End of deprecated API
-
-    // Polyfill Date.now for old browsers.
-    if (typeof Date.now !== 'function') {
-        Date.now = function () {
-            return +new Date();
-        };
-    }
-
-    function Strftime(locale, customTimezoneOffset, useUtcTimezone) {
-        var _locale = locale || DefaultLocale,
-            _customTimezoneOffset = customTimezoneOffset || 0,
-            _useUtcBasedDate = useUtcTimezone || false,
-
-
-        // we store unix timestamp value here to not create new Date() each iteration (each millisecond)
-        // Date.now() is 2 times faster than new Date()
-        // while millisecond precise is enough here
-        // this could be very helpful when strftime triggered a lot of times one by one
-        _cachedDateTimestamp = 0,
-            _cachedDate;
-
-        function _strftime(format, date) {
-            var timestamp;
-
-            if (!date) {
-                var currentTimestamp = Date.now();
-                if (currentTimestamp > _cachedDateTimestamp) {
-                    _cachedDateTimestamp = currentTimestamp;
-                    _cachedDate = new Date(_cachedDateTimestamp);
-
-                    timestamp = _cachedDateTimestamp;
-
-                    if (_useUtcBasedDate) {
-                        // how to avoid duplication of date instantiation for utc here?
-                        // we tied to getTimezoneOffset of the current date
-                        _cachedDate = new Date(_cachedDateTimestamp + getTimestampToUtcOffsetFor(_cachedDate) + _customTimezoneOffset);
-                    }
-                } else {
-                    timestamp = _cachedDateTimestamp;
-                }
-                date = _cachedDate;
-            } else {
-                timestamp = date.getTime();
-
-                if (_useUtcBasedDate) {
-                    date = new Date(date.getTime() + getTimestampToUtcOffsetFor(date) + _customTimezoneOffset);
-                }
-            }
-
-            return _processFormat(format, date, _locale, timestamp);
-        }
-
-        function _processFormat(format, date, locale, timestamp) {
-            var resultString = '',
-                padding = null,
-                isInScope = false,
-                length = format.length,
-                extendedTZ = false;
-
-            for (var i = 0; i < length; i++) {
-
-                var currentCharCode = format.charCodeAt(i);
-
-                if (isInScope === true) {
-                    // '-'
-                    if (currentCharCode === 45) {
-                        padding = '';
-                        continue;
-                    }
-                    // '_'
-                    else if (currentCharCode === 95) {
-                            padding = ' ';
-                            continue;
-                        }
-                        // '0'
-                        else if (currentCharCode === 48) {
-                                padding = '0';
-                                continue;
-                            }
-                            // ':'
-                            else if (currentCharCode === 58) {
-                                    if (extendedTZ) {
-                                        if (typeof console !== 'undefined' && typeof console.warn == 'function') {
-                                            console.warn("[WARNING] detected use of unsupported %:: or %::: modifiers to strftime");
-                                        }
-                                    }
-                                    extendedTZ = true;
-                                    continue;
-                                }
-
-                    switch (currentCharCode) {
-
-                        // Examples for new Date(0) in GMT
-
-                        // 'Thursday'
-                        // case 'A':
-                        case 65:
-                            resultString += locale.days[date.getDay()];
-                            break;
-
-                        // 'January'
-                        // case 'B':
-                        case 66:
-                            resultString += locale.months[date.getMonth()];
-                            break;
-
-                        // '19'
-                        // case 'C':
-                        case 67:
-                            resultString += padTill2(Math.floor(date.getFullYear() / 100), padding);
-                            break;
-
-                        // '01/01/70'
-                        // case 'D':
-                        case 68:
-                            resultString += _processFormat(locale.formats.D, date, locale, timestamp);
-                            break;
-
-                        // '1970-01-01'
-                        // case 'F':
-                        case 70:
-                            resultString += _processFormat(locale.formats.F, date, locale, timestamp);
-                            break;
-
-                        // '00'
-                        // case 'H':
-                        case 72:
-                            resultString += padTill2(date.getHours(), padding);
-                            break;
-
-                        // '12'
-                        // case 'I':
-                        case 73:
-                            resultString += padTill2(hours12(date.getHours()), padding);
-                            break;
-
-                        // '000'
-                        // case 'L':
-                        case 76:
-                            resultString += padTill3(Math.floor(timestamp % 1000));
-                            break;
-
-                        // '00'
-                        // case 'M':
-                        case 77:
-                            resultString += padTill2(date.getMinutes(), padding);
-                            break;
-
-                        // 'am'
-                        // case 'P':
-                        case 80:
-                            resultString += date.getHours() < 12 ? locale.am : locale.pm;
-                            break;
-
-                        // '00:00'
-                        // case 'R':
-                        case 82:
-                            resultString += _processFormat(locale.formats.R, date, locale, timestamp);
-                            break;
-
-                        // '00'
-                        // case 'S':
-                        case 83:
-                            resultString += padTill2(date.getSeconds(), padding);
-                            break;
-
-                        // '00:00:00'
-                        // case 'T':
-                        case 84:
-                            resultString += _processFormat(locale.formats.T, date, locale, timestamp);
-                            break;
-
-                        // '00'
-                        // case 'U':
-                        case 85:
-                            resultString += padTill2(weekNumber(date, 'sunday'), padding);
-                            break;
-
-                        // '00'
-                        // case 'W':
-                        case 87:
-                            resultString += padTill2(weekNumber(date, 'monday'), padding);
-                            break;
-
-                        // '16:00:00'
-                        // case 'X':
-                        case 88:
-                            resultString += _processFormat(locale.formats.X, date, locale, timestamp);
-                            break;
-
-                        // '1970'
-                        // case 'Y':
-                        case 89:
-                            resultString += date.getFullYear();
-                            break;
-
-                        // 'GMT'
-                        // case 'Z':
-                        case 90:
-                            if (_useUtcBasedDate && _customTimezoneOffset === 0) {
-                                resultString += "GMT";
-                            } else {
-                                // fixme optimize
-                                var tzString = date.toString().match(/\(([\w\s]+)\)/);
-                                resultString += tzString && tzString[1] || '';
-                            }
-                            break;
-
-                        // 'Thu'
-                        // case 'a':
-                        case 97:
-                            resultString += locale.shortDays[date.getDay()];
-                            break;
-
-                        // 'Jan'
-                        // case 'b':
-                        case 98:
-                            resultString += locale.shortMonths[date.getMonth()];
-                            break;
-
-                        // ''
-                        // case 'c':
-                        case 99:
-                            resultString += _processFormat(locale.formats.c, date, locale, timestamp);
-                            break;
-
-                        // '01'
-                        // case 'd':
-                        case 100:
-                            resultString += padTill2(date.getDate(), padding);
-                            break;
-
-                        // ' 1'
-                        // case 'e':
-                        case 101:
-                            resultString += padTill2(date.getDate(), padding == null ? ' ' : padding);
-                            break;
-
-                        // 'Jan'
-                        // case 'h':
-                        case 104:
-                            resultString += locale.shortMonths[date.getMonth()];
-                            break;
-
-                        // '000'
-                        // case 'j':
-                        case 106:
-                            var y = new Date(date.getFullYear(), 0, 1);
-                            var day = Math.ceil((date.getTime() - y.getTime()) / (1000 * 60 * 60 * 24));
-                            resultString += padTill3(day);
-                            break;
-
-                        // ' 0'
-                        // case 'k':
-                        case 107:
-                            resultString += padTill2(date.getHours(), padding == null ? ' ' : padding);
-                            break;
-
-                        // '12'
-                        // case 'l':
-                        case 108:
-                            resultString += padTill2(hours12(date.getHours()), padding == null ? ' ' : padding);
-                            break;
-
-                        // '01'
-                        // case 'm':
-                        case 109:
-                            resultString += padTill2(date.getMonth() + 1, padding);
-                            break;
-
-                        // '\n'
-                        // case 'n':
-                        case 110:
-                            resultString += '\n';
-                            break;
-
-                        // '1st'
-                        // case 'o':
-                        case 111:
-                            resultString += String(date.getDate()) + ordinal(date.getDate());
-                            break;
-
-                        // 'AM'
-                        // case 'p':
-                        case 112:
-                            resultString += date.getHours() < 12 ? locale.AM : locale.PM;
-                            break;
-
-                        // '12:00:00 AM'
-                        // case 'r':
-                        case 114:
-                            resultString += _processFormat(locale.formats.r, date, locale, timestamp);
-                            break;
-
-                        // '0'
-                        // case 's':
-                        case 115:
-                            resultString += Math.floor(timestamp / 1000);
-                            break;
-
-                        // '\t'
-                        // case 't':
-                        case 116:
-                            resultString += '\t';
-                            break;
-
-                        // '4'
-                        // case 'u':
-                        case 117:
-                            var day = date.getDay();
-                            resultString += day === 0 ? 7 : day;
-                            break; // 1 - 7, Monday is first day of the week
-
-                        // ' 1-Jan-1970'
-                        // case 'v':
-                        case 118:
-                            resultString += _processFormat(locale.formats.v, date, locale, timestamp);
-                            break;
-
-                        // '4'
-                        // case 'w':
-                        case 119:
-                            resultString += date.getDay();
-                            break; // 0 - 6, Sunday is first day of the week
-
-                        // '12/31/69'
-                        // case 'x':
-                        case 120:
-                            resultString += _processFormat(locale.formats.x, date, locale, timestamp);
-                            break;
-
-                        // '70'
-                        // case 'y':
-                        case 121:
-                            resultString += ('' + date.getFullYear()).slice(2);
-                            break;
-
-                        // '+0000'
-                        // case 'z':
-                        case 122:
-                            if (_useUtcBasedDate && _customTimezoneOffset === 0) {
-                                resultString += extendedTZ ? "+00:00" : "+0000";
-                            } else {
-                                var off;
-                                if (_customTimezoneOffset !== 0) {
-                                    off = _customTimezoneOffset / (60 * 1000);
-                                } else {
-                                    off = -date.getTimezoneOffset();
-                                }
-                                var sign = off < 0 ? '-' : '+';
-                                var sep = extendedTZ ? ':' : '';
-                                var hours = Math.floor(Math.abs(off / 60));
-                                var mins = Math.abs(off % 60);
-                                resultString += sign + padTill2(hours) + sep + padTill2(mins);
-                            }
-                            break;
-
-                        default:
-                            resultString += format[i];
-                            break;
-                    }
-
-                    padding = null;
-                    isInScope = false;
-                    continue;
-                }
-
-                // '%'
-                if (currentCharCode === 37) {
-                    isInScope = true;
-                    continue;
-                }
-
-                resultString += format[i];
-            }
-
-            return resultString;
-        }
-
-        var strftime = _strftime;
-
-        strftime.localize = function (locale) {
-            return new Strftime(locale || _locale, _customTimezoneOffset, _useUtcBasedDate);
-        };
-
-        strftime.timezone = function (timezone) {
-            var customTimezoneOffset = _customTimezoneOffset;
-            var useUtcBasedDate = _useUtcBasedDate;
-
-            var timezoneType = typeof timezone === 'undefined' ? 'undefined' : _typeof(timezone);
-            if (timezoneType === 'number' || timezoneType === 'string') {
-                useUtcBasedDate = true;
-
-                // ISO 8601 format timezone string, [-+]HHMM
-                if (timezoneType === 'string') {
-                    var sign = timezone[0] === '-' ? -1 : 1,
-                        hours = parseInt(timezone.slice(1, 3), 10),
-                        minutes = parseInt(timezone.slice(3, 5), 10);
-
-                    customTimezoneOffset = sign * (60 * hours + minutes) * 60 * 1000;
-                    // in minutes: 420
-                } else if (timezoneType === 'number') {
-                    customTimezoneOffset = timezone * 60 * 1000;
-                }
-            }
-
-            return new Strftime(_locale, customTimezoneOffset, useUtcBasedDate);
-        };
-
-        strftime.utc = function () {
-            return new Strftime(_locale, _customTimezoneOffset, true);
-        };
-
-        return strftime;
-    }
-
-    function padTill2(numberToPad, paddingChar) {
-        if (paddingChar === '' || numberToPad > 9) {
-            return numberToPad;
-        }
-        if (paddingChar == null) {
-            paddingChar = '0';
-        }
-        return paddingChar + numberToPad;
-    }
-
-    function padTill3(numberToPad) {
-        if (numberToPad > 99) {
-            return numberToPad;
-        }
-        if (numberToPad > 9) {
-            return '0' + numberToPad;
-        }
-        return '00' + numberToPad;
-    }
-
-    function hours12(hour) {
-        if (hour === 0) {
-            return 12;
-        } else if (hour > 12) {
-            return hour - 12;
-        }
-        return hour;
-    }
-
-    // firstWeekday: 'sunday' or 'monday', default is 'sunday'
-    //
-    // Pilfered & ported from Ruby's strftime implementation.
-    function weekNumber(date, firstWeekday) {
-        firstWeekday = firstWeekday || 'sunday';
-
-        // This works by shifting the weekday back by one day if we
-        // are treating Monday as the first day of the week.
-        var weekday = date.getDay();
-        if (firstWeekday === 'monday') {
-            if (weekday === 0) // Sunday
-                weekday = 6;else weekday--;
-        }
-
-        var firstDayOfYearUtc = Date.UTC(date.getFullYear(), 0, 1),
-            dateUtc = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()),
-            yday = Math.floor((dateUtc - firstDayOfYearUtc) / 86400000),
-            weekNum = (yday + 7 - weekday) / 7;
-
-        return Math.floor(weekNum);
-    }
-
-    // Get the ordinal suffix for a number: st, nd, rd, or th
-    function ordinal(number) {
-        var i = number % 10;
-        var ii = number % 100;
-
-        if (ii >= 11 && ii <= 13 || i === 0 || i >= 4) {
-            return 'th';
-        }
-        switch (i) {
-            case 1:
-                return 'st';
-            case 2:
-                return 'nd';
-            case 3:
-                return 'rd';
-        }
-    }
-
-    function getTimestampToUtcOffsetFor(date) {
-        return (date.getTimezoneOffset() || 0) * 60000;
-    }
-})();
-
-},{}],11:[function(require,module,exports){
-'use strict';
-
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    ctor.prototype = Object.create(superCtor.prototype, {
-      constructor: {
-        value: ctor,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-  };
-} else {
-  // old school shim for old browsers
-  module.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    var TempCtor = function TempCtor() {};
-    TempCtor.prototype = superCtor.prototype;
-    ctor.prototype = new TempCtor();
-    ctor.prototype.constructor = ctor;
-  };
-}
-
-},{}],12:[function(require,module,exports){
-'use strict';
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
-
-module.exports = function isBuffer(arg) {
-  return arg && (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function';
-};
-
-},{}],13:[function(require,module,exports){
-(function (process,global){
-'use strict';
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
-
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-var formatRegExp = /%[sdj%]/g;
-exports.format = function (f) {
-  if (!isString(f)) {
-    var objects = [];
-    for (var i = 0; i < arguments.length; i++) {
-      objects.push(inspect(arguments[i]));
-    }
-    return objects.join(' ');
-  }
-
-  var i = 1;
-  var args = arguments;
-  var len = args.length;
-  var str = String(f).replace(formatRegExp, function (x) {
-    if (x === '%%') return '%';
-    if (i >= len) return x;
-    switch (x) {
-      case '%s':
-        return String(args[i++]);
-      case '%d':
-        return Number(args[i++]);
-      case '%j':
-        try {
-          return JSON.stringify(args[i++]);
-        } catch (_) {
-          return '[Circular]';
-        }
-      default:
-        return x;
-    }
-  });
-  for (var x = args[i]; i < len; x = args[++i]) {
-    if (isNull(x) || !isObject(x)) {
-      str += ' ' + x;
-    } else {
-      str += ' ' + inspect(x);
-    }
-  }
-  return str;
-};
-
-// Mark that a method should not be used.
-// Returns a modified function which warns once by default.
-// If --no-deprecation is set, then it is a no-op.
-exports.deprecate = function (fn, msg) {
-  // Allow for deprecating things in the process of starting up.
-  if (isUndefined(global.process)) {
-    return function () {
-      return exports.deprecate(fn, msg).apply(this, arguments);
-    };
-  }
-
-  if (process.noDeprecation === true) {
-    return fn;
-  }
-
-  var warned = false;
-  function deprecated() {
-    if (!warned) {
-      if (process.throwDeprecation) {
-        throw new Error(msg);
-      } else if (process.traceDeprecation) {
-        console.trace(msg);
-      } else {
-        console.error(msg);
-      }
-      warned = true;
-    }
-    return fn.apply(this, arguments);
-  }
-
-  return deprecated;
-};
-
-var debugs = {};
-var debugEnviron;
-exports.debuglog = function (set) {
-  if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';
-  set = set.toUpperCase();
-  if (!debugs[set]) {
-    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
-      var pid = process.pid;
-      debugs[set] = function () {
-        var msg = exports.format.apply(exports, arguments);
-        console.error('%s %d: %s', set, pid, msg);
-      };
-    } else {
-      debugs[set] = function () {};
-    }
-  }
-  return debugs[set];
-};
-
-/**
- * Echos the value of a value. Trys to print the value out
- * in the best way possible given the different types.
- *
- * @param {Object} obj The object to print out.
- * @param {Object} opts Optional options object that alters the output.
- */
-/* legacy: obj, showHidden, depth, colors*/
-function inspect(obj, opts) {
-  // default options
-  var ctx = {
-    seen: [],
-    stylize: stylizeNoColor
-  };
-  // legacy...
-  if (arguments.length >= 3) ctx.depth = arguments[2];
-  if (arguments.length >= 4) ctx.colors = arguments[3];
-  if (isBoolean(opts)) {
-    // legacy...
-    ctx.showHidden = opts;
-  } else if (opts) {
-    // got an "options" object
-    exports._extend(ctx, opts);
-  }
-  // set default options
-  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
-  if (isUndefined(ctx.depth)) ctx.depth = 2;
-  if (isUndefined(ctx.colors)) ctx.colors = false;
-  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
-  if (ctx.colors) ctx.stylize = stylizeWithColor;
-  return formatValue(ctx, obj, ctx.depth);
-}
-exports.inspect = inspect;
-
-// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
-inspect.colors = {
-  'bold': [1, 22],
-  'italic': [3, 23],
-  'underline': [4, 24],
-  'inverse': [7, 27],
-  'white': [37, 39],
-  'grey': [90, 39],
-  'black': [30, 39],
-  'blue': [34, 39],
-  'cyan': [36, 39],
-  'green': [32, 39],
-  'magenta': [35, 39],
-  'red': [31, 39],
-  'yellow': [33, 39]
-};
-
-// Don't use 'blue' not visible on cmd.exe
-inspect.styles = {
-  'special': 'cyan',
-  'number': 'yellow',
-  'boolean': 'yellow',
-  'undefined': 'grey',
-  'null': 'bold',
-  'string': 'green',
-  'date': 'magenta',
-  // "name": intentionally not styling
-  'regexp': 'red'
-};
-
-function stylizeWithColor(str, styleType) {
-  var style = inspect.styles[styleType];
-
-  if (style) {
-    return '\u001b[' + inspect.colors[style][0] + 'm' + str + '\u001b[' + inspect.colors[style][1] + 'm';
-  } else {
-    return str;
-  }
-}
-
-function stylizeNoColor(str, styleType) {
-  return str;
-}
-
-function arrayToHash(array) {
-  var hash = {};
-
-  array.forEach(function (val, idx) {
-    hash[val] = true;
-  });
-
-  return hash;
-}
-
-function formatValue(ctx, value, recurseTimes) {
-  // Provide a hook for user-specified inspect functions.
-  // Check that value is an object with an inspect function on it
-  if (ctx.customInspect && value && isFunction(value.inspect) &&
-  // Filter out the util module, it's inspect function is special
-  value.inspect !== exports.inspect &&
-  // Also filter out any prototype objects using the circular check.
-  !(value.constructor && value.constructor.prototype === value)) {
-    var ret = value.inspect(recurseTimes, ctx);
-    if (!isString(ret)) {
-      ret = formatValue(ctx, ret, recurseTimes);
-    }
-    return ret;
-  }
-
-  // Primitive types cannot have properties
-  var primitive = formatPrimitive(ctx, value);
-  if (primitive) {
-    return primitive;
-  }
-
-  // Look up the keys of the object.
-  var keys = Object.keys(value);
-  var visibleKeys = arrayToHash(keys);
-
-  if (ctx.showHidden) {
-    keys = Object.getOwnPropertyNames(value);
-  }
-
-  // IE doesn't make error fields non-enumerable
-  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
-  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
-    return formatError(value);
-  }
-
-  // Some type of object without properties can be shortcutted.
-  if (keys.length === 0) {
-    if (isFunction(value)) {
-      var name = value.name ? ': ' + value.name : '';
-      return ctx.stylize('[Function' + name + ']', 'special');
-    }
-    if (isRegExp(value)) {
-      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
-    }
-    if (isDate(value)) {
-      return ctx.stylize(Date.prototype.toString.call(value), 'date');
-    }
-    if (isError(value)) {
-      return formatError(value);
-    }
-  }
-
-  var base = '',
-      array = false,
-      braces = ['{', '}'];
-
-  // Make Array say that they are Array
-  if (isArray(value)) {
-    array = true;
-    braces = ['[', ']'];
-  }
-
-  // Make functions say that they are functions
-  if (isFunction(value)) {
-    var n = value.name ? ': ' + value.name : '';
-    base = ' [Function' + n + ']';
-  }
-
-  // Make RegExps say that they are RegExps
-  if (isRegExp(value)) {
-    base = ' ' + RegExp.prototype.toString.call(value);
-  }
-
-  // Make dates with properties first say the date
-  if (isDate(value)) {
-    base = ' ' + Date.prototype.toUTCString.call(value);
-  }
-
-  // Make error with message first say the error
-  if (isError(value)) {
-    base = ' ' + formatError(value);
-  }
-
-  if (keys.length === 0 && (!array || value.length == 0)) {
-    return braces[0] + base + braces[1];
-  }
-
-  if (recurseTimes < 0) {
-    if (isRegExp(value)) {
-      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
-    } else {
-      return ctx.stylize('[Object]', 'special');
-    }
-  }
-
-  ctx.seen.push(value);
-
-  var output;
-  if (array) {
-    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
-  } else {
-    output = keys.map(function (key) {
-      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
-    });
-  }
-
-  ctx.seen.pop();
-
-  return reduceToSingleString(output, base, braces);
-}
-
-function formatPrimitive(ctx, value) {
-  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');
-  if (isString(value)) {
-    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\'';
-    return ctx.stylize(simple, 'string');
-  }
-  if (isNumber(value)) return ctx.stylize('' + value, 'number');
-  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
-  // For some reason typeof null is "object", so special case here.
-  if (isNull(value)) return ctx.stylize('null', 'null');
-}
-
-function formatError(value) {
-  return '[' + Error.prototype.toString.call(value) + ']';
-}
-
-function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
-  var output = [];
-  for (var i = 0, l = value.length; i < l; ++i) {
-    if (hasOwnProperty(value, String(i))) {
-      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
-    } else {
-      output.push('');
-    }
-  }
-  keys.forEach(function (key) {
-    if (!key.match(/^\d+$/)) {
-      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
-    }
-  });
-  return output;
-}
-
-function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
-  var name, str, desc;
-  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
-  if (desc.get) {
-    if (desc.set) {
-      str = ctx.stylize('[Getter/Setter]', 'special');
-    } else {
-      str = ctx.stylize('[Getter]', 'special');
-    }
-  } else {
-    if (desc.set) {
-      str = ctx.stylize('[Setter]', 'special');
-    }
-  }
-  if (!hasOwnProperty(visibleKeys, key)) {
-    name = '[' + key + ']';
-  }
-  if (!str) {
-    if (ctx.seen.indexOf(desc.value) < 0) {
-      if (isNull(recurseTimes)) {
-        str = formatValue(ctx, desc.value, null);
-      } else {
-        str = formatValue(ctx, desc.value, recurseTimes - 1);
-      }
-      if (str.indexOf('\n') > -1) {
-        if (array) {
-          str = str.split('\n').map(function (line) {
-            return '  ' + line;
-          }).join('\n').substr(2);
-        } else {
-          str = '\n' + str.split('\n').map(function (line) {
-            return '   ' + line;
-          }).join('\n');
-        }
-      }
-    } else {
-      str = ctx.stylize('[Circular]', 'special');
-    }
-  }
-  if (isUndefined(name)) {
-    if (array && key.match(/^\d+$/)) {
-      return str;
-    }
-    name = JSON.stringify('' + key);
-    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
-      name = name.substr(1, name.length - 2);
-      name = ctx.stylize(name, 'name');
-    } else {
-      name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
-      name = ctx.stylize(name, 'string');
-    }
-  }
-
-  return name + ': ' + str;
-}
-
-function reduceToSingleString(output, base, braces) {
-  var numLinesEst = 0;
-  var length = output.reduce(function (prev, cur) {
-    numLinesEst++;
-    if (cur.indexOf('\n') >= 0) numLinesEst++;
-    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
-  }, 0);
-
-  if (length > 60) {
-    return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n  ') + ' ' + braces[1];
-  }
-
-  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
-}
-
-// NOTE: These type checking functions intentionally don't use `instanceof`
-// because it is fragile and can be easily faked with `Object.create()`.
-function isArray(ar) {
-  return Array.isArray(ar);
-}
-exports.isArray = isArray;
-
-function isBoolean(arg) {
-  return typeof arg === 'boolean';
-}
-exports.isBoolean = isBoolean;
-
-function isNull(arg) {
-  return arg === null;
-}
-exports.isNull = isNull;
-
-function isNullOrUndefined(arg) {
-  return arg == null;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
-
-function isNumber(arg) {
-  return typeof arg === 'number';
-}
-exports.isNumber = isNumber;
-
-function isString(arg) {
-  return typeof arg === 'string';
-}
-exports.isString = isString;
-
-function isSymbol(arg) {
-  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol';
-}
-exports.isSymbol = isSymbol;
-
-function isUndefined(arg) {
-  return arg === void 0;
-}
-exports.isUndefined = isUndefined;
-
-function isRegExp(re) {
-  return isObject(re) && objectToString(re) === '[object RegExp]';
-}
-exports.isRegExp = isRegExp;
-
-function isObject(arg) {
-  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && arg !== null;
-}
-exports.isObject = isObject;
-
-function isDate(d) {
-  return isObject(d) && objectToString(d) === '[object Date]';
-}
-exports.isDate = isDate;
-
-function isError(e) {
-  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
-}
-exports.isError = isError;
-
-function isFunction(arg) {
-  return typeof arg === 'function';
-}
-exports.isFunction = isFunction;
-
-function isPrimitive(arg) {
-  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol' || // ES6 symbol
-  typeof arg === 'undefined';
-}
-exports.isPrimitive = isPrimitive;
-
-exports.isBuffer = require('./support/isBuffer');
-
-function objectToString(o) {
-  return Object.prototype.toString.call(o);
-}
-
-function pad(n) {
-  return n < 10 ? '0' + n.toString(10) : n.toString(10);
-}
-
-var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-
-// 26 Feb 16:19:34
-function timestamp() {
-  var d = new Date();
-  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');
-  return [d.getDate(), months[d.getMonth()], time].join(' ');
-}
-
-// log is just a thin wrapper to console.log that prepends a timestamp
-exports.log = function () {
-  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
-};
-
-/**
- * Inherit the prototype methods from one constructor into another.
- *
- * The Function.prototype.inherits from lang.js rewritten as a standalone
- * function (not on Function.prototype). NOTE: If this file is to be loaded
- * during bootstrapping this function needs to be rewritten using some native
- * functions as prototype setup using normal JavaScript does not work as
- * expected during bootstrapping (see mirror.js in r114903).
- *
- * @param {function} ctor Constructor function which needs to inherit the
- *     prototype.
- * @param {function} superCtor Constructor function to inherit prototype from.
- */
-exports.inherits = require('inherits');
-
-exports._extend = function (origin, add) {
-  // Don't do anything if add isn't an object
-  if (!add || !isObject(add)) return origin;
-
-  var keys = Object.keys(add);
-  var i = keys.length;
-  while (i--) {
-    origin[keys[i]] = add[keys[i]];
-  }
-  return origin;
-};
-
-function hasOwnProperty(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./support/isBuffer":12,"_process":9,"inherits":11}],14:[function(require,module,exports){
-"use strict";
-
-var util = require('util');
-
-function TokenizationError(message, input, line) {
-    Error.captureStackTrace(this, this.constructor);
-    this.name = this.constructor.name;
-
-    this.message = message || "";
-    this.input = input;
-    this.line = line;
-}
-util.inherits(TokenizationError, Error);
-
-function ParseError(message, input, line) {
-    Error.captureStackTrace(this, this.constructor);
-    this.name = this.constructor.name;
-
-    this.message = message || "";
-    this.input = input;
-    this.line = line;
-}
-util.inherits(ParseError, Error);
-
-module.exports = {
-    TokenizationError: TokenizationError, ParseError: ParseError
-};
-
-},{"util":13}],15:[function(require,module,exports){
-'use strict';
-
-var syntax = require('./syntax.js');
-var Exp = require('./expression.js');
-var lexical = require('./lexical.js');
-
-function evalExp(exp, scope) {
-    if (!scope) throw new Error('unable to evalExp: scope undefined');
-    var operatorREs = lexical.operators,
-        match;
-    for (var i = 0; i < operatorREs.length; i++) {
-        var operatorRE = operatorREs[i];
-        var expRE = new RegExp('^(' + lexical.quoteBalanced.source + ')(' + operatorRE.source + ')(' + lexical.quoteBalanced.source + ')$');
-        if (match = exp.match(expRE)) {
-            var l = evalExp(match[1], scope);
-            var op = syntax.operators[match[2].trim()];
-            var r = evalExp(match[3], scope);
-            return op(l, r);
-        }
-    }
-
-    if (match = exp.match(lexical.rangeLine)) {
-        var low = evalValue(match[1], scope),
-            high = evalValue(match[2], scope);
-        var range = [];
-        for (var j = low; j <= high; j++) {
-            range.push(j);
-        }
-        return range;
-    }
-
-    return evalValue(exp, scope);
-}
-
-function evalValue(str, scope) {
-    str = str && str.trim();
-    if (!str) return undefined;
-
-    if (lexical.isLiteral(str)) {
-        var a = lexical.parseLiteral(str);
-        return lexical.parseLiteral(str);
-    }
-    if (lexical.isVariable(str)) {
-        return scope.get(str);
-    }
-}
-
-function isTruthy(val) {
-    if (val instanceof Array) return !!val.length;
-    return !!val;
-}
-
-function isFalsy(val) {
-    return !isTruthy(val);
-}
-
-module.exports = {
-    evalExp: evalExp, evalValue: evalValue, isTruthy: isTruthy, isFalsy: isFalsy
-};
-
-},{"./expression.js":15,"./lexical.js":17,"./syntax.js":21}],16:[function(require,module,exports){
-'use strict';
-
-var lexical = require('./lexical.js');
-var Exp = require('./expression.js');
-
-var valueRE = new RegExp('' + lexical.value.source, 'g');
-
-module.exports = function () {
-    var filters = {};
-
-    var _filterInstance = {
-        render: function render(output, scope) {
-            var args = this.args.map(function (arg) {
-                return Exp.evalValue(arg, scope);
-            });
-            args.unshift(output);
-            return this.filter.apply(null, args);
-        },
-        parse: function parse(str) {
-            var match = lexical.filterLine.exec(str);
-            if (!match) throw new Error('illegal filter: ' + str);
-
-            var name = match[1],
-                argList = match[2] || '',
-                filter = filters[name];
-            if (typeof filter !== 'function') {
-                return {
-                    name: name,
-                    error: new Error('undefined filter: ' + name)
-                };
-            }
-
-            var args = [];
-            while (match = valueRE.exec(argList.trim())) {
-                args.push(match[0]);
-            }
-
-            this.name = name;
-            this.filter = filter;
-            this.args = args;
-
-            return this;
-        }
-    };
-
-    function construct(str) {
-        var instance = Object.create(_filterInstance);
-        return instance.parse(str);
-    }
-
-    function register(name, filter) {
-        filters[name] = filter;
-    }
-
-    function clear() {
-        filters = {};
-    }
-
-    return {
-        construct: construct, register: register, clear: clear
-    };
-};
-
-},{"./expression.js":15,"./lexical.js":17}],17:[function(require,module,exports){
-'use strict';
-
-// quote related
-var singleQuoted = /'[^']*'/;
-var doubleQuoted = /"[^"]*"/;
-var quoteBalanced = new RegExp('(?:' + singleQuoted.source + '|' + doubleQuoted.source + '|[^\'"])*');
-
-var number = /(?:-?\d+\.?\d*|\.?\d+)/;
-var bool = /true|false/;
-var identifier = /[a-zA-Z_$][a-zA-Z_$0-9]*/;
-var subscript = /\[\d+\]/;
-
-var quoted = new RegExp('(?:' + singleQuoted.source + '|' + doubleQuoted.source + ')');
-var literal = new RegExp('(?:' + quoted.source + '|' + bool.source + '|' + number.source + ')');
-var variable = new RegExp(identifier.source + '(?:\\.' + identifier.source + '|' + subscript.source + ')*');
-
-// range related
-var rangeLimit = new RegExp('(?:' + variable.source + '|' + number.source + ')');
-var range = new RegExp('\\(' + rangeLimit.source + '\\.\\.' + rangeLimit.source + '\\)');
-var rangeCapture = new RegExp('\\((' + rangeLimit.source + ')\\.\\.(' + rangeLimit.source + ')\\)');
-
-var value = new RegExp('(?:' + literal.source + '|' + variable.source + '|' + range.source + ')');
-
-// hash related
-var hash = new RegExp('(?:' + identifier.source + ')\\s*:\\s*(?:' + value.source + ')');
-var hashCapture = new RegExp('(' + identifier.source + ')\\s*:\\s*(' + value.source + ')', 'g');
-
-var tagLine = new RegExp('^\\s*(' + identifier.source + ')\\s*(.*)\\s*$');
-var literalLine = new RegExp('^' + literal.source + '$', 'i');
-var variableLine = new RegExp('^' + variable.source + '$');
-var numberLine = new RegExp('^' + number.source + '$');
-var boolLine = new RegExp('^' + bool.source + '$', 'i');
-var quotedLine = new RegExp('^' + quoted.source + '$');
-var rangeLine = new RegExp('^' + rangeCapture.source + '$');
-
-// filter related
-var valueList = new RegExp(value.source + '(\\s*,\\s*' + value.source + ')*');
-var filter = new RegExp(identifier.source + '(?:\\s*:\\s*' + valueList.source + ')?', 'g');
-var filterCapture = new RegExp('(' + identifier.source + ')(?:\\s*:\\s*(' + valueList.source + '))?');
-var filterLine = new RegExp('^' + filterCapture.source + '$');
-
-var operators = [/\s+or\s+/, /\s+and\s+/, /==|!=|<=|>=|<|>|\s+contains\s+/];
-
-function isLiteral(str) {
-    return literalLine.test(str);
-}
-
-function isRange(str) {
-    return rangeLine.test(str);
-}
-
-function isVariable(str) {
-    return variableLine.test(str);
-}
-
-function parseLiteral(str) {
-    var res;
-    if (res = str.match(numberLine)) {
-        return Number(str);
-    }
-    if (res = str.match(boolLine)) {
-        return str.toLowerCase() === 'true';
-    }
-    if (res = str.match(quotedLine)) {
-        return str.slice(1, -1);
-    }
-}
-
-module.exports = {
-    quoted: quoted, number: number, bool: bool, literal: literal, filter: filter,
-    hash: hash, hashCapture: hashCapture,
-    range: range, rangeCapture: rangeCapture,
-    identifier: identifier, value: value, quoteBalanced: quoteBalanced, operators: operators,
-    quotedLine: quotedLine, numberLine: numberLine, boolLine: boolLine, rangeLine: rangeLine, literalLine: literalLine, filterLine: filterLine, tagLine: tagLine,
-    isLiteral: isLiteral, isVariable: isVariable, parseLiteral: parseLiteral, isRange: isRange
-};
-
-},{}],18:[function(require,module,exports){
-'use strict';
-
-var lexical = require('./lexical.js');
-var ParseError = require('./error.js').ParseError;
-
-module.exports = function (Tag, Filter) {
-
-    var stream = {
-        init: function init(tokens) {
-            this.tokens = tokens;
-            this.handlers = {};
-            return this;
-        },
-        on: function on(name, cb) {
-            this.handlers[name] = cb;
-            return this;
-        },
-        trigger: function trigger(event, arg) {
-            var h = this.handlers[event];
-            if (typeof h === 'function') {
-                h(arg);
-                return true;
-            }
-        },
-        start: function start() {
-            this.trigger('start');
-            while (!this.stopRequested && (token = this.tokens.shift())) {
-                if (this.trigger('token', token)) continue;
-                if (token.type == 'tag' && this.trigger('tag:' + token.name, token)) {
-                    continue;
-                }
-                var template = parseToken(token, this.tokens);
-                this.trigger('template', template);
-            }
-            if (!this.stopRequested) this.trigger('end');
-            return this;
-        },
-        stop: function stop() {
-            this.stopRequested = true;
-            return this;
-        }
-    };
-
-    function parse(tokens) {
-        var token,
-            templates = [];
-        while (token = tokens.shift()) {
-            templates.push(parseToken(token, tokens));
-        }
-        return templates;
-    }
-
-    function parseToken(token, tokens) {
-        try {
-            switch (token.type) {
-                case 'tag':
-                    return parseTag(token, tokens);
-                case 'output':
-                    return parseOutput(token.value);
-                case 'html':
-                    return token;
-            }
-        } catch (e) {
-            throw new ParseError(e.message, token.input, token.line);
-        }
-    }
-
-    function parseTag(token, tokens) {
-        if (token.name === 'continue' || token.name === 'break') return token;
-        return Tag.construct(token, tokens);
-    }
-
-    function parseOutput(str) {
-        var match = lexical.value.exec(str);
-        if (!match) throw new Error('illegal output string: ' + str);
-
-        var initial = match[0];
-        str = str.substr(match.index + match[0].length);
-
-        var filters = [];
-        while (match = lexical.filter.exec(str)) {
-            filters.push([match[0].trim()]);
-        }
-
-        return {
-            type: 'output',
-            initial: initial,
-            filters: filters.map(function (str) {
-                return Filter.construct(str);
-            })
-        };
-    }
-
-    function parseStream(tokens) {
-        var s = Object.create(stream);
-        return s.init(tokens);
-    }
-
-    return {
-        parse: parse, parseTag: parseTag, parseStream: parseStream, parseOutput: parseOutput
-    };
-};
-
-},{"./error.js":14,"./lexical.js":17}],19:[function(require,module,exports){
-'use strict';
-
-var error = require('./error.js');
-var Exp = require('./expression.js');
-var assert = require('assert');
-var Promise = require('any-promise');
-
-var render = {
-
-    renderTemplates: function renderTemplates(templates, scope, opts) {
-        var _this = this;
-
-        assert(scope, 'unable to evalTemplates: scope undefined');
-        opts = opts || {};
-        opts.strict_filters = opts.strict_filters || false;
-
-        var html = '';
-
-        // This executes an array of promises sequentially for every template in the templates array - http://webcache.googleusercontent.com/search?q=cache:rNbMUn9TPtkJ:joost.vunderink.net/blog/2014/12/15/processing-an-array-of-promises-sequentially-in-node-js/+&cd=5&hl=en&ct=clnk&gl=us
-        // It's fundamentally equivalent to the following...
-        //  emptyPromise.then(renderTag(template0).then(renderTag(template1).then(renderTag(template2)...
-        var lastPromise = templates.reduce(function (promise, template) {
-            return promise.then(function (partial) {
-                if (scope.safeGet('forloop.skip')) {
-                    return Promise.resolve('');
-                }
-                if (scope.safeGet('forloop.stop')) {
-                    throw new Error('forloop.stop'); // this will stop/break the sequential promise chain and go to the catch
-                }
-
-                var promiseLink = Promise.resolve('');
-                switch (template.type) {
-                    case 'tag':
-                        // Add Promises to the chain
-                        promiseLink = _this.renderTag(template, scope, _this.register).then(function (partial) {
-                            if (partial === undefined) {
-                                return true; // basically a noop (do nothing)
-                            }
-                            return html += partial;
-                        });
-                        break;
-                    case 'html':
-                        promiseLink = Promise.resolve(template.value).then(function (partial) {
-                            return html += partial;
-                        });
-                        break;
-                    case 'output':
-                        var val = _this.evalOutput(template, scope, opts);
-                        promiseLink = Promise.resolve(val === undefined ? '' : stringify(val)).then(function (partial) {
-                            return html += partial;
-                        });
-                        break;
-                }
-
-                return promiseLink;
-            }).catch(function (error) {
-                if (error.message === 'forloop.skip') {
-                    // the error is a controlled, purposeful stop. so just return the html that we have up to this point
-                    return html;
-                } else {
-                    // rethrow actual error
-                    throw error;
-                }
-            });
-        }, Promise.resolve('')); // start the reduce chain with a resolved Promise. After first run, the "promise" argument
-        //  in our reduce callback will be the returned promise from our "then" above.  In this
-        //  case, that's the promise returned from this.renderTag or a resolved promise with raw html.
-
-        return lastPromise.then(function (renderedHtml) {
-            return renderedHtml;
-        }).catch(function (error) {
-            throw error;
-        });
-    },
-
-    renderTag: function renderTag(template, scope, register) {
-        if (template.name === 'continue') {
-            scope.set('forloop.skip', true);
-            return Promise.resolve('');
-        }
-        if (template.name === 'break') {
-            scope.set('forloop.stop', true);
-            scope.set('forloop.skip', true);
-            return Promise.reject(new Error('forloop.stop')); // this will stop the sequential promise chain
-        }
-        return template.render(scope, register);
-    },
-
-    evalOutput: function evalOutput(template, scope, opts) {
-        assert(scope, 'unable to evalOutput: scope undefined');
-        var val = Exp.evalExp(template.initial, scope);
-        template.filters.some(function (filter) {
-            if (filter.error) {
-                if (opts.strict_filters) {
-                    throw filter.error;
-                } else {
-                    // render as null
-                    val = '';
-                    return true;
-                }
-            }
-            val = filter.render(val, scope);
-        });
-        return val;
-    },
-
-    resetRegisters: function resetRegisters() {
-        return this.register = {};
-    }
-};
-
-function factory() {
-    var instance = Object.create(render);
-    instance.register = {};
-    return instance;
-}
-
-function stringify(val) {
-    if (typeof val === 'string') return val;
-    return JSON.stringify(val);
-}
-
-module.exports = factory;
-
-},{"./error.js":14,"./expression.js":15,"any-promise":3,"assert":6}],20:[function(require,module,exports){
-'use strict';
-
-var lexical = require('./lexical.js');
-
-var Scope = {
-    safeGet: function safeGet(str) {
-        var i;
-        // get all
-        if (str === undefined) {
-            var ctx = {};
-            for (i = this.scopes.length - 1; i >= 0; i--) {
-                var scp = this.scopes[i];
-                for (var k in scp) {
-                    if (scp.hasOwnProperty(k)) {
-                        ctx[k] = scp[k];
-                    }
-                }
-            }
-            return ctx;
-        }
-        // get one path
-        for (i = this.scopes.length - 1; i >= 0; i--) {
-            var v = getPropertyByPath(this.scopes[i], str);
-            if (v !== undefined) return v;
-        }
-    },
-    get: function get(str) {
-        var val = this.safeGet(str);
-        if (val === undefined && this.opts.strict) {
-            throw new Error('[strict_variables] undefined variable: ' + str);
-        }
-        return val;
-    },
-    set: function set(k, v) {
-        setPropertyByPath(this.scopes[this.scopes.length - 1], k, v);
-        return this;
-    },
-    push: function push(ctx) {
-        if (!ctx) throw new Error('trying to push ' + ctx + ' into scopes');
-        return this.scopes.push(ctx);
-    },
-    pop: function pop() {
-        return this.scopes.pop();
-    }
-};
-
-function setPropertyByPath(obj, path, val) {
-    if (path instanceof String || typeof path === 'string') {
-        var paths = path.replace(/\[/g, '.').replace(/\]/g, '').split('.');
-        for (var i = 0; i < paths.length; i++) {
-            var key = paths[i];
-            if (i === paths.length - 1) {
-                return obj[key] = val;
-            }
-            if (undefined === obj[key]) obj[key] = {};
-            // case for readonly objects
-            obj = obj[key] || {};
-        }
-        return obj;
-    }
-    return obj[path] = val;
-}
-
-function getPropertyByPath(obj, path) {
-    if (path instanceof String || typeof path === 'string') {
-        var paths = path.replace(/\[/g, '.').replace(/\]/g, '').split('.');
-        paths.forEach(function (p) {
-            return obj = obj && obj[p];
-        });
-        return obj;
-    }
-    return obj[path];
-}
-
-exports.factory = function (_ctx, opts) {
-    opts = opts || {};
-    opts.strict = opts.strict || false;
-
-    var scope = Object.create(Scope);
-    scope.opts = opts;
-    scope.scopes = [_ctx || {}];
-    return scope;
-};
-
-},{"./lexical.js":17}],21:[function(require,module,exports){
-'use strict';
-
-var operators = {
-    '==': function _(l, r) {
-        return l == r;
-    },
-    '!=': function _(l, r) {
-        return l != r;
-    },
-    '>': function _(l, r) {
-        return l > r;
-    },
-    '<': function _(l, r) {
-        return l < r;
-    },
-    '>=': function _(l, r) {
-        return l >= r;
-    },
-    '<=': function _(l, r) {
-        return l <= r;
-    },
-    'contains': function contains(l, r) {
-        return l.indexOf(r) > -1;
-    },
-    'and': function and(l, r) {
-        return l && r;
-    },
-    'or': function or(l, r) {
-        return l || r;
-    }
-};
-
-exports.operators = operators;
-
-},{}],22:[function(require,module,exports){
-'use strict';
-
-var lexical = require('./lexical.js');
-var Promise = require('any-promise');
-var Exp = require('./expression.js');
-var TokenizationError = require('./error.js').TokenizationError;
-
-function hash(markup, scope) {
-    var obj = {};
-    lexical.hashCapture.lastIndex = 0;
-    while (match = lexical.hashCapture.exec(markup)) {
-        var k = match[1],
-            v = match[2];
-        obj[k] = Exp.evalValue(v, scope);
-    }
-    return obj;
-}
-
-module.exports = function () {
-    var tagImpls = {};
-
-    var _tagInstance = {
-        render: function render(scope, register) {
-            var reg = register[this.name];
-            if (!reg) reg = register[this.name] = {};
-            var obj = hash(this.token.args, scope);
-            return this.tagImpl.render && this.tagImpl.render(scope, obj, reg) || Promise.resolve('');
-        },
-        parse: function parse(token, tokens) {
-            this.type = 'tag';
-            this.token = token;
-            this.name = token.name;
-
-            var tagImpl = tagImpls[this.name];
-            if (!tagImpl) throw new Error('tag ' + this.name + ' not found');
-            this.tagImpl = Object.create(tagImpl);
-            if (this.tagImpl.parse) {
-                this.tagImpl.parse(token, tokens);
-            }
-        }
-    };
-
-    function register(name, tag) {
-        tagImpls[name] = tag;
-    }
-
-    function construct(token, tokens) {
-        var instance = Object.create(_tagInstance);
-        instance.parse(token, tokens);
-        return instance;
-    }
-
-    function clear() {
-        tagImpls = {};
-    }
-
-    return {
-        construct: construct, register: register, clear: clear
-    };
-};
-
-},{"./error.js":14,"./expression.js":15,"./lexical.js":17,"any-promise":3}],23:[function(require,module,exports){
-'use strict';
-
-var lexical = require('./lexical.js');
-var TokenizationError = require('./error.js').TokenizationError;
-
-function parse(html) {
-    var tokens = [];
-    if (!html) return tokens;
-
-    var syntax = /({%(.*?)%})|({{(.*?)}})/g;
-    var result, htmlFragment, token;
-    var lastMatchEnd = 0,
-        lastMatchBegin = -1,
-        parsedLinesCount = 0;
-
-    while ((result = syntax.exec(html)) !== null) {
-        // passed html fragments
-        if (result.index > lastMatchEnd) {
-            htmlFragment = html.slice(lastMatchEnd, result.index);
-            tokens.push({
-                type: 'html',
-                raw: htmlFragment,
-                value: htmlFragment
-            });
-        }
-        // tag appeared
-        if (result[1]) {
-            token = factory('tag', 1, result);
-
-            var match = token.value.match(lexical.tagLine);
-            if (!match) {
-                throw new TokenizationError('illegal tag: ' + token.raw, token.input, token.line);
-            }
-            token.name = match[1];
-            token.args = match[2];
-
-            tokens.push(token);
-        }
-        // output
-        else {
-                token = factory('output', 3, result);
-                tokens.push(token);
-            }
-        lastMatchEnd = syntax.lastIndex;
-    }
-
-    // remaining html
-    if (html.length > lastMatchEnd) {
-        htmlFragment = html.slice(lastMatchEnd, html.length);
-        tokens.push({
-            type: 'html',
-            raw: htmlFragment,
-            value: htmlFragment
-        });
-    }
-    return tokens;
-
-    function factory(type, offset, match) {
-        return {
-            type: type,
-            raw: match[offset],
-            value: match[offset + 1].trim(),
-            line: getLineNum(match),
-            input: getLineContent(match)
-        };
-    }
-
-    function getLineContent(match) {
-        var idx1 = match.input.lastIndexOf('\n', match.index);
-        var idx2 = match.input.indexOf('\n', match.index);
-        if (idx2 === -1) idx2 = match.input.length;
-        return match.input.slice(idx1 + 1, idx2);
-    }
-
-    function getLineNum(match) {
-        var lines = match.input.slice(lastMatchBegin + 1, match.index).split('\n');
-        parsedLinesCount += lines.length - 1;
-        lastMatchBegin = match.index;
-        return parsedLinesCount + 1;
-    }
-}
-
-exports.parse = parse;
-
-},{"./error.js":14,"./lexical.js":17}],24:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var re = new RegExp('(' + lexical.identifier.source + ')\\s*=(.*)');
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('assign', {
-        parse: function parse(token) {
-            var match = token.args.match(re);
-            if (!match) throw new Error('illegal token ' + token.raw);
-            this.key = match[1];
-            this.value = match[2];
-        },
-        render: function render(scope, hash) {
-            scope.set(this.key, liquid.evalOutput(this.value, scope));
-            return Promise.resolve('');
-        }
-    });
-};
-
-},{"..":2,"any-promise":3}],25:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-var re = new RegExp('(' + lexical.identifier.source + ')');
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('capture', {
-        parse: function parse(tagToken, remainTokens) {
-            var _this = this;
-
-            var match = tagToken.args.match(re);
-            if (!match) throw new Error(tagToken.args + ' not valid identifier');
-
-            this.variable = match[1];
-            this.templates = [];
-
-            var stream = liquid.parser.parseStream(remainTokens);
-            stream.on('tag:endcapture', function (token) {
-                return stream.stop();
-            }).on('template', function (tpl) {
-                return _this.templates.push(tpl);
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-            stream.start();
-        },
-        render: function render(scope, hash) {
-            var _this2 = this;
-
-            return liquid.renderer.renderTemplates(this.templates, scope).then(function (html) {
-                scope.set(_this2.variable, html);
-            });
-        }
-    });
-};
-
-},{"..":2}],26:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-
-module.exports = function (liquid) {
-    liquid.registerTag('case', {
-
-        parse: function parse(tagToken, remainTokens) {
-            var _this = this;
-
-            this.cond = tagToken.args;
-            this.cases = [];
-            this.elseTemplates = [];
-
-            var p = [],
-                stream = liquid.parser.parseStream(remainTokens).on('tag:when', function (token) {
-                if (!_this.cases[token.args]) {
-                    _this.cases.push({
-                        val: token.args,
-                        templates: p = []
-                    });
-                }
-            }).on('tag:else', function (token) {
-                return p = _this.elseTemplates;
-            }).on('tag:endcase', function (token) {
-                return stream.stop();
-            }).on('template', function (tpl) {
-                return p.push(tpl);
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-
-            stream.start();
-        },
-
-        render: function render(scope, hash) {
-            for (var i = 0; i < this.cases.length; i++) {
-                var branch = this.cases[i];
-                var val = Liquid.evalExp(branch.val, scope);
-                var cond = Liquid.evalExp(this.cond, scope);
-                if (val === cond) {
-                    return liquid.renderer.renderTemplates(branch.templates, scope);
-                }
-            }
-            return liquid.renderer.renderTemplates(this.elseTemplates, scope);
-        }
-
-    });
-};
-
-},{"..":2}],27:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-var re = new RegExp('(' + lexical.identifier.source + ')');
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('comment', {
-        parse: function parse(tagToken, remainTokens) {
-            var stream = liquid.parser.parseStream(remainTokens);
-            stream.on('token', function (token) {
-                if (token.name === 'endcomment') stream.stop();
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-            stream.start();
-        }
-    });
-};
-
-},{"..":2}],28:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var groupRE = new RegExp('^(?:(' + lexical.value.source + ')\\s*:\\s*)?(.*)$');
-var candidatesRE = new RegExp(lexical.value.source, 'g');
-
-module.exports = function (liquid) {
-    liquid.registerTag('cycle', {
-
-        parse: function parse(tagToken, remainTokens) {
-            var match = groupRE.exec(tagToken.args);
-            if (!match) throw new Error('illegal tag: ' + tagToken.raw);
-
-            this.group = match[1] || '';
-            var candidates = match[2];
-
-            this.candidates = [];
-
-            while (match = candidatesRE.exec(candidates)) {
-                this.candidates.push(match[0]);
-            }
-
-            if (!this.candidates.length) {
-                throw new Error('empty candidates: ' + tagToken.raw);
-            }
-        },
-
-        render: function render(scope, hash, register) {
-            var fingerprint = Liquid.evalValue(this.group, scope) + ':' + this.candidates.join(',');
-            var idx = register[fingerprint];
-
-            if (idx === undefined) {
-                idx = register[fingerprint] = 0;
-            }
-
-            var candidate = this.candidates[idx];
-            idx = (idx + 1) % this.candidates.length;
-            register[fingerprint] = idx;
-
-            return Promise.resolve(Liquid.evalValue(candidate, scope));
-        }
-    });
-};
-
-},{"..":2,"any-promise":3}],29:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-var error = Liquid.error;
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('decrement', {
-        parse: function parse(token) {
-            var match = token.args.match(lexical.identifier);
-            if (!match) throw new Error('illegal identifier ' + token.args);
-            this.variable = match[0];
-        },
-        render: function render(scope, hash) {
-            var v = scope.get(this.variable);
-            if (typeof v !== 'number') v = 0;
-            scope.set(this.variable, v - 1);
-        }
-    });
-};
-
-},{"..":2}],30:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var re = new RegExp('^(' + lexical.identifier.source + ')\\s+in\\s+' + ('(' + lexical.value.source + ')') + ('(?:\\s+' + lexical.hash.source + ')*') + '(?:\\s+(reversed))?$');
-
-module.exports = function (liquid) {
-    liquid.registerTag('for', {
-
-        parse: function parse(tagToken, remainTokens) {
-            var _this = this;
-
-            var match = re.exec(tagToken.args);
-            if (!match) throw new Error('illegal tag: ' + tagToken.raw);
-            this.variable = match[1];
-            this.collection = match[2];
-            this.reversed = !!match[3];
-
-            this.templates = [];
-            this.elseTemplates = [];
-
-            var p,
-                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
-                return p = _this.templates;
-            }).on('tag:else', function (token) {
-                return p = _this.elseTemplates;
-            }).on('tag:endfor', function (token) {
-                return stream.stop();
-            }).on('template', function (tpl) {
-                return p.push(tpl);
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-
-            stream.start();
-        },
-
-        render: function render(scope, hash) {
-            var _this2 = this;
-
-            var collection = Liquid.evalExp(this.collection, scope);
-            if (Liquid.isFalsy(collection)) {
-                return liquid.renderer.renderTemplates(this.elseTemplates, scope);
-            }
-
-            var html = '';
-            var length = collection.length;
-            var offset = hash.offset || 0;
-            var limit = hash.limit === undefined ? collection.length : hash.limit;
-
-            collection = collection.slice(offset, offset + limit);
-            if (this.reversed) collection.reverse();
-
-            // for needs to execute the promises sequentially, not just resolve them sequentially, due to break and continue.
-            // We can't just loop through executing everything then resolve them all sequentially like we do for render.renderTemplates
-            // First, we build the array of parameters we are going to use for each call to renderTemplates
-            var contexts = [];
-            collection.some(function (item, i) {
-                var ctx = {};
-                ctx[_this2.variable] = item;
-                ctx.forloop = {
-                    first: i === 0,
-                    index: i + 1,
-                    index0: i,
-                    last: i === length - 1,
-                    length: length,
-                    rindex: length - i,
-                    rindex0: length - i - 1,
-                    stop: false,
-                    skip: false
-                };
-                // We are just putting together an array of the arguments we will be passing to our sequential promises
-                contexts.push(ctx);
-            });
-
-            // This is some pretty tricksy javascript, at least to me.
-            // This executes an array of promises sequentially for every argument in the contexts array - http://webcache.googleusercontent.com/search?q=cache:rNbMUn9TPtkJ:joost.vunderink.net/blog/2014/12/15/processing-an-array-of-promises-sequentially-in-node-js/+&cd=5&hl=en&ct=clnk&gl=us
-            // It's fundamentally equivalent to the following...
-            //  emptyPromise.then(renderTemplates(args0).then(renderTemplates(args1).then(renderTemplates(args2)...
-            var lastPromise = contexts.reduce(function (promise, context) {
-                return promise.then(function (partial) {
-                    if (scope.get('forloop.stop')) {
-                        throw new Error('forloop.stop'); // this will stop the sequential promise chain
-                    }
-
-                    return html += partial;
-                }).then(function (partial) {
-                    // todo: Make sure our scope management is sound here.  Create some tests that revolve around loops
-                    //  with sections that take differing amounts of time to complete.  Make sure the order is maintained
-                    //  and scope doesn't bleed over into other renderTemplate calls.
-                    scope.push(context);
-                    return liquid.renderer.renderTemplates(_this2.templates, scope);
-                }).then(function (partial) {
-                    scope.pop(context);
-                    return partial;
-                });
-            }, Promise.resolve('')); // start the reduce chain with a resolved Promise. After first run, the "promise" argument
-            //  in our reduce callback will be the returned promise from our "then" above.  In this
-            //  case, the promise returned from liquid.renderer.renderTemplates.
-
-            return lastPromise.then(function (partial) {
-                return html += partial;
-            }).catch(function (error) {
-                if (error.message === 'forloop.stop') {
-                    // the error is a controlled, purposeful stop. so just return the html that we have up to this point
-                    return html;
-                } else {
-                    // rethrow actual error
-                    throw error;
-                }
-            });
-        }
-    });
-};
-
-},{"..":2,"any-promise":3}],31:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-
-module.exports = function (liquid) {
-    liquid.registerTag('if', {
-
-        parse: function parse(tagToken, remainTokens) {
-            var _this = this;
-
-            this.branches = [];
-            this.elseTemplates = [];
-
-            var p,
-                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
-                return _this.branches.push({
-                    cond: tagToken.args,
-                    templates: p = []
-                });
-            }).on('tag:elsif', function (token) {
-                if (!_this.branches[token.args]) {
-                    _this.branches.push({
-                        cond: token.args,
-                        templates: p = []
-                    });
-                }
-            }).on('tag:else', function (token) {
-                return p = _this.elseTemplates;
-            }).on('tag:endif', function (token) {
-                return stream.stop();
-            }).on('template', function (tpl) {
-                return p.push(tpl);
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-
-            stream.start();
-        },
-
-        render: function render(scope, hash) {
-            for (var i = 0; i < this.branches.length; i++) {
-                var branch = this.branches[i];
-                var cond = Liquid.evalExp(branch.cond, scope);
-                if (Liquid.isTruthy(cond)) {
-                    return liquid.renderer.renderTemplates(branch.templates, scope);
-                }
-            }
-            return liquid.renderer.renderTemplates(this.elseTemplates, scope);
-        }
-
-    });
-};
-
-},{"..":2}],32:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var withRE = new RegExp('with\\s+(' + lexical.value.source + ')');
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('include', {
-        parse: function parse(token) {
-            var match = lexical.value.exec(token.args);
-            if (!match) throw new Error('illegal token ' + token.raw);
-            this.value = match[0];
-
-            match = withRE.exec(token.args);
-            if (match) {
-                this.with = match[1];
-            }
-        },
-        render: function render(scope, hash) {
-            var filepath = Liquid.evalValue(this.value, scope);
-            if (this.with) {
-                hash[filepath] = Liquid.evalValue(this.with, scope);
-            }
-            return liquid.handleCache(filepath).then(function (templates) {
-                scope.push(hash);
-                return liquid.renderer.renderTemplates(templates, scope);
-            }).then(function (html) {
-                scope.pop();
-                return html;
-            });
-        }
-    });
-};
-
-},{"..":2,"any-promise":3}],33:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('increment', {
-        parse: function parse(token) {
-            var match = token.args.match(lexical.identifier);
-            if (!match) throw new Error('illegal identifier ' + token.args);
-            this.variable = match[0];
-        },
-        render: function render(scope, hash) {
-            var v = scope.get(this.variable);
-            if (typeof v !== 'number') v = 0;
-            scope.set(this.variable, v + 1);
-        }
-    });
-};
-
-},{"..":2}],34:[function(require,module,exports){
-"use strict";
-
-module.exports = function (engine) {
-    require("./assign.js")(engine);
-    require("./capture.js")(engine);
-    require("./case.js")(engine);
-    require("./comment.js")(engine);
-    require("./cycle.js")(engine);
-    require("./decrement.js")(engine);
-    require("./for.js")(engine);
-    require("./if.js")(engine);
-    require("./include.js")(engine);
-    require("./increment.js")(engine);
-    require("./layout.js")(engine);
-    require("./raw.js")(engine);
-    require("./tablerow.js")(engine);
-    require("./unless.js")(engine);
-};
-
-},{"./assign.js":24,"./capture.js":25,"./case.js":26,"./comment.js":27,"./cycle.js":28,"./decrement.js":29,"./for.js":30,"./if.js":31,"./include.js":32,"./increment.js":33,"./layout.js":35,"./raw.js":36,"./tablerow.js":37,"./unless.js":38}],35:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var withRE = new RegExp('with\\s+(' + lexical.value.source + ')');
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('layout', {
-        parse: function parse(token, remainTokens) {
-            var match = lexical.value.exec(token.args);
-            if (!match) throw new Error('illegal token ' + token.raw);
-
-            this.layout = match[0];
-            this.tpls = liquid.parser.parse(remainTokens);
-        },
-        render: function render(scope, hash) {
-            var layout = Liquid.evalValue(this.layout, scope);
-
-            var html = '';
-            scope.push({});
-            // not sure if this first one is needed, since the results are ignored
-            return liquid.renderer.renderTemplates(this.tpls, scope).then(function (partial) {
-                html += partial;
-                return liquid.handleCache(layout);
-            }).then(function (templates) {
-                return liquid.renderer.renderTemplates(templates, scope);
-            }).then(function (partial) {
-                scope.pop();
-                return partial;
-            }).catch(function (e) {
-                e.file = layout;
-                throw e;
-            });
-
-            //            var tpl = liquid.handleCache(layout);
-            //
-            //            scope.push({});
-            //            liquid.renderer.renderTemplates(this.tpls, scope);  // what's the point of this line?
-            //            var html = liquid.renderer.renderTemplates(tpl, scope);
-            //            scope.pop();
-            //            return html;
-        }
-    });
-
-    liquid.registerTag('block', {
-        parse: function parse(token, remainTokens) {
-            var _this = this;
-
-            var match = /\w+/.exec(token.args);
-            this.block = match ? match[0] : '';
-
-            this.tpls = [];
-            var p,
-                stream = liquid.parser.parseStream(remainTokens).on('tag:endblock', function (token) {
-                return stream.stop();
-            }).on('template', function (tpl) {
-                return _this.tpls.push(tpl);
-            }).on('end', function (x) {
-                throw new Error('tag ' + token.raw + ' not closed');
-            });
-            stream.start();
-        },
-        render: function render(scope, hash) {
-            var _this2 = this;
-
-            var html = scope.get('_liquid.blocks.' + this.block);
-            var promise = Promise.resolve('');
-            if (html === undefined) {
-                promise = liquid.renderer.renderTemplates(this.tpls, scope).then(function (partial) {
-                    scope.set('_liquid.blocks.' + _this2.block, partial);
-                    return partial;
-                });
-            } else {
-                scope.set('_liquid.blocks.' + this.block, html);
-                promise = Promise.resolve(html);
-            }
-            return promise;
-
-            //            if(html === undefined){
-            //                html = liquid.renderer.renderTemplates(this.tpls, scope);
-            //            }
-            //            scope.set(`_liquid.blocks.${this.block}`, html);
-            //            return html;
-        }
-    });
-};
-
-},{"..":2,"any-promise":3}],36:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var re = new RegExp('(' + lexical.identifier.source + ')');
-
-module.exports = function (liquid) {
-
-    liquid.registerTag('raw', {
-        parse: function parse(tagToken, remainTokens) {
-            var _this = this;
-
-            this.tokens = [];
-
-            var stream = liquid.parser.parseStream(remainTokens);
-            stream.on('token', function (token) {
-                if (token.name === 'endraw') stream.stop();else _this.tokens.push(token);
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-            stream.start();
-        },
-        render: function render(scope, hash) {
-            var tokens = this.tokens.map(function (token) {
-                return token.raw;
-            }).join('');
-            return Promise.resolve(tokens);
-        }
-    });
-};
-
-},{"..":2,"any-promise":3}],37:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var re = new RegExp('^(' + lexical.identifier.source + ')\\s+in\\s+' + ('(' + lexical.value.source + ')') + ('(?:\\s+' + lexical.hash.source + ')*$'));
-
-module.exports = function (liquid) {
-    liquid.registerTag('tablerow', {
-
-        parse: function parse(tagToken, remainTokens) {
-            var _this = this;
-
-            var match = re.exec(tagToken.args);
-            if (!match) throw new Error('illegal tag: ' + tagToken.raw);
-            this.variable = match[1];
-            this.collection = match[2];
-
-            this.templates = [];
-
-            var p,
-                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
-                return p = _this.templates;
-            }).on('tag:endtablerow', function (token) {
-                return stream.stop();
-            }).on('template', function (tpl) {
-                return p.push(tpl);
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-
-            stream.start();
-        },
-
-        render: function render(scope, hash) {
-            var _this2 = this;
-
-            var collection = Liquid.evalExp(this.collection, scope) || [];
-
-            var html = '<table>',
-                promiseChain = Promise.resolve(''); // create an empty promise to begin the chain
-            length = collection.length;
-            var offset = hash.offset || 0;
-            var limit = hash.limit === undefined ? collection.length : hash.limit;
-
-            var cols = hash.cols,
-                row,
-                col;
-            if (!cols) throw new Error('illegal cols: ' + cols);
-
-            // build array of arguments to pass to sequential promises...
-            collection = collection.slice(offset, offset + limit);
-            var contexts = [];
-            collection.some(function (item, i) {
-                var ctx = {};
-                ctx[_this2.variable] = item;
-                // We are just putting together an array of the arguments we will be passing to our sequential promises
-                contexts.push(ctx);
-            });
-
-            // This executes an array of promises sequentially for every argument in the contexts array - http://webcache.googleusercontent.com/search?q=cache:rNbMUn9TPtkJ:joost.vunderink.net/blog/2014/12/15/processing-an-array-of-promises-sequentially-in-node-js/+&cd=5&hl=en&ct=clnk&gl=us
-            // It's fundamentally equivalent to the following...
-            //  emptyPromise.then(renderTemplates(args0).then(renderTemplates(args1).then(renderTemplates(args2)...
-            var lastPromise = contexts.reduce(function (promise, context, currentIndex) {
-                return promise.then(function (partial) {
-                    row = Math.floor(currentIndex / cols) + 1;
-                    col = currentIndex % cols + 1;
-                    if (col === 1) {
-                        if (row !== 1) {
-                            html += '</tr>';
-                        }
-                        html += '<tr class="row' + row + '">';
-                    }
-
-                    //ctx[this.variable] = context;
-
-                    return html += '<td class="col' + col + '">';
-                }).then(function (partial) {
-                    scope.push(context);
-                    return liquid.renderer.renderTemplates(_this2.templates, scope);
-                }).then(function (partial) {
-                    scope.pop(context);
-                    html += partial;
-                    return html += '</td>';
-                });
-            }, Promise.resolve('')); // start the reduce chain with a resolved Promise. After first run, the "promise" argument
-            //  in our reduce callback will be the returned promise from our "then" above.  In this
-            //  case, the promise returned from liquid.renderer.renderTemplates.
-
-            return lastPromise.then(function () {
-                if (row > 0) {
-                    html += '</tr>';
-                }
-                html += '</table>';
-                return html;
-            }).catch(function (error) {
-                throw error;
-            });
-        }
-    });
-};
-
-},{"..":2,"any-promise":3}],38:[function(require,module,exports){
-'use strict';
-
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-
-module.exports = function (liquid) {
-    liquid.registerTag('unless', {
-        parse: function parse(tagToken, remainTokens) {
-            var _this = this;
-
-            this.templates = [];
-            this.elseTemplates = [];
-            var p,
-                stream = liquid.parser.parseStream(remainTokens).on('start', function (x) {
-                p = _this.templates;
-                _this.cond = tagToken.args;
-            }).on('tag:else', function (token) {
-                return p = _this.elseTemplates;
-            }).on('tag:endunless', function (token) {
-                return stream.stop();
-            }).on('template', function (tpl) {
-                return p.push(tpl);
-            }).on('end', function (x) {
-                throw new Error('tag ' + tagToken.raw + ' not closed');
-            });
-
-            stream.start();
-        },
-
-        render: function render(scope, hash) {
-            var cond = Liquid.evalExp(this.cond, scope);
-            return Liquid.isFalsy(cond) ? liquid.renderer.renderTemplates(this.templates, scope) : liquid.renderer.renderTemplates(this.elseTemplates, scope);
-        }
-    });
-};
-
-},{"..":2}]},{},[2])(2)
-});
\ No newline at end of file
diff --git a/dist/shopify-liquid.min.js b/dist/shopify-liquid.min.js
deleted file mode 100644
index ac6ad0a23..000000000
--- a/dist/shopify-liquid.min.js
+++ /dev/null
@@ -1,4 +0,0 @@
-(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Liquid=f()}})(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module,exports){"use strict";var strftime=require("strftime").timezone(-(new Date).getTimezoneOffset());module.exports=function(liquid){liquid.registerFilter("abs",function(v){return Math.abs(v)});liquid.registerFilter("append",function(v,arg){return v+arg});liquid.registerFilter("capitalize",function(str){return(str||"").charAt(0).toUpperCase()+str.slice(1)});liquid.registerFilter("ceil",function(v){return Math.ceil(v)});liquid.registerFilter("date",function(v,arg){return strftime(arg,v)});liquid.registerFilter("default",function(v,arg){return arg||v});liquid.registerFilter("divided_by",function(v,arg){return Math.floor(v/arg)});liquid.registerFilter("downcase",function(v){return v.toLowerCase()});var escapeMap={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&#34;","'":"&#39;"};function escape(str){return(str||"").replace(/&|<|>|"|'/g,function(m){return escapeMap[m]})}liquid.registerFilter("escape",escape);var unescapeMap={"&amp;":"&","&lt;":"<","&gt;":">","&#34;":'"',"&#39;":"'"};function unescape(str){return(str||"").replace(/&(amp|lt|gt|#34|#39);/g,function(m){return unescapeMap[m]})}liquid.registerFilter("escape_once",function(str){return escape(unescape(str))});liquid.registerFilter("first",function(v){return v[0]});liquid.registerFilter("floor",function(v){return Math.floor(v)});liquid.registerFilter("join",function(v,arg){return v.join(arg)});liquid.registerFilter("last",function(v){return v[v.length-1]});liquid.registerFilter("lstrip",function(v){return(v||"").replace(/^\s+/,"")});liquid.registerFilter("map",function(arr,arg){return arr.map(function(v){return v[arg]})});liquid.registerFilter("minus",bindFixed(function(v,arg){return v-arg}));liquid.registerFilter("modulo",bindFixed(function(v,arg){return v%arg}));liquid.registerFilter("newline_to_br",function(v){return v.replace(/\n/g,"<br />")});liquid.registerFilter("plus",bindFixed(function(v,arg){return v+arg}));liquid.registerFilter("prepend",function(v,arg){return arg+v});liquid.registerFilter("remove",function(v,arg){return v.split(arg).join("")});liquid.registerFilter("remove_first",function(v,l){return v.replace(l,"")});liquid.registerFilter("replace",function(v,pattern,replacement){return(v||"").split(pattern).join(replacement)});liquid.registerFilter("replace_first",function(v,arg1,arg2){return(v||"").replace(arg1,arg2)});liquid.registerFilter("reverse",function(v){return(v||"").reverse()});liquid.registerFilter("round",function(v,arg){var amp=Math.pow(10,arg||0);return Math.round(v*amp,arg)/amp});liquid.registerFilter("rstrip",function(str){return(str||"").replace(/\s+$/,"")});liquid.registerFilter("size",function(v){return v.length});liquid.registerFilter("slice",function(v,begin,length){return v.substr(begin,length===undefined?1:length)});liquid.registerFilter("sort",function(v,arg){return(v||"").sort(arg)});liquid.registerFilter("split",function(v,arg){return(v||"").split(arg)});liquid.registerFilter("strip",function(v){return(v||"").trim()});liquid.registerFilter("strip_html",function(v){return(v||"").replace(/<\/?\s*\w+\s*\/?>/g,"")});liquid.registerFilter("strip_newlines",function(v){return(v||"").replace(/\n/g,"")});liquid.registerFilter("times",function(v,arg){return v*arg});liquid.registerFilter("truncate",function(v,l,o){v=v||"";o=o===undefined?"...":o;l=l||16;if(v.length<=l)return v;return v.substr(0,l-o.length)+o});liquid.registerFilter("truncatewords",function(v,l,o){if(o===undefined)o="...";var arr=v.split(" ");var ret=arr.slice(0,l).join(" ");if(arr.length>l)ret+=o;return ret});liquid.registerFilter("uniq",function(arr){var u={};return(arr||[]).filter(function(val){if(u.hasOwnProperty(val)){return false}u[val]=true;return true})});liquid.registerFilter("upcase",function(str){return(str||"").toUpperCase()});liquid.registerFilter("url_encode",encodeURIComponent)};function getFixed(v){var p=(v+"").split(".");return p.length>1?p[1].length:0}function getMaxFixed(l,r){return Math.max(getFixed(l),getFixed(r))}function bindFixed(cb){return function(l,r){var f=getMaxFixed(l,r);return cb(l,r).toFixed(f)}}},{strftime:10}],2:[function(require,module,exports){"use strict";var Scope=require("./src/scope");var assert=require("assert");var tokenizer=require("./src/tokenizer.js");var Render=require("./src/render.js");var lexical=require("./src/lexical.js");var path=require("path");var fs=require("fs");var Tag=require("./src/tag.js");var Filter=require("./src/filter.js");var Template=require("./src/parser");var Expression=require("./src/expression.js");var tags=require("./tags");var filters=require("./filters");var Promise=require("any-promise");var _engine={init:function init(tag,filter,options){if(options.cache){this.cache={}}this.options=options;this.tag=tag;this.filter=filter;this.parser=Template(tag,filter);this.renderer=Render();tags(this);filters(this);return this},parse:function parse(html){var tokens=tokenizer.parse(html);return this.parser.parse(tokens)},render:function render(tpl,ctx,opts){opts=opts||{};opts.strict_variables=opts.strict_variables||false;opts.strict_filters=opts.strict_filters||false;this.renderer.resetRegisters();var scope=Scope.factory(ctx,{strict:opts.strict_variables});return this.renderer.renderTemplates(tpl,scope,opts)},parseAndRender:function parseAndRender(html,ctx,opts){try{var tpl=this.parse(html);return this.render(tpl,ctx,opts)}catch(error){return Promise.reject(error)}},renderFile:function renderFile(filepath,ctx,opts){var _this=this;return this.handleCache(filepath).then(function(templates){return _this.render(templates,ctx,opts)}).catch(function(e){e.file=filepath;throw e})},evalOutput:function evalOutput(str,scope){var tpl=this.parser.parseOutput(str.trim());return this.renderer.evalOutput(tpl,scope)},registerFilter:function registerFilter(name,filter){return this.filter.register(name,filter)},registerTag:function registerTag(name,tag){return this.tag.register(name,tag)},handleCache:function handleCache(filepath){var _this2=this;assert(filepath,"filepath cannot be null");filepath=path.resolve(this.options.root,filepath);if(path.extname(filepath)===""){filepath+=this.options.extname}return this.getTemplate(filepath).then(function(html){var tpl=_this2.options.cache&&_this2.cache[filepath]||_this2.parse(html);return _this2.options.cache?_this2.cache[filepath]=tpl:tpl})},getTemplate:function getTemplate(filepath){return new Promise(function(resolve,reject){fs.readFile(filepath,"utf8",function(err,html){err?reject(err):resolve(html)})})},express:function express(renderingOptions){var _this3=this;return function(filePath,options,callback){_this3.renderFile(filePath,options,renderingOptions).then(function(html){return callback(null,html)}).catch(function(e){return callback(e)})}}};function factory(options){options=options||{};options.root=options.root||"";options.extname=options.extname||".liquid";var engine=Object.create(_engine);engine.init(Tag(),Filter(),options);return engine}factory.lexical=lexical;factory.isTruthy=Expression.isTruthy;factory.isFalsy=Expression.isFalsy;factory.evalExp=Expression.evalExp;factory.evalValue=Expression.evalValue;module.exports=factory},{"./filters":1,"./src/expression.js":15,"./src/filter.js":16,"./src/lexical.js":17,"./src/parser":18,"./src/render.js":19,"./src/scope":20,"./src/tag.js":22,"./src/tokenizer.js":23,"./tags":34,"any-promise":3,assert:6,fs:7,path:8}],3:[function(require,module,exports){"use strict";module.exports=require("./register")().Promise},{"./register":5}],4:[function(require,module,exports){"use strict";var REGISTRATION_KEY="@@any-promise/REGISTRATION",registered=null;module.exports=function(root,loadImplementation){return function register(implementation,opts){implementation=implementation||null;opts=opts||{};var registerGlobal=opts.global!==false;if(registered===null&&registerGlobal){registered=root[REGISTRATION_KEY]||null}if(registered!==null&&implementation!==null&&registered.implementation!==implementation){throw new Error('any-promise already defined as "'+registered.implementation+'".  You can only register an implementation before the first '+' call to require("any-promise") and an implementation cannot be changed')}if(registered===null){if(implementation!==null&&typeof opts.Promise!=="undefined"){registered={Promise:opts.Promise,implementation:implementation}}else{registered=loadImplementation(implementation)}if(registerGlobal){root[REGISTRATION_KEY]=registered}}return registered}}},{}],5:[function(require,module,exports){"use strict";module.exports=require("./loader")(window,loadImplementation);function loadImplementation(){if(typeof window.Promise==="undefined"){throw new Error("any-promise browser requires a polyfill or explicit registration"+" e.g: require('any-promise/register/bluebird')")}return{Promise:window.Promise,implementation:"window.Promise"}}},{"./loader":4}],6:[function(require,module,exports){"use strict";var util=require("util/");var pSlice=Array.prototype.slice;var hasOwn=Object.prototype.hasOwnProperty;var assert=module.exports=ok;assert.AssertionError=function AssertionError(options){this.name="AssertionError";this.actual=options.actual;this.expected=options.expected;this.operator=options.operator;if(options.message){this.message=options.message;this.generatedMessage=false}else{this.message=getMessage(this);this.generatedMessage=true}var stackStartFunction=options.stackStartFunction||fail;if(Error.captureStackTrace){Error.captureStackTrace(this,stackStartFunction)}else{var err=new Error;if(err.stack){var out=err.stack;var fn_name=stackStartFunction.name;var idx=out.indexOf("\n"+fn_name);if(idx>=0){var next_line=out.indexOf("\n",idx+1);out=out.substring(next_line+1)}this.stack=out}}};util.inherits(assert.AssertionError,Error);function replacer(key,value){if(util.isUndefined(value)){return""+value}if(util.isNumber(value)&&!isFinite(value)){return value.toString()}if(util.isFunction(value)||util.isRegExp(value)){return value.toString()}return value}function truncate(s,n){if(util.isString(s)){return s.length<n?s:s.slice(0,n)}else{return s}}function getMessage(self){return truncate(JSON.stringify(self.actual,replacer),128)+" "+self.operator+" "+truncate(JSON.stringify(self.expected,replacer),128)}function fail(actual,expected,message,operator,stackStartFunction){throw new assert.AssertionError({message:message,actual:actual,expected:expected,operator:operator,stackStartFunction:stackStartFunction})}assert.fail=fail;function ok(value,message){if(!value)fail(value,true,message,"==",assert.ok)}assert.ok=ok;assert.equal=function equal(actual,expected,message){if(actual!=expected)fail(actual,expected,message,"==",assert.equal)};assert.notEqual=function notEqual(actual,expected,message){if(actual==expected){fail(actual,expected,message,"!=",assert.notEqual)}};assert.deepEqual=function deepEqual(actual,expected,message){if(!_deepEqual(actual,expected)){fail(actual,expected,message,"deepEqual",assert.deepEqual)}};function _deepEqual(actual,expected){if(actual===expected){return true}else if(util.isBuffer(actual)&&util.isBuffer(expected)){if(actual.length!=expected.length)return false;for(var i=0;i<actual.length;i++){if(actual[i]!==expected[i])return false}return true}else if(util.isDate(actual)&&util.isDate(expected)){return actual.getTime()===expected.getTime()}else if(util.isRegExp(actual)&&util.isRegExp(expected)){return actual.source===expected.source&&actual.global===expected.global&&actual.multiline===expected.multiline&&actual.lastIndex===expected.lastIndex&&actual.ignoreCase===expected.ignoreCase}else if(!util.isObject(actual)&&!util.isObject(expected)){return actual==expected}else{return objEquiv(actual,expected)}}function isArguments(object){return Object.prototype.toString.call(object)=="[object Arguments]"}function objEquiv(a,b){if(util.isNullOrUndefined(a)||util.isNullOrUndefined(b))return false;if(a.prototype!==b.prototype)return false;if(util.isPrimitive(a)||util.isPrimitive(b)){return a===b}var aIsArgs=isArguments(a),bIsArgs=isArguments(b);if(aIsArgs&&!bIsArgs||!aIsArgs&&bIsArgs)return false;if(aIsArgs){a=pSlice.call(a);b=pSlice.call(b);return _deepEqual(a,b)}var ka=objectKeys(a),kb=objectKeys(b),key,i;if(ka.length!=kb.length)return false;ka.sort();kb.sort();for(i=ka.length-1;i>=0;i--){if(ka[i]!=kb[i])return false}for(i=ka.length-1;i>=0;i--){key=ka[i];if(!_deepEqual(a[key],b[key]))return false}return true}assert.notDeepEqual=function notDeepEqual(actual,expected,message){if(_deepEqual(actual,expected)){fail(actual,expected,message,"notDeepEqual",assert.notDeepEqual)}};assert.strictEqual=function strictEqual(actual,expected,message){if(actual!==expected){fail(actual,expected,message,"===",assert.strictEqual)}};assert.notStrictEqual=function notStrictEqual(actual,expected,message){if(actual===expected){fail(actual,expected,message,"!==",assert.notStrictEqual)}};function expectedException(actual,expected){if(!actual||!expected){return false}if(Object.prototype.toString.call(expected)=="[object RegExp]"){return expected.test(actual)}else if(actual instanceof expected){return true}else if(expected.call({},actual)===true){return true}return false}function _throws(shouldThrow,block,expected,message){var actual;if(util.isString(expected)){message=expected;expected=null}try{block()}catch(e){actual=e}message=(expected&&expected.name?" ("+expected.name+").":".")+(message?" "+message:".");if(shouldThrow&&!actual){fail(actual,expected,"Missing expected exception"+message)}if(!shouldThrow&&expectedException(actual,expected)){fail(actual,expected,"Got unwanted exception"+message)}if(shouldThrow&&actual&&expected&&!expectedException(actual,expected)||!shouldThrow&&actual){throw actual}}assert.throws=function(block,error,message){_throws.apply(this,[true].concat(pSlice.call(arguments)))};assert.doesNotThrow=function(block,message){_throws.apply(this,[false].concat(pSlice.call(arguments)))};assert.ifError=function(err){if(err){throw err}};var objectKeys=Object.keys||function(obj){var keys=[];for(var key in obj){if(hasOwn.call(obj,key))keys.push(key)}return keys}},{"util/":13}],7:[function(require,module,exports){"use strict"},{}],8:[function(require,module,exports){(function(process){"use strict";function normalizeArray(parts,allowAboveRoot){var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up--;up){parts.unshift("..")}}return parts}var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;var splitPath=function splitPath(filename){return splitPathRe.exec(filename).slice(1)};exports.resolve=function(){var resolvedPath="",resolvedAbsolute=false;for(var i=arguments.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?arguments[i]:process.cwd();if(typeof path!=="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){continue}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=path.charAt(0)==="/"}resolvedPath=normalizeArray(filter(resolvedPath.split("/"),function(p){return!!p}),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."};exports.normalize=function(path){var isAbsolute=exports.isAbsolute(path),trailingSlash=substr(path,-1)==="/";path=normalizeArray(filter(path.split("/"),function(p){return!!p}),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path};exports.isAbsolute=function(path){return path.charAt(0)==="/"};exports.join=function(){var paths=Array.prototype.slice.call(arguments,0);return exports.normalize(filter(paths,function(p,index){if(typeof p!=="string"){throw new TypeError("Arguments to path.join must be strings")}return p}).join("/"))};exports.relative=function(from,to){from=exports.resolve(from).substr(1);to=exports.resolve(to).substr(1);function trim(arr){var start=0;for(;start<arr.length;start++){if(arr[start]!=="")break}var end=arr.length-1;for(;end>=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i<length;i++){if(fromParts[i]!==toParts[i]){samePartsLength=i;break}}var outputParts=[];for(var i=samePartsLength;i<fromParts.length;i++){outputParts.push("..")}outputParts=outputParts.concat(toParts.slice(samePartsLength));return outputParts.join("/")};exports.sep="/";exports.delimiter=":";exports.dirname=function(path){var result=splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir};exports.basename=function(path,ext){var f=splitPath(path)[2];if(ext&&f.substr(-1*ext.length)===ext){f=f.substr(0,f.length-ext.length)}return f};exports.extname=function(path){return splitPath(path)[3]};function filter(xs,f){if(xs.filter)return xs.filter(f);var res=[];for(var i=0;i<xs.length;i++){if(f(xs[i],i,xs))res.push(xs[i])}return res}var substr="ab".substr(-1)==="b"?function(str,start,len){return str.substr(start,len)}:function(str,start,len){if(start<0)start=str.length+start;return str.substr(start,len)}}).call(this,require("_process"))},{_process:9}],9:[function(require,module,exports){"use strict";var process=module.exports={};var cachedSetTimeout;var cachedClearTimeout;function defaultSetTimout(){throw new Error("setTimeout has not been defined")}function defaultClearTimeout(){throw new Error("clearTimeout has not been defined")}(function(){try{if(typeof setTimeout==="function"){cachedSetTimeout=setTimeout}else{cachedSetTimeout=defaultSetTimout}}catch(e){cachedSetTimeout=defaultSetTimout}try{if(typeof clearTimeout==="function"){cachedClearTimeout=clearTimeout}else{cachedClearTimeout=defaultClearTimeout}}catch(e){cachedClearTimeout=defaultClearTimeout}})();function runTimeout(fun){if(cachedSetTimeout===setTimeout){return setTimeout(fun,0)}if((cachedSetTimeout===defaultSetTimout||!cachedSetTimeout)&&setTimeout){cachedSetTimeout=setTimeout;return setTimeout(fun,0)}try{return cachedSetTimeout(fun,0)}catch(e){try{return cachedSetTimeout.call(null,fun,0)}catch(e){return cachedSetTimeout.call(this,fun,0)}}}function runClearTimeout(marker){if(cachedClearTimeout===clearTimeout){return clearTimeout(marker)}if((cachedClearTimeout===defaultClearTimeout||!cachedClearTimeout)&&clearTimeout){cachedClearTimeout=clearTimeout;return clearTimeout(marker)}try{return cachedClearTimeout(marker)}catch(e){try{return cachedClearTimeout.call(null,marker)}catch(e){return cachedClearTimeout.call(this,marker)}}}var queue=[];var draining=false;var currentQueue;var queueIndex=-1;function cleanUpNextTick(){if(!draining||!currentQueue){return}draining=false;if(currentQueue.length){queue=currentQueue.concat(queue)}else{queueIndex=-1}if(queue.length){drainQueue()}}function drainQueue(){if(draining){return}var timeout=runTimeout(cleanUpNextTick);draining=true;var len=queue.length;while(len){currentQueue=queue;queue=[];while(++queueIndex<len){if(currentQueue){currentQueue[queueIndex].run()}}queueIndex=-1;len=queue.length}currentQueue=null;draining=false;runClearTimeout(timeout)}process.nextTick=function(fun){var args=new Array(arguments.length-1);if(arguments.length>1){for(var i=1;i<arguments.length;i++){args[i-1]=arguments[i]}}queue.push(new Item(fun,args));if(queue.length===1&&!draining){runTimeout(drainQueue)}};function Item(fun,array){this.fun=fun;this.array=array}Item.prototype.run=function(){this.fun.apply(null,this.array)};process.title="browser";process.browser=true;process.env={};process.argv=[];process.version="";process.versions={};function noop(){}process.on=noop;process.addListener=noop;process.once=noop;process.off=noop;process.removeListener=noop;process.removeAllListeners=noop;process.emit=noop;process.binding=function(name){throw new Error("process.binding is not supported")};process.cwd=function(){return"/"};process.chdir=function(dir){throw new Error("process.chdir is not supported")};process.umask=function(){return 0}},{}],10:[function(require,module,exports){"use strict";var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol?"symbol":typeof obj};(function(){var DefaultLocale={days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],AM:"AM",PM:"PM",am:"am",pm:"pm",formats:{D:"%m/%d/%y",F:"%Y-%m-%d",R:"%H:%M",T:"%H:%M:%S",X:"%T",c:"%a %b %d %X %Y",r:"%I:%M:%S %p",v:"%e-%b-%Y",x:"%D"}},defaultStrftime=new Strftime(DefaultLocale,0,false),isCommonJS=typeof module!=="undefined",namespace;if(isCommonJS){namespace=module.exports=adaptedStrftime;namespace.strftime=deprecatedStrftime}else{namespace=function(){return this||(1,eval)("this")}();namespace.strftime=adaptedStrftime}var _require=isCommonJS?"require('strftime')":"strftime";var _deprecationWarnings={};function deprecationWarning(name,instead){if(!_deprecationWarnings[name]){if(typeof console!=="undefined"&&typeof console.warn=="function"){console.warn("[WARNING] "+name+" is deprecated and will be removed in version 1.0. Instead, use `"+instead+"`.")}_deprecationWarnings[name]=true}}namespace.strftimeTZ=deprecatedStrftimeTZ;namespace.strftimeUTC=deprecatedStrftimeUTC;namespace.localizedStrftime=deprecatedStrftimeLocalized;function adaptForwards(fn){fn.localize=defaultStrftime.localize.bind(defaultStrftime);fn.timezone=defaultStrftime.timezone.bind(defaultStrftime);fn.utc=defaultStrftime.utc.bind(defaultStrftime)}adaptForwards(adaptedStrftime);function adaptedStrftime(fmt,d,locale){if(d&&d.days){locale=d;d=undefined}if(locale){deprecationWarning("`"+_require+"(format, [date], [locale])`","var s = "+_require+".localize(locale); s(format, [date])")}var strftime=locale?defaultStrftime.localize(locale):defaultStrftime;return strftime(fmt,d)}adaptForwards(deprecatedStrftime);function deprecatedStrftime(fmt,d,locale){if(locale){deprecationWarning("`"+_require+".strftime(format, [date], [locale])`","var s = "+_require+".localize(locale); s(format, [date])")}else{deprecationWarning("`"+_require+".strftime(format, [date])`",_require+"(format, [date])")}var strftime=locale?defaultStrftime.localize(locale):defaultStrftime;return strftime(fmt,d)}function deprecatedStrftimeTZ(fmt,d,locale,timezone){if((typeof locale=="number"||typeof locale=="string")&&timezone==null){timezone=locale;locale=undefined}if(locale){deprecationWarning("`"+_require+".strftimeTZ(format, date, locale, tz)`","var s = "+_require+".localize(locale).timezone(tz); s(format, [date])` or `var s = "+_require+".localize(locale); s.timezone(tz)(format, [date])")}else{deprecationWarning("`"+_require+".strftimeTZ(format, date, tz)`","var s = "+_require+".timezone(tz); s(format, [date])` or `"+_require+".timezone(tz)(format, [date])")}var strftime=(locale?defaultStrftime.localize(locale):defaultStrftime).timezone(timezone);return strftime(fmt,d)}var utcStrftime=defaultStrftime.utc();function deprecatedStrftimeUTC(fmt,d,locale){if(locale){deprecationWarning("`"+_require+".strftimeUTC(format, date, locale)`","var s = "+_require+".localize(locale).utc(); s(format, [date])")}else{deprecationWarning("`"+_require+".strftimeUTC(format, [date])`","var s = "+_require+".utc(); s(format, [date])")}var strftime=locale?utcStrftime.localize(locale):utcStrftime;return strftime(fmt,d)}function deprecatedStrftimeLocalized(locale){deprecationWarning("`"+_require+".localizedStrftime(locale)`",_require+".localize(locale)");return defaultStrftime.localize(locale)}if(typeof Date.now!=="function"){Date.now=function(){return+new Date}}function Strftime(locale,customTimezoneOffset,useUtcTimezone){var _locale=locale||DefaultLocale,_customTimezoneOffset=customTimezoneOffset||0,_useUtcBasedDate=useUtcTimezone||false,_cachedDateTimestamp=0,_cachedDate;function _strftime(format,date){var timestamp;if(!date){var currentTimestamp=Date.now();if(currentTimestamp>_cachedDateTimestamp){_cachedDateTimestamp=currentTimestamp;_cachedDate=new Date(_cachedDateTimestamp);timestamp=_cachedDateTimestamp;if(_useUtcBasedDate){_cachedDate=new Date(_cachedDateTimestamp+getTimestampToUtcOffsetFor(_cachedDate)+_customTimezoneOffset)}}else{timestamp=_cachedDateTimestamp}date=_cachedDate}else{timestamp=date.getTime();if(_useUtcBasedDate){date=new Date(date.getTime()+getTimestampToUtcOffsetFor(date)+_customTimezoneOffset)}}return _processFormat(format,date,_locale,timestamp)}function _processFormat(format,date,locale,timestamp){var resultString="",padding=null,isInScope=false,length=format.length,extendedTZ=false;for(var i=0;i<length;i++){var currentCharCode=format.charCodeAt(i);if(isInScope===true){if(currentCharCode===45){padding="";continue}else if(currentCharCode===95){padding=" ";continue}else if(currentCharCode===48){padding="0";continue}else if(currentCharCode===58){if(extendedTZ){if(typeof console!=="undefined"&&typeof console.warn=="function"){console.warn("[WARNING] detected use of unsupported %:: or %::: modifiers to strftime")}}extendedTZ=true;continue}switch(currentCharCode){case 65:resultString+=locale.days[date.getDay()];break;case 66:resultString+=locale.months[date.getMonth()];break;case 67:resultString+=padTill2(Math.floor(date.getFullYear()/100),padding);break;case 68:resultString+=_processFormat(locale.formats.D,date,locale,timestamp);break;case 70:resultString+=_processFormat(locale.formats.F,date,locale,timestamp);break;case 72:resultString+=padTill2(date.getHours(),padding);break;case 73:resultString+=padTill2(hours12(date.getHours()),padding);break;case 76:resultString+=padTill3(Math.floor(timestamp%1e3));break;case 77:resultString+=padTill2(date.getMinutes(),padding);break;case 80:resultString+=date.getHours()<12?locale.am:locale.pm;break;case 82:resultString+=_processFormat(locale.formats.R,date,locale,timestamp);break;case 83:resultString+=padTill2(date.getSeconds(),padding);break;case 84:resultString+=_processFormat(locale.formats.T,date,locale,timestamp);break;case 85:resultString+=padTill2(weekNumber(date,"sunday"),padding);break;case 87:resultString+=padTill2(weekNumber(date,"monday"),padding);break;case 88:resultString+=_processFormat(locale.formats.X,date,locale,timestamp);break;case 89:resultString+=date.getFullYear();break;case 90:if(_useUtcBasedDate&&_customTimezoneOffset===0){resultString+="GMT"}else{var tzString=date.toString().match(/\(([\w\s]+)\)/);resultString+=tzString&&tzString[1]||""}break;case 97:resultString+=locale.shortDays[date.getDay()];break;case 98:resultString+=locale.shortMonths[date.getMonth()];break;case 99:resultString+=_processFormat(locale.formats.c,date,locale,timestamp);break;case 100:resultString+=padTill2(date.getDate(),padding);break;case 101:resultString+=padTill2(date.getDate(),padding==null?" ":padding);break;case 104:resultString+=locale.shortMonths[date.getMonth()];break;case 106:var y=new Date(date.getFullYear(),0,1);var day=Math.ceil((date.getTime()-y.getTime())/(1e3*60*60*24));resultString+=padTill3(day);break;case 107:resultString+=padTill2(date.getHours(),padding==null?" ":padding);break;case 108:resultString+=padTill2(hours12(date.getHours()),padding==null?" ":padding);break;case 109:resultString+=padTill2(date.getMonth()+1,padding);break;case 110:resultString+="\n";break;case 111:resultString+=String(date.getDate())+ordinal(date.getDate());break;case 112:resultString+=date.getHours()<12?locale.AM:locale.PM;break;case 114:resultString+=_processFormat(locale.formats.r,date,locale,timestamp);break;case 115:resultString+=Math.floor(timestamp/1e3);break;case 116:resultString+="	";break;case 117:var day=date.getDay();resultString+=day===0?7:day;break;case 118:resultString+=_processFormat(locale.formats.v,date,locale,timestamp);break;case 119:resultString+=date.getDay();break;case 120:resultString+=_processFormat(locale.formats.x,date,locale,timestamp);break;case 121:resultString+=(""+date.getFullYear()).slice(2);break;case 122:if(_useUtcBasedDate&&_customTimezoneOffset===0){resultString+=extendedTZ?"+00:00":"+0000"}else{var off;if(_customTimezoneOffset!==0){off=_customTimezoneOffset/(60*1e3)}else{off=-date.getTimezoneOffset()}var sign=off<0?"-":"+";var sep=extendedTZ?":":"";var hours=Math.floor(Math.abs(off/60));var mins=Math.abs(off%60);resultString+=sign+padTill2(hours)+sep+padTill2(mins)}break;default:resultString+=format[i];break}padding=null;isInScope=false;continue}if(currentCharCode===37){isInScope=true;continue}resultString+=format[i]}return resultString}var strftime=_strftime;strftime.localize=function(locale){return new Strftime(locale||_locale,_customTimezoneOffset,_useUtcBasedDate)};strftime.timezone=function(timezone){var customTimezoneOffset=_customTimezoneOffset;var useUtcBasedDate=_useUtcBasedDate;var timezoneType=typeof timezone==="undefined"?"undefined":_typeof(timezone);if(timezoneType==="number"||timezoneType==="string"){useUtcBasedDate=true;if(timezoneType==="string"){var sign=timezone[0]==="-"?-1:1,hours=parseInt(timezone.slice(1,3),10),minutes=parseInt(timezone.slice(3,5),10);customTimezoneOffset=sign*(60*hours+minutes)*60*1e3}else if(timezoneType==="number"){customTimezoneOffset=timezone*60*1e3}}return new Strftime(_locale,customTimezoneOffset,useUtcBasedDate)};strftime.utc=function(){return new Strftime(_locale,_customTimezoneOffset,true)};return strftime}function padTill2(numberToPad,paddingChar){if(paddingChar===""||numberToPad>9){return numberToPad}if(paddingChar==null){paddingChar="0"}return paddingChar+numberToPad}function padTill3(numberToPad){if(numberToPad>99){return numberToPad}if(numberToPad>9){return"0"+numberToPad}return"00"+numberToPad}function hours12(hour){if(hour===0){return 12}else if(hour>12){return hour-12}return hour}function weekNumber(date,firstWeekday){firstWeekday=firstWeekday||"sunday";var weekday=date.getDay();if(firstWeekday==="monday"){if(weekday===0)weekday=6;else weekday--}var firstDayOfYearUtc=Date.UTC(date.getFullYear(),0,1),dateUtc=Date.UTC(date.getFullYear(),date.getMonth(),date.getDate()),yday=Math.floor((dateUtc-firstDayOfYearUtc)/864e5),weekNum=(yday+7-weekday)/7;return Math.floor(weekNum)}function ordinal(number){var i=number%10;var ii=number%100;if(ii>=11&&ii<=13||i===0||i>=4){return"th"}switch(i){case 1:return"st";case 2:return"nd";case 3:return"rd"}}function getTimestampToUtcOffsetFor(date){return(date.getTimezoneOffset()||0)*6e4}})()},{}],11:[function(require,module,exports){"use strict";if(typeof Object.create==="function"){module.exports=function inherits(ctor,superCtor){ctor.super_=superCtor;ctor.prototype=Object.create(superCtor.prototype,{constructor:{value:ctor,enumerable:false,writable:true,configurable:true}})}}else{module.exports=function inherits(ctor,superCtor){ctor.super_=superCtor;var TempCtor=function TempCtor(){};TempCtor.prototype=superCtor.prototype;ctor.prototype=new TempCtor;ctor.prototype.constructor=ctor}}},{}],12:[function(require,module,exports){"use strict";
-
-var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol?"symbol":typeof obj};module.exports=function isBuffer(arg){return arg&&(typeof arg==="undefined"?"undefined":_typeof(arg))==="object"&&typeof arg.copy==="function"&&typeof arg.fill==="function"&&typeof arg.readUInt8==="function"}},{}],13:[function(require,module,exports){(function(process,global){"use strict";var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol?"symbol":typeof obj};var formatRegExp=/%[sdj%]/g;exports.format=function(f){if(!isString(f)){var objects=[];for(var i=0;i<arguments.length;i++){objects.push(inspect(arguments[i]))}return objects.join(" ")}var i=1;var args=arguments;var len=args.length;var str=String(f).replace(formatRegExp,function(x){if(x==="%%")return"%";if(i>=len)return x;switch(x){case"%s":return String(args[i++]);case"%d":return Number(args[i++]);case"%j":try{return JSON.stringify(args[i++])}catch(_){return"[Circular]"}default:return x}});for(var x=args[i];i<len;x=args[++i]){if(isNull(x)||!isObject(x)){str+=" "+x}else{str+=" "+inspect(x)}}return str};exports.deprecate=function(fn,msg){if(isUndefined(global.process)){return function(){return exports.deprecate(fn,msg).apply(this,arguments)}}if(process.noDeprecation===true){return fn}var warned=false;function deprecated(){if(!warned){if(process.throwDeprecation){throw new Error(msg)}else if(process.traceDeprecation){console.trace(msg)}else{console.error(msg)}warned=true}return fn.apply(this,arguments)}return deprecated};var debugs={};var debugEnviron;exports.debuglog=function(set){if(isUndefined(debugEnviron))debugEnviron=process.env.NODE_DEBUG||"";set=set.toUpperCase();if(!debugs[set]){if(new RegExp("\\b"+set+"\\b","i").test(debugEnviron)){var pid=process.pid;debugs[set]=function(){var msg=exports.format.apply(exports,arguments);console.error("%s %d: %s",set,pid,msg)}}else{debugs[set]=function(){}}}return debugs[set]};function inspect(obj,opts){var ctx={seen:[],stylize:stylizeNoColor};if(arguments.length>=3)ctx.depth=arguments[2];if(arguments.length>=4)ctx.colors=arguments[3];if(isBoolean(opts)){ctx.showHidden=opts}else if(opts){exports._extend(ctx,opts)}if(isUndefined(ctx.showHidden))ctx.showHidden=false;if(isUndefined(ctx.depth))ctx.depth=2;if(isUndefined(ctx.colors))ctx.colors=false;if(isUndefined(ctx.customInspect))ctx.customInspect=true;if(ctx.colors)ctx.stylize=stylizeWithColor;return formatValue(ctx,obj,ctx.depth)}exports.inspect=inspect;inspect.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]};inspect.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"};function stylizeWithColor(str,styleType){var style=inspect.styles[styleType];if(style){return"["+inspect.colors[style][0]+"m"+str+"["+inspect.colors[style][1]+"m"}else{return str}}function stylizeNoColor(str,styleType){return str}function arrayToHash(array){var hash={};array.forEach(function(val,idx){hash[val]=true});return hash}function formatValue(ctx,value,recurseTimes){if(ctx.customInspect&&value&&isFunction(value.inspect)&&value.inspect!==exports.inspect&&!(value.constructor&&value.constructor.prototype===value)){var ret=value.inspect(recurseTimes,ctx);if(!isString(ret)){ret=formatValue(ctx,ret,recurseTimes)}return ret}var primitive=formatPrimitive(ctx,value);if(primitive){return primitive}var keys=Object.keys(value);var visibleKeys=arrayToHash(keys);if(ctx.showHidden){keys=Object.getOwnPropertyNames(value)}if(isError(value)&&(keys.indexOf("message")>=0||keys.indexOf("description")>=0)){return formatError(value)}if(keys.length===0){if(isFunction(value)){var name=value.name?": "+value.name:"";return ctx.stylize("[Function"+name+"]","special")}if(isRegExp(value)){return ctx.stylize(RegExp.prototype.toString.call(value),"regexp")}if(isDate(value)){return ctx.stylize(Date.prototype.toString.call(value),"date")}if(isError(value)){return formatError(value)}}var base="",array=false,braces=["{","}"];if(isArray(value)){array=true;braces=["[","]"]}if(isFunction(value)){var n=value.name?": "+value.name:"";base=" [Function"+n+"]"}if(isRegExp(value)){base=" "+RegExp.prototype.toString.call(value)}if(isDate(value)){base=" "+Date.prototype.toUTCString.call(value)}if(isError(value)){base=" "+formatError(value)}if(keys.length===0&&(!array||value.length==0)){return braces[0]+base+braces[1]}if(recurseTimes<0){if(isRegExp(value)){return ctx.stylize(RegExp.prototype.toString.call(value),"regexp")}else{return ctx.stylize("[Object]","special")}}ctx.seen.push(value);var output;if(array){output=formatArray(ctx,value,recurseTimes,visibleKeys,keys)}else{output=keys.map(function(key){return formatProperty(ctx,value,recurseTimes,visibleKeys,key,array)})}ctx.seen.pop();return reduceToSingleString(output,base,braces)}function formatPrimitive(ctx,value){if(isUndefined(value))return ctx.stylize("undefined","undefined");if(isString(value)){var simple="'"+JSON.stringify(value).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return ctx.stylize(simple,"string")}if(isNumber(value))return ctx.stylize(""+value,"number");if(isBoolean(value))return ctx.stylize(""+value,"boolean");if(isNull(value))return ctx.stylize("null","null")}function formatError(value){return"["+Error.prototype.toString.call(value)+"]"}function formatArray(ctx,value,recurseTimes,visibleKeys,keys){var output=[];for(var i=0,l=value.length;i<l;++i){if(hasOwnProperty(value,String(i))){output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,String(i),true))}else{output.push("")}}keys.forEach(function(key){if(!key.match(/^\d+$/)){output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,key,true))}});return output}function formatProperty(ctx,value,recurseTimes,visibleKeys,key,array){var name,str,desc;desc=Object.getOwnPropertyDescriptor(value,key)||{value:value[key]};if(desc.get){if(desc.set){str=ctx.stylize("[Getter/Setter]","special")}else{str=ctx.stylize("[Getter]","special")}}else{if(desc.set){str=ctx.stylize("[Setter]","special")}}if(!hasOwnProperty(visibleKeys,key)){name="["+key+"]"}if(!str){if(ctx.seen.indexOf(desc.value)<0){if(isNull(recurseTimes)){str=formatValue(ctx,desc.value,null)}else{str=formatValue(ctx,desc.value,recurseTimes-1)}if(str.indexOf("\n")>-1){if(array){str=str.split("\n").map(function(line){return"  "+line}).join("\n").substr(2)}else{str="\n"+str.split("\n").map(function(line){return"   "+line}).join("\n")}}}else{str=ctx.stylize("[Circular]","special")}}if(isUndefined(name)){if(array&&key.match(/^\d+$/)){return str}name=JSON.stringify(""+key);if(name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)){name=name.substr(1,name.length-2);name=ctx.stylize(name,"name")}else{name=name.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'");name=ctx.stylize(name,"string")}}return name+": "+str}function reduceToSingleString(output,base,braces){var numLinesEst=0;var length=output.reduce(function(prev,cur){numLinesEst++;if(cur.indexOf("\n")>=0)numLinesEst++;return prev+cur.replace(/\u001b\[\d\d?m/g,"").length+1},0);if(length>60){return braces[0]+(base===""?"":base+"\n ")+" "+output.join(",\n  ")+" "+braces[1]}return braces[0]+base+" "+output.join(", ")+" "+braces[1]}function isArray(ar){return Array.isArray(ar)}exports.isArray=isArray;function isBoolean(arg){return typeof arg==="boolean"}exports.isBoolean=isBoolean;function isNull(arg){return arg===null}exports.isNull=isNull;function isNullOrUndefined(arg){return arg==null}exports.isNullOrUndefined=isNullOrUndefined;function isNumber(arg){return typeof arg==="number"}exports.isNumber=isNumber;function isString(arg){return typeof arg==="string"}exports.isString=isString;function isSymbol(arg){return(typeof arg==="undefined"?"undefined":_typeof(arg))==="symbol"}exports.isSymbol=isSymbol;function isUndefined(arg){return arg===void 0}exports.isUndefined=isUndefined;function isRegExp(re){return isObject(re)&&objectToString(re)==="[object RegExp]"}exports.isRegExp=isRegExp;function isObject(arg){return(typeof arg==="undefined"?"undefined":_typeof(arg))==="object"&&arg!==null}exports.isObject=isObject;function isDate(d){return isObject(d)&&objectToString(d)==="[object Date]"}exports.isDate=isDate;function isError(e){return isObject(e)&&(objectToString(e)==="[object Error]"||e instanceof Error)}exports.isError=isError;function isFunction(arg){return typeof arg==="function"}exports.isFunction=isFunction;function isPrimitive(arg){return arg===null||typeof arg==="boolean"||typeof arg==="number"||typeof arg==="string"||(typeof arg==="undefined"?"undefined":_typeof(arg))==="symbol"||typeof arg==="undefined"}exports.isPrimitive=isPrimitive;exports.isBuffer=require("./support/isBuffer");function objectToString(o){return Object.prototype.toString.call(o)}function pad(n){return n<10?"0"+n.toString(10):n.toString(10)}var months=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function timestamp(){var d=new Date;var time=[pad(d.getHours()),pad(d.getMinutes()),pad(d.getSeconds())].join(":");return[d.getDate(),months[d.getMonth()],time].join(" ")}exports.log=function(){console.log("%s - %s",timestamp(),exports.format.apply(exports,arguments))};exports.inherits=require("inherits");exports._extend=function(origin,add){if(!add||!isObject(add))return origin;var keys=Object.keys(add);var i=keys.length;while(i--){origin[keys[i]]=add[keys[i]]}return origin};function hasOwnProperty(obj,prop){return Object.prototype.hasOwnProperty.call(obj,prop)}}).call(this,require("_process"),typeof global!=="undefined"?global:typeof self!=="undefined"?self:typeof window!=="undefined"?window:{})},{"./support/isBuffer":12,_process:9,inherits:11}],14:[function(require,module,exports){"use strict";var util=require("util");function TokenizationError(message,input,line){Error.captureStackTrace(this,this.constructor);this.name=this.constructor.name;this.message=message||"";this.input=input;this.line=line}util.inherits(TokenizationError,Error);function ParseError(message,input,line){Error.captureStackTrace(this,this.constructor);this.name=this.constructor.name;this.message=message||"";this.input=input;this.line=line}util.inherits(ParseError,Error);module.exports={TokenizationError:TokenizationError,ParseError:ParseError}},{util:13}],15:[function(require,module,exports){"use strict";var syntax=require("./syntax.js");var Exp=require("./expression.js");var lexical=require("./lexical.js");function evalExp(exp,scope){if(!scope)throw new Error("unable to evalExp: scope undefined");var operatorREs=lexical.operators,match;for(var i=0;i<operatorREs.length;i++){var operatorRE=operatorREs[i];var expRE=new RegExp("^("+lexical.quoteBalanced.source+")("+operatorRE.source+")("+lexical.quoteBalanced.source+")$");if(match=exp.match(expRE)){var l=evalExp(match[1],scope);var op=syntax.operators[match[2].trim()];var r=evalExp(match[3],scope);return op(l,r)}}if(match=exp.match(lexical.rangeLine)){var low=evalValue(match[1],scope),high=evalValue(match[2],scope);var range=[];for(var j=low;j<=high;j++){range.push(j)}return range}return evalValue(exp,scope)}function evalValue(str,scope){str=str&&str.trim();if(!str)return undefined;if(lexical.isLiteral(str)){var a=lexical.parseLiteral(str);return lexical.parseLiteral(str)}if(lexical.isVariable(str)){return scope.get(str)}}function isTruthy(val){if(val instanceof Array)return!!val.length;return!!val}function isFalsy(val){return!isTruthy(val)}module.exports={evalExp:evalExp,evalValue:evalValue,isTruthy:isTruthy,isFalsy:isFalsy}},{"./expression.js":15,"./lexical.js":17,"./syntax.js":21}],16:[function(require,module,exports){"use strict";var lexical=require("./lexical.js");var Exp=require("./expression.js");var valueRE=new RegExp(""+lexical.value.source,"g");module.exports=function(){var filters={};var _filterInstance={render:function render(output,scope){var args=this.args.map(function(arg){return Exp.evalValue(arg,scope)});args.unshift(output);return this.filter.apply(null,args)},parse:function parse(str){var match=lexical.filterLine.exec(str);if(!match)throw new Error("illegal filter: "+str);var name=match[1],argList=match[2]||"",filter=filters[name];if(typeof filter!=="function"){return{name:name,error:new Error("undefined filter: "+name)}}var args=[];while(match=valueRE.exec(argList.trim())){args.push(match[0])}this.name=name;this.filter=filter;this.args=args;return this}};function construct(str){var instance=Object.create(_filterInstance);return instance.parse(str)}function register(name,filter){filters[name]=filter}function clear(){filters={}}return{construct:construct,register:register,clear:clear}}},{"./expression.js":15,"./lexical.js":17}],17:[function(require,module,exports){"use strict";var singleQuoted=/'[^']*'/;var doubleQuoted=/"[^"]*"/;var quoteBalanced=new RegExp("(?:"+singleQuoted.source+"|"+doubleQuoted.source+"|[^'\"])*");var number=/(?:-?\d+\.?\d*|\.?\d+)/;var bool=/true|false/;var identifier=/[a-zA-Z_$][a-zA-Z_$0-9]*/;var subscript=/\[\d+\]/;var quoted=new RegExp("(?:"+singleQuoted.source+"|"+doubleQuoted.source+")");var literal=new RegExp("(?:"+quoted.source+"|"+bool.source+"|"+number.source+")");var variable=new RegExp(identifier.source+"(?:\\."+identifier.source+"|"+subscript.source+")*");var rangeLimit=new RegExp("(?:"+variable.source+"|"+number.source+")");var range=new RegExp("\\("+rangeLimit.source+"\\.\\."+rangeLimit.source+"\\)");var rangeCapture=new RegExp("\\(("+rangeLimit.source+")\\.\\.("+rangeLimit.source+")\\)");var value=new RegExp("(?:"+literal.source+"|"+variable.source+"|"+range.source+")");var hash=new RegExp("(?:"+identifier.source+")\\s*:\\s*(?:"+value.source+")");var hashCapture=new RegExp("("+identifier.source+")\\s*:\\s*("+value.source+")","g");var tagLine=new RegExp("^\\s*("+identifier.source+")\\s*(.*)\\s*$");var literalLine=new RegExp("^"+literal.source+"$","i");var variableLine=new RegExp("^"+variable.source+"$");var numberLine=new RegExp("^"+number.source+"$");var boolLine=new RegExp("^"+bool.source+"$","i");var quotedLine=new RegExp("^"+quoted.source+"$");var rangeLine=new RegExp("^"+rangeCapture.source+"$");var valueList=new RegExp(value.source+"(\\s*,\\s*"+value.source+")*");var filter=new RegExp(identifier.source+"(?:\\s*:\\s*"+valueList.source+")?","g");var filterCapture=new RegExp("("+identifier.source+")(?:\\s*:\\s*("+valueList.source+"))?");var filterLine=new RegExp("^"+filterCapture.source+"$");var operators=[/\s+or\s+/,/\s+and\s+/,/==|!=|<=|>=|<|>|\s+contains\s+/];function isLiteral(str){return literalLine.test(str)}function isRange(str){return rangeLine.test(str)}function isVariable(str){return variableLine.test(str)}function parseLiteral(str){var res;if(res=str.match(numberLine)){return Number(str)}if(res=str.match(boolLine)){return str.toLowerCase()==="true"}if(res=str.match(quotedLine)){return str.slice(1,-1)}}module.exports={quoted:quoted,number:number,bool:bool,literal:literal,filter:filter,hash:hash,hashCapture:hashCapture,range:range,rangeCapture:rangeCapture,identifier:identifier,value:value,quoteBalanced:quoteBalanced,operators:operators,quotedLine:quotedLine,numberLine:numberLine,boolLine:boolLine,rangeLine:rangeLine,literalLine:literalLine,filterLine:filterLine,tagLine:tagLine,isLiteral:isLiteral,isVariable:isVariable,parseLiteral:parseLiteral,isRange:isRange}},{}],18:[function(require,module,exports){"use strict";var lexical=require("./lexical.js");var ParseError=require("./error.js").ParseError;module.exports=function(Tag,Filter){var stream={init:function init(tokens){this.tokens=tokens;this.handlers={};return this},on:function on(name,cb){this.handlers[name]=cb;return this},trigger:function trigger(event,arg){var h=this.handlers[event];if(typeof h==="function"){h(arg);return true}},start:function start(){this.trigger("start");while(!this.stopRequested&&(token=this.tokens.shift())){if(this.trigger("token",token))continue;if(token.type=="tag"&&this.trigger("tag:"+token.name,token)){continue}var template=parseToken(token,this.tokens);this.trigger("template",template)}if(!this.stopRequested)this.trigger("end");return this},stop:function stop(){this.stopRequested=true;return this}};function parse(tokens){var token,templates=[];while(token=tokens.shift()){templates.push(parseToken(token,tokens))}return templates}function parseToken(token,tokens){try{switch(token.type){case"tag":return parseTag(token,tokens);case"output":return parseOutput(token.value);case"html":return token}}catch(e){throw new ParseError(e.message,token.input,token.line)}}function parseTag(token,tokens){if(token.name==="continue"||token.name==="break")return token;return Tag.construct(token,tokens)}function parseOutput(str){var match=lexical.value.exec(str);if(!match)throw new Error("illegal output string: "+str);var initial=match[0];str=str.substr(match.index+match[0].length);var filters=[];while(match=lexical.filter.exec(str)){filters.push([match[0].trim()])}return{type:"output",initial:initial,filters:filters.map(function(str){return Filter.construct(str)})}}function parseStream(tokens){var s=Object.create(stream);return s.init(tokens)}return{parse:parse,parseTag:parseTag,parseStream:parseStream,parseOutput:parseOutput}}},{"./error.js":14,"./lexical.js":17}],19:[function(require,module,exports){"use strict";var error=require("./error.js");var Exp=require("./expression.js");var assert=require("assert");var Promise=require("any-promise");var render={renderTemplates:function renderTemplates(templates,scope,opts){var _this=this;assert(scope,"unable to evalTemplates: scope undefined");opts=opts||{};opts.strict_filters=opts.strict_filters||false;var html="";var lastPromise=templates.reduce(function(promise,template){return promise.then(function(partial){if(scope.safeGet("forloop.skip")){return Promise.resolve("")}if(scope.safeGet("forloop.stop")){throw new Error("forloop.stop")}var promiseLink=Promise.resolve("");switch(template.type){case"tag":promiseLink=_this.renderTag(template,scope,_this.register).then(function(partial){if(partial===undefined){return true}return html+=partial});break;case"html":promiseLink=Promise.resolve(template.value).then(function(partial){return html+=partial});break;case"output":var val=_this.evalOutput(template,scope,opts);promiseLink=Promise.resolve(val===undefined?"":stringify(val)).then(function(partial){return html+=partial});break}return promiseLink}).catch(function(error){if(error.message==="forloop.skip"){return html}else{throw error}})},Promise.resolve(""));return lastPromise.then(function(renderedHtml){return renderedHtml}).catch(function(error){throw error})},renderTag:function renderTag(template,scope,register){if(template.name==="continue"){scope.set("forloop.skip",true);return Promise.resolve("")}if(template.name==="break"){scope.set("forloop.stop",true);scope.set("forloop.skip",true);return Promise.reject(new Error("forloop.stop"))}return template.render(scope,register)},evalOutput:function evalOutput(template,scope,opts){assert(scope,"unable to evalOutput: scope undefined");var val=Exp.evalExp(template.initial,scope);template.filters.some(function(filter){if(filter.error){if(opts.strict_filters){throw filter.error}else{val="";return true}}val=filter.render(val,scope)});return val},resetRegisters:function resetRegisters(){return this.register={}}};function factory(){var instance=Object.create(render);instance.register={};return instance}function stringify(val){if(typeof val==="string")return val;return JSON.stringify(val)}module.exports=factory},{"./error.js":14,"./expression.js":15,"any-promise":3,assert:6}],20:[function(require,module,exports){"use strict";var lexical=require("./lexical.js");var Scope={safeGet:function safeGet(str){var i;if(str===undefined){var ctx={};for(i=this.scopes.length-1;i>=0;i--){var scp=this.scopes[i];for(var k in scp){if(scp.hasOwnProperty(k)){ctx[k]=scp[k]}}}return ctx}for(i=this.scopes.length-1;i>=0;i--){var v=getPropertyByPath(this.scopes[i],str);if(v!==undefined)return v}},get:function get(str){var val=this.safeGet(str);if(val===undefined&&this.opts.strict){throw new Error("[strict_variables] undefined variable: "+str)}return val},set:function set(k,v){setPropertyByPath(this.scopes[this.scopes.length-1],k,v);return this},push:function push(ctx){if(!ctx)throw new Error("trying to push "+ctx+" into scopes");return this.scopes.push(ctx)},pop:function pop(){return this.scopes.pop()}};function setPropertyByPath(obj,path,val){if(path instanceof String||typeof path==="string"){var paths=path.replace(/\[/g,".").replace(/\]/g,"").split(".");for(var i=0;i<paths.length;i++){var key=paths[i];if(i===paths.length-1){return obj[key]=val}if(undefined===obj[key])obj[key]={};obj=obj[key]||{}}return obj}return obj[path]=val}function getPropertyByPath(obj,path){if(path instanceof String||typeof path==="string"){var paths=path.replace(/\[/g,".").replace(/\]/g,"").split(".");paths.forEach(function(p){return obj=obj&&obj[p]});return obj}return obj[path]}exports.factory=function(_ctx,opts){opts=opts||{};opts.strict=opts.strict||false;var scope=Object.create(Scope);scope.opts=opts;scope.scopes=[_ctx||{}];return scope}},{"./lexical.js":17}],21:[function(require,module,exports){"use strict";var operators={"==":function _(l,r){return l==r},"!=":function _(l,r){return l!=r},">":function _(l,r){return l>r},"<":function _(l,r){return l<r},">=":function _(l,r){return l>=r},"<=":function _(l,r){return l<=r},contains:function contains(l,r){return l.indexOf(r)>-1},and:function and(l,r){return l&&r},or:function or(l,r){return l||r}};exports.operators=operators},{}],22:[function(require,module,exports){"use strict";var lexical=require("./lexical.js");var Promise=require("any-promise");var Exp=require("./expression.js");var TokenizationError=require("./error.js").TokenizationError;function hash(markup,scope){var obj={};lexical.hashCapture.lastIndex=0;while(match=lexical.hashCapture.exec(markup)){var k=match[1],v=match[2];obj[k]=Exp.evalValue(v,scope)}return obj}module.exports=function(){var tagImpls={};var _tagInstance={render:function render(scope,register){var reg=register[this.name];if(!reg)reg=register[this.name]={};var obj=hash(this.token.args,scope);return this.tagImpl.render&&this.tagImpl.render(scope,obj,reg)||Promise.resolve("")},parse:function parse(token,tokens){this.type="tag";this.token=token;this.name=token.name;var tagImpl=tagImpls[this.name];if(!tagImpl)throw new Error("tag "+this.name+" not found");this.tagImpl=Object.create(tagImpl);if(this.tagImpl.parse){this.tagImpl.parse(token,tokens)}}};function register(name,tag){tagImpls[name]=tag}function construct(token,tokens){var instance=Object.create(_tagInstance);instance.parse(token,tokens);return instance}function clear(){tagImpls={}}return{construct:construct,register:register,clear:clear}}},{"./error.js":14,"./expression.js":15,"./lexical.js":17,"any-promise":3}],23:[function(require,module,exports){"use strict";var lexical=require("./lexical.js");var TokenizationError=require("./error.js").TokenizationError;function parse(html){var tokens=[];if(!html)return tokens;var syntax=/({%(.*?)%})|({{(.*?)}})/g;var result,htmlFragment,token;var lastMatchEnd=0,lastMatchBegin=-1,parsedLinesCount=0;while((result=syntax.exec(html))!==null){if(result.index>lastMatchEnd){htmlFragment=html.slice(lastMatchEnd,result.index);tokens.push({type:"html",raw:htmlFragment,value:htmlFragment})}if(result[1]){token=factory("tag",1,result);var match=token.value.match(lexical.tagLine);if(!match){throw new TokenizationError("illegal tag: "+token.raw,token.input,token.line)}token.name=match[1];token.args=match[2];tokens.push(token)}else{token=factory("output",3,result);tokens.push(token)}lastMatchEnd=syntax.lastIndex}if(html.length>lastMatchEnd){htmlFragment=html.slice(lastMatchEnd,html.length);tokens.push({type:"html",raw:htmlFragment,value:htmlFragment})}return tokens;function factory(type,offset,match){return{type:type,raw:match[offset],value:match[offset+1].trim(),line:getLineNum(match),input:getLineContent(match)}}function getLineContent(match){var idx1=match.input.lastIndexOf("\n",match.index);var idx2=match.input.indexOf("\n",match.index);if(idx2===-1)idx2=match.input.length;return match.input.slice(idx1+1,idx2)}function getLineNum(match){var lines=match.input.slice(lastMatchBegin+1,match.index).split("\n");parsedLinesCount+=lines.length-1;lastMatchBegin=match.index;return parsedLinesCount+1}}exports.parse=parse},{"./error.js":14,"./lexical.js":17}],24:[function(require,module,exports){"use strict";var Liquid=require("..");var Promise=require("any-promise");var lexical=Liquid.lexical;var re=new RegExp("("+lexical.identifier.source+")\\s*=(.*)");module.exports=function(liquid){liquid.registerTag("assign",{parse:function parse(token){var match=token.args.match(re);if(!match)throw new Error("illegal token "+token.raw);this.key=match[1];this.value=match[2]},render:function render(scope,hash){scope.set(this.key,liquid.evalOutput(this.value,scope));return Promise.resolve("")}})}},{"..":2,"any-promise":3}],25:[function(require,module,exports){"use strict";var Liquid=require("..");var lexical=Liquid.lexical;var re=new RegExp("("+lexical.identifier.source+")");module.exports=function(liquid){liquid.registerTag("capture",{parse:function parse(tagToken,remainTokens){var _this=this;var match=tagToken.args.match(re);if(!match)throw new Error(tagToken.args+" not valid identifier");this.variable=match[1];this.templates=[];var stream=liquid.parser.parseStream(remainTokens);stream.on("tag:endcapture",function(token){return stream.stop()}).on("template",function(tpl){return _this.templates.push(tpl)}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()},render:function render(scope,hash){var _this2=this;return liquid.renderer.renderTemplates(this.templates,scope).then(function(html){scope.set(_this2.variable,html)})}})}},{"..":2}],26:[function(require,module,exports){"use strict";var Liquid=require("..");var lexical=Liquid.lexical;module.exports=function(liquid){liquid.registerTag("case",{parse:function parse(tagToken,remainTokens){var _this=this;this.cond=tagToken.args;this.cases=[];this.elseTemplates=[];var p=[],stream=liquid.parser.parseStream(remainTokens).on("tag:when",function(token){if(!_this.cases[token.args]){_this.cases.push({val:token.args,templates:p=[]})}}).on("tag:else",function(token){return p=_this.elseTemplates}).on("tag:endcase",function(token){return stream.stop()}).on("template",function(tpl){return p.push(tpl)}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()},render:function render(scope,hash){for(var i=0;i<this.cases.length;i++){var branch=this.cases[i];var val=Liquid.evalExp(branch.val,scope);var cond=Liquid.evalExp(this.cond,scope);if(val===cond){return liquid.renderer.renderTemplates(branch.templates,scope)}}return liquid.renderer.renderTemplates(this.elseTemplates,scope)}})}},{"..":2}],27:[function(require,module,exports){"use strict";var Liquid=require("..");var lexical=Liquid.lexical;var re=new RegExp("("+lexical.identifier.source+")");module.exports=function(liquid){liquid.registerTag("comment",{parse:function parse(tagToken,remainTokens){var stream=liquid.parser.parseStream(remainTokens);stream.on("token",function(token){if(token.name==="endcomment")stream.stop()}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()}})}},{"..":2}],28:[function(require,module,exports){"use strict";var Liquid=require("..");var Promise=require("any-promise");var lexical=Liquid.lexical;var groupRE=new RegExp("^(?:("+lexical.value.source+")\\s*:\\s*)?(.*)$");var candidatesRE=new RegExp(lexical.value.source,"g");module.exports=function(liquid){liquid.registerTag("cycle",{parse:function parse(tagToken,remainTokens){var match=groupRE.exec(tagToken.args);if(!match)throw new Error("illegal tag: "+tagToken.raw);this.group=match[1]||"";var candidates=match[2];this.candidates=[];while(match=candidatesRE.exec(candidates)){this.candidates.push(match[0])}if(!this.candidates.length){throw new Error("empty candidates: "+tagToken.raw)}},render:function render(scope,hash,register){var fingerprint=Liquid.evalValue(this.group,scope)+":"+this.candidates.join(",");var idx=register[fingerprint];if(idx===undefined){idx=register[fingerprint]=0}var candidate=this.candidates[idx];idx=(idx+1)%this.candidates.length;register[fingerprint]=idx;return Promise.resolve(Liquid.evalValue(candidate,scope))}})}},{"..":2,"any-promise":3}],29:[function(require,module,exports){"use strict";var Liquid=require("..");var lexical=Liquid.lexical;var error=Liquid.error;module.exports=function(liquid){liquid.registerTag("decrement",{parse:function parse(token){var match=token.args.match(lexical.identifier);if(!match)throw new Error("illegal identifier "+token.args);this.variable=match[0]},render:function render(scope,hash){var v=scope.get(this.variable);if(typeof v!=="number")v=0;scope.set(this.variable,v-1)}})}},{"..":2}],30:[function(require,module,exports){"use strict";var Liquid=require("..");var Promise=require("any-promise");var lexical=Liquid.lexical;var re=new RegExp("^("+lexical.identifier.source+")\\s+in\\s+"+("("+lexical.value.source+")")+("(?:\\s+"+lexical.hash.source+")*")+"(?:\\s+(reversed))?$");module.exports=function(liquid){liquid.registerTag("for",{parse:function parse(tagToken,remainTokens){var _this=this;var match=re.exec(tagToken.args);if(!match)throw new Error("illegal tag: "+tagToken.raw);this.variable=match[1];this.collection=match[2];this.reversed=!!match[3];this.templates=[];this.elseTemplates=[];var p,stream=liquid.parser.parseStream(remainTokens).on("start",function(x){return p=_this.templates}).on("tag:else",function(token){return p=_this.elseTemplates}).on("tag:endfor",function(token){return stream.stop()}).on("template",function(tpl){return p.push(tpl)}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()},render:function render(scope,hash){var _this2=this;var collection=Liquid.evalExp(this.collection,scope);if(Liquid.isFalsy(collection)){return liquid.renderer.renderTemplates(this.elseTemplates,scope)}var html="";var length=collection.length;var offset=hash.offset||0;var limit=hash.limit===undefined?collection.length:hash.limit;collection=collection.slice(offset,offset+limit);if(this.reversed)collection.reverse();var contexts=[];collection.some(function(item,i){var ctx={};ctx[_this2.variable]=item;ctx.forloop={first:i===0,index:i+1,index0:i,last:i===length-1,length:length,rindex:length-i,rindex0:length-i-1,stop:false,skip:false};contexts.push(ctx)});var lastPromise=contexts.reduce(function(promise,context){return promise.then(function(partial){if(scope.get("forloop.stop")){throw new Error("forloop.stop")}return html+=partial}).then(function(partial){scope.push(context);return liquid.renderer.renderTemplates(_this2.templates,scope)}).then(function(partial){scope.pop(context);return partial})},Promise.resolve(""));return lastPromise.then(function(partial){return html+=partial}).catch(function(error){if(error.message==="forloop.stop"){return html}else{throw error}})}})}},{"..":2,"any-promise":3}],31:[function(require,module,exports){"use strict";var Liquid=require("..");var lexical=Liquid.lexical;module.exports=function(liquid){liquid.registerTag("if",{parse:function parse(tagToken,remainTokens){var _this=this;this.branches=[];this.elseTemplates=[];var p,stream=liquid.parser.parseStream(remainTokens).on("start",function(x){return _this.branches.push({cond:tagToken.args,templates:p=[]})}).on("tag:elsif",function(token){if(!_this.branches[token.args]){_this.branches.push({cond:token.args,templates:p=[]})}}).on("tag:else",function(token){return p=_this.elseTemplates}).on("tag:endif",function(token){
-return stream.stop()}).on("template",function(tpl){return p.push(tpl)}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()},render:function render(scope,hash){for(var i=0;i<this.branches.length;i++){var branch=this.branches[i];var cond=Liquid.evalExp(branch.cond,scope);if(Liquid.isTruthy(cond)){return liquid.renderer.renderTemplates(branch.templates,scope)}}return liquid.renderer.renderTemplates(this.elseTemplates,scope)}})}},{"..":2}],32:[function(require,module,exports){"use strict";var Liquid=require("..");var Promise=require("any-promise");var lexical=Liquid.lexical;var withRE=new RegExp("with\\s+("+lexical.value.source+")");module.exports=function(liquid){liquid.registerTag("include",{parse:function parse(token){var match=lexical.value.exec(token.args);if(!match)throw new Error("illegal token "+token.raw);this.value=match[0];match=withRE.exec(token.args);if(match){this.with=match[1]}},render:function render(scope,hash){var filepath=Liquid.evalValue(this.value,scope);if(this.with){hash[filepath]=Liquid.evalValue(this.with,scope)}return liquid.handleCache(filepath).then(function(templates){scope.push(hash);return liquid.renderer.renderTemplates(templates,scope)}).then(function(html){scope.pop();return html})}})}},{"..":2,"any-promise":3}],33:[function(require,module,exports){"use strict";var Liquid=require("..");var lexical=Liquid.lexical;module.exports=function(liquid){liquid.registerTag("increment",{parse:function parse(token){var match=token.args.match(lexical.identifier);if(!match)throw new Error("illegal identifier "+token.args);this.variable=match[0]},render:function render(scope,hash){var v=scope.get(this.variable);if(typeof v!=="number")v=0;scope.set(this.variable,v+1)}})}},{"..":2}],34:[function(require,module,exports){"use strict";module.exports=function(engine){require("./assign.js")(engine);require("./capture.js")(engine);require("./case.js")(engine);require("./comment.js")(engine);require("./cycle.js")(engine);require("./decrement.js")(engine);require("./for.js")(engine);require("./if.js")(engine);require("./include.js")(engine);require("./increment.js")(engine);require("./layout.js")(engine);require("./raw.js")(engine);require("./tablerow.js")(engine);require("./unless.js")(engine)}},{"./assign.js":24,"./capture.js":25,"./case.js":26,"./comment.js":27,"./cycle.js":28,"./decrement.js":29,"./for.js":30,"./if.js":31,"./include.js":32,"./increment.js":33,"./layout.js":35,"./raw.js":36,"./tablerow.js":37,"./unless.js":38}],35:[function(require,module,exports){"use strict";var Liquid=require("..");var Promise=require("any-promise");var lexical=Liquid.lexical;var withRE=new RegExp("with\\s+("+lexical.value.source+")");module.exports=function(liquid){liquid.registerTag("layout",{parse:function parse(token,remainTokens){var match=lexical.value.exec(token.args);if(!match)throw new Error("illegal token "+token.raw);this.layout=match[0];this.tpls=liquid.parser.parse(remainTokens)},render:function render(scope,hash){var layout=Liquid.evalValue(this.layout,scope);var html="";scope.push({});return liquid.renderer.renderTemplates(this.tpls,scope).then(function(partial){html+=partial;return liquid.handleCache(layout)}).then(function(templates){return liquid.renderer.renderTemplates(templates,scope)}).then(function(partial){scope.pop();return partial}).catch(function(e){e.file=layout;throw e})}});liquid.registerTag("block",{parse:function parse(token,remainTokens){var _this=this;var match=/\w+/.exec(token.args);this.block=match?match[0]:"";this.tpls=[];var p,stream=liquid.parser.parseStream(remainTokens).on("tag:endblock",function(token){return stream.stop()}).on("template",function(tpl){return _this.tpls.push(tpl)}).on("end",function(x){throw new Error("tag "+token.raw+" not closed")});stream.start()},render:function render(scope,hash){var _this2=this;var html=scope.get("_liquid.blocks."+this.block);var promise=Promise.resolve("");if(html===undefined){promise=liquid.renderer.renderTemplates(this.tpls,scope).then(function(partial){scope.set("_liquid.blocks."+_this2.block,partial);return partial})}else{scope.set("_liquid.blocks."+this.block,html);promise=Promise.resolve(html)}return promise}})}},{"..":2,"any-promise":3}],36:[function(require,module,exports){"use strict";var Liquid=require("..");var Promise=require("any-promise");var lexical=Liquid.lexical;var re=new RegExp("("+lexical.identifier.source+")");module.exports=function(liquid){liquid.registerTag("raw",{parse:function parse(tagToken,remainTokens){var _this=this;this.tokens=[];var stream=liquid.parser.parseStream(remainTokens);stream.on("token",function(token){if(token.name==="endraw")stream.stop();else _this.tokens.push(token)}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()},render:function render(scope,hash){var tokens=this.tokens.map(function(token){return token.raw}).join("");return Promise.resolve(tokens)}})}},{"..":2,"any-promise":3}],37:[function(require,module,exports){"use strict";var Liquid=require("..");var Promise=require("any-promise");var lexical=Liquid.lexical;var re=new RegExp("^("+lexical.identifier.source+")\\s+in\\s+"+("("+lexical.value.source+")")+("(?:\\s+"+lexical.hash.source+")*$"));module.exports=function(liquid){liquid.registerTag("tablerow",{parse:function parse(tagToken,remainTokens){var _this=this;var match=re.exec(tagToken.args);if(!match)throw new Error("illegal tag: "+tagToken.raw);this.variable=match[1];this.collection=match[2];this.templates=[];var p,stream=liquid.parser.parseStream(remainTokens).on("start",function(x){return p=_this.templates}).on("tag:endtablerow",function(token){return stream.stop()}).on("template",function(tpl){return p.push(tpl)}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()},render:function render(scope,hash){var _this2=this;var collection=Liquid.evalExp(this.collection,scope)||[];var html="<table>",promiseChain=Promise.resolve("");length=collection.length;var offset=hash.offset||0;var limit=hash.limit===undefined?collection.length:hash.limit;var cols=hash.cols,row,col;if(!cols)throw new Error("illegal cols: "+cols);collection=collection.slice(offset,offset+limit);var contexts=[];collection.some(function(item,i){var ctx={};ctx[_this2.variable]=item;contexts.push(ctx)});var lastPromise=contexts.reduce(function(promise,context,currentIndex){return promise.then(function(partial){row=Math.floor(currentIndex/cols)+1;col=currentIndex%cols+1;if(col===1){if(row!==1){html+="</tr>"}html+='<tr class="row'+row+'">'}return html+='<td class="col'+col+'">'}).then(function(partial){scope.push(context);return liquid.renderer.renderTemplates(_this2.templates,scope)}).then(function(partial){scope.pop(context);html+=partial;return html+="</td>"})},Promise.resolve(""));return lastPromise.then(function(){if(row>0){html+="</tr>"}html+="</table>";return html}).catch(function(error){throw error})}})}},{"..":2,"any-promise":3}],38:[function(require,module,exports){"use strict";var Liquid=require("..");var lexical=Liquid.lexical;module.exports=function(liquid){liquid.registerTag("unless",{parse:function parse(tagToken,remainTokens){var _this=this;this.templates=[];this.elseTemplates=[];var p,stream=liquid.parser.parseStream(remainTokens).on("start",function(x){p=_this.templates;_this.cond=tagToken.args}).on("tag:else",function(token){return p=_this.elseTemplates}).on("tag:endunless",function(token){return stream.stop()}).on("template",function(tpl){return p.push(tpl)}).on("end",function(x){throw new Error("tag "+tagToken.raw+" not closed")});stream.start()},render:function render(scope,hash){var cond=Liquid.evalExp(this.cond,scope);return Liquid.isFalsy(cond)?liquid.renderer.renderTemplates(this.templates,scope):liquid.renderer.renderTemplates(this.elseTemplates,scope)}})}},{"..":2}]},{},[2])(2)});
\ No newline at end of file
diff --git a/filters.js b/filters.js
index 6a603185f..e42f1faaf 100644
--- a/filters.js
+++ b/filters.js
@@ -1,4 +1,5 @@
-const strftime = require('strftime').timezone(-(new Date()).getTimezoneOffset());
+//const strftime = require('strftime').timezone(-(new Date()).getTimezoneOffset());
+const strftime = require('./src/strftime.js');
 
 module.exports = function(liquid) {
     liquid.registerFilter('abs', v => Math.abs(v));
@@ -7,7 +8,8 @@ module.exports = function(liquid) {
         (str || '').charAt(0).toUpperCase() + str.slice(1));
     liquid.registerFilter('ceil', v => Math.ceil(v));
 
-    liquid.registerFilter('date', (v, arg) => strftime(arg, v));
+    //liquid.registerFilter('date', (v, arg) => strftime(arg, v));
+    liquid.registerFilter('date', (v, arg) => strftime(v, arg));
 
     liquid.registerFilter('default', (v, arg) => arg || v);
     liquid.registerFilter('divided_by', (v, arg) => Math.floor(v / arg));
diff --git a/index.js b/index.js
index 7a3189fdf..706f1f6b1 100644
--- a/index.js
+++ b/index.js
@@ -1,10 +1,8 @@
 const Scope = require('./src/scope');
-const assert = require('assert');
 const tokenizer = require('./src/tokenizer.js');
+const fs = require('fs');
 const Render = require('./src/render.js');
 const lexical = require('./src/lexical.js');
-const path = require("path");
-const fs = require('fs');
 const Tag = require('./src/tag.js');
 const Filter = require('./src/filter.js');
 const Template = require('./src/parser');
@@ -75,9 +73,11 @@ var _engine = {
         return this.tag.register(name, tag);
     },
     handleCache: function(filepath) {
-        assert(filepath, 'filepath cannot be null');
-        filepath = path.resolve(this.options.root, filepath);
-        if (path.extname(filepath) === '') {
+        if (!filepath) throw new Error('filepath cannot be null');
+
+        filepath = resolvePath(this.options.root, filepath);
+
+        if (!filepath.match(/\.\w+$/)) {
             filepath += this.options.extname;
         }
 
@@ -114,6 +114,19 @@ function factory(options) {
     return engine;
 }
 
+function resolvePath(root, path) {
+    if (path[0] == '/') return path;
+
+    var arr = root.split('/').concat(path.split('/'));
+    var result = [];
+    arr.forEach(function(slug) {
+        if (slug == '..') result.pop();
+        else if (!slug || slug == '.');
+        else result.push(slug);
+    });
+    return '/' + result.join('/');
+}
+
 factory.lexical = lexical;
 factory.isTruthy = Expression.isTruthy;
 factory.isFalsy = Expression.isFalsy;
diff --git a/makefile b/makefile
index 9dfb4c7f8..df6ec7544 100644
--- a/makefile
+++ b/makefile
@@ -9,8 +9,8 @@ dist:
 	[ -d dist/ ] || mkdir dist/
 	$(BROWSERIFY) index.js -s Liquid \
 		-t [ babelify --global true --presets [ es2015 ] ] \
-		> dist/shopify-liquid.js
-	$(MINIFY) dist/shopify-liquid.js --output dist/shopify-liquid.min.js
+		> dist/liquid.js
+	$(MINIFY) dist/liquid.js --compress warnings=false --mangle --output dist/liquid.min.js
 	ls -lh dist/
 
 clean: 
diff --git a/package.json b/package.json
index 35472bd8a..fd78ab31c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "shopify-liquid",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Liquid template engine in Node.js (Shopify compliant)",
   "main": "index.js",
   "scripts": {
@@ -25,8 +25,7 @@
   },
   "homepage": "https://github.com/harttle/shopify-liquid#readme",
   "dependencies": {
-    "any-promise": "^1.3.0",
-    "strftime": "^0.9.2"
+    "any-promise": "^1.3.0"
   },
   "devDependencies": {
     "babel-preset-es2015": "^6.14.0",
diff --git a/src/error.js b/src/error.js
index 585a85387..b44a0bda0 100644
--- a/src/error.js
+++ b/src/error.js
@@ -1,5 +1,3 @@
-const util = require('util');
-
 function TokenizationError(message, input, line) {
     Error.captureStackTrace(this, this.constructor);
     this.name = this.constructor.name;
@@ -8,17 +6,20 @@ function TokenizationError(message, input, line) {
     this.input = input;
     this.line = line;
 }
-util.inherits(TokenizationError, Error);
+TokenizationError.prototype = Object.create(Error.prototype);
+TokenizationError.prototype.constructor = TokenizationError;
 
-function ParseError(message, input, line) {
+function ParseError(message, input, line, e) {
     Error.captureStackTrace(this, this.constructor);
     this.name = this.constructor.name;
+    this.originalError = e;
 
     this.message = message || "";
     this.input = input;
     this.line = line;
 }
-util.inherits(ParseError, Error);
+ParseError.prototype = Object.create(Error.prototype);
+ParseError.prototype.constructor = ParseError;
 
 module.exports = {
     TokenizationError, ParseError
diff --git a/src/express.js b/src/express.js
index 245484a0b..208fb5bdc 100644
--- a/src/express.js
+++ b/src/express.js
@@ -1,11 +1,11 @@
 const Liquid = require('..');
 
 module.exports = function() {
+    var engine = Liquid({
+        root: '/root/',
+        extname: '.html'
+    });
 
-    var    engine = Liquid({
-            root: '/root/',
-            extname: '.html'
-        });
     function express(filePath, options, callback) {
         fs.readFile(filePath, function(err, content) {
             if (err) return callback(new Error(err));
diff --git a/src/expression.js b/src/expression.js
index ebe77a6fd..dbf2bbfaf 100644
--- a/src/expression.js
+++ b/src/expression.js
@@ -1,5 +1,4 @@
 const syntax = require('./syntax.js');
-const Exp = require('./expression.js');
 const lexical = require('./lexical.js');
 
 function evalExp(exp, scope) {
@@ -35,7 +34,6 @@ function evalValue(str, scope) {
     if (!str) return undefined;
 
     if (lexical.isLiteral(str)) {
-        var a = lexical.parseLiteral(str);
         return lexical.parseLiteral(str);
     }
     if (lexical.isVariable(str)) {
diff --git a/src/parser.js b/src/parser.js
index 6d33876c0..938812c46 100644
--- a/src/parser.js
+++ b/src/parser.js
@@ -22,6 +22,7 @@ module.exports = function(Tag, Filter) {
         },
         start: function() {
             this.trigger('start');
+            var token;
             while (!this.stopRequested && (token = this.tokens.shift())) {
                 if (this.trigger('token', token)) continue;
                 if (token.type == 'tag' &&
@@ -59,7 +60,7 @@ module.exports = function(Tag, Filter) {
                     return token;
             }
         } catch (e) {
-            throw new ParseError(e.message, token.input, token.line);
+            throw new ParseError(e.message, token.input, token.line, e);
         }
     }
 
diff --git a/src/render.js b/src/render.js
index 612fce1d5..72af250ee 100644
--- a/src/render.js
+++ b/src/render.js
@@ -1,12 +1,10 @@
-const error = require('./error.js');
 const Exp = require('./expression.js');
-const assert = require('assert');
 const Promise = require('any-promise');
 
 var render = {
 
     renderTemplates: function(templates, scope, opts) {
-        assert(scope, 'unable to evalTemplates: scope undefined');
+        if(!scope) throw new Error('unable to evalTemplates: scope undefined');
         opts = opts || {};
         opts.strict_filters = opts.strict_filters || false;
 
@@ -90,7 +88,7 @@ var render = {
     },
 
     evalOutput: function(template, scope, opts) {
-        assert(scope, 'unable to evalOutput: scope undefined');
+        if(!scope) throw new Error('unable to evalOutput: scope undefined');
         var val = Exp.evalExp(template.initial, scope);
         template.filters.some(filter => {
             if (filter.error) {
diff --git a/src/scope.js b/src/scope.js
index 3db4bcf8d..84c6d1f77 100644
--- a/src/scope.js
+++ b/src/scope.js
@@ -1,5 +1,3 @@
-const lexical = require('./lexical.js');
-
 var Scope = {
     safeGet: function(str) {
         var i;
diff --git a/src/strftime.js b/src/strftime.js
new file mode 100644
index 000000000..03aef0c10
--- /dev/null
+++ b/src/strftime.js
@@ -0,0 +1,404 @@
+var monthNames = [
+    "January", "February", "March", "April", "May", "June", "July", "August",
+    "September", "October", "November", "December"
+];
+var monthNamesShort = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
+    "Nov", "Dec"
+];
+var dayNames = [
+    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+];
+var dayNamesShort = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var suffixes = {
+    1: 'st',
+    2: 'nd',
+    3: 'rd',
+    'default': 'th'
+};
+
+// prototype extensions
+var _date = {
+    daysInMonth: function(d) {
+        var feb = _date.isLeapYear(d) ? 29 : 28;
+        return [31, feb, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    },
+
+    getTimezone: function(d) {
+        return d.toString().replace(
+            /^.*? ([A-Z]{3}) [0-9]{4}.*$/, "$1"
+        ).replace(
+            /^.*?\(([A-Z])[a-z]+ ([A-Z])[a-z]+ ([A-Z])[a-z]+\)$/, "$1$2$3"
+        );
+    },
+
+    getGMTOffset: function(d) {
+        return (d.getTimezoneOffset() > 0 ? "-" : "+") +
+            _number.pad(Math.floor(d.getTimezoneOffset() / 60), 2) +
+            _number.pad(d.getTimezoneOffset() % 60, 2);
+    },
+
+    getDayOfYear: function(d) {
+        var num = 0;
+        for (var i = 0; i < d.getMonth(); ++i) {
+            num += _date.daysInMonth(d)[i];
+        }
+        return num + d.getDate();
+    },
+
+    // Startday is an integer of which day to start the week measuring from
+    // TODO: that comment was retarted. fix it.
+    getWeekOfYear: function(d, startDay) {
+        // Skip to startDay of this week
+        var now = this.getDayOfYear(d) + (startDay - d.getDay());
+        // Find the first startDay of the year
+        var jan1 = new Date(d.getFullYear(), 0, 1);
+        var then = (7 - jan1.getDay() + startDay);
+        return _number.pad(Math.floor((now - then) / 7) + 1, 2);
+    },
+
+    isLeapYear: function(d) {
+        var year = d.getFullYear();
+        return !!((year & 3) === 0 && (year % 100 || (year % 400 === 0 && year)));
+    },
+
+    getFirstDayOfMonth: function(d) {
+        var day = (d.getDay() - (d.getDate() - 1)) % 7;
+        return (day < 0) ? (day + 7) : day;
+    },
+
+    getLastDayOfMonth: function(d) {
+        var day = (d.getDay() + (_date.daysInMonth(d)[d.getMonth()] - d.getDate())) % 7;
+        return (day < 0) ? (day + 7) : day;
+    },
+
+    getSuffix: function(d) {
+        var str = d.getDate().toString();
+        var index = parseInt(str.slice(-1));
+        return suffixes[index] || suffixes['default'];
+    },
+
+    applyOffset: function(date, offset_seconds) {
+        date.setTime(date.valueOf() - offset_seconds * 1000);
+        return date;
+    },
+
+    century: function(d) {
+        return parseInt(d.getFullYear().toString().substring(0, 2), 10);
+    }
+};
+
+var _obj = {
+    values_of: function(obj) {
+        var values = [];
+        for(var k in obj){
+            if(obj.hasOwnProperty(k)){
+                values.push(obj[k]);
+            }
+        }
+        return values;
+    }
+};
+
+var _number = {
+    pad: function(value, size, ch) {
+        if (!ch) ch = '0';
+        var result = value.toString();
+        var pad = size - result.length;
+
+        while (pad-- > 0) {
+            result = ch + result;
+        }
+
+        return result;
+    }
+};
+
+
+var format_codes = {
+    a: function(d) {
+        return dayNamesShort[d.getDay()];
+    },
+    A: function(d) {
+        return dayNames[d.getDay()];
+    },
+    b: function(d) {
+        return monthNamesShort[d.getMonth()];
+    },
+    B: function(d) {
+        return monthNames[d.getMonth()];
+    },
+    c: function(d) {
+        return d.toLocaleString();
+    },
+    C: function(d) {
+        return _date.century(d);
+    },
+    d: function(d) {
+        return _number.pad(d.getDate(), 2);
+    },
+    e: function(d) {
+        return _number.pad(d.getDate(), 2, ' ');
+    },
+    H: function(d) {
+        return _number.pad(d.getHours(), 2);
+    },
+    I: function(d) {
+        return _number.pad(d.getHours() % 12 || 12, 2);
+    },
+    j: function(d) {
+        return _number.pad(_date.getDayOfYear(d), 3);
+    },
+    k: function(d) {
+        return _number.pad(d.getHours(), 2, ' ');
+    },
+    l: function(d) {
+        return _number.pad(d.getHours() % 12 || 12, 2, ' ');
+    },
+    L: function(d) {
+        return _number.pad(d.getMilliseconds(), 3);
+    },
+    m: function(d) {
+        return _number.pad(d.getMonth() + 1, 2);
+    },
+    M: function(d) {
+        return _number.pad(d.getMinutes(), 2);
+    },
+    p: function(d) {
+        return (d.getHours() < 12 ? 'AM' : 'PM');
+    },
+    P: function(d) {
+        return (d.getHours() < 12 ? 'am' : 'pm');
+    },
+    q: function(d) {
+        return _date.getSuffix(d);
+    },
+    s: function(d) {
+        return Math.round(d.valueOf() / 1000);
+    },
+    S: function(d) {
+        return _number.pad(d.getSeconds(), 2);
+    },
+    u: function(d) {
+        return d.getDay() || 7;
+    },
+    U: function(d) {
+        return _date.getWeekOfYear(d, 0);
+    },
+    w: function(d) {
+        return d.getDay();
+    },
+    W: function(d) {
+        return _date.getWeekOfYear(d, 1);
+    },
+    x: function(d) {
+        return d.toLocaleDateString();
+    },
+    X: function(d) {
+        return d.toLocaleTimeString();
+    },
+    y: function(d) {
+        return d.getFullYear().toString().substring(2, 4);
+    },
+    Y: function(d) {
+        return d.getFullYear();
+    },
+    // TODO: guessing the pad function won't work with negative numbers?
+    // TODO: getTimezoneOffset returns a positive number for GMT-7. Verify my
+    // assumption that it will return negative for GMT+x
+    z: function(d) {
+        var tz = d.getTimezoneOffset() / 60 * 100;
+        return (tz > 0 ? '-' : '+') + _number.pad(tz, 4);
+    },
+    "%": function() {
+        return '%';
+    }
+};
+format_codes.h = format_codes.b;
+format_codes.N = format_codes.L;
+
+
+// * r stands for regex, p stands for parser
+// * all parseInt calls have to have the base supplied as the second
+//   parameter, otherwise they will default to octal when parsing numbers
+//   with leading zeros. This is most evident when parsing a date with 08 as
+//   the minutes / year as 08 is an invalid octal number, and so returns 0
+var parse_codes = {
+    a: {
+        r: "(?:" + dayNamesShort.join("|") + ")"
+    },
+    A: {
+        r: "(?:" + dayNames.join("|") + ")"
+    },
+    b: {
+        r: "(" + monthNamesShort.join("|") + ")",
+        p: function(data) {
+            this.month = $.inArray(data, monthNamesShort);
+        }
+    },
+    B: {
+        r: "(" + monthNames.join("|") + ")",
+        p: function(data) {
+            this.month = $.inArray(data, monthNames);
+        }
+    },
+    C: {
+        r: "(\\d{1,2})",
+        p: function(d) {
+            this.century = parseInt(d, 10);
+        }
+    },
+    d: {
+        r: "(\\d{1,2})",
+        p: function(d) {
+            this.day = parseInt(d, 10);
+        }
+    },
+    H: {
+        r: "(\\d{1,2})",
+        p: function(d) {
+            this.hour = parseInt(d, 10);
+        }
+    },
+    // This gives only the day. Parsing of the month happens at the end because
+    // we also need the year
+    j: {
+        r: "(\\d{1,3})",
+        p: function(d) {
+            this.day = parseInt(d, 10);
+        }
+    },
+    L: {
+        r: "(\\d{3})",
+        p: function(d) {
+            this.milliseconds = parseInt(d, 10);
+        }
+    },
+    m: {
+        r: "(\\d{1,2})",
+        p: function(d) {
+            this.month = parseInt(d, 10) - 1;
+        }
+    },
+    M: {
+        r: "(\\d{2})",
+        p: function(d) {
+            this.minute = parseInt(d, 10);
+        }
+    },
+    p: {
+        r: "(AM|PM)",
+        p: function(d) {
+            if (d == 'AM') {
+                if (this.hour == 12) {
+                    this.hour = 0;
+                }
+            } else {
+                if (this.hour < 12) {
+                    this.hour += 12;
+                }
+            }
+        }
+    },
+    P: {
+        r: "(am|pm)",
+        p: function(d) {
+            if (d == 'am') {
+                if (this.hour == 12) {
+                    this.hour = 0;
+                }
+            } else {
+                if (this.hour < 12) {
+                    this.hour += 12;
+                }
+            }
+        }
+    },
+    q: {
+        r: "(?:" + _obj.values_of(suffixes).join('|') + ")"
+    },
+    S: {
+        r: "(\\d{2})",
+        p: function(d) {
+            this.second = parseInt(d, 10);
+        }
+    },
+    y: {
+        r: "(\\d{1,2})",
+        p: function(d) {
+            this.year = parseInt(d, 10);
+        }
+    },
+    Y: {
+        r: "(\\d{4})",
+        p: function(d) {
+            this.century = Math.floor(parseInt(d, 10) / 100);
+            this.year = parseInt(d, 10) % 100;
+        }
+    },
+    z: { // "Z", "+05:00", "+0500" all acceptable.
+        r: "(Z|[+-]\\d{2}:?\\d{2})",
+        p: function(d) {
+            // UTC, no offset.
+            if (d == "Z") {
+                this.zone = 0;
+                return;
+            }
+
+            var seconds = parseInt(d[0] + d[1] + d[2], 10) * 3600; // e.g., "+05" or "-08"
+            if (d[3] == ":") {
+                // "+HH:MM" is preferred iso8601 format
+                seconds += parseInt(d[4] + d[5], 10) * 60;
+            } else {
+                // "+HHMM" is frequently used, though.
+                seconds += parseInt(d[3] + d[4], 10) * 60;
+            }
+            this.zone = seconds;
+        }
+    }
+};
+parse_codes.e = parse_codes.d;
+parse_codes.h = parse_codes.b;
+parse_codes.I = parse_codes.H;
+parse_codes.k = parse_codes.H;
+parse_codes.l = parse_codes.H;
+
+
+var strftime = function(d, format) {
+    // I used to use string split with a regex and a capturing block here,
+    // which I thought was really clever, but apparently this exact feature is
+    // fucked in IE. In every other browser (and languages), the captured
+    // blocks are present in the output. E.g.
+    // var pairs = "hello%athere".split(/(%.)/);
+    // => ['hello', '%a', 'there']
+    // IE however, just treats it the same as if no capturing block is present
+    // => ['hello', 'there']
+    // An alternate implementation of split is available here
+    // http://blog.stevenlevithan.com/archives/cross-browser-split
+    // Because that's a large amount of code for this one specific use case,
+    // I've just decided to loop through a regex instead.
+
+    var output = '';
+    var remaining = format;
+
+    while (true) {
+        var r = /%./g;
+        var results = r.exec(remaining);
+
+        // No more format codes. Add the remaining text and return
+        if (!results) {
+            return output + remaining;
+        }
+
+        // Add the preceding text
+        output += remaining.slice(0, r.lastIndex - 2);
+        remaining = remaining.slice(r.lastIndex);
+
+        // Add the format code
+        var ch = results[0].charAt(1);
+        var func = format_codes[ch];
+        output += func ? func.call(this, d) : '%' + ch;
+    }
+};
+
+module.exports = strftime;
diff --git a/src/tag.js b/src/tag.js
index e2cdb0c03..1e4e11546 100644
--- a/src/tag.js
+++ b/src/tag.js
@@ -1,10 +1,9 @@
 const lexical = require('./lexical.js');
 const Promise = require('any-promise');
 const Exp = require('./expression.js');
-const TokenizationError = require('./error.js').TokenizationError;
 
 function hash(markup, scope) {
-    var obj = {};
+    var obj = {}, match;
     lexical.hashCapture.lastIndex = 0;
     while (match = lexical.hashCapture.exec(markup)) {
         var k = match[1],
diff --git a/tags/assign.js b/tags/assign.js
index 2126c8b95..a3ca7fd28 100644
--- a/tags/assign.js
+++ b/tags/assign.js
@@ -1,6 +1,6 @@
 var Liquid = require('..');
-var Promise = require('any-promise');
 var lexical = Liquid.lexical;
+var Promise = require('any-promise');
 var re = new RegExp(`(${lexical.identifier.source})\\s*=(.*)`);
 
 module.exports = function(liquid) {
diff --git a/tags/case.js b/tags/case.js
index 89ebc36e0..cea749542 100644
--- a/tags/case.js
+++ b/tags/case.js
@@ -1,5 +1,4 @@
 var Liquid = require('..');
-var lexical = Liquid.lexical;
 
 module.exports = function(liquid) {
     liquid.registerTag('case', {
diff --git a/tags/comment.js b/tags/comment.js
index 6a1877e4a..e702fd0da 100644
--- a/tags/comment.js
+++ b/tags/comment.js
@@ -1,7 +1,3 @@
-var Liquid = require('..');
-var lexical = Liquid.lexical;
-var re = new RegExp(`(${lexical.identifier.source})`);
-
 module.exports = function(liquid) {
 
     liquid.registerTag('comment', {
diff --git a/tags/decrement.js b/tags/decrement.js
index c726267b1..327002b5a 100644
--- a/tags/decrement.js
+++ b/tags/decrement.js
@@ -1,6 +1,5 @@
 const Liquid = require('..');
 const lexical = Liquid.lexical;
-const error = Liquid.error;
 
 module.exports = function(liquid) {
 
diff --git a/tags/if.js b/tags/if.js
index 92f12f06d..b83cab6dc 100644
--- a/tags/if.js
+++ b/tags/if.js
@@ -1,5 +1,4 @@
 var Liquid = require('..');
-var lexical = Liquid.lexical;
 
 module.exports = function(liquid) {
     liquid.registerTag('if', {
diff --git a/tags/include.js b/tags/include.js
index edf621516..7d995040e 100644
--- a/tags/include.js
+++ b/tags/include.js
@@ -1,5 +1,4 @@
 var Liquid = require('..');
-var Promise = require('any-promise');
 var lexical = Liquid.lexical;
 var withRE = new RegExp(`with\\s+(${lexical.value.source})`);
 
diff --git a/tags/layout.js b/tags/layout.js
index 2a2b3a5c2..7cb9ed355 100644
--- a/tags/layout.js
+++ b/tags/layout.js
@@ -1,7 +1,6 @@
 var Liquid = require('..');
 var Promise = require('any-promise');
 var lexical = Liquid.lexical;
-var withRE = new RegExp(`with\\s+(${lexical.value.source})`);
 
 module.exports = function(liquid) {
 
@@ -35,14 +34,6 @@ module.exports = function(liquid) {
                     e.file = layout;
                     throw e;
                 });
-
-//            var tpl = liquid.handleCache(layout);
-//
-//            scope.push({});
-//            liquid.renderer.renderTemplates(this.tpls, scope);  // what's the point of this line?
-//            var html = liquid.renderer.renderTemplates(tpl, scope);
-//            scope.pop();
-//            return html;
         }
     });
 
@@ -75,12 +66,6 @@ module.exports = function(liquid) {
                 promise = Promise.resolve(html);
             }
             return promise;
-
-//            if(html === undefined){
-//                html = liquid.renderer.renderTemplates(this.tpls, scope);
-//            }
-//            scope.set(`_liquid.blocks.${this.block}`, html);
-//            return html;
         }
     });
 
diff --git a/tags/raw.js b/tags/raw.js
index 1f6fe097e..0ac7dc5b4 100644
--- a/tags/raw.js
+++ b/tags/raw.js
@@ -1,7 +1,4 @@
-var Liquid = require('..');
 var Promise = require('any-promise');
-var lexical = Liquid.lexical;
-var re = new RegExp(`(${lexical.identifier.source})`);
 
 module.exports = function(liquid) {
 
diff --git a/tags/tablerow.js b/tags/tablerow.js
index 07077a460..95f84afc7 100644
--- a/tags/tablerow.js
+++ b/tags/tablerow.js
@@ -30,9 +30,7 @@ module.exports = function(liquid) {
         render: function(scope, hash) {
             var collection = Liquid.evalExp(this.collection, scope) || [];
 
-            var html = '<table>',
-                promiseChain = Promise.resolve(''); // create an empty promise to begin the chain
-                length = collection.length;
+            var html = '<table>';
             var offset = hash.offset || 0;
             var limit = (hash.limit === undefined) ? collection.length : hash.limit;
 
diff --git a/tags/unless.js b/tags/unless.js
index 86311e433..c5589c408 100644
--- a/tags/unless.js
+++ b/tags/unless.js
@@ -1,5 +1,4 @@
 var Liquid = require('..');
-var lexical = Liquid.lexical;
 
 module.exports = function(liquid) {
     liquid.registerTag('unless', {
diff --git a/test/filters.js b/test/filters.js
index c0bafb1cb..aeea75750 100644
--- a/test/filters.js
+++ b/test/filters.js
@@ -37,7 +37,7 @@ describe('filters', function() {
     it('should support ceil 3', () => test('{{ "3.5" | ceil }}', '4'));
     it('should support ceil 4', () => test('{{ 183.357 | ceil }}', '184'));
 
-    it('should support date', function() {
+    it('should support date: %a %b %d %Y', function() {
         str = ctx.date.toDateString();
         return test('{{ date | date:"%a %b %d %Y"}}', str);
     });
diff --git a/test/liquid.js b/test/liquid.js
index d0c717fea..e25a80709 100644
--- a/test/liquid.js
+++ b/test/liquid.js
@@ -74,15 +74,28 @@ describe('liquid', function() {
         it('should render file', function() {
             return engine.renderFile('/root/files/foo.html', ctx).should.eventually.equal('foo');
         });
-        it('should render file relative to root', function() {
-            return engine.renderFile('files/foo.html', ctx).should.eventually.equal('foo');
+        it('should accept relative path', function() {
+            return expect(engine.renderFile('files/foo.html')).to.eventually.equal('foo');
         });
         it('should render file with context', function() {
             return engine.renderFile('/root/files/name.html', ctx).should.eventually.equal('My name is harttle.');
         });
-        it('should render file with default extname', function() {
+        it('should use default extname', function() {
             return engine.renderFile('files/name', ctx).should.eventually.equal('My name is harttle.');
         });
+        it('should accept root with no trailing slash', function(){
+            engine = Liquid({
+                root: '/root',
+                extname: '.html'
+            });
+            return expect(engine.renderFile('files/foo.html')).to.eventually.equal('foo');
+        });
+        it('should accept dot path', function(){
+            return expect(engine.renderFile('./files/foo.html')).to.eventually.equal('foo');
+        });
+        it('should accept double-dot path', function(){
+            return expect(engine.renderFile('files/foo/../foo.html')).to.eventually.equal('foo');
+        });
     });
     describe('#express()', function() {
         it('should render templates', function() {
