This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1468 lines
40 KiB
1468 lines
40 KiB
/**! |
|
|
|
@license |
|
handlebars v4.0.11 |
|
|
|
Copyright (C) 2011-2017 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. |
|
|
|
*/ |
|
(function webpackUniversalModuleDefinition(root, factory) { |
|
if(typeof exports === 'object' && typeof module === 'object') |
|
module.exports = factory(); |
|
else if(typeof define === 'function' && define.amd) |
|
define([], factory); |
|
else if(typeof exports === 'object') |
|
exports["Handlebars"] = factory(); |
|
else |
|
root["Handlebars"] = factory(); |
|
})(this, function() { |
|
return /******/ (function(modules) { // webpackBootstrap |
|
/******/ // The module cache |
|
/******/ var installedModules = {}; |
|
|
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
|
|
/******/ // Check if module is in cache |
|
/******/ if(installedModules[moduleId]) |
|
/******/ return installedModules[moduleId].exports; |
|
|
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = installedModules[moduleId] = { |
|
/******/ 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 _interopRequireWildcard = __webpack_require__(1)['default']; |
|
|
|
var _interopRequireDefault = __webpack_require__(2)['default']; |
|
|
|
exports.__esModule = true; |
|
|
|
var _handlebarsBase = __webpack_require__(3); |
|
|
|
var base = _interopRequireWildcard(_handlebarsBase); |
|
|
|
// 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 _handlebarsSafeString = __webpack_require__(20); |
|
|
|
var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString); |
|
|
|
var _handlebarsException = __webpack_require__(5); |
|
|
|
var _handlebarsException2 = _interopRequireDefault(_handlebarsException); |
|
|
|
var _handlebarsUtils = __webpack_require__(4); |
|
|
|
var Utils = _interopRequireWildcard(_handlebarsUtils); |
|
|
|
var _handlebarsRuntime = __webpack_require__(21); |
|
|
|
var runtime = _interopRequireWildcard(_handlebarsRuntime); |
|
|
|
var _handlebarsNoConflict = __webpack_require__(33); |
|
|
|
var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict); |
|
|
|
// For compatibility and usage outside of module systems, make the Handlebars object a namespace |
|
function create() { |
|
var hb = new base.HandlebarsEnvironment(); |
|
|
|
Utils.extend(hb, base); |
|
hb.SafeString = _handlebarsSafeString2['default']; |
|
hb.Exception = _handlebarsException2['default']; |
|
hb.Utils = Utils; |
|
hb.escapeExpression = Utils.escapeExpression; |
|
|
|
hb.VM = runtime; |
|
hb.template = function (spec) { |
|
return runtime.template(spec, hb); |
|
}; |
|
|
|
return hb; |
|
} |
|
|
|
var inst = create(); |
|
inst.create = create; |
|
|
|
_handlebarsNoConflict2['default'](inst); |
|
|
|
inst['default'] = inst; |
|
|
|
exports['default'] = inst; |
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 1 */ |
|
/***/ (function(module, exports) { |
|
|
|
"use strict"; |
|
|
|
exports["default"] = function (obj) { |
|
if (obj && obj.__esModule) { |
|
return obj; |
|
} else { |
|
var newObj = {}; |
|
|
|
if (obj != null) { |
|
for (var key in obj) { |
|
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; |
|
} |
|
} |
|
|
|
newObj["default"] = obj; |
|
return newObj; |
|
} |
|
}; |
|
|
|
exports.__esModule = true; |
|
|
|
/***/ }), |
|
/* 2 */ |
|
/***/ (function(module, exports) { |
|
|
|
"use strict"; |
|
|
|
exports["default"] = function (obj) { |
|
return obj && obj.__esModule ? obj : { |
|
"default": obj |
|
}; |
|
}; |
|
|
|
exports.__esModule = true; |
|
|
|
/***/ }), |
|
/* 3 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var _interopRequireDefault = __webpack_require__(2)['default']; |
|
|
|
exports.__esModule = true; |
|
exports.HandlebarsEnvironment = HandlebarsEnvironment; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
var _exception = __webpack_require__(5); |
|
|
|
var _exception2 = _interopRequireDefault(_exception); |
|
|
|
var _helpers = __webpack_require__(9); |
|
|
|
var _decorators = __webpack_require__(17); |
|
|
|
var _logger = __webpack_require__(19); |
|
|
|
var _logger2 = _interopRequireDefault(_logger); |
|
|
|
var VERSION = '4.0.11'; |
|
exports.VERSION = VERSION; |
|
var COMPILER_REVISION = 7; |
|
|
|
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', |
|
7: '>= 4.0.0' |
|
}; |
|
|
|
exports.REVISION_CHANGES = REVISION_CHANGES; |
|
var objectType = '[object Object]'; |
|
|
|
function HandlebarsEnvironment(helpers, partials, decorators) { |
|
this.helpers = helpers || {}; |
|
this.partials = partials || {}; |
|
this.decorators = decorators || {}; |
|
|
|
_helpers.registerDefaultHelpers(this); |
|
_decorators.registerDefaultDecorators(this); |
|
} |
|
|
|
HandlebarsEnvironment.prototype = { |
|
constructor: HandlebarsEnvironment, |
|
|
|
logger: _logger2['default'], |
|
log: _logger2['default'].log, |
|
|
|
registerHelper: function registerHelper(name, fn) { |
|
if (_utils.toString.call(name) === objectType) { |
|
if (fn) { |
|
throw new _exception2['default']('Arg not supported with multiple helpers'); |
|
} |
|
_utils.extend(this.helpers, name); |
|
} else { |
|
this.helpers[name] = fn; |
|
} |
|
}, |
|
unregisterHelper: function unregisterHelper(name) { |
|
delete this.helpers[name]; |
|
}, |
|
|
|
registerPartial: function registerPartial(name, partial) { |
|
if (_utils.toString.call(name) === objectType) { |
|
_utils.extend(this.partials, name); |
|
} else { |
|
if (typeof partial === 'undefined') { |
|
throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined'); |
|
} |
|
this.partials[name] = partial; |
|
} |
|
}, |
|
unregisterPartial: function unregisterPartial(name) { |
|
delete this.partials[name]; |
|
}, |
|
|
|
registerDecorator: function registerDecorator(name, fn) { |
|
if (_utils.toString.call(name) === objectType) { |
|
if (fn) { |
|
throw new _exception2['default']('Arg not supported with multiple decorators'); |
|
} |
|
_utils.extend(this.decorators, name); |
|
} else { |
|
this.decorators[name] = fn; |
|
} |
|
}, |
|
unregisterDecorator: function unregisterDecorator(name) { |
|
delete this.decorators[name]; |
|
} |
|
}; |
|
|
|
var log = _logger2['default'].log; |
|
|
|
exports.log = log; |
|
exports.createFrame = _utils.createFrame; |
|
exports.logger = _logger2['default']; |
|
|
|
/***/ }), |
|
/* 4 */ |
|
/***/ (function(module, exports) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
exports.extend = extend; |
|
exports.indexOf = indexOf; |
|
exports.escapeExpression = escapeExpression; |
|
exports.isEmpty = isEmpty; |
|
exports.createFrame = createFrame; |
|
exports.blockParams = blockParams; |
|
exports.appendContextPath = appendContextPath; |
|
var escape = { |
|
'&': '&', |
|
'<': '<', |
|
'>': '>', |
|
'"': '"', |
|
"'": ''', |
|
'`': '`', |
|
'=': '=' |
|
}; |
|
|
|
var badChars = /[&<>"'`=]/g, |
|
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; |
|
} |
|
|
|
var toString = Object.prototype.toString; |
|
|
|
exports.toString = toString; |
|
// Sourced from lodash |
|
// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt |
|
/* eslint-disable func-style */ |
|
var isFunction = function isFunction(value) { |
|
return typeof value === 'function'; |
|
}; |
|
// fallback for older versions of Chrome and Safari |
|
/* istanbul ignore next */ |
|
if (isFunction(/x/)) { |
|
exports.isFunction = isFunction = function (value) { |
|
return typeof value === 'function' && toString.call(value) === '[object Function]'; |
|
}; |
|
} |
|
exports.isFunction = isFunction; |
|
|
|
/* eslint-enable func-style */ |
|
|
|
/* istanbul ignore next */ |
|
var isArray = Array.isArray || function (value) { |
|
return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false; |
|
}; |
|
|
|
exports.isArray = isArray; |
|
// Older IE versions do not directly support indexOf so we must implement our own, sadly. |
|
|
|
function indexOf(array, value) { |
|
for (var i = 0, len = array.length; i < len; i++) { |
|
if (array[i] === value) { |
|
return i; |
|
} |
|
} |
|
return -1; |
|
} |
|
|
|
function escapeExpression(string) { |
|
if (typeof string !== 'string') { |
|
// don't escape SafeStrings, since they're already safe |
|
if (string && string.toHTML) { |
|
return string.toHTML(); |
|
} 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); |
|
} |
|
|
|
function isEmpty(value) { |
|
if (!value && value !== 0) { |
|
return true; |
|
} else if (isArray(value) && value.length === 0) { |
|
return true; |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
function createFrame(object) { |
|
var frame = extend({}, object); |
|
frame._parent = object; |
|
return frame; |
|
} |
|
|
|
function blockParams(params, ids) { |
|
params.path = ids; |
|
return params; |
|
} |
|
|
|
function appendContextPath(contextPath, id) { |
|
return (contextPath ? contextPath + '.' : '') + id; |
|
} |
|
|
|
/***/ }), |
|
/* 5 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var _Object$defineProperty = __webpack_require__(6)['default']; |
|
|
|
exports.__esModule = true; |
|
|
|
var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack']; |
|
|
|
function Exception(message, node) { |
|
var loc = node && node.loc, |
|
line = undefined, |
|
column = undefined; |
|
if (loc) { |
|
line = loc.start.line; |
|
column = loc.start.column; |
|
|
|
message += ' - ' + line + ':' + column; |
|
} |
|
|
|
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]]; |
|
} |
|
|
|
/* istanbul ignore else */ |
|
if (Error.captureStackTrace) { |
|
Error.captureStackTrace(this, Exception); |
|
} |
|
|
|
try { |
|
if (loc) { |
|
this.lineNumber = line; |
|
|
|
// Work around issue under safari where we can't directly set the column value |
|
/* istanbul ignore next */ |
|
if (_Object$defineProperty) { |
|
Object.defineProperty(this, 'column', { |
|
value: column, |
|
enumerable: true |
|
}); |
|
} else { |
|
this.column = column; |
|
} |
|
} |
|
} catch (nop) { |
|
/* Ignore if the browser is very particular */ |
|
} |
|
} |
|
|
|
Exception.prototype = new Error(); |
|
|
|
exports['default'] = Exception; |
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 6 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
module.exports = { "default": __webpack_require__(7), __esModule: true }; |
|
|
|
/***/ }), |
|
/* 7 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var $ = __webpack_require__(8); |
|
module.exports = function defineProperty(it, key, desc){ |
|
return $.setDesc(it, key, desc); |
|
}; |
|
|
|
/***/ }), |
|
/* 8 */ |
|
/***/ (function(module, exports) { |
|
|
|
var $Object = Object; |
|
module.exports = { |
|
create: $Object.create, |
|
getProto: $Object.getPrototypeOf, |
|
isEnum: {}.propertyIsEnumerable, |
|
getDesc: $Object.getOwnPropertyDescriptor, |
|
setDesc: $Object.defineProperty, |
|
setDescs: $Object.defineProperties, |
|
getKeys: $Object.keys, |
|
getNames: $Object.getOwnPropertyNames, |
|
getSymbols: $Object.getOwnPropertySymbols, |
|
each: [].forEach |
|
}; |
|
|
|
/***/ }), |
|
/* 9 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var _interopRequireDefault = __webpack_require__(2)['default']; |
|
|
|
exports.__esModule = true; |
|
exports.registerDefaultHelpers = registerDefaultHelpers; |
|
|
|
var _helpersBlockHelperMissing = __webpack_require__(10); |
|
|
|
var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing); |
|
|
|
var _helpersEach = __webpack_require__(11); |
|
|
|
var _helpersEach2 = _interopRequireDefault(_helpersEach); |
|
|
|
var _helpersHelperMissing = __webpack_require__(12); |
|
|
|
var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing); |
|
|
|
var _helpersIf = __webpack_require__(13); |
|
|
|
var _helpersIf2 = _interopRequireDefault(_helpersIf); |
|
|
|
var _helpersLog = __webpack_require__(14); |
|
|
|
var _helpersLog2 = _interopRequireDefault(_helpersLog); |
|
|
|
var _helpersLookup = __webpack_require__(15); |
|
|
|
var _helpersLookup2 = _interopRequireDefault(_helpersLookup); |
|
|
|
var _helpersWith = __webpack_require__(16); |
|
|
|
var _helpersWith2 = _interopRequireDefault(_helpersWith); |
|
|
|
function registerDefaultHelpers(instance) { |
|
_helpersBlockHelperMissing2['default'](instance); |
|
_helpersEach2['default'](instance); |
|
_helpersHelperMissing2['default'](instance); |
|
_helpersIf2['default'](instance); |
|
_helpersLog2['default'](instance); |
|
_helpersLookup2['default'](instance); |
|
_helpersWith2['default'](instance); |
|
} |
|
|
|
/***/ }), |
|
/* 10 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
exports['default'] = function (instance) { |
|
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 (_utils.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 = _utils.createFrame(options.data); |
|
data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name); |
|
options = { data: data }; |
|
} |
|
|
|
return fn(context, options); |
|
} |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 11 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var _interopRequireDefault = __webpack_require__(2)['default']; |
|
|
|
exports.__esModule = true; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
var _exception = __webpack_require__(5); |
|
|
|
var _exception2 = _interopRequireDefault(_exception); |
|
|
|
exports['default'] = function (instance) { |
|
instance.registerHelper('each', function (context, options) { |
|
if (!options) { |
|
throw new _exception2['default']('Must pass iterator to #each'); |
|
} |
|
|
|
var fn = options.fn, |
|
inverse = options.inverse, |
|
i = 0, |
|
ret = '', |
|
data = undefined, |
|
contextPath = undefined; |
|
|
|
if (options.data && options.ids) { |
|
contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.'; |
|
} |
|
|
|
if (_utils.isFunction(context)) { |
|
context = context.call(this); |
|
} |
|
|
|
if (options.data) { |
|
data = _utils.createFrame(options.data); |
|
} |
|
|
|
function execIteration(field, index, last) { |
|
if (data) { |
|
data.key = field; |
|
data.index = index; |
|
data.first = index === 0; |
|
data.last = !!last; |
|
|
|
if (contextPath) { |
|
data.contextPath = contextPath + field; |
|
} |
|
} |
|
|
|
ret = ret + fn(context[field], { |
|
data: data, |
|
blockParams: _utils.blockParams([context[field], field], [contextPath + field, null]) |
|
}); |
|
} |
|
|
|
if (context && typeof context === 'object') { |
|
if (_utils.isArray(context)) { |
|
for (var j = context.length; i < j; i++) { |
|
if (i in context) { |
|
execIteration(i, i, i === context.length - 1); |
|
} |
|
} |
|
} else { |
|
var priorKey = undefined; |
|
|
|
for (var key in context) { |
|
if (context.hasOwnProperty(key)) { |
|
// We're running the iterations one step out of sync so we can detect |
|
// the last iteration without have to scan the object twice and create |
|
// an itermediate keys array. |
|
if (priorKey !== undefined) { |
|
execIteration(priorKey, i - 1); |
|
} |
|
priorKey = key; |
|
i++; |
|
} |
|
} |
|
if (priorKey !== undefined) { |
|
execIteration(priorKey, i - 1, true); |
|
} |
|
} |
|
} |
|
|
|
if (i === 0) { |
|
ret = inverse(this); |
|
} |
|
|
|
return ret; |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 12 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var _interopRequireDefault = __webpack_require__(2)['default']; |
|
|
|
exports.__esModule = true; |
|
|
|
var _exception = __webpack_require__(5); |
|
|
|
var _exception2 = _interopRequireDefault(_exception); |
|
|
|
exports['default'] = function (instance) { |
|
instance.registerHelper('helperMissing', function () /* [args, ]options */{ |
|
if (arguments.length === 1) { |
|
// A missing field in a {{foo}} construct. |
|
return undefined; |
|
} else { |
|
// Someone is actually trying to call something, blow up. |
|
throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"'); |
|
} |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 13 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
exports['default'] = function (instance) { |
|
instance.registerHelper('if', function (conditional, options) { |
|
if (_utils.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 }); |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 14 */ |
|
/***/ (function(module, exports) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
exports['default'] = function (instance) { |
|
instance.registerHelper('log', function () /* message, options */{ |
|
var args = [undefined], |
|
options = arguments[arguments.length - 1]; |
|
for (var i = 0; i < arguments.length - 1; i++) { |
|
args.push(arguments[i]); |
|
} |
|
|
|
var level = 1; |
|
if (options.hash.level != null) { |
|
level = options.hash.level; |
|
} else if (options.data && options.data.level != null) { |
|
level = options.data.level; |
|
} |
|
args[0] = level; |
|
|
|
instance.log.apply(instance, args); |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 15 */ |
|
/***/ (function(module, exports) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
exports['default'] = function (instance) { |
|
instance.registerHelper('lookup', function (obj, field) { |
|
return obj && obj[field]; |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 16 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
exports['default'] = function (instance) { |
|
instance.registerHelper('with', function (context, options) { |
|
if (_utils.isFunction(context)) { |
|
context = context.call(this); |
|
} |
|
|
|
var fn = options.fn; |
|
|
|
if (!_utils.isEmpty(context)) { |
|
var data = options.data; |
|
if (options.data && options.ids) { |
|
data = _utils.createFrame(options.data); |
|
data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]); |
|
} |
|
|
|
return fn(context, { |
|
data: data, |
|
blockParams: _utils.blockParams([context], [data && data.contextPath]) |
|
}); |
|
} else { |
|
return options.inverse(this); |
|
} |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 17 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var _interopRequireDefault = __webpack_require__(2)['default']; |
|
|
|
exports.__esModule = true; |
|
exports.registerDefaultDecorators = registerDefaultDecorators; |
|
|
|
var _decoratorsInline = __webpack_require__(18); |
|
|
|
var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline); |
|
|
|
function registerDefaultDecorators(instance) { |
|
_decoratorsInline2['default'](instance); |
|
} |
|
|
|
/***/ }), |
|
/* 18 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
exports['default'] = function (instance) { |
|
instance.registerDecorator('inline', function (fn, props, container, options) { |
|
var ret = fn; |
|
if (!props.partials) { |
|
props.partials = {}; |
|
ret = function (context, options) { |
|
// Create a new partials stack frame prior to exec. |
|
var original = container.partials; |
|
container.partials = _utils.extend({}, original, props.partials); |
|
var ret = fn(context, options); |
|
container.partials = original; |
|
return ret; |
|
}; |
|
} |
|
|
|
props.partials[options.args[0]] = options.fn; |
|
|
|
return ret; |
|
}); |
|
}; |
|
|
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 19 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
var logger = { |
|
methodMap: ['debug', 'info', 'warn', 'error'], |
|
level: 'info', |
|
|
|
// Maps a given level value to the `methodMap` indexes above. |
|
lookupLevel: function lookupLevel(level) { |
|
if (typeof level === 'string') { |
|
var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase()); |
|
if (levelMap >= 0) { |
|
level = levelMap; |
|
} else { |
|
level = parseInt(level, 10); |
|
} |
|
} |
|
|
|
return level; |
|
}, |
|
|
|
// Can be overridden in the host environment |
|
log: function log(level) { |
|
level = logger.lookupLevel(level); |
|
|
|
if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) { |
|
var method = logger.methodMap[level]; |
|
if (!console[method]) { |
|
// eslint-disable-line no-console |
|
method = 'log'; |
|
} |
|
|
|
for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
|
message[_key - 1] = arguments[_key]; |
|
} |
|
|
|
console[method].apply(console, message); // eslint-disable-line no-console |
|
} |
|
} |
|
}; |
|
|
|
exports['default'] = logger; |
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 20 */ |
|
/***/ (function(module, exports) { |
|
|
|
// Build out our basic SafeString type |
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
function SafeString(string) { |
|
this.string = string; |
|
} |
|
|
|
SafeString.prototype.toString = SafeString.prototype.toHTML = function () { |
|
return '' + this.string; |
|
}; |
|
|
|
exports['default'] = SafeString; |
|
module.exports = exports['default']; |
|
|
|
/***/ }), |
|
/* 21 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var _Object$seal = __webpack_require__(22)['default']; |
|
|
|
var _interopRequireWildcard = __webpack_require__(1)['default']; |
|
|
|
var _interopRequireDefault = __webpack_require__(2)['default']; |
|
|
|
exports.__esModule = true; |
|
exports.checkRevision = checkRevision; |
|
exports.template = template; |
|
exports.wrapProgram = wrapProgram; |
|
exports.resolvePartial = resolvePartial; |
|
exports.invokePartial = invokePartial; |
|
exports.noop = noop; |
|
|
|
var _utils = __webpack_require__(4); |
|
|
|
var Utils = _interopRequireWildcard(_utils); |
|
|
|
var _exception = __webpack_require__(5); |
|
|
|
var _exception2 = _interopRequireDefault(_exception); |
|
|
|
var _base = __webpack_require__(3); |
|
|
|
function checkRevision(compilerInfo) { |
|
var compilerRevision = compilerInfo && compilerInfo[0] || 1, |
|
currentRevision = _base.COMPILER_REVISION; |
|
|
|
if (compilerRevision !== currentRevision) { |
|
if (compilerRevision < currentRevision) { |
|
var runtimeVersions = _base.REVISION_CHANGES[currentRevision], |
|
compilerVersions = _base.REVISION_CHANGES[compilerRevision]; |
|
throw new _exception2['default']('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 _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').'); |
|
} |
|
} |
|
} |
|
|
|
function template(templateSpec, env) { |
|
/* istanbul ignore next */ |
|
if (!env) { |
|
throw new _exception2['default']('No environment passed to template'); |
|
} |
|
if (!templateSpec || !templateSpec.main) { |
|
throw new _exception2['default']('Unknown template object: ' + typeof templateSpec); |
|
} |
|
|
|
templateSpec.main.decorator = templateSpec.main_d; |
|
|
|
// 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); |
|
|
|
function invokePartialWrapper(partial, context, options) { |
|
if (options.hash) { |
|
context = Utils.extend({}, context, options.hash); |
|
if (options.ids) { |
|
options.ids[0] = true; |
|
} |
|
} |
|
|
|
partial = env.VM.resolvePartial.call(this, partial, context, options); |
|
var result = env.VM.invokePartial.call(this, partial, context, options); |
|
|
|
if (result == null && env.compile) { |
|
options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env); |
|
result = options.partials[options.name](context, options); |
|
} |
|
if (result != null) { |
|
if (options.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] = options.indent + lines[i]; |
|
} |
|
result = lines.join('\n'); |
|
} |
|
return result; |
|
} else { |
|
throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode'); |
|
} |
|
} |
|
|
|
// Just add water |
|
var container = { |
|
strict: function strict(obj, name) { |
|
if (!(name in obj)) { |
|
throw new _exception2['default']('"' + name + '" not defined in ' + obj); |
|
} |
|
return obj[name]; |
|
}, |
|
lookup: function lookup(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 lambda(current, context) { |
|
return typeof current === 'function' ? current.call(context) : current; |
|
}, |
|
|
|
escapeExpression: Utils.escapeExpression, |
|
invokePartial: invokePartialWrapper, |
|
|
|
fn: function fn(i) { |
|
var ret = templateSpec[i]; |
|
ret.decorator = templateSpec[i + '_d']; |
|
return ret; |
|
}, |
|
|
|
programs: [], |
|
program: function program(i, data, declaredBlockParams, blockParams, depths) { |
|
var programWrapper = this.programs[i], |
|
fn = this.fn(i); |
|
if (data || depths || blockParams || declaredBlockParams) { |
|
programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths); |
|
} else if (!programWrapper) { |
|
programWrapper = this.programs[i] = wrapProgram(this, i, fn); |
|
} |
|
return programWrapper; |
|
}, |
|
|
|
data: function data(value, depth) { |
|
while (value && depth--) { |
|
value = value._parent; |
|
} |
|
return value; |
|
}, |
|
merge: function merge(param, common) { |
|
var obj = param || common; |
|
|
|
if (param && common && param !== common) { |
|
obj = Utils.extend({}, common, param); |
|
} |
|
|
|
return obj; |
|
}, |
|
// An empty object to use as replacement for null-contexts |
|
nullContext: _Object$seal({}), |
|
|
|
noop: env.VM.noop, |
|
compilerInfo: templateSpec.compiler |
|
}; |
|
|
|
function ret(context) { |
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; |
|
|
|
var data = options.data; |
|
|
|
ret._setup(options); |
|
if (!options.partial && templateSpec.useData) { |
|
data = initData(context, data); |
|
} |
|
var depths = undefined, |
|
blockParams = templateSpec.useBlockParams ? [] : undefined; |
|
if (templateSpec.useDepths) { |
|
if (options.depths) { |
|
depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths; |
|
} else { |
|
depths = [context]; |
|
} |
|
} |
|
|
|
function main(context /*, options*/) { |
|
return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths); |
|
} |
|
main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams); |
|
return main(context, options); |
|
} |
|
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); |
|
} |
|
if (templateSpec.usePartial || templateSpec.useDecorators) { |
|
container.decorators = container.merge(options.decorators, env.decorators); |
|
} |
|
} else { |
|
container.helpers = options.helpers; |
|
container.partials = options.partials; |
|
container.decorators = options.decorators; |
|
} |
|
}; |
|
|
|
ret._child = function (i, data, blockParams, depths) { |
|
if (templateSpec.useBlockParams && !blockParams) { |
|
throw new _exception2['default']('must pass block params'); |
|
} |
|
if (templateSpec.useDepths && !depths) { |
|
throw new _exception2['default']('must pass parent depths'); |
|
} |
|
|
|
return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths); |
|
}; |
|
return ret; |
|
} |
|
|
|
function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) { |
|
function prog(context) { |
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; |
|
|
|
var currentDepths = depths; |
|
if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) { |
|
currentDepths = [context].concat(depths); |
|
} |
|
|
|
return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths); |
|
} |
|
|
|
prog = executeDecorators(fn, prog, container, depths, data, blockParams); |
|
|
|
prog.program = i; |
|
prog.depth = depths ? depths.length : 0; |
|
prog.blockParams = declaredBlockParams || 0; |
|
return prog; |
|
} |
|
|
|
function resolvePartial(partial, context, options) { |
|
if (!partial) { |
|
if (options.name === '@partial-block') { |
|
partial = options.data['partial-block']; |
|
} else { |
|
partial = options.partials[options.name]; |
|
} |
|
} else if (!partial.call && !options.name) { |
|
// This is a dynamic partial that returned a string |
|
options.name = partial; |
|
partial = options.partials[partial]; |
|
} |
|
return partial; |
|
} |
|
|
|
function invokePartial(partial, context, options) { |
|
// Use the current closure context to save the partial-block if this partial |
|
var currentPartialBlock = options.data && options.data['partial-block']; |
|
options.partial = true; |
|
if (options.ids) { |
|
options.data.contextPath = options.ids[0] || options.data.contextPath; |
|
} |
|
|
|
var partialBlock = undefined; |
|
if (options.fn && options.fn !== noop) { |
|
(function () { |
|
options.data = _base.createFrame(options.data); |
|
// Wrapper function to get access to currentPartialBlock from the closure |
|
var fn = options.fn; |
|
partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) { |
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; |
|
|
|
// Restore the partial-block from the closure for the execution of the block |
|
// i.e. the part inside the block of the partial call. |
|
options.data = _base.createFrame(options.data); |
|
options.data['partial-block'] = currentPartialBlock; |
|
return fn(context, options); |
|
}; |
|
if (fn.partials) { |
|
options.partials = Utils.extend({}, options.partials, fn.partials); |
|
} |
|
})(); |
|
} |
|
|
|
if (partial === undefined && partialBlock) { |
|
partial = partialBlock; |
|
} |
|
|
|
if (partial === undefined) { |
|
throw new _exception2['default']('The partial ' + options.name + ' could not be found'); |
|
} else if (partial instanceof Function) { |
|
return partial(context, options); |
|
} |
|
} |
|
|
|
function noop() { |
|
return ''; |
|
} |
|
|
|
function initData(context, data) { |
|
if (!data || !('root' in data)) { |
|
data = data ? _base.createFrame(data) : {}; |
|
data.root = context; |
|
} |
|
return data; |
|
} |
|
|
|
function executeDecorators(fn, prog, container, depths, data, blockParams) { |
|
if (fn.decorator) { |
|
var props = {}; |
|
prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths); |
|
Utils.extend(prog, props); |
|
} |
|
return prog; |
|
} |
|
|
|
/***/ }), |
|
/* 22 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
module.exports = { "default": __webpack_require__(23), __esModule: true }; |
|
|
|
/***/ }), |
|
/* 23 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
__webpack_require__(24); |
|
module.exports = __webpack_require__(29).Object.seal; |
|
|
|
/***/ }), |
|
/* 24 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
// 19.1.2.17 Object.seal(O) |
|
var isObject = __webpack_require__(25); |
|
|
|
__webpack_require__(26)('seal', function($seal){ |
|
return function seal(it){ |
|
return $seal && isObject(it) ? $seal(it) : it; |
|
}; |
|
}); |
|
|
|
/***/ }), |
|
/* 25 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = function(it){ |
|
return typeof it === 'object' ? it !== null : typeof it === 'function'; |
|
}; |
|
|
|
/***/ }), |
|
/* 26 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
// most Object methods by ES6 should accept primitives |
|
var $export = __webpack_require__(27) |
|
, core = __webpack_require__(29) |
|
, fails = __webpack_require__(32); |
|
module.exports = function(KEY, exec){ |
|
var fn = (core.Object || {})[KEY] || Object[KEY] |
|
, exp = {}; |
|
exp[KEY] = exec(fn); |
|
$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp); |
|
}; |
|
|
|
/***/ }), |
|
/* 27 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
var global = __webpack_require__(28) |
|
, core = __webpack_require__(29) |
|
, ctx = __webpack_require__(30) |
|
, PROTOTYPE = 'prototype'; |
|
|
|
var $export = function(type, name, source){ |
|
var IS_FORCED = type & $export.F |
|
, IS_GLOBAL = type & $export.G |
|
, IS_STATIC = type & $export.S |
|
, IS_PROTO = type & $export.P |
|
, IS_BIND = type & $export.B |
|
, IS_WRAP = type & $export.W |
|
, exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) |
|
, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE] |
|
, key, own, out; |
|
if(IS_GLOBAL)source = name; |
|
for(key in source){ |
|
// contains in native |
|
own = !IS_FORCED && target && key in target; |
|
if(own && key in exports)continue; |
|
// export native or passed |
|
out = own ? target[key] : source[key]; |
|
// prevent global pollution for namespaces |
|
exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] |
|
// bind timers to global for call from export context |
|
: IS_BIND && own ? ctx(out, global) |
|
// wrap global constructors for prevent change them in library |
|
: IS_WRAP && target[key] == out ? (function(C){ |
|
var F = function(param){ |
|
return this instanceof C ? new C(param) : C(param); |
|
}; |
|
F[PROTOTYPE] = C[PROTOTYPE]; |
|
return F; |
|
// make static versions for prototype methods |
|
})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; |
|
if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out; |
|
} |
|
}; |
|
// type bitmap |
|
$export.F = 1; // forced |
|
$export.G = 2; // global |
|
$export.S = 4; // static |
|
$export.P = 8; // proto |
|
$export.B = 16; // bind |
|
$export.W = 32; // wrap |
|
module.exports = $export; |
|
|
|
/***/ }), |
|
/* 28 */ |
|
/***/ (function(module, exports) { |
|
|
|
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 |
|
var global = module.exports = typeof window != 'undefined' && window.Math == Math |
|
? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); |
|
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef |
|
|
|
/***/ }), |
|
/* 29 */ |
|
/***/ (function(module, exports) { |
|
|
|
var core = module.exports = {version: '1.2.6'}; |
|
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef |
|
|
|
/***/ }), |
|
/* 30 */ |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
// optional / simple context binding |
|
var aFunction = __webpack_require__(31); |
|
module.exports = function(fn, that, length){ |
|
aFunction(fn); |
|
if(that === undefined)return fn; |
|
switch(length){ |
|
case 1: return function(a){ |
|
return fn.call(that, a); |
|
}; |
|
case 2: return function(a, b){ |
|
return fn.call(that, a, b); |
|
}; |
|
case 3: return function(a, b, c){ |
|
return fn.call(that, a, b, c); |
|
}; |
|
} |
|
return function(/* ...args */){ |
|
return fn.apply(that, arguments); |
|
}; |
|
}; |
|
|
|
/***/ }), |
|
/* 31 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = function(it){ |
|
if(typeof it != 'function')throw TypeError(it + ' is not a function!'); |
|
return it; |
|
}; |
|
|
|
/***/ }), |
|
/* 32 */ |
|
/***/ (function(module, exports) { |
|
|
|
module.exports = function(exec){ |
|
try { |
|
return !!exec(); |
|
} catch(e){ |
|
return true; |
|
} |
|
}; |
|
|
|
/***/ }), |
|
/* 33 */ |
|
/***/ (function(module, exports) { |
|
|
|
/* WEBPACK VAR INJECTION */(function(global) {/* global window */ |
|
'use strict'; |
|
|
|
exports.__esModule = true; |
|
|
|
exports['default'] = function (Handlebars) { |
|
/* istanbul ignore next */ |
|
var root = typeof global !== 'undefined' ? global : window, |
|
$Handlebars = root.Handlebars; |
|
/* istanbul ignore next */ |
|
Handlebars.noConflict = function () { |
|
if (root.Handlebars === Handlebars) { |
|
root.Handlebars = $Handlebars; |
|
} |
|
return Handlebars; |
|
}; |
|
}; |
|
|
|
module.exports = exports['default']; |
|
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) |
|
|
|
/***/ }) |
|
/******/ ]) |
|
}); |
|
; |