2633 lines
73 KiB
JavaScript
2633 lines
73 KiB
JavaScript
|
/*! Browser bundle of nunjucks 2.3.0 (slim, only works with precompiled templates) */
|
|||
|
|
var nunjucks =
|
|||
|
|
/******/ (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] = {
|
|||
|
|
/******/ exports: {},
|
|||
|
|
/******/ id: moduleId,
|
|||
|
|
/******/ loaded: false
|
|||
|
|
/******/ };
|
|||
|
|
|
|||
|
|
/******/ // Execute the module function
|
|||
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|||
|
|
|
|||
|
|
/******/ // Flag the module as loaded
|
|||
|
|
/******/ module.loaded = 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;
|
|||
|
|
|
|||
|
|
/******/ // __webpack_public_path__
|
|||
|
|
/******/ __webpack_require__.p = "";
|
|||
|
|
|
|||
|
|
/******/ // Load entry module and return exports
|
|||
|
|
/******/ return __webpack_require__(0);
|
|||
|
|
/******/ })
|
|||
|
|
/************************************************************************/
|
|||
|
|
/******/ ([
|
|||
|
|
/* 0 */
|
|||
|
|
/***/ function(module, exports, __webpack_require__) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
var lib = __webpack_require__(1);
|
|||
|
|
var env = __webpack_require__(2);
|
|||
|
|
var Loader = __webpack_require__(11);
|
|||
|
|
var loaders = __webpack_require__(3);
|
|||
|
|
var precompile = __webpack_require__(3);
|
|||
|
|
|
|||
|
|
module.exports = {};
|
|||
|
|
module.exports.Environment = env.Environment;
|
|||
|
|
module.exports.Template = env.Template;
|
|||
|
|
|
|||
|
|
module.exports.Loader = Loader;
|
|||
|
|
module.exports.FileSystemLoader = loaders.FileSystemLoader;
|
|||
|
|
module.exports.PrecompiledLoader = loaders.PrecompiledLoader;
|
|||
|
|
module.exports.WebLoader = loaders.WebLoader;
|
|||
|
|
|
|||
|
|
module.exports.compiler = __webpack_require__(3);
|
|||
|
|
module.exports.parser = __webpack_require__(3);
|
|||
|
|
module.exports.lexer = __webpack_require__(3);
|
|||
|
|
module.exports.runtime = __webpack_require__(8);
|
|||
|
|
module.exports.lib = lib;
|
|||
|
|
module.exports.nodes = __webpack_require__(3);
|
|||
|
|
|
|||
|
|
module.exports.installJinjaCompat = __webpack_require__(12);
|
|||
|
|
|
|||
|
|
// A single instance of an environment, since this is so commonly used
|
|||
|
|
|
|||
|
|
var e;
|
|||
|
|
module.exports.configure = function(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 env.Environment(TemplateLoader, opts);
|
|||
|
|
|
|||
|
|
if(opts && opts.express) {
|
|||
|
|
e.express(opts.express);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return e;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports.compile = function(src, env, path, eagerCompile) {
|
|||
|
|
if(!e) {
|
|||
|
|
module.exports.configure();
|
|||
|
|
}
|
|||
|
|
return new module.exports.Template(src, env, path, eagerCompile);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports.render = function(name, ctx, cb) {
|
|||
|
|
if(!e) {
|
|||
|
|
module.exports.configure();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return e.render(name, ctx, cb);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports.renderString = function(src, ctx, cb) {
|
|||
|
|
if(!e) {
|
|||
|
|
module.exports.configure();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return e.renderString(src, ctx, cb);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
if(precompile) {
|
|||
|
|
module.exports.precompile = precompile.precompile;
|
|||
|
|
module.exports.precompileString = precompile.precompileString;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 1 */
|
|||
|
|
/***/ function(module, exports) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
var ArrayProto = Array.prototype;
|
|||
|
|
var ObjProto = Object.prototype;
|
|||
|
|
|
|||
|
|
var escapeMap = {
|
|||
|
|
'&': '&',
|
|||
|
|
'"': '"',
|
|||
|
|
'\'': ''',
|
|||
|
|
'<': '<',
|
|||
|
|
'>': '>'
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var escapeRegex = /[&"'<>]/g;
|
|||
|
|
|
|||
|
|
var lookupEscape = function(ch) {
|
|||
|
|
return escapeMap[ch];
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var exports = module.exports = {};
|
|||
|
|
|
|||
|
|
exports.prettifyError = function(path, withInternals, err) {
|
|||
|
|
// jshint -W022
|
|||
|
|
// http://jslinterrors.com/do-not-assign-to-the-exception-parameter
|
|||
|
|
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.TemplateError = function(message, lineno, colno) {
|
|||
|
|
var err = this;
|
|||
|
|
|
|||
|
|
if (message instanceof Error) { // for casting regular js errors
|
|||
|
|
err = message;
|
|||
|
|
message = message.name + ': ' + message.message;
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
if(err.name = '') {}
|
|||
|
|
}
|
|||
|
|
catch(e) {
|
|||
|
|
// If we can't set the name of the error object in this
|
|||
|
|
// environment, don't use it
|
|||
|
|
err = this;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
if(Error.captureStackTrace) {
|
|||
|
|
Error.captureStackTrace(err);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
err.name = 'Template render error';
|
|||
|
|
err.message = message;
|
|||
|
|
err.lineno = lineno;
|
|||
|
|
err.colno = colno;
|
|||
|
|
err.firstUpdate = true;
|
|||
|
|
|
|||
|
|
err.Update = function(path) {
|
|||
|
|
var message = '(' + (path || 'unknown path') + ')';
|
|||
|
|
|
|||
|
|
// only show lineno + colno next to path of template
|
|||
|
|
// where error occurred
|
|||
|
|
if (this.firstUpdate) {
|
|||
|
|
if(this.lineno && this.colno) {
|
|||
|
|
message += ' [Line ' + this.lineno + ', Column ' + this.colno + ']';
|
|||
|
|
}
|
|||
|
|
else if(this.lineno) {
|
|||
|
|
message += ' [Line ' + this.lineno + ']';
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
message += '\n ';
|
|||
|
|
if (this.firstUpdate) {
|
|||
|
|
message += ' ';
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.message = message + (this.message || '');
|
|||
|
|
this.firstUpdate = false;
|
|||
|
|
return this;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
return err;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.TemplateError.prototype = Error.prototype;
|
|||
|
|
|
|||
|
|
exports.escape = function(val) {
|
|||
|
|
return val.replace(escapeRegex, lookupEscape);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.isFunction = function(obj) {
|
|||
|
|
return ObjProto.toString.call(obj) === '[object Function]';
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.isArray = Array.isArray || function(obj) {
|
|||
|
|
return ObjProto.toString.call(obj) === '[object Array]';
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.isString = function(obj) {
|
|||
|
|
return ObjProto.toString.call(obj) === '[object String]';
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.isObject = function(obj) {
|
|||
|
|
return ObjProto.toString.call(obj) === '[object Object]';
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.groupBy = function(obj, val) {
|
|||
|
|
var result = {};
|
|||
|
|
var iterator = exports.isFunction(val) ? val : function(obj) { return obj[val]; };
|
|||
|
|
for(var i=0; i<obj.length; i++) {
|
|||
|
|
var value = obj[i];
|
|||
|
|
var key = iterator(value, i);
|
|||
|
|
(result[key] || (result[key] = [])).push(value);
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.toArray = function(obj) {
|
|||
|
|
return Array.prototype.slice.call(obj);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.without = function(array) {
|
|||
|
|
var result = [];
|
|||
|
|
if (!array) {
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
var index = -1,
|
|||
|
|
length = array.length,
|
|||
|
|
contains = exports.toArray(arguments).slice(1);
|
|||
|
|
|
|||
|
|
while(++index < length) {
|
|||
|
|
if(exports.indexOf(contains, array[index]) === -1) {
|
|||
|
|
result.push(array[index]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.extend = function(obj, obj2) {
|
|||
|
|
for(var k in obj2) {
|
|||
|
|
obj[k] = obj2[k];
|
|||
|
|
}
|
|||
|
|
return obj;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.repeat = function(char_, n) {
|
|||
|
|
var str = '';
|
|||
|
|
for(var i=0; i<n; i++) {
|
|||
|
|
str += char_;
|
|||
|
|
}
|
|||
|
|
return str;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.each = function(obj, func, context) {
|
|||
|
|
if(obj == null) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(ArrayProto.each && obj.each === ArrayProto.each) {
|
|||
|
|
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.map = function(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.asyncIter = function(arr, iter, cb) {
|
|||
|
|
var i = -1;
|
|||
|
|
|
|||
|
|
function next() {
|
|||
|
|
i++;
|
|||
|
|
|
|||
|
|
if(i < arr.length) {
|
|||
|
|
iter(arr[i], i, next, cb);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
cb();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
next();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
exports.asyncFor = function(obj, iter, cb) {
|
|||
|
|
var keys = exports.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();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf#Polyfill
|
|||
|
|
exports.indexOf = Array.prototype.indexOf ?
|
|||
|
|
function (arr, searchElement, fromIndex) {
|
|||
|
|
return Array.prototype.indexOf.call(arr, searchElement, fromIndex);
|
|||
|
|
} :
|
|||
|
|
function (arr, searchElement, fromIndex) {
|
|||
|
|
var length = this.length >>> 0; // Hack to convert object.length to a UInt32
|
|||
|
|
|
|||
|
|
fromIndex = +fromIndex || 0;
|
|||
|
|
|
|||
|
|
if(Math.abs(fromIndex) === Infinity) {
|
|||
|
|
fromIndex = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(fromIndex < 0) {
|
|||
|
|
fromIndex += length;
|
|||
|
|
if (fromIndex < 0) {
|
|||
|
|
fromIndex = 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for(;fromIndex < length; fromIndex++) {
|
|||
|
|
if (arr[fromIndex] === searchElement) {
|
|||
|
|
return fromIndex;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return -1;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
if(!Array.prototype.map) {
|
|||
|
|
Array.prototype.map = function() {
|
|||
|
|
throw new Error('map is unimplemented for this js engine');
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
exports.keys = function(obj) {
|
|||
|
|
if(Object.prototype.keys) {
|
|||
|
|
return obj.keys();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
var keys = [];
|
|||
|
|
for(var k in obj) {
|
|||
|
|
if(obj.hasOwnProperty(k)) {
|
|||
|
|
keys.push(k);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return keys;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 2 */
|
|||
|
|
/***/ function(module, exports, __webpack_require__) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
var path = __webpack_require__(3);
|
|||
|
|
var asap = __webpack_require__(4);
|
|||
|
|
var lib = __webpack_require__(1);
|
|||
|
|
var Obj = __webpack_require__(6);
|
|||
|
|
var compiler = __webpack_require__(3);
|
|||
|
|
var builtin_filters = __webpack_require__(7);
|
|||
|
|
var builtin_loaders = __webpack_require__(3);
|
|||
|
|
var runtime = __webpack_require__(8);
|
|||
|
|
var globals = __webpack_require__(9);
|
|||
|
|
var Frame = runtime.Frame;
|
|||
|
|
var Template;
|
|||
|
|
|
|||
|
|
// Unconditionally load in this loader, even if no other ones are
|
|||
|
|
// included (possible in the slim browser build)
|
|||
|
|
builtin_loaders.PrecompiledLoader = __webpack_require__(10);
|
|||
|
|
|
|||
|
|
// 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); });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var Environment = Obj.extend({
|
|||
|
|
init: function(loaders, opts) {
|
|||
|
|
// 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(builtin_loaders.FileSystemLoader) {
|
|||
|
|
this.loaders = [new builtin_loaders.FileSystemLoader('views')];
|
|||
|
|
}
|
|||
|
|
else if(builtin_loaders.WebLoader) {
|
|||
|
|
this.loaders = [new builtin_loaders.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((true) && window.nunjucksPrecompiled) {
|
|||
|
|
this.loaders.unshift(
|
|||
|
|
new builtin_loaders.PrecompiledLoader(window.nunjucksPrecompiled)
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.initCache();
|
|||
|
|
|
|||
|
|
this.globals = globals();
|
|||
|
|
this.filters = {};
|
|||
|
|
this.asyncFilters = [];
|
|||
|
|
this.extensions = {};
|
|||
|
|
this.extensionsList = [];
|
|||
|
|
|
|||
|
|
for(var name in builtin_filters) {
|
|||
|
|
this.addFilter(name, builtin_filters[name]);
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
initCache: function() {
|
|||
|
|
// Caching and cache busting
|
|||
|
|
lib.each(this.loaders, function(loader) {
|
|||
|
|
loader.cache = {};
|
|||
|
|
|
|||
|
|
if(typeof loader.on === 'function') {
|
|||
|
|
loader.on('update', function(template) {
|
|||
|
|
loader.cache[template] = null;
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addExtension: function(name, extension) {
|
|||
|
|
extension._name = name;
|
|||
|
|
this.extensions[name] = extension;
|
|||
|
|
this.extensionsList.push(extension);
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
removeExtension: function(name) {
|
|||
|
|
var extension = this.getExtension(name);
|
|||
|
|
if (!extension) return;
|
|||
|
|
|
|||
|
|
this.extensionsList = lib.without(this.extensionsList, extension);
|
|||
|
|
delete this.extensions[name];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getExtension: function(name) {
|
|||
|
|
return this.extensions[name];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
hasExtension: function(name) {
|
|||
|
|
return !!this.extensions[name];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addGlobal: function(name, value) {
|
|||
|
|
this.globals[name] = value;
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getGlobal: function(name) {
|
|||
|
|
if(!this.globals[name]) {
|
|||
|
|
throw new Error('global not found: ' + name);
|
|||
|
|
}
|
|||
|
|
return this.globals[name];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addFilter: function(name, func, async) {
|
|||
|
|
var wrapped = func;
|
|||
|
|
|
|||
|
|
if(async) {
|
|||
|
|
this.asyncFilters.push(name);
|
|||
|
|
}
|
|||
|
|
this.filters[name] = wrapped;
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getFilter: function(name) {
|
|||
|
|
if(!this.filters[name]) {
|
|||
|
|
throw new Error('filter not found: ' + name);
|
|||
|
|
}
|
|||
|
|
return this.filters[name];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
resolveTemplate: function(loader, parentName, filename) {
|
|||
|
|
var isRelative = (loader.isRelative && parentName)? loader.isRelative(filename) : false;
|
|||
|
|
return (isRelative && loader.resolve)? loader.resolve(parentName, filename) : filename;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getTemplate: function(name, eagerCompile, parentName, ignoreMissing, cb) {
|
|||
|
|
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 _name = this.resolveTemplate(this.loaders[i], parentName, name);
|
|||
|
|
tmpl = this.loaders[i].cache[_name];
|
|||
|
|
if (tmpl) break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(tmpl) {
|
|||
|
|
if(eagerCompile) {
|
|||
|
|
tmpl.compile();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(cb) {
|
|||
|
|
cb(null, tmpl);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
return tmpl;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
var syncResult;
|
|||
|
|
var _this = this;
|
|||
|
|
|
|||
|
|
var createTemplate = function(err, info) {
|
|||
|
|
if(!info && !err) {
|
|||
|
|
if(!ignoreMissing) {
|
|||
|
|
err = new Error('template not found: ' + name);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (err) {
|
|||
|
|
if(cb) {
|
|||
|
|
cb(err);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
throw err;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
var tmpl;
|
|||
|
|
if(info) {
|
|||
|
|
tmpl = new Template(info.src, _this,
|
|||
|
|
info.path, eagerCompile);
|
|||
|
|
|
|||
|
|
if(!info.noCache) {
|
|||
|
|
info.loader.cache[name] = tmpl;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
tmpl = new Template('', _this,
|
|||
|
|
'', eagerCompile);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(cb) {
|
|||
|
|
cb(null, tmpl);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
syncResult = tmpl;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
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;
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
express: function(app) {
|
|||
|
|
var env = this;
|
|||
|
|
|
|||
|
|
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(opts, cb) {
|
|||
|
|
env.render(this.name, opts, cb);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
app.set('view', NunjucksView);
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
render: function(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;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
renderString: function(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);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
var Context = Obj.extend({
|
|||
|
|
init: function(ctx, blocks, env) {
|
|||
|
|
// 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 = {};
|
|||
|
|
for(var k in ctx) {
|
|||
|
|
if(ctx.hasOwnProperty(k)) {
|
|||
|
|
this.ctx[k] = ctx[k];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.blocks = {};
|
|||
|
|
this.exported = [];
|
|||
|
|
|
|||
|
|
for(var name in blocks) {
|
|||
|
|
this.addBlock(name, blocks[name]);
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
lookup: function(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];
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
setVariable: function(name, val) {
|
|||
|
|
this.ctx[name] = val;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getVariables: function() {
|
|||
|
|
return this.ctx;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addBlock: function(name, block) {
|
|||
|
|
this.blocks[name] = this.blocks[name] || [];
|
|||
|
|
this.blocks[name].push(block);
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getBlock: function(name) {
|
|||
|
|
if(!this.blocks[name]) {
|
|||
|
|
throw new Error('unknown block "' + name + '"');
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.blocks[name][0];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getSuper: function(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);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addExport: function(name) {
|
|||
|
|
this.exported.push(name);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getExported: function() {
|
|||
|
|
var exported = {};
|
|||
|
|
for(var i=0; i<this.exported.length; i++) {
|
|||
|
|
var name = this.exported[i];
|
|||
|
|
exported[name] = this.ctx[name];
|
|||
|
|
}
|
|||
|
|
return exported;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
Template = Obj.extend({
|
|||
|
|
init: function (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;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
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) {
|
|||
|
|
var _this = this;
|
|||
|
|
try {
|
|||
|
|
_this._compile();
|
|||
|
|
}
|
|||
|
|
catch(err) {
|
|||
|
|
throw lib.prettifyError(this.path, this.env.dev, err);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
this.compiled = false;
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
render: function(ctx, parentFrame, cb) {
|
|||
|
|
if (typeof ctx === 'function') {
|
|||
|
|
cb = ctx;
|
|||
|
|
ctx = {};
|
|||
|
|
}
|
|||
|
|
else if (typeof parentFrame === 'function') {
|
|||
|
|
cb = parentFrame;
|
|||
|
|
parentFrame = null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var forceAsync = true;
|
|||
|
|
if(parentFrame) {
|
|||
|
|
// If there is a 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
|
|||
|
|
forceAsync = false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var _this = this;
|
|||
|
|
// Catch compile errors for async rendering
|
|||
|
|
try {
|
|||
|
|
_this.compile();
|
|||
|
|
} catch (_err) {
|
|||
|
|
var err = lib.prettifyError(this.path, this.env.dev, _err);
|
|||
|
|
if (cb) return callbackAsap(cb, err);
|
|||
|
|
else throw err;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var context = new Context(ctx || {}, _this.blocks, _this.env);
|
|||
|
|
var frame = parentFrame ? parentFrame.push() : new Frame();
|
|||
|
|
frame.topLevel = true;
|
|||
|
|
var syncResult = null;
|
|||
|
|
|
|||
|
|
_this.rootRenderFunc(
|
|||
|
|
_this.env,
|
|||
|
|
context,
|
|||
|
|
frame || new Frame(),
|
|||
|
|
runtime,
|
|||
|
|
function(err, res) {
|
|||
|
|
if(err) {
|
|||
|
|
err = lib.prettifyError(_this.path, _this.env.dev, err);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(cb) {
|
|||
|
|
if(forceAsync) {
|
|||
|
|
callbackAsap(cb, err, res);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
cb(err, res);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
if(err) { throw err; }
|
|||
|
|
syncResult = res;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
return syncResult;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
|
|||
|
|
getExported: function(ctx, parentFrame, cb) {
|
|||
|
|
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,
|
|||
|
|
runtime,
|
|||
|
|
function(err) {
|
|||
|
|
if ( err ) {
|
|||
|
|
cb(err, null);
|
|||
|
|
} else {
|
|||
|
|
cb(null, context.getExported());
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
compile: function() {
|
|||
|
|
if(!this.compiled) {
|
|||
|
|
this._compile();
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
_compile: function() {
|
|||
|
|
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);
|
|||
|
|
|
|||
|
|
/* jslint evil: true */
|
|||
|
|
var func = new Function(source);
|
|||
|
|
props = func();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.blocks = this._getBlocks(props);
|
|||
|
|
this.rootRenderFunc = props.root;
|
|||
|
|
this.compiled = true;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
_getBlocks: function(props) {
|
|||
|
|
var blocks = {};
|
|||
|
|
|
|||
|
|
for(var k in props) {
|
|||
|
|
if(k.slice(0, 2) === 'b_') {
|
|||
|
|
blocks[k.slice(2)] = props[k];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return blocks;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
module.exports = {
|
|||
|
|
Environment: Environment,
|
|||
|
|
Template: Template
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 3 */
|
|||
|
|
/***/ function(module, exports) {
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 4 */
|
|||
|
|
/***/ function(module, exports, __webpack_require__) {
|
|||
|
|
|
|||
|
|
"use strict";
|
|||
|
|
|
|||
|
|
// rawAsap provides everything we need except exception management.
|
|||
|
|
var rawAsap = __webpack_require__(5);
|
|||
|
|
// 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;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 5 */
|
|||
|
|
/***/ function(module, exports) {
|
|||
|
|
|
|||
|
|
/* WEBPACK VAR INJECTION */(function(global) {"use strict";
|
|||
|
|
|
|||
|
|
// 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` instead of `window` to work in both frames and web
|
|||
|
|
// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.
|
|||
|
|
var BrowserMutationObserver = global.MutationObserver || global.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, (function() { return this; }())))
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 6 */
|
|||
|
|
/***/ function(module, exports) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
// A simple class system, more documentation to come
|
|||
|
|
|
|||
|
|
function extend(cls, name, props) {
|
|||
|
|
// This does that same thing as Object.create, but with support for IE8
|
|||
|
|
var F = function() {};
|
|||
|
|
F.prototype = cls.prototype;
|
|||
|
|
var prototype = new F();
|
|||
|
|
|
|||
|
|
// jshint undef: false
|
|||
|
|
var fnTest = /xyz/.test(function(){ xyz; }) ? /\bparent\b/ : /.*/;
|
|||
|
|
props = props || {};
|
|||
|
|
|
|||
|
|
for(var k in props) {
|
|||
|
|
var src = props[k];
|
|||
|
|
var parent = prototype[k];
|
|||
|
|
|
|||
|
|
if(typeof parent === 'function' &&
|
|||
|
|
typeof src === 'function' &&
|
|||
|
|
fnTest.test(src)) {
|
|||
|
|
/*jshint -W083 */
|
|||
|
|
prototype[k] = (function (src, parent) {
|
|||
|
|
return function() {
|
|||
|
|
// Save the current parent method
|
|||
|
|
var tmp = this.parent;
|
|||
|
|
|
|||
|
|
// Set parent to the previous method, call, and restore
|
|||
|
|
this.parent = parent;
|
|||
|
|
var res = src.apply(this, arguments);
|
|||
|
|
this.parent = tmp;
|
|||
|
|
|
|||
|
|
return res;
|
|||
|
|
};
|
|||
|
|
})(src, parent);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
prototype[k] = src;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
prototype.typename = name;
|
|||
|
|
|
|||
|
|
var new_cls = function() {
|
|||
|
|
if(prototype.init) {
|
|||
|
|
prototype.init.apply(this, arguments);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
new_cls.prototype = prototype;
|
|||
|
|
new_cls.prototype.constructor = new_cls;
|
|||
|
|
|
|||
|
|
new_cls.extend = function(name, props) {
|
|||
|
|
if(typeof name === 'object') {
|
|||
|
|
props = name;
|
|||
|
|
name = 'anonymous';
|
|||
|
|
}
|
|||
|
|
return extend(new_cls, name, props);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
return new_cls;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
module.exports = extend(Object, 'Object', {});
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 7 */
|
|||
|
|
/***/ function(module, exports, __webpack_require__) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
var lib = __webpack_require__(1);
|
|||
|
|
var r = __webpack_require__(8);
|
|||
|
|
|
|||
|
|
function normalize(value, defaultValue) {
|
|||
|
|
if(value === null || value === undefined || value === false) {
|
|||
|
|
return defaultValue;
|
|||
|
|
}
|
|||
|
|
return value;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var filters = {
|
|||
|
|
abs: function(n) {
|
|||
|
|
return Math.abs(n);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
batch: function(arr, linecount, fill_with) {
|
|||
|
|
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(fill_with) {
|
|||
|
|
for(i = tmp.length; i < linecount; i++) {
|
|||
|
|
tmp.push(fill_with);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
res.push(tmp);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return res;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
capitalize: function(str) {
|
|||
|
|
str = normalize(str, '');
|
|||
|
|
var ret = str.toLowerCase();
|
|||
|
|
return r.copySafeness(str, ret.charAt(0).toUpperCase() + ret.slice(1));
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
center: function(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);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
'default': function(val, def, bool) {
|
|||
|
|
if(bool) {
|
|||
|
|
return val ? val : def;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
return (val !== undefined) ? val : def;
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
dictsort: function(val, case_sensitive, by) {
|
|||
|
|
if (!lib.isObject(val)) {
|
|||
|
|
throw new lib.TemplateError('dictsort filter: val must be an object');
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var array = [];
|
|||
|
|
for (var k in val) {
|
|||
|
|
// deliberately include properties from the object's prototype
|
|||
|
|
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 (!case_sensitive) {
|
|||
|
|
if (lib.isString(a)) {
|
|||
|
|
a = a.toUpperCase();
|
|||
|
|
}
|
|||
|
|
if (lib.isString(b)) {
|
|||
|
|
b = b.toUpperCase();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return a > b ? 1 : (a === b ? 0 : -1);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return array;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
dump: function(obj) {
|
|||
|
|
return JSON.stringify(obj);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
escape: function(str) {
|
|||
|
|
if(typeof str === 'string' ||
|
|||
|
|
str instanceof r.SafeString) {
|
|||
|
|
return lib.escape(str);
|
|||
|
|
}
|
|||
|
|
return str;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
safe: function(str) {
|
|||
|
|
return r.markSafe(str);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
first: function(arr) {
|
|||
|
|
return arr[0];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
groupby: function(arr, attr) {
|
|||
|
|
return lib.groupBy(arr, attr);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
indent: function(str, width, indentfirst) {
|
|||
|
|
str = normalize(str, '');
|
|||
|
|
|
|||
|
|
if (str === '') return '';
|
|||
|
|
|
|||
|
|
width = width || 4;
|
|||
|
|
var res = '';
|
|||
|
|
var lines = str.split('\n');
|
|||
|
|
var sp = lib.repeat(' ', width);
|
|||
|
|
|
|||
|
|
for(var i=0; i<lines.length; i++) {
|
|||
|
|
if(i === 0 && !indentfirst) {
|
|||
|
|
res += lines[i] + '\n';
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
res += sp + lines[i] + '\n';
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return r.copySafeness(str, res);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
join: function(arr, del, attr) {
|
|||
|
|
del = del || '';
|
|||
|
|
|
|||
|
|
if(attr) {
|
|||
|
|
arr = lib.map(arr, function(v) {
|
|||
|
|
return v[attr];
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return arr.join(del);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
last: function(arr) {
|
|||
|
|
return arr[arr.length-1];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
length: function(val) {
|
|||
|
|
var value = normalize(val, '');
|
|||
|
|
|
|||
|
|
return value !== undefined ? value.length : 0;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
list: function(val) {
|
|||
|
|
if(lib.isString(val)) {
|
|||
|
|
return val.split('');
|
|||
|
|
}
|
|||
|
|
else if(lib.isObject(val)) {
|
|||
|
|
var keys = [];
|
|||
|
|
|
|||
|
|
if(Object.keys) {
|
|||
|
|
keys = Object.keys(val);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
for(var k in val) {
|
|||
|
|
keys.push(k);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return lib.map(keys, function(k) {
|
|||
|
|
return { key: k,
|
|||
|
|
value: val[k] };
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
else if(lib.isArray(val)) {
|
|||
|
|
return val;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
throw new lib.TemplateError('list filter: type not iterable');
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
lower: function(str) {
|
|||
|
|
str = normalize(str, '');
|
|||
|
|
return str.toLowerCase();
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
random: function(arr) {
|
|||
|
|
return arr[Math.floor(Math.random() * arr.length)];
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
rejectattr: function(arr, attr) {
|
|||
|
|
return arr.filter(function (item) {
|
|||
|
|
return !item[attr];
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
selectattr: function(arr, attr) {
|
|||
|
|
return arr.filter(function (item) {
|
|||
|
|
return !!item[attr];
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
replace: function(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);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
reverse: function(val) {
|
|||
|
|
var arr;
|
|||
|
|
if(lib.isString(val)) {
|
|||
|
|
arr = filters.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;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
round: function(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;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
slice: function(arr, slices, fillWith) {
|
|||
|
|
var sliceLength = Math.floor(arr.length / slices);
|
|||
|
|
var extra = arr.length % slices;
|
|||
|
|
var offset = 0;
|
|||
|
|
var res = [];
|
|||
|
|
|
|||
|
|
for(var i=0; i<slices; i++) {
|
|||
|
|
var start = offset + i * sliceLength;
|
|||
|
|
if(i < extra) {
|
|||
|
|
offset++;
|
|||
|
|
}
|
|||
|
|
var end = offset + (i + 1) * sliceLength;
|
|||
|
|
|
|||
|
|
var slice = arr.slice(start, end);
|
|||
|
|
if(fillWith && i >= extra) {
|
|||
|
|
slice.push(fillWith);
|
|||
|
|
}
|
|||
|
|
res.push(slice);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return res;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
sort: r.makeMacro(['value', 'reverse', 'case_sensitive', 'attribute'], [], function(arr, reverse, caseSens, attr) {
|
|||
|
|
// Copy it
|
|||
|
|
arr = lib.map(arr, function(v) { return v; });
|
|||
|
|
|
|||
|
|
arr.sort(function(a, b) {
|
|||
|
|
var x, y;
|
|||
|
|
|
|||
|
|
if(attr) {
|
|||
|
|
x = a[attr];
|
|||
|
|
y = b[attr];
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
x = a;
|
|||
|
|
y = b;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(!caseSens && lib.isString(x) && lib.isString(y)) {
|
|||
|
|
x = x.toLowerCase();
|
|||
|
|
y = y.toLowerCase();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(x < y) {
|
|||
|
|
return reverse ? 1 : -1;
|
|||
|
|
}
|
|||
|
|
else if(x > y) {
|
|||
|
|
return reverse ? -1: 1;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return arr;
|
|||
|
|
}),
|
|||
|
|
|
|||
|
|
string: function(obj) {
|
|||
|
|
return r.copySafeness(obj, obj);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
striptags: function(input, preserve_linebreaks) {
|
|||
|
|
input = normalize(input, '');
|
|||
|
|
preserve_linebreaks = preserve_linebreaks || false;
|
|||
|
|
var tags = /<\/?([a-z][a-z0-9]*)\b[^>]*>|<!--[\s\S]*?-->/gi;
|
|||
|
|
var trimmedInput = filters.trim(input.replace(tags, ''));
|
|||
|
|
var res = '';
|
|||
|
|
if (preserve_linebreaks) {
|
|||
|
|
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);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
title: function(str) {
|
|||
|
|
str = normalize(str, '');
|
|||
|
|
var words = str.split(' ');
|
|||
|
|
for(var i = 0; i < words.length; i++) {
|
|||
|
|
words[i] = filters.capitalize(words[i]);
|
|||
|
|
}
|
|||
|
|
return r.copySafeness(str, words.join(' '));
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
trim: function(str) {
|
|||
|
|
return r.copySafeness(str, str.replace(/^\s*|\s*$/g, ''));
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
truncate: function(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);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
upper: function(str) {
|
|||
|
|
str = normalize(str, '');
|
|||
|
|
return str.toUpperCase();
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
urlencode: function(obj) {
|
|||
|
|
var enc = encodeURIComponent;
|
|||
|
|
if (lib.isString(obj)) {
|
|||
|
|
return enc(obj);
|
|||
|
|
} else {
|
|||
|
|
var parts;
|
|||
|
|
if (lib.isArray(obj)) {
|
|||
|
|
parts = obj.map(function(item) {
|
|||
|
|
return enc(item[0]) + '=' + enc(item[1]);
|
|||
|
|
});
|
|||
|
|
} else {
|
|||
|
|
parts = [];
|
|||
|
|
for (var k in obj) {
|
|||
|
|
if (obj.hasOwnProperty(k)) {
|
|||
|
|
parts.push(enc(k) + '=' + enc(obj[k]));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return parts.join('&');
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
urlize: function(str, length, nofollow) {
|
|||
|
|
if (isNaN(length)) length = Infinity;
|
|||
|
|
|
|||
|
|
var noFollowAttr = (nofollow === true ? ' rel="nofollow"' : '');
|
|||
|
|
|
|||
|
|
// For the jinja regexp, see
|
|||
|
|
// https://github.com/mitsuhiko/jinja2/blob/f15b814dcba6aa12bc74d1f7d0c881d55f7126be/jinja2/utils.py#L20-L23
|
|||
|
|
var puncRE = /^(?:\(|<|<)?(.*?)(?:\.|,|\)|\n|>)?$/;
|
|||
|
|
// 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)(?:\:|\/|$)/;
|
|||
|
|
|
|||
|
|
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;
|
|||
|
|
|
|||
|
|
// url that starts with http or https
|
|||
|
|
if (httpHttpsRE.test(possibleUrl))
|
|||
|
|
return '<a href="' + possibleUrl + '"' + noFollowAttr + '>' + possibleUrl.substr(0, length) + '</a>';
|
|||
|
|
|
|||
|
|
// url that starts with www.
|
|||
|
|
if (wwwRE.test(possibleUrl))
|
|||
|
|
return '<a href="http://' + possibleUrl + '"' + noFollowAttr + '>' + possibleUrl.substr(0, length) + '</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 + '>' + possibleUrl.substr(0, length) + '</a>';
|
|||
|
|
|
|||
|
|
return word;
|
|||
|
|
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return words.join(' ');
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
wordcount: function(str) {
|
|||
|
|
str = normalize(str, '');
|
|||
|
|
var words = (str) ? str.match(/\w+/g) : null;
|
|||
|
|
return (words) ? words.length : null;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
'float': function(val, def) {
|
|||
|
|
var res = parseFloat(val);
|
|||
|
|
return isNaN(res) ? def : res;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
'int': function(val, def) {
|
|||
|
|
var res = parseInt(val, 10);
|
|||
|
|
return isNaN(res) ? def : res;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Aliases
|
|||
|
|
filters.d = filters['default'];
|
|||
|
|
filters.e = filters.escape;
|
|||
|
|
|
|||
|
|
module.exports = filters;
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 8 */
|
|||
|
|
/***/ function(module, exports, __webpack_require__) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
var lib = __webpack_require__(1);
|
|||
|
|
var Obj = __webpack_require__(6);
|
|||
|
|
|
|||
|
|
// 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 = Obj.extend({
|
|||
|
|
init: function(parent) {
|
|||
|
|
this.variables = {};
|
|||
|
|
this.parent = parent;
|
|||
|
|
this.topLevel = false;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
set: function(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]))) {
|
|||
|
|
frame.set(name, val);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
frame = this;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
get: function(name) {
|
|||
|
|
var val = this.variables[name];
|
|||
|
|
if(val !== undefined && val !== null) {
|
|||
|
|
return val;
|
|||
|
|
}
|
|||
|
|
return null;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
lookup: function(name) {
|
|||
|
|
var p = this.parent;
|
|||
|
|
var val = this.variables[name];
|
|||
|
|
if(val !== undefined && val !== null) {
|
|||
|
|
return val;
|
|||
|
|
}
|
|||
|
|
return p && p.lookup(name);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
resolve: function(name) {
|
|||
|
|
var p = this.parent;
|
|||
|
|
var val = this.variables[name];
|
|||
|
|
if(val !== undefined && val !== null) {
|
|||
|
|
return this;
|
|||
|
|
}
|
|||
|
|
return p && p.resolve(name);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
push: function() {
|
|||
|
|
return new Frame(this);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
pop: function() {
|
|||
|
|
return this.parent;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
function makeMacro(argNames, kwargNames, func) {
|
|||
|
|
return function() {
|
|||
|
|
var argCount = numArgs(arguments);
|
|||
|
|
var args;
|
|||
|
|
var kwargs = getKeywordArgs(arguments);
|
|||
|
|
var i;
|
|||
|
|
|
|||
|
|
if(argCount > argNames.length) {
|
|||
|
|
args = Array.prototype.slice.call(arguments, 0, argNames.length);
|
|||
|
|
|
|||
|
|
// Positional arguments that should be passed in as
|
|||
|
|
// keyword arguments (essentially default values)
|
|||
|
|
var vals = Array.prototype.slice.call(arguments, args.length, argCount);
|
|||
|
|
for(i = 0; i < vals.length; i++) {
|
|||
|
|
if(i < kwargNames.length) {
|
|||
|
|
kwargs[kwargNames[i]] = vals[i];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
args.push(kwargs);
|
|||
|
|
}
|
|||
|
|
else if(argCount < argNames.length) {
|
|||
|
|
args = Array.prototype.slice.call(arguments, 0, argCount);
|
|||
|
|
|
|||
|
|
for(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 = arguments;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return func.apply(this, args);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function makeKeywordArgs(obj) {
|
|||
|
|
obj.__keywords = true;
|
|||
|
|
return obj;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function getKeywordArgs(args) {
|
|||
|
|
var len = args.length;
|
|||
|
|
if(len) {
|
|||
|
|
var lastArg = args[len - 1];
|
|||
|
|
if(lastArg && lastArg.hasOwnProperty('__keywords')) {
|
|||
|
|
return lastArg;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return {};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function numArgs(args) {
|
|||
|
|
var len = args.length;
|
|||
|
|
if(len === 0) {
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var lastArg = args[len - 1];
|
|||
|
|
if(lastArg && lastArg.hasOwnProperty('__keywords')) {
|
|||
|
|
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() {
|
|||
|
|
return this.val;
|
|||
|
|
};
|
|||
|
|
SafeString.prototype.toString = function() {
|
|||
|
|
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() {
|
|||
|
|
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 && typeof val === 'string') {
|
|||
|
|
val = lib.escape(val);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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) {
|
|||
|
|
obj = obj || {};
|
|||
|
|
|
|||
|
|
if(typeof obj[val] === 'function') {
|
|||
|
|
return function() {
|
|||
|
|
return obj[val].apply(obj, arguments);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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');
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// jshint validthis: true
|
|||
|
|
return obj.apply(context, args);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function contextOrFrameLookup(context, frame, name) {
|
|||
|
|
var val = frame.lookup(name);
|
|||
|
|
return (val !== undefined && val !== null) ?
|
|||
|
|
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(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, next);
|
|||
|
|
iter.apply(this, item);
|
|||
|
|
}
|
|||
|
|
}, cb);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
lib.asyncFor(arr, function(key, val, i, len, next) {
|
|||
|
|
iter(key, val, i, len, next);
|
|||
|
|
}, cb);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function asyncAll(arr, dimen, func, cb) {
|
|||
|
|
var finished = 0;
|
|||
|
|
var len, i;
|
|||
|
|
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(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, done);
|
|||
|
|
// jshint validthis: true
|
|||
|
|
func.apply(this, item);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
var keys = lib.keys(arr);
|
|||
|
|
len = keys.length;
|
|||
|
|
outputArr = new Array(len);
|
|||
|
|
|
|||
|
|
if(len === 0) {
|
|||
|
|
cb(null, '');
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
for(i = 0; i < keys.length; i++) {
|
|||
|
|
var k = keys[i];
|
|||
|
|
func(k, arr[k], i, len, done);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 9 */
|
|||
|
|
/***/ function(module, exports) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
function cycler(items) {
|
|||
|
|
var index = -1;
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
current: null,
|
|||
|
|
reset: function() {
|
|||
|
|
index = -1;
|
|||
|
|
this.current = null;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
next: function() {
|
|||
|
|
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(start, stop, step) {
|
|||
|
|
if(!stop) {
|
|||
|
|
stop = start;
|
|||
|
|
start = 0;
|
|||
|
|
step = 1;
|
|||
|
|
}
|
|||
|
|
else if(!step) {
|
|||
|
|
step = 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var arr = [];
|
|||
|
|
var i;
|
|||
|
|
if (step > 0) {
|
|||
|
|
for (i=start; i<stop; i+=step) {
|
|||
|
|
arr.push(i);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
for (i=start; i>stop; i+=step) {
|
|||
|
|
arr.push(i);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return arr;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
// lipsum: function(n, html, min, max) {
|
|||
|
|
// },
|
|||
|
|
|
|||
|
|
cycler: function() {
|
|||
|
|
return cycler(Array.prototype.slice.call(arguments));
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
joiner: function(sep) {
|
|||
|
|
return joiner(sep);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
module.exports = globals;
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 10 */
|
|||
|
|
/***/ function(module, exports, __webpack_require__) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
var Loader = __webpack_require__(11);
|
|||
|
|
|
|||
|
|
var PrecompiledLoader = Loader.extend({
|
|||
|
|
init: function(compiledTemplates) {
|
|||
|
|
this.precompiled = compiledTemplates || {};
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getSource: function(name) {
|
|||
|
|
if (this.precompiled[name]) {
|
|||
|
|
return {
|
|||
|
|
src: { type: 'code',
|
|||
|
|
obj: this.precompiled[name] },
|
|||
|
|
path: name
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
module.exports = PrecompiledLoader;
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 11 */
|
|||
|
|
/***/ function(module, exports, __webpack_require__) {
|
|||
|
|
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
var path = __webpack_require__(3);
|
|||
|
|
var Obj = __webpack_require__(6);
|
|||
|
|
var lib = __webpack_require__(1);
|
|||
|
|
|
|||
|
|
var Loader = Obj.extend({
|
|||
|
|
on: function(name, func) {
|
|||
|
|
this.listeners = this.listeners || {};
|
|||
|
|
this.listeners[name] = this.listeners[name] || [];
|
|||
|
|
this.listeners[name].push(func);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
emit: function(name /*, arg1, arg2, ...*/) {
|
|||
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|||
|
|
|
|||
|
|
if(this.listeners && this.listeners[name]) {
|
|||
|
|
lib.each(this.listeners[name], function(listener) {
|
|||
|
|
listener.apply(null, args);
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
resolve: function(from, to) {
|
|||
|
|
return path.resolve(path.dirname(from), to);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
isRelative: function(filename) {
|
|||
|
|
return (filename.indexOf('./') === 0 || filename.indexOf('../') === 0);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
module.exports = Loader;
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ },
|
|||
|
|
/* 12 */
|
|||
|
|
/***/ function(module, exports) {
|
|||
|
|
|
|||
|
|
function installCompat() {
|
|||
|
|
'use strict';
|
|||
|
|
|
|||
|
|
// This must be called like `nunjucks.installCompat` so that `this`
|
|||
|
|
// references the nunjucks instance
|
|||
|
|
var runtime = this.runtime; // jshint ignore:line
|
|||
|
|
var lib = this.lib; // jshint ignore:line
|
|||
|
|
|
|||
|
|
var orig_contextOrFrameLookup = runtime.contextOrFrameLookup;
|
|||
|
|
runtime.contextOrFrameLookup = function(context, frame, key) {
|
|||
|
|
var val = orig_contextOrFrameLookup.apply(this, arguments);
|
|||
|
|
if (val === undefined) {
|
|||
|
|
switch (key) {
|
|||
|
|
case 'True':
|
|||
|
|
return true;
|
|||
|
|
case 'False':
|
|||
|
|
return false;
|
|||
|
|
case 'None':
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return val;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var orig_memberLookup = runtime.memberLookup;
|
|||
|
|
var ARRAY_MEMBERS = {
|
|||
|
|
pop: function(index) {
|
|||
|
|
if (index === undefined) {
|
|||
|
|
return this.pop();
|
|||
|
|
}
|
|||
|
|
if (index >= this.length || index < 0) {
|
|||
|
|
throw new Error('KeyError');
|
|||
|
|
}
|
|||
|
|
return this.splice(index, 1);
|
|||
|
|
},
|
|||
|
|
remove: function(element) {
|
|||
|
|
for (var i = 0; i < this.length; i++) {
|
|||
|
|
if (this[i] === element) {
|
|||
|
|
return this.splice(i, 1);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
throw new Error('ValueError');
|
|||
|
|
},
|
|||
|
|
count: function(element) {
|
|||
|
|
var count = 0;
|
|||
|
|
for (var i = 0; i < this.length; i++) {
|
|||
|
|
if (this[i] === element) {
|
|||
|
|
count++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return count;
|
|||
|
|
},
|
|||
|
|
index: function(element) {
|
|||
|
|
var i;
|
|||
|
|
if ((i = this.indexOf(element)) === -1) {
|
|||
|
|
throw new Error('ValueError');
|
|||
|
|
}
|
|||
|
|
return i;
|
|||
|
|
},
|
|||
|
|
find: function(element) {
|
|||
|
|
return this.indexOf(element);
|
|||
|
|
},
|
|||
|
|
insert: function(index, elem) {
|
|||
|
|
return this.splice(index, 0, elem);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
var OBJECT_MEMBERS = {
|
|||
|
|
items: function() {
|
|||
|
|
var ret = [];
|
|||
|
|
for(var k in this) {
|
|||
|
|
ret.push([k, this[k]]);
|
|||
|
|
}
|
|||
|
|
return ret;
|
|||
|
|
},
|
|||
|
|
values: function() {
|
|||
|
|
var ret = [];
|
|||
|
|
for(var k in this) {
|
|||
|
|
ret.push(this[k]);
|
|||
|
|
}
|
|||
|
|
return ret;
|
|||
|
|
},
|
|||
|
|
keys: function() {
|
|||
|
|
var ret = [];
|
|||
|
|
for(var k in this) {
|
|||
|
|
ret.push(k);
|
|||
|
|
}
|
|||
|
|
return ret;
|
|||
|
|
},
|
|||
|
|
get: function(key, def) {
|
|||
|
|
var output = this[key];
|
|||
|
|
if (output === undefined) {
|
|||
|
|
output = def;
|
|||
|
|
}
|
|||
|
|
return output;
|
|||
|
|
},
|
|||
|
|
has_key: function(key) {
|
|||
|
|
return this.hasOwnProperty(key);
|
|||
|
|
},
|
|||
|
|
pop: function(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() {
|
|||
|
|
for (var k in this) {
|
|||
|
|
// Return the first object pair.
|
|||
|
|
var val = this[k];
|
|||
|
|
delete this[k];
|
|||
|
|
return [k, val];
|
|||
|
|
}
|
|||
|
|
throw new Error('KeyError');
|
|||
|
|
},
|
|||
|
|
setdefault: function(key, def) {
|
|||
|
|
if (key in this) {
|
|||
|
|
return this[key];
|
|||
|
|
}
|
|||
|
|
if (def === undefined) {
|
|||
|
|
def = null;
|
|||
|
|
}
|
|||
|
|
return this[key] = def;
|
|||
|
|
},
|
|||
|
|
update: function(kwargs) {
|
|||
|
|
for (var k in kwargs) {
|
|||
|
|
this[k] = kwargs[k];
|
|||
|
|
}
|
|||
|
|
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(obj, val, autoescape) { // jshint ignore:line
|
|||
|
|
obj = obj || {};
|
|||
|
|
|
|||
|
|
// If the object is an object, return any of the methods that Python would
|
|||
|
|
// otherwise provide.
|
|||
|
|
if (lib.isArray(obj) && ARRAY_MEMBERS.hasOwnProperty(val)) {
|
|||
|
|
return function() {return ARRAY_MEMBERS[val].apply(obj, arguments);};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (lib.isObject(obj) && OBJECT_MEMBERS.hasOwnProperty(val)) {
|
|||
|
|
return function() {return OBJECT_MEMBERS[val].apply(obj, arguments);};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return orig_memberLookup.apply(this, arguments);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
module.exports = installCompat;
|
|||
|
|
|
|||
|
|
|
|||
|
|
/***/ }
|
|||
|
|
/******/ ]);
|