summaryrefslogtreecommitdiff
path: root/node_modules/nunjucks/browser/nunjucks-slim.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/nunjucks/browser/nunjucks-slim.js')
-rw-r--r--node_modules/nunjucks/browser/nunjucks-slim.js3709
1 files changed, 3709 insertions, 0 deletions
diff --git a/node_modules/nunjucks/browser/nunjucks-slim.js b/node_modules/nunjucks/browser/nunjucks-slim.js
new file mode 100644
index 0000000..2825de9
--- /dev/null
+++ b/node_modules/nunjucks/browser/nunjucks-slim.js
@@ -0,0 +1,3709 @@
+/*! Browser bundle of nunjucks 3.2.4 (slim, only works with precompiled templates) */
+(function webpackUniversalModuleDefinition(root, factory) {
+ if(typeof exports === 'object' && typeof module === 'object')
+ module.exports = factory();
+ else if(typeof define === 'function' && define.amd)
+ define([], factory);
+ else if(typeof exports === 'object')
+ exports["nunjucks"] = factory();
+ else
+ root["nunjucks"] = factory();
+})(typeof self !== 'undefined' ? self : this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 6);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var ArrayProto = Array.prototype;
+var ObjProto = Object.prototype;
+var escapeMap = {
+ '&': '&',
+ '"': '"',
+ '\'': ''',
+ '<': '&lt;',
+ '>': '&gt;',
+ '\\': '&#92;'
+};
+var escapeRegex = /[&"'<>\\]/g;
+var exports = module.exports = {};
+function hasOwnProp(obj, k) {
+ return ObjProto.hasOwnProperty.call(obj, k);
+}
+exports.hasOwnProp = hasOwnProp;
+function lookupEscape(ch) {
+ return escapeMap[ch];
+}
+function _prettifyError(path, withInternals, err) {
+ if (!err.Update) {
+ // not one of ours, cast it
+ err = new exports.TemplateError(err);
+ }
+ err.Update(path);
+
+ // Unless they marked the dev flag, show them a trace from here
+ if (!withInternals) {
+ var old = err;
+ err = new Error(old.message);
+ err.name = old.name;
+ }
+ return err;
+}
+exports._prettifyError = _prettifyError;
+function TemplateError(message, lineno, colno) {
+ var err;
+ var cause;
+ if (message instanceof Error) {
+ cause = message;
+ message = cause.name + ": " + cause.message;
+ }
+ if (Object.setPrototypeOf) {
+ err = new Error(message);
+ Object.setPrototypeOf(err, TemplateError.prototype);
+ } else {
+ err = this;
+ Object.defineProperty(err, 'message', {
+ enumerable: false,
+ writable: true,
+ value: message
+ });
+ }
+ Object.defineProperty(err, 'name', {
+ value: 'Template render error'
+ });
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(err, this.constructor);
+ }
+ var getStack;
+ if (cause) {
+ var stackDescriptor = Object.getOwnPropertyDescriptor(cause, 'stack');
+ getStack = stackDescriptor && (stackDescriptor.get || function () {
+ return stackDescriptor.value;
+ });
+ if (!getStack) {
+ getStack = function getStack() {
+ return cause.stack;
+ };
+ }
+ } else {
+ var stack = new Error(message).stack;
+ getStack = function getStack() {
+ return stack;
+ };
+ }
+ Object.defineProperty(err, 'stack', {
+ get: function get() {
+ return getStack.call(err);
+ }
+ });
+ Object.defineProperty(err, 'cause', {
+ value: cause
+ });
+ err.lineno = lineno;
+ err.colno = colno;
+ err.firstUpdate = true;
+ err.Update = function Update(path) {
+ var msg = '(' + (path || 'unknown path') + ')';
+
+ // only show lineno + colno next to path of template
+ // where error occurred
+ if (this.firstUpdate) {
+ if (this.lineno && this.colno) {
+ msg += " [Line " + this.lineno + ", Column " + this.colno + "]";
+ } else if (this.lineno) {
+ msg += " [Line " + this.lineno + "]";
+ }
+ }
+ msg += '\n ';
+ if (this.firstUpdate) {
+ msg += ' ';
+ }
+ this.message = msg + (this.message || '');
+ this.firstUpdate = false;
+ return this;
+ };
+ return err;
+}
+if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
+} else {
+ TemplateError.prototype = Object.create(Error.prototype, {
+ constructor: {
+ value: TemplateError
+ }
+ });
+}
+exports.TemplateError = TemplateError;
+function escape(val) {
+ return val.replace(escapeRegex, lookupEscape);
+}
+exports.escape = escape;
+function isFunction(obj) {
+ return ObjProto.toString.call(obj) === '[object Function]';
+}
+exports.isFunction = isFunction;
+function isArray(obj) {
+ return ObjProto.toString.call(obj) === '[object Array]';
+}
+exports.isArray = isArray;
+function isString(obj) {
+ return ObjProto.toString.call(obj) === '[object String]';
+}
+exports.isString = isString;
+function isObject(obj) {
+ return ObjProto.toString.call(obj) === '[object Object]';
+}
+exports.isObject = isObject;
+
+/**
+ * @param {string|number} attr
+ * @returns {(string|number)[]}
+ * @private
+ */
+function _prepareAttributeParts(attr) {
+ if (!attr) {
+ return [];
+ }
+ if (typeof attr === 'string') {
+ return attr.split('.');
+ }
+ return [attr];
+}
+
+/**
+ * @param {string} attribute Attribute value. Dots allowed.
+ * @returns {function(Object): *}
+ */
+function getAttrGetter(attribute) {
+ var parts = _prepareAttributeParts(attribute);
+ return function attrGetter(item) {
+ var _item = item;
+ for (var i = 0; i < parts.length; i++) {
+ var part = parts[i];
+
+ // If item is not an object, and we still got parts to handle, it means
+ // that something goes wrong. Just roll out to undefined in that case.
+ if (hasOwnProp(_item, part)) {
+ _item = _item[part];
+ } else {
+ return undefined;
+ }
+ }
+ return _item;
+ };
+}
+exports.getAttrGetter = getAttrGetter;
+function groupBy(obj, val, throwOnUndefined) {
+ var result = {};
+ var iterator = isFunction(val) ? val : getAttrGetter(val);
+ for (var i = 0; i < obj.length; i++) {
+ var value = obj[i];
+ var key = iterator(value, i);
+ if (key === undefined && throwOnUndefined === true) {
+ throw new TypeError("groupby: attribute \"" + val + "\" resolved to undefined");
+ }
+ (result[key] || (result[key] = [])).push(value);
+ }
+ return result;
+}
+exports.groupBy = groupBy;
+function toArray(obj) {
+ return Array.prototype.slice.call(obj);
+}
+exports.toArray = toArray;
+function without(array) {
+ var result = [];
+ if (!array) {
+ return result;
+ }
+ var length = array.length;
+ var contains = toArray(arguments).slice(1);
+ var index = -1;
+ while (++index < length) {
+ if (indexOf(contains, array[index]) === -1) {
+ result.push(array[index]);
+ }
+ }
+ return result;
+}
+exports.without = without;
+function repeat(char_, n) {
+ var str = '';
+ for (var i = 0; i < n; i++) {
+ str += char_;
+ }
+ return str;
+}
+exports.repeat = repeat;
+function each(obj, func, context) {
+ if (obj == null) {
+ return;
+ }
+ if (ArrayProto.forEach && obj.forEach === ArrayProto.forEach) {
+ obj.forEach(func, context);
+ } else if (obj.length === +obj.length) {
+ for (var i = 0, l = obj.length; i < l; i++) {
+ func.call(context, obj[i], i, obj);
+ }
+ }
+}
+exports.each = each;
+function map(obj, func) {
+ var results = [];
+ if (obj == null) {
+ return results;
+ }
+ if (ArrayProto.map && obj.map === ArrayProto.map) {
+ return obj.map(func);
+ }
+ for (var i = 0; i < obj.length; i++) {
+ results[results.length] = func(obj[i], i);
+ }
+ if (obj.length === +obj.length) {
+ results.length = obj.length;
+ }
+ return results;
+}
+exports.map = map;
+function asyncIter(arr, iter, cb) {
+ var i = -1;
+ function next() {
+ i++;
+ if (i < arr.length) {
+ iter(arr[i], i, next, cb);
+ } else {
+ cb();
+ }
+ }
+ next();
+}
+exports.asyncIter = asyncIter;
+function asyncFor(obj, iter, cb) {
+ var keys = keys_(obj || {});
+ var len = keys.length;
+ var i = -1;
+ function next() {
+ i++;
+ var k = keys[i];
+ if (i < len) {
+ iter(k, obj[k], i, len, next);
+ } else {
+ cb();
+ }
+ }
+ next();
+}
+exports.asyncFor = asyncFor;
+function indexOf(arr, searchElement, fromIndex) {
+ return Array.prototype.indexOf.call(arr || [], searchElement, fromIndex);
+}
+exports.indexOf = indexOf;
+function keys_(obj) {
+ /* eslint-disable no-restricted-syntax */
+ var arr = [];
+ for (var k in obj) {
+ if (hasOwnProp(obj, k)) {
+ arr.push(k);
+ }
+ }
+ return arr;
+}
+exports.keys = keys_;
+function _entries(obj) {
+ return keys_(obj).map(function (k) {
+ return [k, obj[k]];
+ });
+}
+exports._entries = _entries;
+function _values(obj) {
+ return keys_(obj).map(function (k) {
+ return obj[k];
+ });
+}
+exports._values = _values;
+function extend(obj1, obj2) {
+ obj1 = obj1 || {};
+ keys_(obj2).forEach(function (k) {
+ obj1[k] = obj2[k];
+ });
+ return obj1;
+}
+exports._assign = exports.extend = extend;
+function inOperator(key, val) {
+ if (isArray(val) || isString(val)) {
+ return val.indexOf(key) !== -1;
+ } else if (isObject(val)) {
+ return key in val;
+ }
+ throw new Error('Cannot use "in" operator to search for "' + key + '" in unexpected types.');
+}
+exports.inOperator = inOperator;
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var lib = __webpack_require__(1);
+var arrayFrom = Array.from;
+var supportsIterators = typeof Symbol === 'function' && Symbol.iterator && typeof arrayFrom === 'function';
+
+// Frames keep track of scoping both at compile-time and run-time so
+// we know how to access variables. Block tags can introduce special
+// variables, for example.
+var Frame = /*#__PURE__*/function () {
+ function Frame(parent, isolateWrites) {
+ this.variables = Object.create(null);
+ this.parent = parent;
+ this.topLevel = false;
+ // if this is true, writes (set) should never propagate upwards past
+ // this frame to its parent (though reads may).
+ this.isolateWrites = isolateWrites;
+ }
+ var _proto = Frame.prototype;
+ _proto.set = function set(name, val, resolveUp) {
+ // Allow variables with dots by automatically creating the
+ // nested structure
+ var parts = name.split('.');
+ var obj = this.variables;
+ var frame = this;
+ if (resolveUp) {
+ if (frame = this.resolve(parts[0], true)) {
+ frame.set(name, val);
+ return;
+ }
+ }
+ for (var i = 0; i < parts.length - 1; i++) {
+ var id = parts[i];
+ if (!obj[id]) {
+ obj[id] = {};
+ }
+ obj = obj[id];
+ }
+ obj[parts[parts.length - 1]] = val;
+ };
+ _proto.get = function get(name) {
+ var val = this.variables[name];
+ if (val !== undefined) {
+ return val;
+ }
+ return null;
+ };
+ _proto.lookup = function lookup(name) {
+ var p = this.parent;
+ var val = this.variables[name];
+ if (val !== undefined) {
+ return val;
+ }
+ return p && p.lookup(name);
+ };
+ _proto.resolve = function resolve(name, forWrite) {
+ var p = forWrite && this.isolateWrites ? undefined : this.parent;
+ var val = this.variables[name];
+ if (val !== undefined) {
+ return this;
+ }
+ return p && p.resolve(name);
+ };
+ _proto.push = function push(isolateWrites) {
+ return new Frame(this, isolateWrites);
+ };
+ _proto.pop = function pop() {
+ return this.parent;
+ };
+ return Frame;
+}();
+function makeMacro(argNames, kwargNames, func) {
+ return function macro() {
+ for (var _len = arguments.length, macroArgs = new Array(_len), _key = 0; _key < _len; _key++) {
+ macroArgs[_key] = arguments[_key];
+ }
+ var argCount = numArgs(macroArgs);
+ var args;
+ var kwargs = getKeywordArgs(macroArgs);
+ if (argCount > argNames.length) {
+ args = macroArgs.slice(0, argNames.length);
+
+ // Positional arguments that should be passed in as
+ // keyword arguments (essentially default values)
+ macroArgs.slice(args.length, argCount).forEach(function (val, i) {
+ if (i < kwargNames.length) {
+ kwargs[kwargNames[i]] = val;
+ }
+ });
+ args.push(kwargs);
+ } else if (argCount < argNames.length) {
+ args = macroArgs.slice(0, argCount);
+ for (var i = argCount; i < argNames.length; i++) {
+ var arg = argNames[i];
+
+ // Keyword arguments that should be passed as
+ // positional arguments, i.e. the caller explicitly
+ // used the name of a positional arg
+ args.push(kwargs[arg]);
+ delete kwargs[arg];
+ }
+ args.push(kwargs);
+ } else {
+ args = macroArgs;
+ }
+ return func.apply(this, args);
+ };
+}
+function makeKeywordArgs(obj) {
+ obj.__keywords = true;
+ return obj;
+}
+function isKeywordArgs(obj) {
+ return obj && Object.prototype.hasOwnProperty.call(obj, '__keywords');
+}
+function getKeywordArgs(args) {
+ var len = args.length;
+ if (len) {
+ var lastArg = args[len - 1];
+ if (isKeywordArgs(lastArg)) {
+ return lastArg;
+ }
+ }
+ return {};
+}
+function numArgs(args) {
+ var len = args.length;
+ if (len === 0) {
+ return 0;
+ }
+ var lastArg = args[len - 1];
+ if (isKeywordArgs(lastArg)) {
+ return len - 1;
+ } else {
+ return len;
+ }
+}
+
+// A SafeString object indicates that the string should not be
+// autoescaped. This happens magically because autoescaping only
+// occurs on primitive string objects.
+function SafeString(val) {
+ if (typeof val !== 'string') {
+ return val;
+ }
+ this.val = val;
+ this.length = val.length;
+}
+SafeString.prototype = Object.create(String.prototype, {
+ length: {
+ writable: true,
+ configurable: true,
+ value: 0
+ }
+});
+SafeString.prototype.valueOf = function valueOf() {
+ return this.val;
+};
+SafeString.prototype.toString = function toString() {
+ return this.val;
+};
+function copySafeness(dest, target) {
+ if (dest instanceof SafeString) {
+ return new SafeString(target);
+ }
+ return target.toString();
+}
+function markSafe(val) {
+ var type = typeof val;
+ if (type === 'string') {
+ return new SafeString(val);
+ } else if (type !== 'function') {
+ return val;
+ } else {
+ return function wrapSafe(args) {
+ var ret = val.apply(this, arguments);
+ if (typeof ret === 'string') {
+ return new SafeString(ret);
+ }
+ return ret;
+ };
+ }
+}
+function suppressValue(val, autoescape) {
+ val = val !== undefined && val !== null ? val : '';
+ if (autoescape && !(val instanceof SafeString)) {
+ val = lib.escape(val.toString());
+ }
+ return val;
+}
+function ensureDefined(val, lineno, colno) {
+ if (val === null || val === undefined) {
+ throw new lib.TemplateError('attempted to output null or undefined value', lineno + 1, colno + 1);
+ }
+ return val;
+}
+function memberLookup(obj, val) {
+ if (obj === undefined || obj === null) {
+ return undefined;
+ }
+ if (typeof obj[val] === 'function') {
+ return function () {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+ return obj[val].apply(obj, args);
+ };
+ }
+ return obj[val];
+}
+function callWrap(obj, name, context, args) {
+ if (!obj) {
+ throw new Error('Unable to call `' + name + '`, which is undefined or falsey');
+ } else if (typeof obj !== 'function') {
+ throw new Error('Unable to call `' + name + '`, which is not a function');
+ }
+ return obj.apply(context, args);
+}
+function contextOrFrameLookup(context, frame, name) {
+ var val = frame.lookup(name);
+ return val !== undefined ? val : context.lookup(name);
+}
+function handleError(error, lineno, colno) {
+ if (error.lineno) {
+ return error;
+ } else {
+ return new lib.TemplateError(error, lineno, colno);
+ }
+}
+function asyncEach(arr, dimen, iter, cb) {
+ if (lib.isArray(arr)) {
+ var len = arr.length;
+ lib.asyncIter(arr, function iterCallback(item, i, next) {
+ switch (dimen) {
+ case 1:
+ iter(item, i, len, next);
+ break;
+ case 2:
+ iter(item[0], item[1], i, len, next);
+ break;
+ case 3:
+ iter(item[0], item[1], item[2], i, len, next);
+ break;
+ default:
+ item.push(i, len, next);
+ iter.apply(this, item);
+ }
+ }, cb);
+ } else {
+ lib.asyncFor(arr, function iterCallback(key, val, i, len, next) {
+ iter(key, val, i, len, next);
+ }, cb);
+ }
+}
+function asyncAll(arr, dimen, func, cb) {
+ var finished = 0;
+ var len;
+ var outputArr;
+ function done(i, output) {
+ finished++;
+ outputArr[i] = output;
+ if (finished === len) {
+ cb(null, outputArr.join(''));
+ }
+ }
+ if (lib.isArray(arr)) {
+ len = arr.length;
+ outputArr = new Array(len);
+ if (len === 0) {
+ cb(null, '');
+ } else {
+ for (var i = 0; i < arr.length; i++) {
+ var item = arr[i];
+ switch (dimen) {
+ case 1:
+ func(item, i, len, done);
+ break;
+ case 2:
+ func(item[0], item[1], i, len, done);
+ break;
+ case 3:
+ func(item[0], item[1], item[2], i, len, done);
+ break;
+ default:
+ item.push(i, len, done);
+ func.apply(this, item);
+ }
+ }
+ }
+ } else {
+ var keys = lib.keys(arr || {});
+ len = keys.length;
+ outputArr = new Array(len);
+ if (len === 0) {
+ cb(null, '');
+ } else {
+ for (var _i = 0; _i < keys.length; _i++) {
+ var k = keys[_i];
+ func(k, arr[k], _i, len, done);
+ }
+ }
+ }
+}
+function fromIterator(arr) {
+ if (typeof arr !== 'object' || arr === null || lib.isArray(arr)) {
+ return arr;
+ } else if (supportsIterators && Symbol.iterator in arr) {
+ return arrayFrom(arr);
+ } else {
+ return arr;
+ }
+}
+module.exports = {
+ Frame: Frame,
+ makeMacro: makeMacro,
+ makeKeywordArgs: makeKeywordArgs,
+ numArgs: numArgs,
+ suppressValue: suppressValue,
+ ensureDefined: ensureDefined,
+ memberLookup: memberLookup,
+ contextOrFrameLookup: contextOrFrameLookup,
+ callWrap: callWrap,
+ handleError: handleError,
+ isArray: lib.isArray,
+ keys: lib.keys,
+ SafeString: SafeString,
+ copySafeness: copySafeness,
+ markSafe: markSafe,
+ asyncEach: asyncEach,
+ asyncAll: asyncAll,
+ inOperator: lib.inOperator,
+ fromIterator: fromIterator
+};
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+var Loader = __webpack_require__(4);
+var PrecompiledLoader = /*#__PURE__*/function (_Loader) {
+ _inheritsLoose(PrecompiledLoader, _Loader);
+ function PrecompiledLoader(compiledTemplates) {
+ var _this;
+ _this = _Loader.call(this) || this;
+ _this.precompiled = compiledTemplates || {};
+ return _this;
+ }
+ var _proto = PrecompiledLoader.prototype;
+ _proto.getSource = function getSource(name) {
+ if (this.precompiled[name]) {
+ return {
+ src: {
+ type: 'code',
+ obj: this.precompiled[name]
+ },
+ path: name
+ };
+ }
+ return null;
+ };
+ return PrecompiledLoader;
+}(Loader);
+module.exports = {
+ PrecompiledLoader: PrecompiledLoader
+};
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+var path = __webpack_require__(0);
+var _require = __webpack_require__(5),
+ EmitterObj = _require.EmitterObj;
+module.exports = /*#__PURE__*/function (_EmitterObj) {
+ _inheritsLoose(Loader, _EmitterObj);
+ function Loader() {
+ return _EmitterObj.apply(this, arguments) || this;
+ }
+ var _proto = Loader.prototype;
+ _proto.resolve = function resolve(from, to) {
+ return path.resolve(path.dirname(from), to);
+ };
+ _proto.isRelative = function isRelative(filename) {
+ return filename.indexOf('./') === 0 || filename.indexOf('../') === 0;
+ };
+ return Loader;
+}(EmitterObj);
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+// A simple class system, more documentation to come
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+var EventEmitter = __webpack_require__(13);
+var lib = __webpack_require__(1);
+function parentWrap(parent, prop) {
+ if (typeof parent !== 'function' || typeof prop !== 'function') {
+ return prop;
+ }
+ return function wrap() {
+ // Save the current parent method
+ var tmp = this.parent;
+
+ // Set parent to the previous method, call, and restore
+ this.parent = parent;
+ var res = prop.apply(this, arguments);
+ this.parent = tmp;
+ return res;
+ };
+}
+function extendClass(cls, name, props) {
+ props = props || {};
+ lib.keys(props).forEach(function (k) {
+ props[k] = parentWrap(cls.prototype[k], props[k]);
+ });
+ var subclass = /*#__PURE__*/function (_cls) {
+ _inheritsLoose(subclass, _cls);
+ function subclass() {
+ return _cls.apply(this, arguments) || this;
+ }
+ _createClass(subclass, [{
+ key: "typename",
+ get: function get() {
+ return name;
+ }
+ }]);
+ return subclass;
+ }(cls);
+ lib._assign(subclass.prototype, props);
+ return subclass;
+}
+var Obj = /*#__PURE__*/function () {
+ function Obj() {
+ // Unfortunately necessary for backwards compatibility
+ this.init.apply(this, arguments);
+ }
+ var _proto = Obj.prototype;
+ _proto.init = function init() {};
+ Obj.extend = function extend(name, props) {
+ if (typeof name === 'object') {
+ props = name;
+ name = 'anonymous';
+ }
+ return extendClass(this, name, props);
+ };
+ _createClass(Obj, [{
+ key: "typename",
+ get: function get() {
+ return this.constructor.name;
+ }
+ }]);
+ return Obj;
+}();
+var EmitterObj = /*#__PURE__*/function (_EventEmitter) {
+ _inheritsLoose(EmitterObj, _EventEmitter);
+ function EmitterObj() {
+ var _this2;
+ var _this;
+ _this = _EventEmitter.call(this) || this;
+ // Unfortunately necessary for backwards compatibility
+ (_this2 = _this).init.apply(_this2, arguments);
+ return _this;
+ }
+ var _proto2 = EmitterObj.prototype;
+ _proto2.init = function init() {};
+ EmitterObj.extend = function extend(name, props) {
+ if (typeof name === 'object') {
+ props = name;
+ name = 'anonymous';
+ }
+ return extendClass(this, name, props);
+ };
+ _createClass(EmitterObj, [{
+ key: "typename",
+ get: function get() {
+ return this.constructor.name;
+ }
+ }]);
+ return EmitterObj;
+}(EventEmitter);
+module.exports = {
+ Obj: Obj,
+ EmitterObj: EmitterObj
+};
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var lib = __webpack_require__(1);
+var _require = __webpack_require__(7),
+ Environment = _require.Environment,
+ Template = _require.Template;
+var Loader = __webpack_require__(4);
+var loaders = __webpack_require__(3);
+var precompile = __webpack_require__(0);
+var compiler = __webpack_require__(0);
+var parser = __webpack_require__(0);
+var lexer = __webpack_require__(0);
+var runtime = __webpack_require__(2);
+var nodes = __webpack_require__(0);
+var installJinjaCompat = __webpack_require__(17);
+
+// A single instance of an environment, since this is so commonly used
+var e;
+function configure(templatesPath, opts) {
+ opts = opts || {};
+ if (lib.isObject(templatesPath)) {
+ opts = templatesPath;
+ templatesPath = null;
+ }
+ var TemplateLoader;
+ if (loaders.FileSystemLoader) {
+ TemplateLoader = new loaders.FileSystemLoader(templatesPath, {
+ watch: opts.watch,
+ noCache: opts.noCache
+ });
+ } else if (loaders.WebLoader) {
+ TemplateLoader = new loaders.WebLoader(templatesPath, {
+ useCache: opts.web && opts.web.useCache,
+ async: opts.web && opts.web.async
+ });
+ }
+ e = new Environment(TemplateLoader, opts);
+ if (opts && opts.express) {
+ e.express(opts.express);
+ }
+ return e;
+}
+module.exports = {
+ Environment: Environment,
+ Template: Template,
+ Loader: Loader,
+ FileSystemLoader: loaders.FileSystemLoader,
+ NodeResolveLoader: loaders.NodeResolveLoader,
+ PrecompiledLoader: loaders.PrecompiledLoader,
+ WebLoader: loaders.WebLoader,
+ compiler: compiler,
+ parser: parser,
+ lexer: lexer,
+ runtime: runtime,
+ lib: lib,
+ nodes: nodes,
+ installJinjaCompat: installJinjaCompat,
+ configure: configure,
+ reset: function reset() {
+ e = undefined;
+ },
+ compile: function compile(src, env, path, eagerCompile) {
+ if (!e) {
+ configure();
+ }
+ return new Template(src, env, path, eagerCompile);
+ },
+ render: function render(name, ctx, cb) {
+ if (!e) {
+ configure();
+ }
+ return e.render(name, ctx, cb);
+ },
+ renderString: function renderString(src, ctx, cb) {
+ if (!e) {
+ configure();
+ }
+ return e.renderString(src, ctx, cb);
+ },
+ precompile: precompile ? precompile.precompile : undefined,
+ precompileString: precompile ? precompile.precompileString : undefined
+};
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+var asap = __webpack_require__(8);
+var _waterfall = __webpack_require__(11);
+var lib = __webpack_require__(1);
+var compiler = __webpack_require__(0);
+var filters = __webpack_require__(12);
+var _require = __webpack_require__(3),
+ FileSystemLoader = _require.FileSystemLoader,
+ WebLoader = _require.WebLoader,
+ PrecompiledLoader = _require.PrecompiledLoader;
+var tests = __webpack_require__(14);
+var globals = __webpack_require__(15);
+var _require2 = __webpack_require__(5),
+ Obj = _require2.Obj,
+ EmitterObj = _require2.EmitterObj;
+var globalRuntime = __webpack_require__(2);
+var handleError = globalRuntime.handleError,
+ Frame = globalRuntime.Frame;
+var expressApp = __webpack_require__(16);
+
+// If the user is using the async API, *always* call it
+// asynchronously even if the template was synchronous.
+function callbackAsap(cb, err, res) {
+ asap(function () {
+ cb(err, res);
+ });
+}
+
+/**
+ * A no-op template, for use with {% include ignore missing %}
+ */
+var noopTmplSrc = {
+ type: 'code',
+ obj: {
+ root: function root(env, context, frame, runtime, cb) {
+ try {
+ cb(null, '');
+ } catch (e) {
+ cb(handleError(e, null, null));
+ }
+ }
+ }
+};
+var Environment = /*#__PURE__*/function (_EmitterObj) {
+ _inheritsLoose(Environment, _EmitterObj);
+ function Environment() {
+ return _EmitterObj.apply(this, arguments) || this;
+ }
+ var _proto = Environment.prototype;
+ _proto.init = function init(loaders, opts) {
+ var _this = this;
+ // The dev flag determines the trace that'll be shown on errors.
+ // If set to true, returns the full trace from the error point,
+ // otherwise will return trace starting from Template.render
+ // (the full trace from within nunjucks may confuse developers using
+ // the library)
+ // defaults to false
+ opts = this.opts = opts || {};
+ this.opts.dev = !!opts.dev;
+
+ // The autoescape flag sets global autoescaping. If true,
+ // every string variable will be escaped by default.
+ // If false, strings can be manually escaped using the `escape` filter.
+ // defaults to true
+ this.opts.autoescape = opts.autoescape != null ? opts.autoescape : true;
+
+ // If true, this will make the system throw errors if trying
+ // to output a null or undefined value
+ this.opts.throwOnUndefined = !!opts.throwOnUndefined;
+ this.opts.trimBlocks = !!opts.trimBlocks;
+ this.opts.lstripBlocks = !!opts.lstripBlocks;
+ this.loaders = [];
+ if (!loaders) {
+ // The filesystem loader is only available server-side
+ if (FileSystemLoader) {
+ this.loaders = [new FileSystemLoader('views')];
+ } else if (WebLoader) {
+ this.loaders = [new WebLoader('/views')];
+ }
+ } else {
+ this.loaders = lib.isArray(loaders) ? loaders : [loaders];
+ }
+
+ // It's easy to use precompiled templates: just include them
+ // before you configure nunjucks and this will automatically
+ // pick it up and use it
+ if (typeof window !== 'undefined' && window.nunjucksPrecompiled) {
+ this.loaders.unshift(new PrecompiledLoader(window.nunjucksPrecompiled));
+ }
+ this._initLoaders();
+ this.globals = globals();
+ this.filters = {};
+ this.tests = {};
+ this.asyncFilters = [];
+ this.extensions = {};
+ this.extensionsList = [];
+ lib._entries(filters).forEach(function (_ref) {
+ var name = _ref[0],
+ filter = _ref[1];
+ return _this.addFilter(name, filter);
+ });
+ lib._entries(tests).forEach(function (_ref2) {
+ var name = _ref2[0],
+ test = _ref2[1];
+ return _this.addTest(name, test);
+ });
+ };
+ _proto._initLoaders = function _initLoaders() {
+ var _this2 = this;
+ this.loaders.forEach(function (loader) {
+ // Caching and cache busting
+ loader.cache = {};
+ if (typeof loader.on === 'function') {
+ loader.on('update', function (name, fullname) {
+ loader.cache[name] = null;
+ _this2.emit('update', name, fullname, loader);
+ });
+ loader.on('load', function (name, source) {
+ _this2.emit('load', name, source, loader);
+ });
+ }
+ });
+ };
+ _proto.invalidateCache = function invalidateCache() {
+ this.loaders.forEach(function (loader) {
+ loader.cache = {};
+ });
+ };
+ _proto.addExtension = function addExtension(name, extension) {
+ extension.__name = name;
+ this.extensions[name] = extension;
+ this.extensionsList.push(extension);
+ return this;
+ };
+ _proto.removeExtension = function removeExtension(name) {
+ var extension = this.getExtension(name);
+ if (!extension) {
+ return;
+ }
+ this.extensionsList = lib.without(this.extensionsList, extension);
+ delete this.extensions[name];
+ };
+ _proto.getExtension = function getExtension(name) {
+ return this.extensions[name];
+ };
+ _proto.hasExtension = function hasExtension(name) {
+ return !!this.extensions[name];
+ };
+ _proto.addGlobal = function addGlobal(name, value) {
+ this.globals[name] = value;
+ return this;
+ };
+ _proto.getGlobal = function getGlobal(name) {
+ if (typeof this.globals[name] === 'undefined') {
+ throw new Error('global not found: ' + name);
+ }
+ return this.globals[name];
+ };
+ _proto.addFilter = function addFilter(name, func, async) {
+ var wrapped = func;
+ if (async) {
+ this.asyncFilters.push(name);
+ }
+ this.filters[name] = wrapped;
+ return this;
+ };
+ _proto.getFilter = function getFilter(name) {
+ if (!this.filters[name]) {
+ throw new Error('filter not found: ' + name);
+ }
+ return this.filters[name];
+ };
+ _proto.addTest = function addTest(name, func) {
+ this.tests[name] = func;
+ return this;
+ };
+ _proto.getTest = function getTest(name) {
+ if (!this.tests[name]) {
+ throw new Error('test not found: ' + name);
+ }
+ return this.tests[name];
+ };
+ _proto.resolveTemplate = function resolveTemplate(loader, parentName, filename) {
+ var isRelative = loader.isRelative && parentName ? loader.isRelative(filename) : false;
+ return isRelative && loader.resolve ? loader.resolve(parentName, filename) : filename;
+ };
+ _proto.getTemplate = function getTemplate(name, eagerCompile, parentName, ignoreMissing, cb) {
+ var _this3 = this;
+ var that = this;
+ var tmpl = null;
+ if (name && name.raw) {
+ // this fixes autoescape for templates referenced in symbols
+ name = name.raw;
+ }
+ if (lib.isFunction(parentName)) {
+ cb = parentName;
+ parentName = null;
+ eagerCompile = eagerCompile || false;
+ }
+ if (lib.isFunction(eagerCompile)) {
+ cb = eagerCompile;
+ eagerCompile = false;
+ }
+ if (name instanceof Template) {
+ tmpl = name;
+ } else if (typeof name !== 'string') {
+ throw new Error('template names must be a string: ' + name);
+ } else {
+ for (var i = 0; i < this.loaders.length; i++) {
+ var loader = this.loaders[i];
+ tmpl = loader.cache[this.resolveTemplate(loader, parentName, name)];
+ if (tmpl) {
+ break;
+ }
+ }
+ }
+ if (tmpl) {
+ if (eagerCompile) {
+ tmpl.compile();
+ }
+ if (cb) {
+ cb(null, tmpl);
+ return undefined;
+ } else {
+ return tmpl;
+ }
+ }
+ var syncResult;
+ var createTemplate = function createTemplate(err, info) {
+ if (!info && !err && !ignoreMissing) {
+ err = new Error('template not found: ' + name);
+ }
+ if (err) {
+ if (cb) {
+ cb(err);
+ return;
+ } else {
+ throw err;
+ }
+ }
+ var newTmpl;
+ if (!info) {
+ newTmpl = new Template(noopTmplSrc, _this3, '', eagerCompile);
+ } else {
+ newTmpl = new Template(info.src, _this3, info.path, eagerCompile);
+ if (!info.noCache) {
+ info.loader.cache[name] = newTmpl;
+ }
+ }
+ if (cb) {
+ cb(null, newTmpl);
+ } else {
+ syncResult = newTmpl;
+ }
+ };
+ lib.asyncIter(this.loaders, function (loader, i, next, done) {
+ function handle(err, src) {
+ if (err) {
+ done(err);
+ } else if (src) {
+ src.loader = loader;
+ done(null, src);
+ } else {
+ next();
+ }
+ }
+
+ // Resolve name relative to parentName
+ name = that.resolveTemplate(loader, parentName, name);
+ if (loader.async) {
+ loader.getSource(name, handle);
+ } else {
+ handle(null, loader.getSource(name));
+ }
+ }, createTemplate);
+ return syncResult;
+ };
+ _proto.express = function express(app) {
+ return expressApp(this, app);
+ };
+ _proto.render = function render(name, ctx, cb) {
+ if (lib.isFunction(ctx)) {
+ cb = ctx;
+ ctx = null;
+ }
+
+ // We support a synchronous API to make it easier to migrate
+ // existing code to async. This works because if you don't do
+ // anything async work, the whole thing is actually run
+ // synchronously.
+ var syncResult = null;
+ this.getTemplate(name, function (err, tmpl) {
+ if (err && cb) {
+ callbackAsap(cb, err);
+ } else if (err) {
+ throw err;
+ } else {
+ syncResult = tmpl.render(ctx, cb);
+ }
+ });
+ return syncResult;
+ };
+ _proto.renderString = function renderString(src, ctx, opts, cb) {
+ if (lib.isFunction(opts)) {
+ cb = opts;
+ opts = {};
+ }
+ opts = opts || {};
+ var tmpl = new Template(src, this, opts.path);
+ return tmpl.render(ctx, cb);
+ };
+ _proto.waterfall = function waterfall(tasks, callback, forceAsync) {
+ return _waterfall(tasks, callback, forceAsync);
+ };
+ return Environment;
+}(EmitterObj);
+var Context = /*#__PURE__*/function (_Obj) {
+ _inheritsLoose(Context, _Obj);
+ function Context() {
+ return _Obj.apply(this, arguments) || this;
+ }
+ var _proto2 = Context.prototype;
+ _proto2.init = function init(ctx, blocks, env) {
+ var _this4 = this;
+ // Has to be tied to an environment so we can tap into its globals.
+ this.env = env || new Environment();
+
+ // Make a duplicate of ctx
+ this.ctx = lib.extend({}, ctx);
+ this.blocks = {};
+ this.exported = [];
+ lib.keys(blocks).forEach(function (name) {
+ _this4.addBlock(name, blocks[name]);
+ });
+ };
+ _proto2.lookup = function lookup(name) {
+ // This is one of the most called functions, so optimize for
+ // the typical case where the name isn't in the globals
+ if (name in this.env.globals && !(name in this.ctx)) {
+ return this.env.globals[name];
+ } else {
+ return this.ctx[name];
+ }
+ };
+ _proto2.setVariable = function setVariable(name, val) {
+ this.ctx[name] = val;
+ };
+ _proto2.getVariables = function getVariables() {
+ return this.ctx;
+ };
+ _proto2.addBlock = function addBlock(name, block) {
+ this.blocks[name] = this.blocks[name] || [];
+ this.blocks[name].push(block);
+ return this;
+ };
+ _proto2.getBlock = function getBlock(name) {
+ if (!this.blocks[name]) {
+ throw new Error('unknown block "' + name + '"');
+ }
+ return this.blocks[name][0];
+ };
+ _proto2.getSuper = function getSuper(env, name, block, frame, runtime, cb) {
+ var idx = lib.indexOf(this.blocks[name] || [], block);
+ var blk = this.blocks[name][idx + 1];
+ var context = this;
+ if (idx === -1 || !blk) {
+ throw new Error('no super block available for "' + name + '"');
+ }
+ blk(env, context, frame, runtime, cb);
+ };
+ _proto2.addExport = function addExport(name) {
+ this.exported.push(name);
+ };
+ _proto2.getExported = function getExported() {
+ var _this5 = this;
+ var exported = {};
+ this.exported.forEach(function (name) {
+ exported[name] = _this5.ctx[name];
+ });
+ return exported;
+ };
+ return Context;
+}(Obj);
+var Template = /*#__PURE__*/function (_Obj2) {
+ _inheritsLoose(Template, _Obj2);
+ function Template() {
+ return _Obj2.apply(this, arguments) || this;
+ }
+ var _proto3 = Template.prototype;
+ _proto3.init = function init(src, env, path, eagerCompile) {
+ this.env = env || new Environment();
+ if (lib.isObject(src)) {
+ switch (src.type) {
+ case 'code':
+ this.tmplProps = src.obj;
+ break;
+ case 'string':
+ this.tmplStr = src.obj;
+ break;
+ default:
+ throw new Error("Unexpected template object type " + src.type + "; expected 'code', or 'string'");
+ }
+ } else if (lib.isString(src)) {
+ this.tmplStr = src;
+ } else {
+ throw new Error('src must be a string or an object describing the source');
+ }
+ this.path = path;
+ if (eagerCompile) {
+ try {
+ this._compile();
+ } catch (err) {
+ throw lib._prettifyError(this.path, this.env.opts.dev, err);
+ }
+ } else {
+ this.compiled = false;
+ }
+ };
+ _proto3.render = function render(ctx, parentFrame, cb) {
+ var _this6 = this;
+ if (typeof ctx === 'function') {
+ cb = ctx;
+ ctx = {};
+ } else if (typeof parentFrame === 'function') {
+ cb = parentFrame;
+ parentFrame = null;
+ }
+
+ // If there is a parent frame, we are being called from internal
+ // code of another template, and the internal system
+ // depends on the sync/async nature of the parent template
+ // to be inherited, so force an async callback
+ var forceAsync = !parentFrame;
+
+ // Catch compile errors for async rendering
+ try {
+ this.compile();
+ } catch (e) {
+ var err = lib._prettifyError(this.path, this.env.opts.dev, e);
+ if (cb) {
+ return callbackAsap(cb, err);
+ } else {
+ throw err;
+ }
+ }
+ var context = new Context(ctx || {}, this.blocks, this.env);
+ var frame = parentFrame ? parentFrame.push(true) : new Frame();
+ frame.topLevel = true;
+ var syncResult = null;
+ var didError = false;
+ this.rootRenderFunc(this.env, context, frame, globalRuntime, function (err, res) {
+ // TODO: this is actually a bug in the compiled template (because waterfall
+ // tasks are both not passing errors up the chain of callbacks AND are not
+ // causing a return from the top-most render function). But fixing that
+ // will require a more substantial change to the compiler.
+ if (didError && cb && typeof res !== 'undefined') {
+ // prevent multiple calls to cb
+ return;
+ }
+ if (err) {
+ err = lib._prettifyError(_this6.path, _this6.env.opts.dev, err);
+ didError = true;
+ }
+ if (cb) {
+ if (forceAsync) {
+ callbackAsap(cb, err, res);
+ } else {
+ cb(err, res);
+ }
+ } else {
+ if (err) {
+ throw err;
+ }
+ syncResult = res;
+ }
+ });
+ return syncResult;
+ };
+ _proto3.getExported = function getExported(ctx, parentFrame, cb) {
+ // eslint-disable-line consistent-return
+ if (typeof ctx === 'function') {
+ cb = ctx;
+ ctx = {};
+ }
+ if (typeof parentFrame === 'function') {
+ cb = parentFrame;
+ parentFrame = null;
+ }
+
+ // Catch compile errors for async rendering
+ try {
+ this.compile();
+ } catch (e) {
+ if (cb) {
+ return cb(e);
+ } else {
+ throw e;
+ }
+ }
+ var frame = parentFrame ? parentFrame.push() : new Frame();
+ frame.topLevel = true;
+
+ // Run the rootRenderFunc to populate the context with exported vars
+ var context = new Context(ctx || {}, this.blocks, this.env);
+ this.rootRenderFunc(this.env, context, frame, globalRuntime, function (err) {
+ if (err) {
+ cb(err, null);
+ } else {
+ cb(null, context.getExported());
+ }
+ });
+ };
+ _proto3.compile = function compile() {
+ if (!this.compiled) {
+ this._compile();
+ }
+ };
+ _proto3._compile = function _compile() {
+ var props;
+ if (this.tmplProps) {
+ props = this.tmplProps;
+ } else {
+ var source = compiler.compile(this.tmplStr, this.env.asyncFilters, this.env.extensionsList, this.path, this.env.opts);
+ var func = new Function(source); // eslint-disable-line no-new-func
+ props = func();
+ }
+ this.blocks = this._getBlocks(props);
+ this.rootRenderFunc = props.root;
+ this.compiled = true;
+ };
+ _proto3._getBlocks = function _getBlocks(props) {
+ var blocks = {};
+ lib.keys(props).forEach(function (k) {
+ if (k.slice(0, 2) === 'b_') {
+ blocks[k.slice(2)] = props[k];
+ }
+ });
+ return blocks;
+ };
+ return Template;
+}(Obj);
+module.exports = {
+ Environment: Environment,
+ Template: Template
+};
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+// rawAsap provides everything we need except exception management.
+var rawAsap = __webpack_require__(9);
+// RawTasks are recycled to reduce GC churn.
+var freeTasks = [];
+// We queue errors to ensure they are thrown in right order (FIFO).
+// Array-as-queue is good enough here, since we are just dealing with exceptions.
+var pendingErrors = [];
+var requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);
+
+function throwFirstError() {
+ if (pendingErrors.length) {
+ throw pendingErrors.shift();
+ }
+}
+
+/**
+ * Calls a task as soon as possible after returning, in its own event, with priority
+ * over other events like animation, reflow, and repaint. An error thrown from an
+ * event will not interrupt, nor even substantially slow down the processing of
+ * other events, but will be rather postponed to a lower priority event.
+ * @param {{call}} task A callable object, typically a function that takes no
+ * arguments.
+ */
+module.exports = asap;
+function asap(task) {
+ var rawTask;
+ if (freeTasks.length) {
+ rawTask = freeTasks.pop();
+ } else {
+ rawTask = new RawTask();
+ }
+ rawTask.task = task;
+ rawAsap(rawTask);
+}
+
+// We wrap tasks with recyclable task objects. A task object implements
+// `call`, just like a function.
+function RawTask() {
+ this.task = null;
+}
+
+// The sole purpose of wrapping the task is to catch the exception and recycle
+// the task object after its single use.
+RawTask.prototype.call = function () {
+ try {
+ this.task.call();
+ } catch (error) {
+ if (asap.onerror) {
+ // This hook exists purely for testing purposes.
+ // Its name will be periodically randomized to break any code that
+ // depends on its existence.
+ asap.onerror(error);
+ } else {
+ // In a web browser, exceptions are not fatal. However, to avoid
+ // slowing down the queue of pending tasks, we rethrow the error in a
+ // lower priority turn.
+ pendingErrors.push(error);
+ requestErrorThrow();
+ }
+ } finally {
+ this.task = null;
+ freeTasks[freeTasks.length] = this;
+ }
+};
+
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+
+// Use the fastest means possible to execute a task in its own turn, with
+// priority over other events including IO, animation, reflow, and redraw
+// events in browsers.
+//
+// An exception thrown by a task will permanently interrupt the processing of
+// subsequent tasks. The higher level `asap` function ensures that if an
+// exception is thrown by a task, that the task queue will continue flushing as
+// soon as possible, but if you use `rawAsap` directly, you are responsible to
+// either ensure that no exceptions are thrown from your task, or to manually
+// call `rawAsap.requestFlush` if an exception is thrown.
+module.exports = rawAsap;
+function rawAsap(task) {
+ if (!queue.length) {
+ requestFlush();
+ flushing = true;
+ }
+ // Equivalent to push, but avoids a function call.
+ queue[queue.length] = task;
+}
+
+var queue = [];
+// Once a flush has been requested, no further calls to `requestFlush` are
+// necessary until the next `flush` completes.
+var flushing = false;
+// `requestFlush` is an implementation-specific method that attempts to kick
+// off a `flush` event as quickly as possible. `flush` will attempt to exhaust
+// the event queue before yielding to the browser's own event loop.
+var requestFlush;
+// The position of the next task to execute in the task queue. This is
+// preserved between calls to `flush` so that it can be resumed if
+// a task throws an exception.
+var index = 0;
+// If a task schedules additional tasks recursively, the task queue can grow
+// unbounded. To prevent memory exhaustion, the task queue will periodically
+// truncate already-completed tasks.
+var capacity = 1024;
+
+// The flush function processes all tasks that have been scheduled with
+// `rawAsap` unless and until one of those tasks throws an exception.
+// If a task throws an exception, `flush` ensures that its state will remain
+// consistent and will resume where it left off when called again.
+// However, `flush` does not make any arrangements to be called again if an
+// exception is thrown.
+function flush() {
+ while (index < queue.length) {
+ var currentIndex = index;
+ // Advance the index before calling the task. This ensures that we will
+ // begin flushing on the next task the task throws an error.
+ index = index + 1;
+ queue[currentIndex].call();
+ // Prevent leaking memory for long chains of recursive calls to `asap`.
+ // If we call `asap` within tasks scheduled by `asap`, the queue will
+ // grow, but to avoid an O(n) walk for every task we execute, we don't
+ // shift tasks off the queue after they have been executed.
+ // Instead, we periodically shift 1024 tasks off the queue.
+ if (index > capacity) {
+ // Manually shift all values starting at the index back to the
+ // beginning of the queue.
+ for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
+ queue[scan] = queue[scan + index];
+ }
+ queue.length -= index;
+ index = 0;
+ }
+ }
+ queue.length = 0;
+ index = 0;
+ flushing = false;
+}
+
+// `requestFlush` is implemented using a strategy based on data collected from
+// every available SauceLabs Selenium web driver worker at time of writing.
+// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593
+
+// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
+// have WebKitMutationObserver but not un-prefixed MutationObserver.
+// Must use `global` or `self` instead of `window` to work in both frames and web
+// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.
+
+/* globals self */
+var scope = typeof global !== "undefined" ? global : self;
+var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
+
+// MutationObservers are desirable because they have high priority and work
+// reliably everywhere they are implemented.
+// They are implemented in all modern browsers.
+//
+// - Android 4-4.3
+// - Chrome 26-34
+// - Firefox 14-29
+// - Internet Explorer 11
+// - iPad Safari 6-7.1
+// - iPhone Safari 7-7.1
+// - Safari 6-7
+if (typeof BrowserMutationObserver === "function") {
+ requestFlush = makeRequestCallFromMutationObserver(flush);
+
+// MessageChannels are desirable because they give direct access to the HTML
+// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
+// 11-12, and in web workers in many engines.
+// Although message channels yield to any queued rendering and IO tasks, they
+// would be better than imposing the 4ms delay of timers.
+// However, they do not work reliably in Internet Explorer or Safari.
+
+// Internet Explorer 10 is the only browser that has setImmediate but does
+// not have MutationObservers.
+// Although setImmediate yields to the browser's renderer, it would be
+// preferrable to falling back to setTimeout since it does not have
+// the minimum 4ms penalty.
+// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
+// Desktop to a lesser extent) that renders both setImmediate and
+// MessageChannel useless for the purposes of ASAP.
+// https://github.com/kriskowal/q/issues/396
+
+// Timers are implemented universally.
+// We fall back to timers in workers in most engines, and in foreground
+// contexts in the following browsers.
+// However, note that even this simple case requires nuances to operate in a
+// broad spectrum of browsers.
+//
+// - Firefox 3-13
+// - Internet Explorer 6-9
+// - iPad Safari 4.3
+// - Lynx 2.8.7
+} else {
+ requestFlush = makeRequestCallFromTimer(flush);
+}
+
+// `requestFlush` requests that the high priority event queue be flushed as
+// soon as possible.
+// This is useful to prevent an error thrown in a task from stalling the event
+// queue if the exception handled by Node.js’s
+// `process.on("uncaughtException")` or by a domain.
+rawAsap.requestFlush = requestFlush;
+
+// To request a high priority event, we induce a mutation observer by toggling
+// the text of a text node between "1" and "-1".
+function makeRequestCallFromMutationObserver(callback) {
+ var toggle = 1;
+ var observer = new BrowserMutationObserver(callback);
+ var node = document.createTextNode("");
+ observer.observe(node, {characterData: true});
+ return function requestCall() {
+ toggle = -toggle;
+ node.data = toggle;
+ };
+}
+
+// The message channel technique was discovered by Malte Ubl and was the
+// original foundation for this library.
+// http://www.nonblocking.io/2011/06/windownexttick.html
+
+// Safari 6.0.5 (at least) intermittently fails to create message ports on a
+// page's first load. Thankfully, this version of Safari supports
+// MutationObservers, so we don't need to fall back in that case.
+
+// function makeRequestCallFromMessageChannel(callback) {
+// var channel = new MessageChannel();
+// channel.port1.onmessage = callback;
+// return function requestCall() {
+// channel.port2.postMessage(0);
+// };
+// }
+
+// For reasons explained above, we are also unable to use `setImmediate`
+// under any circumstances.
+// Even if we were, there is another bug in Internet Explorer 10.
+// It is not sufficient to assign `setImmediate` to `requestFlush` because
+// `setImmediate` must be called *by name* and therefore must be wrapped in a
+// closure.
+// Never forget.
+
+// function makeRequestCallFromSetImmediate(callback) {
+// return function requestCall() {
+// setImmediate(callback);
+// };
+// }
+
+// Safari 6.0 has a problem where timers will get lost while the user is
+// scrolling. This problem does not impact ASAP because Safari 6.0 supports
+// mutation observers, so that implementation is used instead.
+// However, if we ever elect to use timers in Safari, the prevalent work-around
+// is to add a scroll event listener that calls for a flush.
+
+// `setTimeout` does not call the passed callback if the delay is less than
+// approximately 7 in web workers in Firefox 8 through 18, and sometimes not
+// even then.
+
+function makeRequestCallFromTimer(callback) {
+ return function requestCall() {
+ // We dispatch a timeout with a specified delay of 0 for engines that
+ // can reliably accommodate that request. This will usually be snapped
+ // to a 4 milisecond delay, but once we're flushing, there's no delay
+ // between events.
+ var timeoutHandle = setTimeout(handleTimer, 0);
+ // However, since this timer gets frequently dropped in Firefox
+ // workers, we enlist an interval handle that will try to fire
+ // an event 20 times per second until it succeeds.
+ var intervalHandle = setInterval(handleTimer, 50);
+
+ function handleTimer() {
+ // Whichever timer succeeds will cancel both timers and
+ // execute the callback.
+ clearTimeout(timeoutHandle);
+ clearInterval(intervalHandle);
+ callback();
+ }
+ };
+}
+
+// This is for `asap.js` only.
+// Its name will be periodically randomized to break any code that depends on
+// its existence.
+rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;
+
+// ASAP was originally a nextTick shim included in Q. This was factored out
+// into this ASAP package. It was later adapted to RSVP which made further
+// amendments. These decisions, particularly to marginalize MessageChannel and
+// to capture the MutationObserver implementation in a closure, were integrated
+// back into ASAP proper.
+// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(10)))
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports) {
+
+var g;
+
+// This works in non-strict mode
+g = (function() {
+ return this;
+})();
+
+try {
+ // This works if eval is allowed (see CSP)
+ g = g || Function("return this")() || (1,eval)("this");
+} catch(e) {
+ // This works if the window reference is available
+ if(typeof window === "object")
+ g = window;
+}
+
+// g can still be undefined, but nothing to do about it...
+// We return undefined, instead of nothing here, so it's
+// easier to handle this case. if(!global) { ...}
+
+module.exports = g;
+
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// MIT license (by Elan Shanker).
+(function(globals) {
+ 'use strict';
+
+ var executeSync = function(){
+ var args = Array.prototype.slice.call(arguments);
+ if (typeof args[0] === 'function'){
+ args[0].apply(null, args.splice(1));
+ }
+ };
+
+ var executeAsync = function(fn){
+ if (typeof setImmediate === 'function') {
+ setImmediate(fn);
+ } else if (typeof process !== 'undefined' && process.nextTick) {
+ process.nextTick(fn);
+ } else {
+ setTimeout(fn, 0);
+ }
+ };
+
+ var makeIterator = function (tasks) {
+ var makeCallback = function (index) {
+ var fn = function () {
+ if (tasks.length) {
+ tasks[index].apply(null, arguments);
+ }
+ return fn.next();
+ };
+ fn.next = function () {
+ return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+ };
+ return fn;
+ };
+ return makeCallback(0);
+ };
+
+ var _isArray = Array.isArray || function(maybeArray){
+ return Object.prototype.toString.call(maybeArray) === '[object Array]';
+ };
+
+ var waterfall = function (tasks, callback, forceAsync) {
+ var nextTick = forceAsync ? executeAsync : executeSync;
+ callback = callback || function () {};
+ if (!_isArray(tasks)) {
+ var err = new Error('First argument to waterfall must be an array of functions');
+ return callback(err);
+ }
+ if (!tasks.length) {
+ return callback();
+ }
+ var wrapIterator = function (iterator) {
+ return function (err) {
+ if (err) {
+ callback.apply(null, arguments);
+ callback = function () {};
+ } else {
+ var args = Array.prototype.slice.call(arguments, 1);
+ var next = iterator.next();
+ if (next) {
+ args.push(wrapIterator(next));
+ } else {
+ args.push(callback);
+ }
+ nextTick(function () {
+ iterator.apply(null, args);
+ });
+ }
+ };
+ };
+ wrapIterator(makeIterator(tasks))();
+ };
+
+ if (true) {
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
+ return waterfall;
+ }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // RequireJS
+ } else if (typeof module !== 'undefined' && module.exports) {
+ module.exports = waterfall; // CommonJS
+ } else {
+ globals.waterfall = waterfall; // <script>
+ }
+})(this);
+
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var lib = __webpack_require__(1);
+var r = __webpack_require__(2);
+var exports = module.exports = {};
+function normalize(value, defaultValue) {
+ if (value === null || value === undefined || value === false) {
+ return defaultValue;
+ }
+ return value;
+}
+exports.abs = Math.abs;
+function isNaN(num) {
+ return num !== num; // eslint-disable-line no-self-compare
+}
+
+function batch(arr, linecount, fillWith) {
+ var i;
+ var res = [];
+ var tmp = [];
+ for (i = 0; i < arr.length; i++) {
+ if (i % linecount === 0 && tmp.length) {
+ res.push(tmp);
+ tmp = [];
+ }
+ tmp.push(arr[i]);
+ }
+ if (tmp.length) {
+ if (fillWith) {
+ for (i = tmp.length; i < linecount; i++) {
+ tmp.push(fillWith);
+ }
+ }
+ res.push(tmp);
+ }
+ return res;
+}
+exports.batch = batch;
+function capitalize(str) {
+ str = normalize(str, '');
+ var ret = str.toLowerCase();
+ return r.copySafeness(str, ret.charAt(0).toUpperCase() + ret.slice(1));
+}
+exports.capitalize = capitalize;
+function center(str, width) {
+ str = normalize(str, '');
+ width = width || 80;
+ if (str.length >= width) {
+ return str;
+ }
+ var spaces = width - str.length;
+ var pre = lib.repeat(' ', spaces / 2 - spaces % 2);
+ var post = lib.repeat(' ', spaces / 2);
+ return r.copySafeness(str, pre + str + post);
+}
+exports.center = center;
+function default_(val, def, bool) {
+ if (bool) {
+ return val || def;
+ } else {
+ return val !== undefined ? val : def;
+ }
+}
+
+// TODO: it is confusing to export something called 'default'
+exports['default'] = default_; // eslint-disable-line dot-notation
+
+function dictsort(val, caseSensitive, by) {
+ if (!lib.isObject(val)) {
+ throw new lib.TemplateError('dictsort filter: val must be an object');
+ }
+ var array = [];
+ // deliberately include properties from the object's prototype
+ for (var k in val) {
+ // eslint-disable-line guard-for-in, no-restricted-syntax
+ array.push([k, val[k]]);
+ }
+ var si;
+ if (by === undefined || by === 'key') {
+ si = 0;
+ } else if (by === 'value') {
+ si = 1;
+ } else {
+ throw new lib.TemplateError('dictsort filter: You can only sort by either key or value');
+ }
+ array.sort(function (t1, t2) {
+ var a = t1[si];
+ var b = t2[si];
+ if (!caseSensitive) {
+ if (lib.isString(a)) {
+ a = a.toUpperCase();
+ }
+ if (lib.isString(b)) {
+ b = b.toUpperCase();
+ }
+ }
+ return a > b ? 1 : a === b ? 0 : -1; // eslint-disable-line no-nested-ternary
+ });
+
+ return array;
+}
+exports.dictsort = dictsort;
+function dump(obj, spaces) {
+ return JSON.stringify(obj, null, spaces);
+}
+exports.dump = dump;
+function escape(str) {
+ if (str instanceof r.SafeString) {
+ return str;
+ }
+ str = str === null || str === undefined ? '' : str;
+ return r.markSafe(lib.escape(str.toString()));
+}
+exports.escape = escape;
+function safe(str) {
+ if (str instanceof r.SafeString) {
+ return str;
+ }
+ str = str === null || str === undefined ? '' : str;
+ return r.markSafe(str.toString());
+}
+exports.safe = safe;
+function first(arr) {
+ return arr[0];
+}
+exports.first = first;
+function forceescape(str) {
+ str = str === null || str === undefined ? '' : str;
+ return r.markSafe(lib.escape(str.toString()));
+}
+exports.forceescape = forceescape;
+function groupby(arr, attr) {
+ return lib.groupBy(arr, attr, this.env.opts.throwOnUndefined);
+}
+exports.groupby = groupby;
+function indent(str, width, indentfirst) {
+ str = normalize(str, '');
+ if (str === '') {
+ return '';
+ }
+ width = width || 4;
+ // let res = '';
+ var lines = str.split('\n');
+ var sp = lib.repeat(' ', width);
+ var res = lines.map(function (l, i) {
+ return i === 0 && !indentfirst ? l : "" + sp + l;
+ }).join('\n');
+ return r.copySafeness(str, res);
+}
+exports.indent = indent;
+function join(arr, del, attr) {
+ del = del || '';
+ if (attr) {
+ arr = lib.map(arr, function (v) {
+ return v[attr];
+ });
+ }
+ return arr.join(del);
+}
+exports.join = join;
+function last(arr) {
+ return arr[arr.length - 1];
+}
+exports.last = last;
+function lengthFilter(val) {
+ var value = normalize(val, '');
+ if (value !== undefined) {
+ if (typeof Map === 'function' && value instanceof Map || typeof Set === 'function' && value instanceof Set) {
+ // ECMAScript 2015 Maps and Sets
+ return value.size;
+ }
+ if (lib.isObject(value) && !(value instanceof r.SafeString)) {
+ // Objects (besides SafeStrings), non-primative Arrays
+ return lib.keys(value).length;
+ }
+ return value.length;
+ }
+ return 0;
+}
+exports.length = lengthFilter;
+function list(val) {
+ if (lib.isString(val)) {
+ return val.split('');
+ } else if (lib.isObject(val)) {
+ return lib._entries(val || {}).map(function (_ref) {
+ var key = _ref[0],
+ value = _ref[1];
+ return {
+ key: key,
+ value: value
+ };
+ });
+ } else if (lib.isArray(val)) {
+ return val;
+ } else {
+ throw new lib.TemplateError('list filter: type not iterable');
+ }
+}
+exports.list = list;
+function lower(str) {
+ str = normalize(str, '');
+ return str.toLowerCase();
+}
+exports.lower = lower;
+function nl2br(str) {
+ if (str === null || str === undefined) {
+ return '';
+ }
+ return r.copySafeness(str, str.replace(/\r\n|\n/g, '<br />\n'));
+}
+exports.nl2br = nl2br;
+function random(arr) {
+ return arr[Math.floor(Math.random() * arr.length)];
+}
+exports.random = random;
+
+/**
+ * Construct select or reject filter
+ *
+ * @param {boolean} expectedTestResult
+ * @returns {function(array, string, *): array}
+ */
+function getSelectOrReject(expectedTestResult) {
+ function filter(arr, testName, secondArg) {
+ if (testName === void 0) {
+ testName = 'truthy';
+ }
+ var context = this;
+ var test = context.env.getTest(testName);
+ return lib.toArray(arr).filter(function examineTestResult(item) {
+ return test.call(context, item, secondArg) === expectedTestResult;
+ });
+ }
+ return filter;
+}
+exports.reject = getSelectOrReject(false);
+function rejectattr(arr, attr) {
+ return arr.filter(function (item) {
+ return !item[attr];
+ });
+}
+exports.rejectattr = rejectattr;
+exports.select = getSelectOrReject(true);
+function selectattr(arr, attr) {
+ return arr.filter(function (item) {
+ return !!item[attr];
+ });
+}
+exports.selectattr = selectattr;
+function replace(str, old, new_, maxCount) {
+ var originalStr = str;
+ if (old instanceof RegExp) {
+ return str.replace(old, new_);
+ }
+ if (typeof maxCount === 'undefined') {
+ maxCount = -1;
+ }
+ var res = ''; // Output
+
+ // Cast Numbers in the search term to string
+ if (typeof old === 'number') {
+ old = '' + old;
+ } else if (typeof old !== 'string') {
+ // If it is something other than number or string,
+ // return the original string
+ return str;
+ }
+
+ // Cast numbers in the replacement to string
+ if (typeof str === 'number') {
+ str = '' + str;
+ }
+
+ // If by now, we don't have a string, throw it back
+ if (typeof str !== 'string' && !(str instanceof r.SafeString)) {
+ return str;
+ }
+
+ // ShortCircuits
+ if (old === '') {
+ // Mimic the python behaviour: empty string is replaced
+ // by replacement e.g. "abc"|replace("", ".") -> .a.b.c.
+ res = new_ + str.split('').join(new_) + new_;
+ return r.copySafeness(str, res);
+ }
+ var nextIndex = str.indexOf(old);
+ // if # of replacements to perform is 0, or the string to does
+ // not contain the old value, return the string
+ if (maxCount === 0 || nextIndex === -1) {
+ return str;
+ }
+ var pos = 0;
+ var count = 0; // # of replacements made
+
+ while (nextIndex > -1 && (maxCount === -1 || count < maxCount)) {
+ // Grab the next chunk of src string and add it with the
+ // replacement, to the result
+ res += str.substring(pos, nextIndex) + new_;
+ // Increment our pointer in the src string
+ pos = nextIndex + old.length;
+ count++;
+ // See if there are any more replacements to be made
+ nextIndex = str.indexOf(old, pos);
+ }
+
+ // We've either reached the end, or done the max # of
+ // replacements, tack on any remaining string
+ if (pos < str.length) {
+ res += str.substring(pos);
+ }
+ return r.copySafeness(originalStr, res);
+}
+exports.replace = replace;
+function reverse(val) {
+ var arr;
+ if (lib.isString(val)) {
+ arr = list(val);
+ } else {
+ // Copy it
+ arr = lib.map(val, function (v) {
+ return v;
+ });
+ }
+ arr.reverse();
+ if (lib.isString(val)) {
+ return r.copySafeness(val, arr.join(''));
+ }
+ return arr;
+}
+exports.reverse = reverse;
+function round(val, precision, method) {
+ precision = precision || 0;
+ var factor = Math.pow(10, precision);
+ var rounder;
+ if (method === 'ceil') {
+ rounder = Math.ceil;
+ } else if (method === 'floor') {
+ rounder = Math.floor;
+ } else {
+ rounder = Math.round;
+ }
+ return rounder(val * factor) / factor;
+}
+exports.round = round;
+function slice(arr, slices, fillWith) {
+ var sliceLength = Math.floor(arr.length / slices);
+ var extra = arr.length % slices;
+ var res = [];
+ var offset = 0;
+ for (var i = 0; i < slices; i++) {
+ var start = offset + i * sliceLength;
+ if (i < extra) {
+ offset++;
+ }
+ var end = offset + (i + 1) * sliceLength;
+ var currSlice = arr.slice(start, end);
+ if (fillWith && i >= extra) {
+ currSlice.push(fillWith);
+ }
+ res.push(currSlice);
+ }
+ return res;
+}
+exports.slice = slice;
+function sum(arr, attr, start) {
+ if (start === void 0) {
+ start = 0;
+ }
+ if (attr) {
+ arr = lib.map(arr, function (v) {
+ return v[attr];
+ });
+ }
+ return start + arr.reduce(function (a, b) {
+ return a + b;
+ }, 0);
+}
+exports.sum = sum;
+exports.sort = r.makeMacro(['value', 'reverse', 'case_sensitive', 'attribute'], [], function sortFilter(arr, reversed, caseSens, attr) {
+ var _this = this;
+ // Copy it
+ var array = lib.map(arr, function (v) {
+ return v;
+ });
+ var getAttribute = lib.getAttrGetter(attr);
+ array.sort(function (a, b) {
+ var x = attr ? getAttribute(a) : a;
+ var y = attr ? getAttribute(b) : b;
+ if (_this.env.opts.throwOnUndefined && attr && (x === undefined || y === undefined)) {
+ throw new TypeError("sort: attribute \"" + attr + "\" resolved to undefined");
+ }
+ if (!caseSens && lib.isString(x) && lib.isString(y)) {
+ x = x.toLowerCase();
+ y = y.toLowerCase();
+ }
+ if (x < y) {
+ return reversed ? 1 : -1;
+ } else if (x > y) {
+ return reversed ? -1 : 1;
+ } else {
+ return 0;
+ }
+ });
+ return array;
+});
+function string(obj) {
+ return r.copySafeness(obj, obj);
+}
+exports.string = string;
+function striptags(input, preserveLinebreaks) {
+ input = normalize(input, '');
+ var tags = /<\/?([a-z][a-z0-9]*)\b[^>]*>|<!--[\s\S]*?-->/gi;
+ var trimmedInput = trim(input.replace(tags, ''));
+ var res = '';
+ if (preserveLinebreaks) {
+ res = trimmedInput.replace(/^ +| +$/gm, '') // remove leading and trailing spaces
+ .replace(/ +/g, ' ') // squash adjacent spaces
+ .replace(/(\r\n)/g, '\n') // normalize linebreaks (CRLF -> LF)
+ .replace(/\n\n\n+/g, '\n\n'); // squash abnormal adjacent linebreaks
+ } else {
+ res = trimmedInput.replace(/\s+/gi, ' ');
+ }
+ return r.copySafeness(input, res);
+}
+exports.striptags = striptags;
+function title(str) {
+ str = normalize(str, '');
+ var words = str.split(' ').map(function (word) {
+ return capitalize(word);
+ });
+ return r.copySafeness(str, words.join(' '));
+}
+exports.title = title;
+function trim(str) {
+ return r.copySafeness(str, str.replace(/^\s*|\s*$/g, ''));
+}
+exports.trim = trim;
+function truncate(input, length, killwords, end) {
+ var orig = input;
+ input = normalize(input, '');
+ length = length || 255;
+ if (input.length <= length) {
+ return input;
+ }
+ if (killwords) {
+ input = input.substring(0, length);
+ } else {
+ var idx = input.lastIndexOf(' ', length);
+ if (idx === -1) {
+ idx = length;
+ }
+ input = input.substring(0, idx);
+ }
+ input += end !== undefined && end !== null ? end : '...';
+ return r.copySafeness(orig, input);
+}
+exports.truncate = truncate;
+function upper(str) {
+ str = normalize(str, '');
+ return str.toUpperCase();
+}
+exports.upper = upper;
+function urlencode(obj) {
+ var enc = encodeURIComponent;
+ if (lib.isString(obj)) {
+ return enc(obj);
+ } else {
+ var keyvals = lib.isArray(obj) ? obj : lib._entries(obj);
+ return keyvals.map(function (_ref2) {
+ var k = _ref2[0],
+ v = _ref2[1];
+ return enc(k) + "=" + enc(v);
+ }).join('&');
+ }
+}
+exports.urlencode = urlencode;
+
+// For the jinja regexp, see
+// https://github.com/mitsuhiko/jinja2/blob/f15b814dcba6aa12bc74d1f7d0c881d55f7126be/jinja2/utils.py#L20-L23
+var puncRe = /^(?:\(|<|&lt;)?(.*?)(?:\.|,|\)|\n|&gt;)?$/;
+// from http://blog.gerv.net/2011/05/html5_email_address_regexp/
+var emailRe = /^[\w.!#$%&'*+\-\/=?\^`{|}~]+@[a-z\d\-]+(\.[a-z\d\-]+)+$/i;
+var httpHttpsRe = /^https?:\/\/.*$/;
+var wwwRe = /^www\./;
+var tldRe = /\.(?:org|net|com)(?:\:|\/|$)/;
+function urlize(str, length, nofollow) {
+ if (isNaN(length)) {
+ length = Infinity;
+ }
+ var noFollowAttr = nofollow === true ? ' rel="nofollow"' : '';
+ var words = str.split(/(\s+)/).filter(function (word) {
+ // If the word has no length, bail. This can happen for str with
+ // trailing whitespace.
+ return word && word.length;
+ }).map(function (word) {
+ var matches = word.match(puncRe);
+ var possibleUrl = matches ? matches[1] : word;
+ var shortUrl = possibleUrl.substr(0, length);
+
+ // url that starts with http or https
+ if (httpHttpsRe.test(possibleUrl)) {
+ return "<a href=\"" + possibleUrl + "\"" + noFollowAttr + ">" + shortUrl + "</a>";
+ }
+
+ // url that starts with www.
+ if (wwwRe.test(possibleUrl)) {
+ return "<a href=\"http://" + possibleUrl + "\"" + noFollowAttr + ">" + shortUrl + "</a>";
+ }
+
+ // an email address of the form username@domain.tld
+ if (emailRe.test(possibleUrl)) {
+ return "<a href=\"mailto:" + possibleUrl + "\">" + possibleUrl + "</a>";
+ }
+
+ // url that ends in .com, .org or .net that is not an email address
+ if (tldRe.test(possibleUrl)) {
+ return "<a href=\"http://" + possibleUrl + "\"" + noFollowAttr + ">" + shortUrl + "</a>";
+ }
+ return word;
+ });
+ return words.join('');
+}
+exports.urlize = urlize;
+function wordcount(str) {
+ str = normalize(str, '');
+ var words = str ? str.match(/\w+/g) : null;
+ return words ? words.length : null;
+}
+exports.wordcount = wordcount;
+function float(val, def) {
+ var res = parseFloat(val);
+ return isNaN(res) ? def : res;
+}
+exports.float = float;
+var intFilter = r.makeMacro(['value', 'default', 'base'], [], function doInt(value, defaultValue, base) {
+ if (base === void 0) {
+ base = 10;
+ }
+ var res = parseInt(value, base);
+ return isNaN(res) ? defaultValue : res;
+});
+exports.int = intFilter;
+
+// Aliases
+exports.d = exports.default;
+exports.e = exports.escape;
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"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.
+
+
+
+var R = typeof Reflect === 'object' ? Reflect : null
+var ReflectApply = R && typeof R.apply === 'function'
+ ? R.apply
+ : function ReflectApply(target, receiver, args) {
+ return Function.prototype.apply.call(target, receiver, args);
+ }
+
+var ReflectOwnKeys
+if (R && typeof R.ownKeys === 'function') {
+ ReflectOwnKeys = R.ownKeys
+} else if (Object.getOwnPropertySymbols) {
+ ReflectOwnKeys = function ReflectOwnKeys(target) {
+ return Object.getOwnPropertyNames(target)
+ .concat(Object.getOwnPropertySymbols(target));
+ };
+} else {
+ ReflectOwnKeys = function ReflectOwnKeys(target) {
+ return Object.getOwnPropertyNames(target);
+ };
+}
+
+function ProcessEmitWarning(warning) {
+ if (console && console.warn) console.warn(warning);
+}
+
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+ return value !== value;
+}
+
+function EventEmitter() {
+ EventEmitter.init.call(this);
+}
+module.exports = EventEmitter;
+module.exports.once = once;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+function checkListener(listener) {
+ if (typeof listener !== 'function') {
+ throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+ }
+}
+
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+ enumerable: true,
+ get: function() {
+ return defaultMaxListeners;
+ },
+ set: function(arg) {
+ if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+ throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+ }
+ defaultMaxListeners = arg;
+ }
+});
+
+EventEmitter.init = function() {
+
+ if (this._events === undefined ||
+ this._events === Object.getPrototypeOf(this)._events) {
+ this._events = Object.create(null);
+ this._eventsCount = 0;
+ }
+
+ this._maxListeners = this._maxListeners || undefined;
+};
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+ if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+ throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+ }
+ this._maxListeners = n;
+ return this;
+};
+
+function _getMaxListeners(that) {
+ if (that._maxListeners === undefined)
+ return EventEmitter.defaultMaxListeners;
+ return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+ return _getMaxListeners(this);
+};
+
+EventEmitter.prototype.emit = function emit(type) {
+ var args = [];
+ for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+ var doError = (type === 'error');
+
+ var events = this._events;
+ if (events !== undefined)
+ doError = (doError && events.error === undefined);
+ else if (!doError)
+ return false;
+
+ // If there is no 'error' event listener then throw.
+ if (doError) {
+ var er;
+ if (args.length > 0)
+ er = args[0];
+ if (er instanceof Error) {
+ // Note: The comments on the `throw` lines are intentional, they show
+ // up in Node's output if this results in an unhandled exception.
+ throw er; // Unhandled 'error' event
+ }
+ // At least give some kind of context to the user
+ var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+ err.context = er;
+ throw err; // Unhandled 'error' event
+ }
+
+ var handler = events[type];
+
+ if (handler === undefined)
+ return false;
+
+ if (typeof handler === 'function') {
+ ReflectApply(handler, this, args);
+ } else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ ReflectApply(listeners[i], this, args);
+ }
+
+ return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+ var m;
+ var events;
+ var existing;
+
+ checkListener(listener);
+
+ events = target._events;
+ if (events === undefined) {
+ events = target._events = Object.create(null);
+ target._eventsCount = 0;
+ } else {
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (events.newListener !== undefined) {
+ target.emit('newListener', type,
+ listener.listener ? listener.listener : listener);
+
+ // Re-assign `events` because a newListener handler could have caused the
+ // this._events to be assigned to a new object
+ events = target._events;
+ }
+ existing = events[type];
+ }
+
+ if (existing === undefined) {
+ // Optimize the case of one listener. Don't need the extra array object.
+ existing = events[type] = listener;
+ ++target._eventsCount;
+ } else {
+ if (typeof existing === 'function') {
+ // Adding the second element, need to change to array.
+ existing = events[type] =
+ prepend ? [listener, existing] : [existing, listener];
+ // If we've already got an array, just append.
+ } else if (prepend) {
+ existing.unshift(listener);
+ } else {
+ existing.push(listener);
+ }
+
+ // Check for listener leak
+ m = _getMaxListeners(target);
+ if (m > 0 && existing.length > m && !existing.warned) {
+ existing.warned = true;
+ // No error code for this since it is a Warning
+ // eslint-disable-next-line no-restricted-syntax
+ var w = new Error('Possible EventEmitter memory leak detected. ' +
+ existing.length + ' ' + String(type) + ' listeners ' +
+ 'added. Use emitter.setMaxListeners() to ' +
+ 'increase limit');
+ w.name = 'MaxListenersExceededWarning';
+ w.emitter = target;
+ w.type = type;
+ w.count = existing.length;
+ ProcessEmitWarning(w);
+ }
+ }
+
+ return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+ return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+ function prependListener(type, listener) {
+ return _addListener(this, type, listener, true);
+ };
+
+function onceWrapper() {
+ if (!this.fired) {
+ this.target.removeListener(this.type, this.wrapFn);
+ this.fired = true;
+ if (arguments.length === 0)
+ return this.listener.call(this.target);
+ return this.listener.apply(this.target, arguments);
+ }
+}
+
+function _onceWrap(target, type, listener) {
+ var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+ var wrapped = onceWrapper.bind(state);
+ wrapped.listener = listener;
+ state.wrapFn = wrapped;
+ return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+ checkListener(listener);
+ this.on(type, _onceWrap(this, type, listener));
+ return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+ function prependOnceListener(type, listener) {
+ checkListener(listener);
+ this.prependListener(type, _onceWrap(this, type, listener));
+ return this;
+ };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+ function removeListener(type, listener) {
+ var list, events, position, i, originalListener;
+
+ checkListener(listener);
+
+ events = this._events;
+ if (events === undefined)
+ return this;
+
+ list = events[type];
+ if (list === undefined)
+ return this;
+
+ if (list === listener || list.listener === listener) {
+ if (--this._eventsCount === 0)
+ this._events = Object.create(null);
+ else {
+ delete events[type];
+ if (events.removeListener)
+ this.emit('removeListener', type, list.listener || listener);
+ }
+ } else if (typeof list !== 'function') {
+ position = -1;
+
+ for (i = list.length - 1; i >= 0; i--) {
+ if (list[i] === listener || list[i].listener === listener) {
+ originalListener = list[i].listener;
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (position === 0)
+ list.shift();
+ else {
+ spliceOne(list, position);
+ }
+
+ if (list.length === 1)
+ events[type] = list[0];
+
+ if (events.removeListener !== undefined)
+ this.emit('removeListener', type, originalListener || listener);
+ }
+
+ return this;
+ };
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners =
+ function removeAllListeners(type) {
+ var listeners, events, i;
+
+ events = this._events;
+ if (events === undefined)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (events.removeListener === undefined) {
+ if (arguments.length === 0) {
+ this._events = Object.create(null);
+ this._eventsCount = 0;
+ } else if (events[type] !== undefined) {
+ if (--this._eventsCount === 0)
+ this._events = Object.create(null);
+ else
+ delete events[type];
+ }
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ var keys = Object.keys(events);
+ var key;
+ for (i = 0; i < keys.length; ++i) {
+ key = keys[i];
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = Object.create(null);
+ this._eventsCount = 0;
+ return this;
+ }
+
+ listeners = events[type];
+
+ if (typeof listeners === 'function') {
+ this.removeListener(type, listeners);
+ } else if (listeners !== undefined) {
+ // LIFO order
+ for (i = listeners.length - 1; i >= 0; i--) {
+ this.removeListener(type, listeners[i]);
+ }
+ }
+
+ return this;
+ };
+
+function _listeners(target, type, unwrap) {
+ var events = target._events;
+
+ if (events === undefined)
+ return [];
+
+ var evlistener = events[type];
+ if (evlistener === undefined)
+ return [];
+
+ if (typeof evlistener === 'function')
+ return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+ return unwrap ?
+ unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+ return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+ return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ if (typeof emitter.listenerCount === 'function') {
+ return emitter.listenerCount(type);
+ } else {
+ return listenerCount.call(emitter, type);
+ }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+ var events = this._events;
+
+ if (events !== undefined) {
+ var evlistener = events[type];
+
+ if (typeof evlistener === 'function') {
+ return 1;
+ } else if (evlistener !== undefined) {
+ return evlistener.length;
+ }
+ }
+
+ return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+ return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+ var copy = new Array(n);
+ for (var i = 0; i < n; ++i)
+ copy[i] = arr[i];
+ return copy;
+}
+
+function spliceOne(list, index) {
+ for (; index + 1 < list.length; index++)
+ list[index] = list[index + 1];
+ list.pop();
+}
+
+function unwrapListeners(arr) {
+ var ret = new Array(arr.length);
+ for (var i = 0; i < ret.length; ++i) {
+ ret[i] = arr[i].listener || arr[i];
+ }
+ return ret;
+}
+
+function once(emitter, name) {
+ return new Promise(function (resolve, reject) {
+ function errorListener(err) {
+ emitter.removeListener(name, resolver);
+ reject(err);
+ }
+
+ function resolver() {
+ if (typeof emitter.removeListener === 'function') {
+ emitter.removeListener('error', errorListener);
+ }
+ resolve([].slice.call(arguments));
+ };
+
+ eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+ if (name !== 'error') {
+ addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+ }
+ });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+ if (typeof emitter.on === 'function') {
+ eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+ }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+ if (typeof emitter.on === 'function') {
+ if (flags.once) {
+ emitter.once(name, listener);
+ } else {
+ emitter.on(name, listener);
+ }
+ } else if (typeof emitter.addEventListener === 'function') {
+ // EventTarget does not have `error` event semantics like Node
+ // EventEmitters, we do not listen for `error` events here.
+ emitter.addEventListener(name, function wrapListener(arg) {
+ // IE does not have builtin `{ once: true }` support so we
+ // have to do it manually.
+ if (flags.once) {
+ emitter.removeEventListener(name, wrapListener);
+ }
+ listener(arg);
+ });
+ } else {
+ throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+ }
+}
+
+
+/***/ }),
+/* 14 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var SafeString = __webpack_require__(2).SafeString;
+
+/**
+ * Returns `true` if the object is a function, otherwise `false`.
+ * @param { any } value
+ * @returns { boolean }
+ */
+function callable(value) {
+ return typeof value === 'function';
+}
+exports.callable = callable;
+
+/**
+ * Returns `true` if the object is strictly not `undefined`.
+ * @param { any } value
+ * @returns { boolean }
+ */
+function defined(value) {
+ return value !== undefined;
+}
+exports.defined = defined;
+
+/**
+ * Returns `true` if the operand (one) is divisble by the test's argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+function divisibleby(one, two) {
+ return one % two === 0;
+}
+exports.divisibleby = divisibleby;
+
+/**
+ * Returns true if the string has been escaped (i.e., is a SafeString).
+ * @param { any } value
+ * @returns { boolean }
+ */
+function escaped(value) {
+ return value instanceof SafeString;
+}
+exports.escaped = escaped;
+
+/**
+ * Returns `true` if the arguments are strictly equal.
+ * @param { any } one
+ * @param { any } two
+ */
+function equalto(one, two) {
+ return one === two;
+}
+exports.equalto = equalto;
+
+// Aliases
+exports.eq = exports.equalto;
+exports.sameas = exports.equalto;
+
+/**
+ * Returns `true` if the value is evenly divisible by 2.
+ * @param { number } value
+ * @returns { boolean }
+ */
+function even(value) {
+ return value % 2 === 0;
+}
+exports.even = even;
+
+/**
+ * Returns `true` if the value is falsy - if I recall correctly, '', 0, false,
+ * undefined, NaN or null. I don't know if we should stick to the default JS
+ * behavior or attempt to replicate what Python believes should be falsy (i.e.,
+ * empty arrays, empty dicts, not 0...).
+ * @param { any } value
+ * @returns { boolean }
+ */
+function falsy(value) {
+ return !value;
+}
+exports.falsy = falsy;
+
+/**
+ * Returns `true` if the operand (one) is greater or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+function ge(one, two) {
+ return one >= two;
+}
+exports.ge = ge;
+
+/**
+ * Returns `true` if the operand (one) is greater than the test's argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+function greaterthan(one, two) {
+ return one > two;
+}
+exports.greaterthan = greaterthan;
+
+// alias
+exports.gt = exports.greaterthan;
+
+/**
+ * Returns `true` if the operand (one) is less than or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+function le(one, two) {
+ return one <= two;
+}
+exports.le = le;
+
+/**
+ * Returns `true` if the operand (one) is less than the test's passed argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+function lessthan(one, two) {
+ return one < two;
+}
+exports.lessthan = lessthan;
+
+// alias
+exports.lt = exports.lessthan;
+
+/**
+ * Returns `true` if the string is lowercased.
+ * @param { string } value
+ * @returns { boolean }
+ */
+function lower(value) {
+ return value.toLowerCase() === value;
+}
+exports.lower = lower;
+
+/**
+ * Returns `true` if the operand (one) is less than or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+function ne(one, two) {
+ return one !== two;
+}
+exports.ne = ne;
+
+/**
+ * Returns true if the value is strictly equal to `null`.
+ * @param { any }
+ * @returns { boolean }
+ */
+function nullTest(value) {
+ return value === null;
+}
+exports.null = nullTest;
+
+/**
+ * Returns true if value is a number.
+ * @param { any }
+ * @returns { boolean }
+ */
+function number(value) {
+ return typeof value === 'number';
+}
+exports.number = number;
+
+/**
+ * Returns `true` if the value is *not* evenly divisible by 2.
+ * @param { number } value
+ * @returns { boolean }
+ */
+function odd(value) {
+ return value % 2 === 1;
+}
+exports.odd = odd;
+
+/**
+ * Returns `true` if the value is a string, `false` if not.
+ * @param { any } value
+ * @returns { boolean }
+ */
+function string(value) {
+ return typeof value === 'string';
+}
+exports.string = string;
+
+/**
+ * Returns `true` if the value is not in the list of things considered falsy:
+ * '', null, undefined, 0, NaN and false.
+ * @param { any } value
+ * @returns { boolean }
+ */
+function truthy(value) {
+ return !!value;
+}
+exports.truthy = truthy;
+
+/**
+ * Returns `true` if the value is undefined.
+ * @param { any } value
+ * @returns { boolean }
+ */
+function undefinedTest(value) {
+ return value === undefined;
+}
+exports.undefined = undefinedTest;
+
+/**
+ * Returns `true` if the string is uppercased.
+ * @param { string } value
+ * @returns { boolean }
+ */
+function upper(value) {
+ return value.toUpperCase() === value;
+}
+exports.upper = upper;
+
+/**
+ * If ES6 features are available, returns `true` if the value implements the
+ * `Symbol.iterator` method. If not, it's a string or Array.
+ *
+ * Could potentially cause issues if a browser exists that has Set and Map but
+ * not Symbol.
+ *
+ * @param { any } value
+ * @returns { boolean }
+ */
+function iterable(value) {
+ if (typeof Symbol !== 'undefined') {
+ return !!value[Symbol.iterator];
+ } else {
+ return Array.isArray(value) || typeof value === 'string';
+ }
+}
+exports.iterable = iterable;
+
+/**
+ * If ES6 features are available, returns `true` if the value is an object hash
+ * or an ES6 Map. Otherwise just return if it's an object hash.
+ * @param { any } value
+ * @returns { boolean }
+ */
+function mapping(value) {
+ // only maps and object hashes
+ var bool = value !== null && value !== undefined && typeof value === 'object' && !Array.isArray(value);
+ if (Set) {
+ return bool && !(value instanceof Set);
+ } else {
+ return bool;
+ }
+}
+exports.mapping = mapping;
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _cycler(items) {
+ var index = -1;
+ return {
+ current: null,
+ reset: function reset() {
+ index = -1;
+ this.current = null;
+ },
+ next: function next() {
+ index++;
+ if (index >= items.length) {
+ index = 0;
+ }
+ this.current = items[index];
+ return this.current;
+ }
+ };
+}
+function _joiner(sep) {
+ sep = sep || ',';
+ var first = true;
+ return function () {
+ var val = first ? '' : sep;
+ first = false;
+ return val;
+ };
+}
+
+// Making this a function instead so it returns a new object
+// each time it's called. That way, if something like an environment
+// uses it, they will each have their own copy.
+function globals() {
+ return {
+ range: function range(start, stop, step) {
+ if (typeof stop === 'undefined') {
+ stop = start;
+ start = 0;
+ step = 1;
+ } else if (!step) {
+ step = 1;
+ }
+ var arr = [];
+ if (step > 0) {
+ for (var i = start; i < stop; i += step) {
+ arr.push(i);
+ }
+ } else {
+ for (var _i = start; _i > stop; _i += step) {
+ // eslint-disable-line for-direction
+ arr.push(_i);
+ }
+ }
+ return arr;
+ },
+ cycler: function cycler() {
+ return _cycler(Array.prototype.slice.call(arguments));
+ },
+ joiner: function joiner(sep) {
+ return _joiner(sep);
+ }
+ };
+}
+module.exports = globals;
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var path = __webpack_require__(0);
+module.exports = function express(env, app) {
+ function NunjucksView(name, opts) {
+ this.name = name;
+ this.path = name;
+ this.defaultEngine = opts.defaultEngine;
+ this.ext = path.extname(name);
+ if (!this.ext && !this.defaultEngine) {
+ throw new Error('No default engine was specified and no extension was provided.');
+ }
+ if (!this.ext) {
+ this.name += this.ext = (this.defaultEngine[0] !== '.' ? '.' : '') + this.defaultEngine;
+ }
+ }
+ NunjucksView.prototype.render = function render(opts, cb) {
+ env.render(this.name, opts, cb);
+ };
+ app.set('view', NunjucksView);
+ app.set('nunjucksEnv', env);
+ return env;
+};
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports, __webpack_require__) {
+
+function installCompat() {
+ 'use strict';
+
+ /* eslint-disable camelcase */
+
+ // This must be called like `nunjucks.installCompat` so that `this`
+ // references the nunjucks instance
+ var runtime = this.runtime;
+ var lib = this.lib;
+ // Handle slim case where these 'modules' are excluded from the built source
+ var Compiler = this.compiler.Compiler;
+ var Parser = this.parser.Parser;
+ var nodes = this.nodes;
+ var lexer = this.lexer;
+ var orig_contextOrFrameLookup = runtime.contextOrFrameLookup;
+ var orig_memberLookup = runtime.memberLookup;
+ var orig_Compiler_assertType;
+ var orig_Parser_parseAggregate;
+ if (Compiler) {
+ orig_Compiler_assertType = Compiler.prototype.assertType;
+ }
+ if (Parser) {
+ orig_Parser_parseAggregate = Parser.prototype.parseAggregate;
+ }
+ function uninstall() {
+ runtime.contextOrFrameLookup = orig_contextOrFrameLookup;
+ runtime.memberLookup = orig_memberLookup;
+ if (Compiler) {
+ Compiler.prototype.assertType = orig_Compiler_assertType;
+ }
+ if (Parser) {
+ Parser.prototype.parseAggregate = orig_Parser_parseAggregate;
+ }
+ }
+ runtime.contextOrFrameLookup = function contextOrFrameLookup(context, frame, key) {
+ var val = orig_contextOrFrameLookup.apply(this, arguments);
+ if (val !== undefined) {
+ return val;
+ }
+ switch (key) {
+ case 'True':
+ return true;
+ case 'False':
+ return false;
+ case 'None':
+ return null;
+ default:
+ return undefined;
+ }
+ };
+ function getTokensState(tokens) {
+ return {
+ index: tokens.index,
+ lineno: tokens.lineno,
+ colno: tokens.colno
+ };
+ }
+ if (false) {
+ // i.e., not slim mode
+ var Slice = nodes.Node.extend('Slice', {
+ fields: ['start', 'stop', 'step'],
+ init: function init(lineno, colno, start, stop, step) {
+ start = start || new nodes.Literal(lineno, colno, null);
+ stop = stop || new nodes.Literal(lineno, colno, null);
+ step = step || new nodes.Literal(lineno, colno, 1);
+ this.parent(lineno, colno, start, stop, step);
+ }
+ });
+ Compiler.prototype.assertType = function assertType(node) {
+ if (node instanceof Slice) {
+ return;
+ }
+ orig_Compiler_assertType.apply(this, arguments);
+ };
+ Compiler.prototype.compileSlice = function compileSlice(node, frame) {
+ this._emit('(');
+ this._compileExpression(node.start, frame);
+ this._emit('),(');
+ this._compileExpression(node.stop, frame);
+ this._emit('),(');
+ this._compileExpression(node.step, frame);
+ this._emit(')');
+ };
+ Parser.prototype.parseAggregate = function parseAggregate() {
+ var _this = this;
+ var origState = getTokensState(this.tokens);
+ // Set back one accounting for opening bracket/parens
+ origState.colno--;
+ origState.index--;
+ try {
+ return orig_Parser_parseAggregate.apply(this);
+ } catch (e) {
+ var errState = getTokensState(this.tokens);
+ var rethrow = function rethrow() {
+ lib._assign(_this.tokens, errState);
+ return e;
+ };
+
+ // Reset to state before original parseAggregate called
+ lib._assign(this.tokens, origState);
+ this.peeked = false;
+ var tok = this.peekToken();
+ if (tok.type !== lexer.TOKEN_LEFT_BRACKET) {
+ throw rethrow();
+ } else {
+ this.nextToken();
+ }
+ var node = new Slice(tok.lineno, tok.colno);
+
+ // If we don't encounter a colon while parsing, this is not a slice,
+ // so re-raise the original exception.
+ var isSlice = false;
+ for (var i = 0; i <= node.fields.length; i++) {
+ if (this.skip(lexer.TOKEN_RIGHT_BRACKET)) {
+ break;
+ }
+ if (i === node.fields.length) {
+ if (isSlice) {
+ this.fail('parseSlice: too many slice components', tok.lineno, tok.colno);
+ } else {
+ break;
+ }
+ }
+ if (this.skip(lexer.TOKEN_COLON)) {
+ isSlice = true;
+ } else {
+ var field = node.fields[i];
+ node[field] = this.parseExpression();
+ isSlice = this.skip(lexer.TOKEN_COLON) || isSlice;
+ }
+ }
+ if (!isSlice) {
+ throw rethrow();
+ }
+ return new nodes.Array(tok.lineno, tok.colno, [node]);
+ }
+ };
+ }
+ function sliceLookup(obj, start, stop, step) {
+ obj = obj || [];
+ if (start === null) {
+ start = step < 0 ? obj.length - 1 : 0;
+ }
+ if (stop === null) {
+ stop = step < 0 ? -1 : obj.length;
+ } else if (stop < 0) {
+ stop += obj.length;
+ }
+ if (start < 0) {
+ start += obj.length;
+ }
+ var results = [];
+ for (var i = start;; i += step) {
+ if (i < 0 || i > obj.length) {
+ break;
+ }
+ if (step > 0 && i >= stop) {
+ break;
+ }
+ if (step < 0 && i <= stop) {
+ break;
+ }
+ results.push(runtime.memberLookup(obj, i));
+ }
+ return results;
+ }
+ function hasOwnProp(obj, key) {
+ return Object.prototype.hasOwnProperty.call(obj, key);
+ }
+ var ARRAY_MEMBERS = {
+ pop: function pop(index) {
+ if (index === undefined) {
+ return this.pop();
+ }
+ if (index >= this.length || index < 0) {
+ throw new Error('KeyError');
+ }
+ return this.splice(index, 1);
+ },
+ append: function append(element) {
+ return this.push(element);
+ },
+ remove: function remove(element) {
+ for (var i = 0; i < this.length; i++) {
+ if (this[i] === element) {
+ return this.splice(i, 1);
+ }
+ }
+ throw new Error('ValueError');
+ },
+ count: function count(element) {
+ var count = 0;
+ for (var i = 0; i < this.length; i++) {
+ if (this[i] === element) {
+ count++;
+ }
+ }
+ return count;
+ },
+ index: function index(element) {
+ var i;
+ if ((i = this.indexOf(element)) === -1) {
+ throw new Error('ValueError');
+ }
+ return i;
+ },
+ find: function find(element) {
+ return this.indexOf(element);
+ },
+ insert: function insert(index, elem) {
+ return this.splice(index, 0, elem);
+ }
+ };
+ var OBJECT_MEMBERS = {
+ items: function items() {
+ return lib._entries(this);
+ },
+ values: function values() {
+ return lib._values(this);
+ },
+ keys: function keys() {
+ return lib.keys(this);
+ },
+ get: function get(key, def) {
+ var output = this[key];
+ if (output === undefined) {
+ output = def;
+ }
+ return output;
+ },
+ has_key: function has_key(key) {
+ return hasOwnProp(this, key);
+ },
+ pop: function pop(key, def) {
+ var output = this[key];
+ if (output === undefined && def !== undefined) {
+ output = def;
+ } else if (output === undefined) {
+ throw new Error('KeyError');
+ } else {
+ delete this[key];
+ }
+ return output;
+ },
+ popitem: function popitem() {
+ var keys = lib.keys(this);
+ if (!keys.length) {
+ throw new Error('KeyError');
+ }
+ var k = keys[0];
+ var val = this[k];
+ delete this[k];
+ return [k, val];
+ },
+ setdefault: function setdefault(key, def) {
+ if (def === void 0) {
+ def = null;
+ }
+ if (!(key in this)) {
+ this[key] = def;
+ }
+ return this[key];
+ },
+ update: function update(kwargs) {
+ lib._assign(this, kwargs);
+ return null; // Always returns None
+ }
+ };
+
+ OBJECT_MEMBERS.iteritems = OBJECT_MEMBERS.items;
+ OBJECT_MEMBERS.itervalues = OBJECT_MEMBERS.values;
+ OBJECT_MEMBERS.iterkeys = OBJECT_MEMBERS.keys;
+ runtime.memberLookup = function memberLookup(obj, val, autoescape) {
+ if (arguments.length === 4) {
+ return sliceLookup.apply(this, arguments);
+ }
+ obj = obj || {};
+
+ // If the object is an object, return any of the methods that Python would
+ // otherwise provide.
+ if (lib.isArray(obj) && hasOwnProp(ARRAY_MEMBERS, val)) {
+ return ARRAY_MEMBERS[val].bind(obj);
+ }
+ if (lib.isObject(obj) && hasOwnProp(OBJECT_MEMBERS, val)) {
+ return OBJECT_MEMBERS[val].bind(obj);
+ }
+ return orig_memberLookup.apply(this, arguments);
+ };
+ return uninstall;
+}
+module.exports = installCompat;
+
+/***/ })
+/******/ ]);
+});
+//# sourceMappingURL=nunjucks-slim.js.map \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-14 02:54:31 +0000