661 lines
20 KiB
JavaScript
661 lines
20 KiB
JavaScript
/*!
|
|
|
|
handlebars v2.0.0
|
|
|
|
Copyright (C) 2011-2014 by Yehuda Katz
|
|
|
|
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.
|
|
|
|
@license
|
|
*/
|
|
/* exported Handlebars */
|
|
(function (root, factory) {
|
|
if (typeof define === 'function' && define.amd) {
|
|
define([], factory);
|
|
} else if (typeof exports === 'object') {
|
|
module.exports = factory();
|
|
} else {
|
|
root.Handlebars = root.Handlebars || factory();
|
|
}
|
|
}(this, function () {
|
|
// handlebars/safe-string.js
|
|
var __module3__ = (function() {
|
|
"use strict";
|
|
var __exports__;
|
|
// Build out our basic SafeString type
|
|
function SafeString(string) {
|
|
this.string = string;
|
|
}
|
|
|
|
SafeString.prototype.toString = function() {
|
|
return "" + this.string;
|
|
};
|
|
|
|
__exports__ = SafeString;
|
|
return __exports__;
|
|
})();
|
|
|
|
// handlebars/utils.js
|
|
var __module2__ = (function(__dependency1__) {
|
|
"use strict";
|
|
var __exports__ = {};
|
|
/*jshint -W004 */
|
|
var SafeString = __dependency1__;
|
|
|
|
var escape = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
'"': """,
|
|
"'": "'",
|
|
"`": "`"
|
|
};
|
|
|
|
var badChars = /[&<>"'`]/g;
|
|
var possible = /[&<>"'`]/;
|
|
|
|
function escapeChar(chr) {
|
|
return escape[chr];
|
|
}
|
|
|
|
function extend(obj /* , ...source */) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
for (var key in arguments[i]) {
|
|
if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
|
|
obj[key] = arguments[i][key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
__exports__.extend = extend;var toString = Object.prototype.toString;
|
|
__exports__.toString = toString;
|
|
// Sourced from lodash
|
|
// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
|
|
var isFunction = function(value) {
|
|
return typeof value === 'function';
|
|
};
|
|
// fallback for older versions of Chrome and Safari
|
|
/* istanbul ignore next */
|
|
if (isFunction(/x/)) {
|
|
isFunction = function(value) {
|
|
return typeof value === 'function' && toString.call(value) === '[object Function]';
|
|
};
|
|
}
|
|
var isFunction;
|
|
__exports__.isFunction = isFunction;
|
|
/* istanbul ignore next */
|
|
var isArray = Array.isArray || function(value) {
|
|
return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
|
|
};
|
|
__exports__.isArray = isArray;
|
|
|
|
function escapeExpression(string) {
|
|
// don't escape SafeStrings, since they're already safe
|
|
if (string instanceof SafeString) {
|
|
return string.toString();
|
|
} else if (string == null) {
|
|
return "";
|
|
} else if (!string) {
|
|
return string + '';
|
|
}
|
|
|
|
// Force a string conversion as this will be done by the append regardless and
|
|
// the regex test will do this transparently behind the scenes, causing issues if
|
|
// an object's to string has escaped characters in it.
|
|
string = "" + string;
|
|
|
|
if(!possible.test(string)) { return string; }
|
|
return string.replace(badChars, escapeChar);
|
|
}
|
|
|
|
__exports__.escapeExpression = escapeExpression;function isEmpty(value) {
|
|
if (!value && value !== 0) {
|
|
return true;
|
|
} else if (isArray(value) && value.length === 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
__exports__.isEmpty = isEmpty;function appendContextPath(contextPath, id) {
|
|
return (contextPath ? contextPath + '.' : '') + id;
|
|
}
|
|
|
|
__exports__.appendContextPath = appendContextPath;
|
|
return __exports__;
|
|
})(__module3__);
|
|
|
|
// handlebars/exception.js
|
|
var __module4__ = (function() {
|
|
"use strict";
|
|
var __exports__;
|
|
|
|
var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
|
|
|
|
function Exception(message, node) {
|
|
var line;
|
|
if (node && node.firstLine) {
|
|
line = node.firstLine;
|
|
|
|
message += ' - ' + line + ':' + node.firstColumn;
|
|
}
|
|
|
|
var tmp = Error.prototype.constructor.call(this, message);
|
|
|
|
// Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
|
|
for (var idx = 0; idx < errorProps.length; idx++) {
|
|
this[errorProps[idx]] = tmp[errorProps[idx]];
|
|
}
|
|
|
|
if (line) {
|
|
this.lineNumber = line;
|
|
this.column = node.firstColumn;
|
|
}
|
|
}
|
|
|
|
Exception.prototype = new Error();
|
|
|
|
__exports__ = Exception;
|
|
return __exports__;
|
|
})();
|
|
|
|
// handlebars/base.js
|
|
var __module1__ = (function(__dependency1__, __dependency2__) {
|
|
"use strict";
|
|
var __exports__ = {};
|
|
var Utils = __dependency1__;
|
|
var Exception = __dependency2__;
|
|
|
|
var VERSION = "2.0.0";
|
|
__exports__.VERSION = VERSION;var COMPILER_REVISION = 6;
|
|
__exports__.COMPILER_REVISION = COMPILER_REVISION;
|
|
var REVISION_CHANGES = {
|
|
1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
|
|
2: '== 1.0.0-rc.3',
|
|
3: '== 1.0.0-rc.4',
|
|
4: '== 1.x.x',
|
|
5: '== 2.0.0-alpha.x',
|
|
6: '>= 2.0.0-beta.1'
|
|
};
|
|
__exports__.REVISION_CHANGES = REVISION_CHANGES;
|
|
var isArray = Utils.isArray,
|
|
isFunction = Utils.isFunction,
|
|
toString = Utils.toString,
|
|
objectType = '[object Object]';
|
|
|
|
function HandlebarsEnvironment(helpers, partials) {
|
|
this.helpers = helpers || {};
|
|
this.partials = partials || {};
|
|
|
|
registerDefaultHelpers(this);
|
|
}
|
|
|
|
__exports__.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = {
|
|
constructor: HandlebarsEnvironment,
|
|
|
|
logger: logger,
|
|
log: log,
|
|
|
|
registerHelper: function(name, fn) {
|
|
if (toString.call(name) === objectType) {
|
|
if (fn) { throw new Exception('Arg not supported with multiple helpers'); }
|
|
Utils.extend(this.helpers, name);
|
|
} else {
|
|
this.helpers[name] = fn;
|
|
}
|
|
},
|
|
unregisterHelper: function(name) {
|
|
delete this.helpers[name];
|
|
},
|
|
|
|
registerPartial: function(name, partial) {
|
|
if (toString.call(name) === objectType) {
|
|
Utils.extend(this.partials, name);
|
|
} else {
|
|
this.partials[name] = partial;
|
|
}
|
|
},
|
|
unregisterPartial: function(name) {
|
|
delete this.partials[name];
|
|
}
|
|
};
|
|
|
|
function registerDefaultHelpers(instance) {
|
|
instance.registerHelper('helperMissing', function(/* [args, ]options */) {
|
|
if(arguments.length === 1) {
|
|
// A missing field in a {{foo}} constuct.
|
|
return undefined;
|
|
} else {
|
|
// Someone is actually trying to call something, blow up.
|
|
throw new Exception("Missing helper: '" + arguments[arguments.length-1].name + "'");
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('blockHelperMissing', function(context, options) {
|
|
var inverse = options.inverse,
|
|
fn = options.fn;
|
|
|
|
if(context === true) {
|
|
return fn(this);
|
|
} else if(context === false || context == null) {
|
|
return inverse(this);
|
|
} else if (isArray(context)) {
|
|
if(context.length > 0) {
|
|
if (options.ids) {
|
|
options.ids = [options.name];
|
|
}
|
|
|
|
return instance.helpers.each(context, options);
|
|
} else {
|
|
return inverse(this);
|
|
}
|
|
} else {
|
|
if (options.data && options.ids) {
|
|
var data = createFrame(options.data);
|
|
data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
|
|
options = {data: data};
|
|
}
|
|
|
|
return fn(context, options);
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('each', function(context, options) {
|
|
if (!options) {
|
|
throw new Exception('Must pass iterator to #each');
|
|
}
|
|
|
|
var fn = options.fn, inverse = options.inverse;
|
|
var i = 0, ret = "", data;
|
|
|
|
var contextPath;
|
|
if (options.data && options.ids) {
|
|
contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
|
|
}
|
|
|
|
if (isFunction(context)) { context = context.call(this); }
|
|
|
|
if (options.data) {
|
|
data = createFrame(options.data);
|
|
}
|
|
|
|
if(context && typeof context === 'object') {
|
|
if (isArray(context)) {
|
|
for(var j = context.length; i<j; i++) {
|
|
if (data) {
|
|
data.index = i;
|
|
data.first = (i === 0);
|
|
data.last = (i === (context.length-1));
|
|
|
|
if (contextPath) {
|
|
data.contextPath = contextPath + i;
|
|
}
|
|
}
|
|
ret = ret + fn(context[i], { data: data });
|
|
}
|
|
} else {
|
|
for(var key in context) {
|
|
if(context.hasOwnProperty(key)) {
|
|
if(data) {
|
|
data.key = key;
|
|
data.index = i;
|
|
data.first = (i === 0);
|
|
|
|
if (contextPath) {
|
|
data.contextPath = contextPath + key;
|
|
}
|
|
}
|
|
ret = ret + fn(context[key], {data: data});
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(i === 0){
|
|
ret = inverse(this);
|
|
}
|
|
|
|
return ret;
|
|
});
|
|
|
|
instance.registerHelper('if', function(conditional, options) {
|
|
if (isFunction(conditional)) { conditional = conditional.call(this); }
|
|
|
|
// Default behavior is to render the positive path if the value is truthy and not empty.
|
|
// The `includeZero` option may be set to treat the condtional as purely not empty based on the
|
|
// behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
|
|
if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) {
|
|
return options.inverse(this);
|
|
} else {
|
|
return options.fn(this);
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('unless', function(conditional, options) {
|
|
return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});
|
|
});
|
|
|
|
instance.registerHelper('with', function(context, options) {
|
|
if (isFunction(context)) { context = context.call(this); }
|
|
|
|
var fn = options.fn;
|
|
|
|
if (!Utils.isEmpty(context)) {
|
|
if (options.data && options.ids) {
|
|
var data = createFrame(options.data);
|
|
data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
|
|
options = {data:data};
|
|
}
|
|
|
|
return fn(context, options);
|
|
} else {
|
|
return options.inverse(this);
|
|
}
|
|
});
|
|
|
|
instance.registerHelper('log', function(message, options) {
|
|
var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
|
|
instance.log(level, message);
|
|
});
|
|
|
|
instance.registerHelper('lookup', function(obj, field) {
|
|
return obj && obj[field];
|
|
});
|
|
}
|
|
|
|
var logger = {
|
|
methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },
|
|
|
|
// State enum
|
|
DEBUG: 0,
|
|
INFO: 1,
|
|
WARN: 2,
|
|
ERROR: 3,
|
|
level: 3,
|
|
|
|
// can be overridden in the host environment
|
|
log: function(level, message) {
|
|
if (logger.level <= level) {
|
|
var method = logger.methodMap[level];
|
|
if (typeof console !== 'undefined' && console[method]) {
|
|
console[method].call(console, message);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
__exports__.logger = logger;
|
|
var log = logger.log;
|
|
__exports__.log = log;
|
|
var createFrame = function(object) {
|
|
var frame = Utils.extend({}, object);
|
|
frame._parent = object;
|
|
return frame;
|
|
};
|
|
__exports__.createFrame = createFrame;
|
|
return __exports__;
|
|
})(__module2__, __module4__);
|
|
|
|
// handlebars/runtime.js
|
|
var __module5__ = (function(__dependency1__, __dependency2__, __dependency3__) {
|
|
"use strict";
|
|
var __exports__ = {};
|
|
var Utils = __dependency1__;
|
|
var Exception = __dependency2__;
|
|
var COMPILER_REVISION = __dependency3__.COMPILER_REVISION;
|
|
var REVISION_CHANGES = __dependency3__.REVISION_CHANGES;
|
|
var createFrame = __dependency3__.createFrame;
|
|
|
|
function checkRevision(compilerInfo) {
|
|
var compilerRevision = compilerInfo && compilerInfo[0] || 1,
|
|
currentRevision = COMPILER_REVISION;
|
|
|
|
if (compilerRevision !== currentRevision) {
|
|
if (compilerRevision < currentRevision) {
|
|
var runtimeVersions = REVISION_CHANGES[currentRevision],
|
|
compilerVersions = REVISION_CHANGES[compilerRevision];
|
|
throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+
|
|
"Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");
|
|
} else {
|
|
// Use the embedded version info since the runtime doesn't know about this revision yet
|
|
throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+
|
|
"Please update your runtime to a newer version ("+compilerInfo[1]+").");
|
|
}
|
|
}
|
|
}
|
|
|
|
__exports__.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial
|
|
|
|
function template(templateSpec, env) {
|
|
/* istanbul ignore next */
|
|
if (!env) {
|
|
throw new Exception("No environment passed to template");
|
|
}
|
|
if (!templateSpec || !templateSpec.main) {
|
|
throw new Exception('Unknown template object: ' + typeof templateSpec);
|
|
}
|
|
|
|
// Note: Using env.VM references rather than local var references throughout this section to allow
|
|
// for external users to override these as psuedo-supported APIs.
|
|
env.VM.checkRevision(templateSpec.compiler);
|
|
|
|
var invokePartialWrapper = function(partial, indent, name, context, hash, helpers, partials, data, depths) {
|
|
if (hash) {
|
|
context = Utils.extend({}, context, hash);
|
|
}
|
|
|
|
var result = env.VM.invokePartial.call(this, partial, name, context, helpers, partials, data, depths);
|
|
|
|
if (result == null && env.compile) {
|
|
var options = { helpers: helpers, partials: partials, data: data, depths: depths };
|
|
partials[name] = env.compile(partial, { data: data !== undefined, compat: templateSpec.compat }, env);
|
|
result = partials[name](context, options);
|
|
}
|
|
if (result != null) {
|
|
if (indent) {
|
|
var lines = result.split('\n');
|
|
for (var i = 0, l = lines.length; i < l; i++) {
|
|
if (!lines[i] && i + 1 === l) {
|
|
break;
|
|
}
|
|
|
|
lines[i] = indent + lines[i];
|
|
}
|
|
result = lines.join('\n');
|
|
}
|
|
return result;
|
|
} else {
|
|
throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
|
|
}
|
|
};
|
|
|
|
// Just add water
|
|
var container = {
|
|
lookup: function(depths, name) {
|
|
var len = depths.length;
|
|
for (var i = 0; i < len; i++) {
|
|
if (depths[i] && depths[i][name] != null) {
|
|
return depths[i][name];
|
|
}
|
|
}
|
|
},
|
|
lambda: function(current, context) {
|
|
return typeof current === 'function' ? current.call(context) : current;
|
|
},
|
|
|
|
escapeExpression: Utils.escapeExpression,
|
|
invokePartial: invokePartialWrapper,
|
|
|
|
fn: function(i) {
|
|
return templateSpec[i];
|
|
},
|
|
|
|
programs: [],
|
|
program: function(i, data, depths) {
|
|
var programWrapper = this.programs[i],
|
|
fn = this.fn(i);
|
|
if (data || depths) {
|
|
programWrapper = program(this, i, fn, data, depths);
|
|
} else if (!programWrapper) {
|
|
programWrapper = this.programs[i] = program(this, i, fn);
|
|
}
|
|
return programWrapper;
|
|
},
|
|
|
|
data: function(data, depth) {
|
|
while (data && depth--) {
|
|
data = data._parent;
|
|
}
|
|
return data;
|
|
},
|
|
merge: function(param, common) {
|
|
var ret = param || common;
|
|
|
|
if (param && common && (param !== common)) {
|
|
ret = Utils.extend({}, common, param);
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
noop: env.VM.noop,
|
|
compilerInfo: templateSpec.compiler
|
|
};
|
|
|
|
var ret = function(context, options) {
|
|
options = options || {};
|
|
var data = options.data;
|
|
|
|
ret._setup(options);
|
|
if (!options.partial && templateSpec.useData) {
|
|
data = initData(context, data);
|
|
}
|
|
var depths;
|
|
if (templateSpec.useDepths) {
|
|
depths = options.depths ? [context].concat(options.depths) : [context];
|
|
}
|
|
|
|
return templateSpec.main.call(container, context, container.helpers, container.partials, data, depths);
|
|
};
|
|
ret.isTop = true;
|
|
|
|
ret._setup = function(options) {
|
|
if (!options.partial) {
|
|
container.helpers = container.merge(options.helpers, env.helpers);
|
|
|
|
if (templateSpec.usePartial) {
|
|
container.partials = container.merge(options.partials, env.partials);
|
|
}
|
|
} else {
|
|
container.helpers = options.helpers;
|
|
container.partials = options.partials;
|
|
}
|
|
};
|
|
|
|
ret._child = function(i, data, depths) {
|
|
if (templateSpec.useDepths && !depths) {
|
|
throw new Exception('must pass parent depths');
|
|
}
|
|
|
|
return program(container, i, templateSpec[i], data, depths);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
__exports__.template = template;function program(container, i, fn, data, depths) {
|
|
var prog = function(context, options) {
|
|
options = options || {};
|
|
|
|
return fn.call(container, context, container.helpers, container.partials, options.data || data, depths && [context].concat(depths));
|
|
};
|
|
prog.program = i;
|
|
prog.depth = depths ? depths.length : 0;
|
|
return prog;
|
|
}
|
|
|
|
__exports__.program = program;function invokePartial(partial, name, context, helpers, partials, data, depths) {
|
|
var options = { partial: true, helpers: helpers, partials: partials, data: data, depths: depths };
|
|
|
|
if(partial === undefined) {
|
|
throw new Exception("The partial " + name + " could not be found");
|
|
} else if(partial instanceof Function) {
|
|
return partial(context, options);
|
|
}
|
|
}
|
|
|
|
__exports__.invokePartial = invokePartial;function noop() { return ""; }
|
|
|
|
__exports__.noop = noop;function initData(context, data) {
|
|
if (!data || !('root' in data)) {
|
|
data = data ? createFrame(data) : {};
|
|
data.root = context;
|
|
}
|
|
return data;
|
|
}
|
|
return __exports__;
|
|
})(__module2__, __module4__, __module1__);
|
|
|
|
// handlebars.runtime.js
|
|
var __module0__ = (function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
|
|
"use strict";
|
|
var __exports__;
|
|
/*globals Handlebars: true */
|
|
var base = __dependency1__;
|
|
|
|
// Each of these augment the Handlebars object. No need to setup here.
|
|
// (This is done to easily share code between commonjs and browse envs)
|
|
var SafeString = __dependency2__;
|
|
var Exception = __dependency3__;
|
|
var Utils = __dependency4__;
|
|
var runtime = __dependency5__;
|
|
|
|
// For compatibility and usage outside of module systems, make the Handlebars object a namespace
|
|
var create = function() {
|
|
var hb = new base.HandlebarsEnvironment();
|
|
|
|
Utils.extend(hb, base);
|
|
hb.SafeString = SafeString;
|
|
hb.Exception = Exception;
|
|
hb.Utils = Utils;
|
|
hb.escapeExpression = Utils.escapeExpression;
|
|
|
|
hb.VM = runtime;
|
|
hb.template = function(spec) {
|
|
return runtime.template(spec, hb);
|
|
};
|
|
|
|
return hb;
|
|
};
|
|
|
|
var Handlebars = create();
|
|
Handlebars.create = create;
|
|
|
|
Handlebars['default'] = Handlebars;
|
|
|
|
__exports__ = Handlebars;
|
|
return __exports__;
|
|
})(__module1__, __module3__, __module4__, __module2__, __module5__);
|
|
|
|
return __module0__;
|
|
}));
|