UpdraftCentral Dashboard / trunk

UpdraftCentral Dashboard vtrunk

updraftcentral / js / handlebars / handlebars.runtime.js

handlebars.runtime.js in UpdraftCentral Dashboard trunk, at js/handlebars/handlebars.runtime.js

2,563 lines 73.2 KB

Raw Download Zip

1	/**!
2
3	@license
4	handlebars v4.7.8
5
6	Copyright (C) 2011-2019 by Yehuda Katz
7
8	Permission is hereby granted, free of charge, to any person obtaining a copy
9	of this software and associated documentation files (the "Software"), to deal
10	in the Software without restriction, including without limitation the rights
11	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12	copies of the Software, and to permit persons to whom the Software is
13	furnished to do so, subject to the following conditions:
14
15	The above copyright notice and this permission notice shall be included in
16	all copies or substantial portions of the Software.
17
18	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24	THE SOFTWARE.
25
26	*/
27	(function webpackUniversalModuleDefinition(root, factory) {
28	if(typeof exports === 'object' && typeof module === 'object')
29	module.exports = factory();
30	else if(typeof define === 'function' && define.amd)
31	define([], factory);
32	else if(typeof exports === 'object')
33	exports["Handlebars"] = factory();
34	else
35	root["Handlebars"] = factory();
36	})(this, function() {
37	return /******/ (function(modules) { // webpackBootstrap
38	/******/ // The module cache
39	/******/ var installedModules = {};
40
41	/******/ // The require function
42	/******/ function __webpack_require__(moduleId) {
43
44	/******/ // Check if module is in cache
45	/******/ if(installedModules[moduleId])
46	/******/ return installedModules[moduleId].exports;
47
48	/******/ // Create a new module (and put it into the cache)
49	/******/ var module = installedModules[moduleId] = {
50	/******/ exports: {},
51	/******/ id: moduleId,
52	/******/ loaded: false
53	/******/ };
54
55	/******/ // Execute the module function
56	/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
57
58	/******/ // Flag the module as loaded
59	/******/ module.loaded = true;
60
61	/******/ // Return the exports of the module
62	/******/ return module.exports;
63	/******/ }
64
65
66	/******/ // expose the modules object (__webpack_modules__)
67	/******/ __webpack_require__.m = modules;
68
69	/******/ // expose the module cache
70	/******/ __webpack_require__.c = installedModules;
71
72	/******/ // __webpack_public_path__
73	/******/ __webpack_require__.p = "";
74
75	/******/ // Load entry module and return exports
76	/******/ return __webpack_require__(0);
77	/******/ })
78	/************************************************************************/
79	/******/ ([
80	/* 0 */
81	/***/ (function(module, exports, __webpack_require__) {
82
83	'use strict';
84
85	var _interopRequireWildcard = __webpack_require__(1)['default'];
86
87	var _interopRequireDefault = __webpack_require__(2)['default'];
88
89	exports.__esModule = true;
90
91	var _handlebarsBase = __webpack_require__(3);
92
93	var base = _interopRequireWildcard(_handlebarsBase);
94
95	// Each of these augment the Handlebars object. No need to setup here.
96	// (This is done to easily share code between commonjs and browse envs)
97
98	var _handlebarsSafeString = __webpack_require__(76);
99
100	var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);
101
102	var _handlebarsException = __webpack_require__(5);
103
104	var _handlebarsException2 = _interopRequireDefault(_handlebarsException);
105
106	var _handlebarsUtils = __webpack_require__(4);
107
108	var Utils = _interopRequireWildcard(_handlebarsUtils);
109
110	var _handlebarsRuntime = __webpack_require__(77);
111
112	var runtime = _interopRequireWildcard(_handlebarsRuntime);
113
114	var _handlebarsNoConflict = __webpack_require__(82);
115
116	var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);
117
118	// For compatibility and usage outside of module systems, make the Handlebars object a namespace
119	function create() {
120	var hb = new base.HandlebarsEnvironment();
121
122	Utils.extend(hb, base);
123	hb.SafeString = _handlebarsSafeString2['default'];
124	hb.Exception = _handlebarsException2['default'];
125	hb.Utils = Utils;
126	hb.escapeExpression = Utils.escapeExpression;
127
128	hb.VM = runtime;
129	hb.template = function (spec) {
130	return runtime.template(spec, hb);
131	};
132
133	return hb;
134	}
135
136	var inst = create();
137	inst.create = create;
138
139	_handlebarsNoConflict2['default'](inst);
140
141	inst['default'] = inst;
142
143	exports['default'] = inst;
144	module.exports = exports['default'];
145
146	/***/ }),
147	/* 1 */
148	/***/ (function(module, exports) {
149
150	"use strict";
151
152	exports["default"] = function (obj) {
153	if (obj && obj.__esModule) {
154	return obj;
155	} else {
156	var newObj = {};
157
158	if (obj != null) {
159	for (var key in obj) {
160	if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
161	}
162	}
163
164	newObj["default"] = obj;
165	return newObj;
166	}
167	};
168
169	exports.__esModule = true;
170
171	/***/ }),
172	/* 2 */
173	/***/ (function(module, exports) {
174
175	"use strict";
176
177	exports["default"] = function (obj) {
178	return obj && obj.__esModule ? obj : {
179	"default": obj
180	};
181	};
182
183	exports.__esModule = true;
184
185	/***/ }),
186	/* 3 */
187	/***/ (function(module, exports, __webpack_require__) {
188
189	'use strict';
190
191	var _interopRequireDefault = __webpack_require__(2)['default'];
192
193	exports.__esModule = true;
194	exports.HandlebarsEnvironment = HandlebarsEnvironment;
195
196	var _utils = __webpack_require__(4);
197
198	var _exception = __webpack_require__(5);
199
200	var _exception2 = _interopRequireDefault(_exception);
201
202	var _helpers = __webpack_require__(9);
203
204	var _decorators = __webpack_require__(69);
205
206	var _logger = __webpack_require__(71);
207
208	var _logger2 = _interopRequireDefault(_logger);
209
210	var _internalProtoAccess = __webpack_require__(72);
211
212	var VERSION = '4.7.8';
213	exports.VERSION = VERSION;
214	var COMPILER_REVISION = 8;
215	exports.COMPILER_REVISION = COMPILER_REVISION;
216	var LAST_COMPATIBLE_COMPILER_REVISION = 7;
217
218	exports.LAST_COMPATIBLE_COMPILER_REVISION = LAST_COMPATIBLE_COMPILER_REVISION;
219	var REVISION_CHANGES = {
220	1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
221	2: '== 1.0.0-rc.3',
222	3: '== 1.0.0-rc.4',
223	4: '== 1.x.x',
224	5: '== 2.0.0-alpha.x',
225	6: '>= 2.0.0-beta.1',
226	7: '>= 4.0.0 <4.3.0',
227	8: '>= 4.3.0'
228	};
229
230	exports.REVISION_CHANGES = REVISION_CHANGES;
231	var objectType = '[object Object]';
232
233	function HandlebarsEnvironment(helpers, partials, decorators) {
234	this.helpers = helpers \|\| {};
235	this.partials = partials \|\| {};
236	this.decorators = decorators \|\| {};
237
238	_helpers.registerDefaultHelpers(this);
239	_decorators.registerDefaultDecorators(this);
240	}
241
242	HandlebarsEnvironment.prototype = {
243	constructor: HandlebarsEnvironment,
244
245	logger: _logger2['default'],
246	log: _logger2['default'].log,
247
248	registerHelper: function registerHelper(name, fn) {
249	if (_utils.toString.call(name) === objectType) {
250	if (fn) {
251	throw new _exception2['default']('Arg not supported with multiple helpers');
252	}
253	_utils.extend(this.helpers, name);
254	} else {
255	this.helpers[name] = fn;
256	}
257	},
258	unregisterHelper: function unregisterHelper(name) {
259	delete this.helpers[name];
260	},
261
262	registerPartial: function registerPartial(name, partial) {
263	if (_utils.toString.call(name) === objectType) {
264	_utils.extend(this.partials, name);
265	} else {
266	if (typeof partial === 'undefined') {
267	throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined');
268	}
269	this.partials[name] = partial;
270	}
271	},
272	unregisterPartial: function unregisterPartial(name) {
273	delete this.partials[name];
274	},
275
276	registerDecorator: function registerDecorator(name, fn) {
277	if (_utils.toString.call(name) === objectType) {
278	if (fn) {
279	throw new _exception2['default']('Arg not supported with multiple decorators');
280	}
281	_utils.extend(this.decorators, name);
282	} else {
283	this.decorators[name] = fn;
284	}
285	},
286	unregisterDecorator: function unregisterDecorator(name) {
287	delete this.decorators[name];
288	},
289	/**
290	* Reset the memory of illegal property accesses that have already been logged.
291	* @deprecated should only be used in handlebars test-cases
292	*/
293	resetLoggedPropertyAccesses: function resetLoggedPropertyAccesses() {
294	_internalProtoAccess.resetLoggedProperties();
295	}
296	};
297
298	var log = _logger2['default'].log;
299
300	exports.log = log;
301	exports.createFrame = _utils.createFrame;
302	exports.logger = _logger2['default'];
303
304	/***/ }),
305	/* 4 */
306	/***/ (function(module, exports) {
307
308	'use strict';
309
310	exports.__esModule = true;
311	exports.extend = extend;
312	exports.indexOf = indexOf;
313	exports.escapeExpression = escapeExpression;
314	exports.isEmpty = isEmpty;
315	exports.createFrame = createFrame;
316	exports.blockParams = blockParams;
317	exports.appendContextPath = appendContextPath;
318	var escape = {
319	'&': '&',
320	'<': '<',
321	'>': '>',
322	'"': '"',
323	"'": ''',
324	'`': '`',
325	'=': '='
326	};
327
328	var badChars = /[&<>"'`=]/g,
329	possible = /[&<>"'`=]/;
330
331	function escapeChar(chr) {
332	return escape[chr];
333	}
334
335	function extend(obj /* , ...source */) {
336	for (var i = 1; i < arguments.length; i++) {
337	for (var key in arguments[i]) {
338	if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
339	obj[key] = arguments[i][key];
340	}
341	}
342	}
343
344	return obj;
345	}
346
347	var toString = Object.prototype.toString;
348
349	exports.toString = toString;
350	// Sourced from lodash
351	// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
352	/* eslint-disable func-style */
353	var isFunction = function isFunction(value) {
354	return typeof value === 'function';
355	};
356	// fallback for older versions of Chrome and Safari
357	/* istanbul ignore next */
358	if (isFunction(/x/)) {
359	exports.isFunction = isFunction = function (value) {
360	return typeof value === 'function' && toString.call(value) === '[object Function]';
361	};
362	}
363	exports.isFunction = isFunction;
364
365	/* eslint-enable func-style */
366
367	/* istanbul ignore next */
368	var isArray = Array.isArray \|\| function (value) {
369	return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
370	};
371
372	exports.isArray = isArray;
373	// Older IE versions do not directly support indexOf so we must implement our own, sadly.
374
375	function indexOf(array, value) {
376	for (var i = 0, len = array.length; i < len; i++) {
377	if (array[i] === value) {
378	return i;
379	}
380	}
381	return -1;
382	}
383
384	function escapeExpression(string) {
385	if (typeof string !== 'string') {
386	// don't escape SafeStrings, since they're already safe
387	if (string && string.toHTML) {
388	return string.toHTML();
389	} else if (string == null) {
390	return '';
391	} else if (!string) {
392	return string + '';
393	}
394
395	// Force a string conversion as this will be done by the append regardless and
396	// the regex test will do this transparently behind the scenes, causing issues if
397	// an object's to string has escaped characters in it.
398	string = '' + string;
399	}
400
401	if (!possible.test(string)) {
402	return string;
403	}
404	return string.replace(badChars, escapeChar);
405	}
406
407	function isEmpty(value) {
408	if (!value && value !== 0) {
409	return true;
410	} else if (isArray(value) && value.length === 0) {
411	return true;
412	} else {
413	return false;
414	}
415	}
416
417	function createFrame(object) {
418	var frame = extend({}, object);
419	frame._parent = object;
420	return frame;
421	}
422
423	function blockParams(params, ids) {
424	params.path = ids;
425	return params;
426	}
427
428	function appendContextPath(contextPath, id) {
429	return (contextPath ? contextPath + '.' : '') + id;
430	}
431
432	/***/ }),
433	/* 5 */
434	/***/ (function(module, exports, __webpack_require__) {
435
436	'use strict';
437
438	var _Object$defineProperty = __webpack_require__(6)['default'];
439
440	exports.__esModule = true;
441	var errorProps = ['description', 'fileName', 'lineNumber', 'endLineNumber', 'message', 'name', 'number', 'stack'];
442
443	function Exception(message, node) {
444	var loc = node && node.loc,
445	line = undefined,
446	endLineNumber = undefined,
447	column = undefined,
448	endColumn = undefined;
449
450	if (loc) {
451	line = loc.start.line;
452	endLineNumber = loc.end.line;
453	column = loc.start.column;
454	endColumn = loc.end.column;
455
456	message += ' - ' + line + ':' + column;
457	}
458
459	var tmp = Error.prototype.constructor.call(this, message);
460
461	// Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
462	for (var idx = 0; idx < errorProps.length; idx++) {
463	this[errorProps[idx]] = tmp[errorProps[idx]];
464	}
465
466	/* istanbul ignore else */
467	if (Error.captureStackTrace) {
468	Error.captureStackTrace(this, Exception);
469	}
470
471	try {
472	if (loc) {
473	this.lineNumber = line;
474	this.endLineNumber = endLineNumber;
475
476	// Work around issue under safari where we can't directly set the column value
477	/* istanbul ignore next */
478	if (_Object$defineProperty) {
479	Object.defineProperty(this, 'column', {
480	value: column,
481	enumerable: true
482	});
483	Object.defineProperty(this, 'endColumn', {
484	value: endColumn,
485	enumerable: true
486	});
487	} else {
488	this.column = column;
489	this.endColumn = endColumn;
490	}
491	}
492	} catch (nop) {
493	/* Ignore if the browser is very particular */
494	}
495	}
496
497	Exception.prototype = new Error();
498
499	exports['default'] = Exception;
500	module.exports = exports['default'];
501
502	/***/ }),
503	/* 6 */
504	/***/ (function(module, exports, __webpack_require__) {
505
506	module.exports = { "default": __webpack_require__(7), __esModule: true };
507
508	/***/ }),
509	/* 7 */
510	/***/ (function(module, exports, __webpack_require__) {
511
512	var $ = __webpack_require__(8);
513	module.exports = function defineProperty(it, key, desc){
514	return $.setDesc(it, key, desc);
515	};
516
517	/***/ }),
518	/* 8 */
519	/***/ (function(module, exports) {
520
521	var $Object = Object;
522	module.exports = {
523	create: $Object.create,
524	getProto: $Object.getPrototypeOf,
525	isEnum: {}.propertyIsEnumerable,
526	getDesc: $Object.getOwnPropertyDescriptor,
527	setDesc: $Object.defineProperty,
528	setDescs: $Object.defineProperties,
529	getKeys: $Object.keys,
530	getNames: $Object.getOwnPropertyNames,
531	getSymbols: $Object.getOwnPropertySymbols,
532	each: [].forEach
533	};
534
535	/***/ }),
536	/* 9 */
537	/***/ (function(module, exports, __webpack_require__) {
538
539	'use strict';
540
541	var _interopRequireDefault = __webpack_require__(2)['default'];
542
543	exports.__esModule = true;
544	exports.registerDefaultHelpers = registerDefaultHelpers;
545	exports.moveHelperToHooks = moveHelperToHooks;
546
547	var _helpersBlockHelperMissing = __webpack_require__(10);
548
549	var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing);
550
551	var _helpersEach = __webpack_require__(11);
552
553	var _helpersEach2 = _interopRequireDefault(_helpersEach);
554
555	var _helpersHelperMissing = __webpack_require__(64);
556
557	var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing);
558
559	var _helpersIf = __webpack_require__(65);
560
561	var _helpersIf2 = _interopRequireDefault(_helpersIf);
562
563	var _helpersLog = __webpack_require__(66);
564
565	var _helpersLog2 = _interopRequireDefault(_helpersLog);
566
567	var _helpersLookup = __webpack_require__(67);
568
569	var _helpersLookup2 = _interopRequireDefault(_helpersLookup);
570
571	var _helpersWith = __webpack_require__(68);
572
573	var _helpersWith2 = _interopRequireDefault(_helpersWith);
574
575	function registerDefaultHelpers(instance) {
576	_helpersBlockHelperMissing2['default'](instance);
577	_helpersEach2['default'](instance);
578	_helpersHelperMissing2['default'](instance);
579	_helpersIf2['default'](instance);
580	_helpersLog2['default'](instance);
581	_helpersLookup2['default'](instance);
582	_helpersWith2['default'](instance);
583	}
584
585	function moveHelperToHooks(instance, helperName, keepHelper) {
586	if (instance.helpers[helperName]) {
587	instance.hooks[helperName] = instance.helpers[helperName];
588	if (!keepHelper) {
589	delete instance.helpers[helperName];
590	}
591	}
592	}
593
594	/***/ }),
595	/* 10 */
596	/***/ (function(module, exports, __webpack_require__) {
597
598	'use strict';
599
600	exports.__esModule = true;
601
602	var _utils = __webpack_require__(4);
603
604	exports['default'] = function (instance) {
605	instance.registerHelper('blockHelperMissing', function (context, options) {
606	var inverse = options.inverse,
607	fn = options.fn;
608
609	if (context === true) {
610	return fn(this);
611	} else if (context === false \|\| context == null) {
612	return inverse(this);
613	} else if (_utils.isArray(context)) {
614	if (context.length > 0) {
615	if (options.ids) {
616	options.ids = [options.name];
617	}
618
619	return instance.helpers.each(context, options);
620	} else {
621	return inverse(this);
622	}
623	} else {
624	if (options.data && options.ids) {
625	var data = _utils.createFrame(options.data);
626	data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
627	options = { data: data };
628	}
629
630	return fn(context, options);
631	}
632	});
633	};
634
635	module.exports = exports['default'];
636
637	/***/ }),
638	/* 11 */
639	/***/ (function(module, exports, __webpack_require__) {
640
641	'use strict';
642
643	var _Symbol = __webpack_require__(12)['default'];
644
645	var _Symbol$iterator = __webpack_require__(42)['default'];
646
647	var _getIterator = __webpack_require__(54)['default'];
648
649	var _Object$keys = __webpack_require__(59)['default'];
650
651	var _interopRequireDefault = __webpack_require__(2)['default'];
652
653	exports.__esModule = true;
654
655	var _utils = __webpack_require__(4);
656
657	var _exception = __webpack_require__(5);
658
659	var _exception2 = _interopRequireDefault(_exception);
660
661	exports['default'] = function (instance) {
662	instance.registerHelper('each', function (context, options) {
663	if (!options) {
664	throw new _exception2['default']('Must pass iterator to #each');
665	}
666
667	var fn = options.fn,
668	inverse = options.inverse,
669	i = 0,
670	ret = '',
671	data = undefined,
672	contextPath = undefined;
673
674	if (options.data && options.ids) {
675	contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
676	}
677
678	if (_utils.isFunction(context)) {
679	context = context.call(this);
680	}
681
682	if (options.data) {
683	data = _utils.createFrame(options.data);
684	}
685
686	function execIteration(field, index, last) {
687	if (data) {
688	data.key = field;
689	data.index = index;
690	data.first = index === 0;
691	data.last = !!last;
692
693	if (contextPath) {
694	data.contextPath = contextPath + field;
695	}
696	}
697
698	ret = ret + fn(context[field], {
699	data: data,
700	blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])
701	});
702	}
703
704	if (context && typeof context === 'object') {
705	if (_utils.isArray(context)) {
706	for (var j = context.length; i < j; i++) {
707	if (i in context) {
708	execIteration(i, i, i === context.length - 1);
709	}
710	}
711	} else if (typeof _Symbol === 'function' && context[_Symbol$iterator]) {
712	var newContext = [];
713	var iterator = _getIterator(context);
714	for (var it = iterator.next(); !it.done; it = iterator.next()) {
715	newContext.push(it.value);
716	}
717	context = newContext;
718	for (var j = context.length; i < j; i++) {
719	execIteration(i, i, i === context.length - 1);
720	}
721	} else {
722	(function () {
723	var priorKey = undefined;
724
725	_Object$keys(context).forEach(function (key) {
726	// We're running the iterations one step out of sync so we can detect
727	// the last iteration without have to scan the object twice and create
728	// an itermediate keys array.
729	if (priorKey !== undefined) {
730	execIteration(priorKey, i - 1);
731	}
732	priorKey = key;
733	i++;
734	});
735	if (priorKey !== undefined) {
736	execIteration(priorKey, i - 1, true);
737	}
738	})();
739	}
740	}
741
742	if (i === 0) {
743	ret = inverse(this);
744	}
745
746	return ret;
747	});
748	};
749
750	module.exports = exports['default'];
751
752	/***/ }),
753	/* 12 */
754	/***/ (function(module, exports, __webpack_require__) {
755
756	module.exports = { "default": __webpack_require__(13), __esModule: true };
757
758	/***/ }),
759	/* 13 */
760	/***/ (function(module, exports, __webpack_require__) {
761
762	__webpack_require__(14);
763	__webpack_require__(41);
764	module.exports = __webpack_require__(20).Symbol;
765
766	/***/ }),
767	/* 14 */
768	/***/ (function(module, exports, __webpack_require__) {
769
770	'use strict';
771	// ECMAScript 6 symbols shim
772	var $ = __webpack_require__(8)
773	, global = __webpack_require__(15)
774	, has = __webpack_require__(16)
775	, DESCRIPTORS = __webpack_require__(17)
776	, $export = __webpack_require__(19)
777	, redefine = __webpack_require__(23)
778	, $fails = __webpack_require__(18)
779	, shared = __webpack_require__(26)
780	, setToStringTag = __webpack_require__(27)
781	, uid = __webpack_require__(29)
782	, wks = __webpack_require__(28)
783	, keyOf = __webpack_require__(30)
784	, $names = __webpack_require__(35)
785	, enumKeys = __webpack_require__(36)
786	, isArray = __webpack_require__(37)
787	, anObject = __webpack_require__(38)
788	, toIObject = __webpack_require__(31)
789	, createDesc = __webpack_require__(25)
790	, getDesc = $.getDesc
791	, setDesc = $.setDesc
792	, _create = $.create
793	, getNames = $names.get
794	, $Symbol = global.Symbol
795	, $JSON = global.JSON
796	, _stringify = $JSON && $JSON.stringify
797	, setter = false
798	, HIDDEN = wks('_hidden')
799	, isEnum = $.isEnum
800	, SymbolRegistry = shared('symbol-registry')
801	, AllSymbols = shared('symbols')
802	, useNative = typeof $Symbol == 'function'
803	, ObjectProto = Object.prototype;
804
805	// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
806	var setSymbolDesc = DESCRIPTORS && $fails(function(){
807	return _create(setDesc({}, 'a', {
808	get: function(){ return setDesc(this, 'a', {value: 7}).a; }
809	})).a != 7;
810	}) ? function(it, key, D){
811	var protoDesc = getDesc(ObjectProto, key);
812	if(protoDesc)delete ObjectProto[key];
813	setDesc(it, key, D);
814	if(protoDesc && it !== ObjectProto)setDesc(ObjectProto, key, protoDesc);
815	} : setDesc;
816
817	var wrap = function(tag){
818	var sym = AllSymbols[tag] = _create($Symbol.prototype);
819	sym._k = tag;
820	DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, {
821	configurable: true,
822	set: function(value){
823	if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
824	setSymbolDesc(this, tag, createDesc(1, value));
825	}
826	});
827	return sym;
828	};
829
830	var isSymbol = function(it){
831	return typeof it == 'symbol';
832	};
833
834	var $defineProperty = function defineProperty(it, key, D){
835	if(D && has(AllSymbols, key)){
836	if(!D.enumerable){
837	if(!has(it, HIDDEN))setDesc(it, HIDDEN, createDesc(1, {}));
838	it[HIDDEN][key] = true;
839	} else {
840	if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
841	D = _create(D, {enumerable: createDesc(0, false)});
842	} return setSymbolDesc(it, key, D);
843	} return setDesc(it, key, D);
844	};
845	var $defineProperties = function defineProperties(it, P){
846	anObject(it);
847	var keys = enumKeys(P = toIObject(P))
848	, i = 0
849	, l = keys.length
850	, key;
851	while(l > i)$defineProperty(it, key = keys[i++], P[key]);
852	return it;
853	};
854	var $create = function create(it, P){
855	return P === undefined ? _create(it) : $defineProperties(_create(it), P);
856	};
857	var $propertyIsEnumerable = function propertyIsEnumerable(key){
858	var E = isEnum.call(this, key);
859	return E \|\| !has(this, key) \|\| !has(AllSymbols, key) \|\| has(this, HIDDEN) && this[HIDDEN][key]
860	? E : true;
861	};
862	var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
863	var D = getDesc(it = toIObject(it), key);
864	if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
865	return D;
866	};
867	var $getOwnPropertyNames = function getOwnPropertyNames(it){
868	var names = getNames(toIObject(it))
869	, result = []
870	, i = 0
871	, key;
872	while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);
873	return result;
874	};
875	var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
876	var names = getNames(toIObject(it))
877	, result = []
878	, i = 0
879	, key;
880	while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);
881	return result;
882	};
883	var $stringify = function stringify(it){
884	if(it === undefined \|\| isSymbol(it))return; // IE8 returns string on undefined
885	var args = [it]
886	, i = 1
887	, $$ = arguments
888	, replacer, $replacer;
889	while($$.length > i)args.push($$[i++]);
890	replacer = args[1];
891	if(typeof replacer == 'function')$replacer = replacer;
892	if($replacer \|\| !isArray(replacer))replacer = function(key, value){
893	if($replacer)value = $replacer.call(this, key, value);
894	if(!isSymbol(value))return value;
895	};
896	args[1] = replacer;
897	return _stringify.apply($JSON, args);
898	};
899	var buggyJSON = $fails(function(){
900	var S = $Symbol();
901	// MS Edge converts symbol values to JSON as {}
902	// WebKit converts symbol values to JSON as null
903	// V8 throws on boxed symbols
904	return _stringify([S]) != '[null]' \|\| _stringify({a: S}) != '{}' \|\| _stringify(Object(S)) != '{}';
905	});
906
907	// 19.4.1.1 Symbol([description])
908	if(!useNative){
909	$Symbol = function Symbol(){
910	if(isSymbol(this))throw TypeError('Symbol is not a constructor');
911	return wrap(uid(arguments.length > 0 ? arguments[0] : undefined));
912	};
913	redefine($Symbol.prototype, 'toString', function toString(){
914	return this._k;
915	});
916
917	isSymbol = function(it){
918	return it instanceof $Symbol;
919	};
920
921	$.create = $create;
922	$.isEnum = $propertyIsEnumerable;
923	$.getDesc = $getOwnPropertyDescriptor;
924	$.setDesc = $defineProperty;
925	$.setDescs = $defineProperties;
926	$.getNames = $names.get = $getOwnPropertyNames;
927	$.getSymbols = $getOwnPropertySymbols;
928
929	if(DESCRIPTORS && !__webpack_require__(40)){
930	redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
931	}
932	}
933
934	var symbolStatics = {
935	// 19.4.2.1 Symbol.for(key)
936	'for': function(key){
937	return has(SymbolRegistry, key += '')
938	? SymbolRegistry[key]
939	: SymbolRegistry[key] = $Symbol(key);
940	},
941	// 19.4.2.5 Symbol.keyFor(sym)
942	keyFor: function keyFor(key){
943	return keyOf(SymbolRegistry, key);
944	},
945	useSetter: function(){ setter = true; },
946	useSimple: function(){ setter = false; }
947	};
948	// 19.4.2.2 Symbol.hasInstance
949	// 19.4.2.3 Symbol.isConcatSpreadable
950	// 19.4.2.4 Symbol.iterator
951	// 19.4.2.6 Symbol.match
952	// 19.4.2.8 Symbol.replace
953	// 19.4.2.9 Symbol.search
954	// 19.4.2.10 Symbol.species
955	// 19.4.2.11 Symbol.split
956	// 19.4.2.12 Symbol.toPrimitive
957	// 19.4.2.13 Symbol.toStringTag
958	// 19.4.2.14 Symbol.unscopables
959	$.each.call((
960	'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +
961	'species,split,toPrimitive,toStringTag,unscopables'
962	).split(','), function(it){
963	var sym = wks(it);
964	symbolStatics[it] = useNative ? sym : wrap(sym);
965	});
966
967	setter = true;
968
969	$export($export.G + $export.W, {Symbol: $Symbol});
970
971	$export($export.S, 'Symbol', symbolStatics);
972
973	$export($export.S + $export.F * !useNative, 'Object', {
974	// 19.1.2.2 Object.create(O [, Properties])
975	create: $create,
976	// 19.1.2.4 Object.defineProperty(O, P, Attributes)
977	defineProperty: $defineProperty,
978	// 19.1.2.3 Object.defineProperties(O, Properties)
979	defineProperties: $defineProperties,
980	// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
981	getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
982	// 19.1.2.7 Object.getOwnPropertyNames(O)
983	getOwnPropertyNames: $getOwnPropertyNames,
984	// 19.1.2.8 Object.getOwnPropertySymbols(O)
985	getOwnPropertySymbols: $getOwnPropertySymbols
986	});
987
988	// 24.3.2 JSON.stringify(value [, replacer [, space]])
989	$JSON && $export($export.S + $export.F * (!useNative \|\| buggyJSON), 'JSON', {stringify: $stringify});
990
991	// 19.4.3.5 Symbol.prototype[@@toStringTag]
992	setToStringTag($Symbol, 'Symbol');
993	// 20.2.1.9 Math[@@toStringTag]
994	setToStringTag(Math, 'Math', true);
995	// 24.3.3 JSON[@@toStringTag]
996	setToStringTag(global.JSON, 'JSON', true);
997
998	/***/ }),
999	/* 15 */
1000	/***/ (function(module, exports) {
1001
1002	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
1003	var global = module.exports = typeof window != 'undefined' && window.Math == Math
1004	? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
1005	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
1006
1007	/***/ }),
1008	/* 16 */
1009	/***/ (function(module, exports) {
1010
1011	var hasOwnProperty = {}.hasOwnProperty;
1012	module.exports = function(it, key){
1013	return hasOwnProperty.call(it, key);
1014	};
1015
1016	/***/ }),
1017	/* 17 */
1018	/***/ (function(module, exports, __webpack_require__) {
1019
1020	// Thank's IE8 for his funny defineProperty
1021	module.exports = !__webpack_require__(18)(function(){
1022	return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
1023	});
1024
1025	/***/ }),
1026	/* 18 */
1027	/***/ (function(module, exports) {
1028
1029	module.exports = function(exec){
1030	try {
1031	return !!exec();
1032	} catch(e){
1033	return true;
1034	}
1035	};
1036
1037	/***/ }),
1038	/* 19 */
1039	/***/ (function(module, exports, __webpack_require__) {
1040
1041	var global = __webpack_require__(15)
1042	, core = __webpack_require__(20)
1043	, ctx = __webpack_require__(21)
1044	, PROTOTYPE = 'prototype';
1045
1046	var $export = function(type, name, source){
1047	var IS_FORCED = type & $export.F
1048	, IS_GLOBAL = type & $export.G
1049	, IS_STATIC = type & $export.S
1050	, IS_PROTO = type & $export.P
1051	, IS_BIND = type & $export.B
1052	, IS_WRAP = type & $export.W
1053	, exports = IS_GLOBAL ? core : core[name] \|\| (core[name] = {})
1054	, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] \|\| {})[PROTOTYPE]
1055	, key, own, out;
1056	if(IS_GLOBAL)source = name;
1057	for(key in source){
1058	// contains in native
1059	own = !IS_FORCED && target && key in target;
1060	if(own && key in exports)continue;
1061	// export native or passed
1062	out = own ? target[key] : source[key];
1063	// prevent global pollution for namespaces
1064	exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
1065	// bind timers to global for call from export context
1066	: IS_BIND && own ? ctx(out, global)
1067	// wrap global constructors for prevent change them in library
1068	: IS_WRAP && target[key] == out ? (function(C){
1069	var F = function(param){
1070	return this instanceof C ? new C(param) : C(param);
1071	};
1072	F[PROTOTYPE] = C[PROTOTYPE];
1073	return F;
1074	// make static versions for prototype methods
1075	})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
1076	if(IS_PROTO)(exports[PROTOTYPE] \|\| (exports[PROTOTYPE] = {}))[key] = out;
1077	}
1078	};
1079	// type bitmap
1080	$export.F = 1; // forced
1081	$export.G = 2; // global
1082	$export.S = 4; // static
1083	$export.P = 8; // proto
1084	$export.B = 16; // bind
1085	$export.W = 32; // wrap
1086	module.exports = $export;
1087
1088	/***/ }),
1089	/* 20 */
1090	/***/ (function(module, exports) {
1091
1092	var core = module.exports = {version: '1.2.6'};
1093	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
1094
1095	/***/ }),
1096	/* 21 */
1097	/***/ (function(module, exports, __webpack_require__) {
1098
1099	// optional / simple context binding
1100	var aFunction = __webpack_require__(22);
1101	module.exports = function(fn, that, length){
1102	aFunction(fn);
1103	if(that === undefined)return fn;
1104	switch(length){
1105	case 1: return function(a){
1106	return fn.call(that, a);
1107	};
1108	case 2: return function(a, b){
1109	return fn.call(that, a, b);
1110	};
1111	case 3: return function(a, b, c){
1112	return fn.call(that, a, b, c);
1113	};
1114	}
1115	return function(/* ...args */){
1116	return fn.apply(that, arguments);
1117	};
1118	};
1119
1120	/***/ }),
1121	/* 22 */
1122	/***/ (function(module, exports) {
1123
1124	module.exports = function(it){
1125	if(typeof it != 'function')throw TypeError(it + ' is not a function!');
1126	return it;
1127	};
1128
1129	/***/ }),
1130	/* 23 */
1131	/***/ (function(module, exports, __webpack_require__) {
1132
1133	module.exports = __webpack_require__(24);
1134
1135	/***/ }),
1136	/* 24 */
1137	/***/ (function(module, exports, __webpack_require__) {
1138
1139	var $ = __webpack_require__(8)
1140	, createDesc = __webpack_require__(25);
1141	module.exports = __webpack_require__(17) ? function(object, key, value){
1142	return $.setDesc(object, key, createDesc(1, value));
1143	} : function(object, key, value){
1144	object[key] = value;
1145	return object;
1146	};
1147
1148	/***/ }),
1149	/* 25 */
1150	/***/ (function(module, exports) {
1151
1152	module.exports = function(bitmap, value){
1153	return {
1154	enumerable : !(bitmap & 1),
1155	configurable: !(bitmap & 2),
1156	writable : !(bitmap & 4),
1157	value : value
1158	};
1159	};
1160
1161	/***/ }),
1162	/* 26 */
1163	/***/ (function(module, exports, __webpack_require__) {
1164
1165	var global = __webpack_require__(15)
1166	, SHARED = '__core-js_shared__'
1167	, store = global[SHARED] \|\| (global[SHARED] = {});
1168	module.exports = function(key){
1169	return store[key] \|\| (store[key] = {});
1170	};
1171
1172	/***/ }),
1173	/* 27 */
1174	/***/ (function(module, exports, __webpack_require__) {
1175
1176	var def = __webpack_require__(8).setDesc
1177	, has = __webpack_require__(16)
1178	, TAG = __webpack_require__(28)('toStringTag');
1179
1180	module.exports = function(it, tag, stat){
1181	if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
1182	};
1183
1184	/***/ }),
1185	/* 28 */
1186	/***/ (function(module, exports, __webpack_require__) {
1187
1188	var store = __webpack_require__(26)('wks')
1189	, uid = __webpack_require__(29)
1190	, Symbol = __webpack_require__(15).Symbol;
1191	module.exports = function(name){
1192	return store[name] \|\| (store[name] =
1193	Symbol && Symbol[name] \|\| (Symbol \|\| uid)('Symbol.' + name));
1194	};
1195
1196	/***/ }),
1197	/* 29 */
1198	/***/ (function(module, exports) {
1199
1200	var id = 0
1201	, px = Math.random();
1202	module.exports = function(key){
1203	return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
1204	};
1205
1206	/***/ }),
1207	/* 30 */
1208	/***/ (function(module, exports, __webpack_require__) {
1209
1210	var $ = __webpack_require__(8)
1211	, toIObject = __webpack_require__(31);
1212	module.exports = function(object, el){
1213	var O = toIObject(object)
1214	, keys = $.getKeys(O)
1215	, length = keys.length
1216	, index = 0
1217	, key;
1218	while(length > index)if(O[key = keys[index++]] === el)return key;
1219	};
1220
1221	/***/ }),
1222	/* 31 */
1223	/***/ (function(module, exports, __webpack_require__) {
1224
1225	// to indexed object, toObject with fallback for non-array-like ES3 strings
1226	var IObject = __webpack_require__(32)
1227	, defined = __webpack_require__(34);
1228	module.exports = function(it){
1229	return IObject(defined(it));
1230	};
1231
1232	/***/ }),
1233	/* 32 */
1234	/***/ (function(module, exports, __webpack_require__) {
1235
1236	// fallback for non-array-like ES3 and non-enumerable old V8 strings
1237	var cof = __webpack_require__(33);
1238	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
1239	return cof(it) == 'String' ? it.split('') : Object(it);
1240	};
1241
1242	/***/ }),
1243	/* 33 */
1244	/***/ (function(module, exports) {
1245
1246	var toString = {}.toString;
1247
1248	module.exports = function(it){
1249	return toString.call(it).slice(8, -1);
1250	};
1251
1252	/***/ }),
1253	/* 34 */
1254	/***/ (function(module, exports) {
1255
1256	// 7.2.1 RequireObjectCoercible(argument)
1257	module.exports = function(it){
1258	if(it == undefined)throw TypeError("Can't call method on " + it);
1259	return it;
1260	};
1261
1262	/***/ }),
1263	/* 35 */
1264	/***/ (function(module, exports, __webpack_require__) {
1265
1266	// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
1267	var toIObject = __webpack_require__(31)
1268	, getNames = __webpack_require__(8).getNames
1269	, toString = {}.toString;
1270
1271	var windowNames = typeof window == 'object' && Object.getOwnPropertyNames
1272	? Object.getOwnPropertyNames(window) : [];
1273
1274	var getWindowNames = function(it){
1275	try {
1276	return getNames(it);
1277	} catch(e){
1278	return windowNames.slice();
1279	}
1280	};
1281
1282	module.exports.get = function getOwnPropertyNames(it){
1283	if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);
1284	return getNames(toIObject(it));
1285	};
1286
1287	/***/ }),
1288	/* 36 */
1289	/***/ (function(module, exports, __webpack_require__) {
1290
1291	// all enumerable object keys, includes symbols
1292	var $ = __webpack_require__(8);
1293	module.exports = function(it){
1294	var keys = $.getKeys(it)
1295	, getSymbols = $.getSymbols;
1296	if(getSymbols){
1297	var symbols = getSymbols(it)
1298	, isEnum = $.isEnum
1299	, i = 0
1300	, key;
1301	while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);
1302	}
1303	return keys;
1304	};
1305
1306	/***/ }),
1307	/* 37 */
1308	/***/ (function(module, exports, __webpack_require__) {
1309
1310	// 7.2.2 IsArray(argument)
1311	var cof = __webpack_require__(33);
1312	module.exports = Array.isArray \|\| function(arg){
1313	return cof(arg) == 'Array';
1314	};
1315
1316	/***/ }),
1317	/* 38 */
1318	/***/ (function(module, exports, __webpack_require__) {
1319
1320	var isObject = __webpack_require__(39);
1321	module.exports = function(it){
1322	if(!isObject(it))throw TypeError(it + ' is not an object!');
1323	return it;
1324	};
1325
1326	/***/ }),
1327	/* 39 */
1328	/***/ (function(module, exports) {
1329
1330	module.exports = function(it){
1331	return typeof it === 'object' ? it !== null : typeof it === 'function';
1332	};
1333
1334	/***/ }),
1335	/* 40 */
1336	/***/ (function(module, exports) {
1337
1338	module.exports = true;
1339
1340	/***/ }),
1341	/* 41 */
1342	/***/ (function(module, exports) {
1343
1344
1345
1346	/***/ }),
1347	/* 42 */
1348	/***/ (function(module, exports, __webpack_require__) {
1349
1350	module.exports = { "default": __webpack_require__(43), __esModule: true };
1351
1352	/***/ }),
1353	/* 43 */
1354	/***/ (function(module, exports, __webpack_require__) {
1355
1356	__webpack_require__(44);
1357	__webpack_require__(50);
1358	module.exports = __webpack_require__(28)('iterator');
1359
1360	/***/ }),
1361	/* 44 */
1362	/***/ (function(module, exports, __webpack_require__) {
1363
1364	'use strict';
1365	var $at = __webpack_require__(45)(true);
1366
1367	// 21.1.3.27 String.prototype[@@iterator]()
1368	__webpack_require__(47)(String, 'String', function(iterated){
1369	this._t = String(iterated); // target
1370	this._i = 0; // next index
1371	// 21.1.5.2.1 %StringIteratorPrototype%.next()
1372	}, function(){
1373	var O = this._t
1374	, index = this._i
1375	, point;
1376	if(index >= O.length)return {value: undefined, done: true};
1377	point = $at(O, index);
1378	this._i += point.length;
1379	return {value: point, done: false};
1380	});
1381
1382	/***/ }),
1383	/* 45 */
1384	/***/ (function(module, exports, __webpack_require__) {
1385
1386	var toInteger = __webpack_require__(46)
1387	, defined = __webpack_require__(34);
1388	// true -> String#at
1389	// false -> String#codePointAt
1390	module.exports = function(TO_STRING){
1391	return function(that, pos){
1392	var s = String(defined(that))
1393	, i = toInteger(pos)
1394	, l = s.length
1395	, a, b;
1396	if(i < 0 \|\| i >= l)return TO_STRING ? '' : undefined;
1397	a = s.charCodeAt(i);
1398	return a < 0xd800 \|\| a > 0xdbff \|\| i + 1 === l \|\| (b = s.charCodeAt(i + 1)) < 0xdc00 \|\| b > 0xdfff
1399	? TO_STRING ? s.charAt(i) : a
1400	: TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
1401	};
1402	};
1403
1404	/***/ }),
1405	/* 46 */
1406	/***/ (function(module, exports) {
1407
1408	// 7.1.4 ToInteger
1409	var ceil = Math.ceil
1410	, floor = Math.floor;
1411	module.exports = function(it){
1412	return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
1413	};
1414
1415	/***/ }),
1416	/* 47 */
1417	/***/ (function(module, exports, __webpack_require__) {
1418
1419	'use strict';
1420	var LIBRARY = __webpack_require__(40)
1421	, $export = __webpack_require__(19)
1422	, redefine = __webpack_require__(23)
1423	, hide = __webpack_require__(24)
1424	, has = __webpack_require__(16)
1425	, Iterators = __webpack_require__(48)
1426	, $iterCreate = __webpack_require__(49)
1427	, setToStringTag = __webpack_require__(27)
1428	, getProto = __webpack_require__(8).getProto
1429	, ITERATOR = __webpack_require__(28)('iterator')
1430	, BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
1431	, FF_ITERATOR = '@@iterator'
1432	, KEYS = 'keys'
1433	, VALUES = 'values';
1434
1435	var returnThis = function(){ return this; };
1436
1437	module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
1438	$iterCreate(Constructor, NAME, next);
1439	var getMethod = function(kind){
1440	if(!BUGGY && kind in proto)return proto[kind];
1441	switch(kind){
1442	case KEYS: return function keys(){ return new Constructor(this, kind); };
1443	case VALUES: return function values(){ return new Constructor(this, kind); };
1444	} return function entries(){ return new Constructor(this, kind); };
1445	};
1446	var TAG = NAME + ' Iterator'
1447	, DEF_VALUES = DEFAULT == VALUES
1448	, VALUES_BUG = false
1449	, proto = Base.prototype
1450	, $native = proto[ITERATOR] \|\| proto[FF_ITERATOR] \|\| DEFAULT && proto[DEFAULT]
1451	, $default = $native \|\| getMethod(DEFAULT)
1452	, methods, key;
1453	// Fix native
1454	if($native){
1455	var IteratorPrototype = getProto($default.call(new Base));
1456	// Set @@toStringTag to native iterators
1457	setToStringTag(IteratorPrototype, TAG, true);
1458	// FF fix
1459	if(!LIBRARY && has(proto, FF_ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
1460	// fix Array#{values, @@iterator}.name in V8 / FF
1461	if(DEF_VALUES && $native.name !== VALUES){
1462	VALUES_BUG = true;
1463	$default = function values(){ return $native.call(this); };
1464	}
1465	}
1466	// Define iterator
1467	if((!LIBRARY \|\| FORCED) && (BUGGY \|\| VALUES_BUG \|\| !proto[ITERATOR])){
1468	hide(proto, ITERATOR, $default);
1469	}
1470	// Plug for library
1471	Iterators[NAME] = $default;
1472	Iterators[TAG] = returnThis;
1473	if(DEFAULT){
1474	methods = {
1475	values: DEF_VALUES ? $default : getMethod(VALUES),
1476	keys: IS_SET ? $default : getMethod(KEYS),
1477	entries: !DEF_VALUES ? $default : getMethod('entries')
1478	};
1479	if(FORCED)for(key in methods){
1480	if(!(key in proto))redefine(proto, key, methods[key]);
1481	} else $export($export.P + $export.F * (BUGGY \|\| VALUES_BUG), NAME, methods);
1482	}
1483	return methods;
1484	};
1485
1486	/***/ }),
1487	/* 48 */
1488	/***/ (function(module, exports) {
1489
1490	module.exports = {};
1491
1492	/***/ }),
1493	/* 49 */
1494	/***/ (function(module, exports, __webpack_require__) {
1495
1496	'use strict';
1497	var $ = __webpack_require__(8)
1498	, descriptor = __webpack_require__(25)
1499	, setToStringTag = __webpack_require__(27)
1500	, IteratorPrototype = {};
1501
1502	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
1503	__webpack_require__(24)(IteratorPrototype, __webpack_require__(28)('iterator'), function(){ return this; });
1504
1505	module.exports = function(Constructor, NAME, next){
1506	Constructor.prototype = $.create(IteratorPrototype, {next: descriptor(1, next)});
1507	setToStringTag(Constructor, NAME + ' Iterator');
1508	};
1509
1510	/***/ }),
1511	/* 50 */
1512	/***/ (function(module, exports, __webpack_require__) {
1513
1514	__webpack_require__(51);
1515	var Iterators = __webpack_require__(48);
1516	Iterators.NodeList = Iterators.HTMLCollection = Iterators.Array;
1517
1518	/***/ }),
1519	/* 51 */
1520	/***/ (function(module, exports, __webpack_require__) {
1521
1522	'use strict';
1523	var addToUnscopables = __webpack_require__(52)
1524	, step = __webpack_require__(53)
1525	, Iterators = __webpack_require__(48)
1526	, toIObject = __webpack_require__(31);
1527
1528	// 22.1.3.4 Array.prototype.entries()
1529	// 22.1.3.13 Array.prototype.keys()
1530	// 22.1.3.29 Array.prototype.values()
1531	// 22.1.3.30 Array.prototype[@@iterator]()
1532	module.exports = __webpack_require__(47)(Array, 'Array', function(iterated, kind){
1533	this._t = toIObject(iterated); // target
1534	this._i = 0; // next index
1535	this._k = kind; // kind
1536	// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
1537	}, function(){
1538	var O = this._t
1539	, kind = this._k
1540	, index = this._i++;
1541	if(!O \|\| index >= O.length){
1542	this._t = undefined;
1543	return step(1);
1544	}
1545	if(kind == 'keys' )return step(0, index);
1546	if(kind == 'values')return step(0, O[index]);
1547	return step(0, [index, O[index]]);
1548	}, 'values');
1549
1550	// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
1551	Iterators.Arguments = Iterators.Array;
1552
1553	addToUnscopables('keys');
1554	addToUnscopables('values');
1555	addToUnscopables('entries');
1556
1557	/***/ }),
1558	/* 52 */
1559	/***/ (function(module, exports) {
1560
1561	module.exports = function(){ /* empty */ };
1562
1563	/***/ }),
1564	/* 53 */
1565	/***/ (function(module, exports) {
1566
1567	module.exports = function(done, value){
1568	return {value: value, done: !!done};
1569	};
1570
1571	/***/ }),
1572	/* 54 */
1573	/***/ (function(module, exports, __webpack_require__) {
1574
1575	module.exports = { "default": __webpack_require__(55), __esModule: true };
1576
1577	/***/ }),
1578	/* 55 */
1579	/***/ (function(module, exports, __webpack_require__) {
1580
1581	__webpack_require__(50);
1582	__webpack_require__(44);
1583	module.exports = __webpack_require__(56);
1584
1585	/***/ }),
1586	/* 56 */
1587	/***/ (function(module, exports, __webpack_require__) {
1588
1589	var anObject = __webpack_require__(38)
1590	, get = __webpack_require__(57);
1591	module.exports = __webpack_require__(20).getIterator = function(it){
1592	var iterFn = get(it);
1593	if(typeof iterFn != 'function')throw TypeError(it + ' is not iterable!');
1594	return anObject(iterFn.call(it));
1595	};
1596
1597	/***/ }),
1598	/* 57 */
1599	/***/ (function(module, exports, __webpack_require__) {
1600
1601	var classof = __webpack_require__(58)
1602	, ITERATOR = __webpack_require__(28)('iterator')
1603	, Iterators = __webpack_require__(48);
1604	module.exports = __webpack_require__(20).getIteratorMethod = function(it){
1605	if(it != undefined)return it[ITERATOR]
1606	\|\| it['@@iterator']
1607	\|\| Iterators[classof(it)];
1608	};
1609
1610	/***/ }),
1611	/* 58 */
1612	/***/ (function(module, exports, __webpack_require__) {
1613
1614	// getting tag from 19.1.3.6 Object.prototype.toString()
1615	var cof = __webpack_require__(33)
1616	, TAG = __webpack_require__(28)('toStringTag')
1617	// ES3 wrong here
1618	, ARG = cof(function(){ return arguments; }()) == 'Arguments';
1619
1620	module.exports = function(it){
1621	var O, T, B;
1622	return it === undefined ? 'Undefined' : it === null ? 'Null'
1623	// @@toStringTag case
1624	: typeof (T = (O = Object(it))[TAG]) == 'string' ? T
1625	// builtinTag case
1626	: ARG ? cof(O)
1627	// ES3 arguments fallback
1628	: (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
1629	};
1630
1631	/***/ }),
1632	/* 59 */
1633	/***/ (function(module, exports, __webpack_require__) {
1634
1635	module.exports = { "default": __webpack_require__(60), __esModule: true };
1636
1637	/***/ }),
1638	/* 60 */
1639	/***/ (function(module, exports, __webpack_require__) {
1640
1641	__webpack_require__(61);
1642	module.exports = __webpack_require__(20).Object.keys;
1643
1644	/***/ }),
1645	/* 61 */
1646	/***/ (function(module, exports, __webpack_require__) {
1647
1648	// 19.1.2.14 Object.keys(O)
1649	var toObject = __webpack_require__(62);
1650
1651	__webpack_require__(63)('keys', function($keys){
1652	return function keys(it){
1653	return $keys(toObject(it));
1654	};
1655	});
1656
1657	/***/ }),
1658	/* 62 */
1659	/***/ (function(module, exports, __webpack_require__) {
1660
1661	// 7.1.13 ToObject(argument)
1662	var defined = __webpack_require__(34);
1663	module.exports = function(it){
1664	return Object(defined(it));
1665	};
1666
1667	/***/ }),
1668	/* 63 */
1669	/***/ (function(module, exports, __webpack_require__) {
1670
1671	// most Object methods by ES6 should accept primitives
1672	var $export = __webpack_require__(19)
1673	, core = __webpack_require__(20)
1674	, fails = __webpack_require__(18);
1675	module.exports = function(KEY, exec){
1676	var fn = (core.Object \|\| {})[KEY] \|\| Object[KEY]
1677	, exp = {};
1678	exp[KEY] = exec(fn);
1679	$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
1680	};
1681
1682	/***/ }),
1683	/* 64 */
1684	/***/ (function(module, exports, __webpack_require__) {
1685
1686	'use strict';
1687
1688	var _interopRequireDefault = __webpack_require__(2)['default'];
1689
1690	exports.__esModule = true;
1691
1692	var _exception = __webpack_require__(5);
1693
1694	var _exception2 = _interopRequireDefault(_exception);
1695
1696	exports['default'] = function (instance) {
1697	instance.registerHelper('helperMissing', function () /* [args, ]options */{
1698	if (arguments.length === 1) {
1699	// A missing field in a {{foo}} construct.
1700	return undefined;
1701	} else {
1702	// Someone is actually trying to call something, blow up.
1703	throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
1704	}
1705	});
1706	};
1707
1708	module.exports = exports['default'];
1709
1710	/***/ }),
1711	/* 65 */
1712	/***/ (function(module, exports, __webpack_require__) {
1713
1714	'use strict';
1715
1716	var _interopRequireDefault = __webpack_require__(2)['default'];
1717
1718	exports.__esModule = true;
1719
1720	var _utils = __webpack_require__(4);
1721
1722	var _exception = __webpack_require__(5);
1723
1724	var _exception2 = _interopRequireDefault(_exception);
1725
1726	exports['default'] = function (instance) {
1727	instance.registerHelper('if', function (conditional, options) {
1728	if (arguments.length != 2) {
1729	throw new _exception2['default']('#if requires exactly one argument');
1730	}
1731	if (_utils.isFunction(conditional)) {
1732	conditional = conditional.call(this);
1733	}
1734
1735	// Default behavior is to render the positive path if the value is truthy and not empty.
1736	// The `includeZero` option may be set to treat the condtional as purely not empty based on the
1737	// behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
1738	if (!options.hash.includeZero && !conditional \|\| _utils.isEmpty(conditional)) {
1739	return options.inverse(this);
1740	} else {
1741	return options.fn(this);
1742	}
1743	});
1744
1745	instance.registerHelper('unless', function (conditional, options) {
1746	if (arguments.length != 2) {
1747	throw new _exception2['default']('#unless requires exactly one argument');
1748	}
1749	return instance.helpers['if'].call(this, conditional, {
1750	fn: options.inverse,
1751	inverse: options.fn,
1752	hash: options.hash
1753	});
1754	});
1755	};
1756
1757	module.exports = exports['default'];
1758
1759	/***/ }),
1760	/* 66 */
1761	/***/ (function(module, exports) {
1762
1763	'use strict';
1764
1765	exports.__esModule = true;
1766
1767	exports['default'] = function (instance) {
1768	instance.registerHelper('log', function () /* message, options */{
1769	var args = [undefined],
1770	options = arguments[arguments.length - 1];
1771	for (var i = 0; i < arguments.length - 1; i++) {
1772	args.push(arguments[i]);
1773	}
1774
1775	var level = 1;
1776	if (options.hash.level != null) {
1777	level = options.hash.level;
1778	} else if (options.data && options.data.level != null) {
1779	level = options.data.level;
1780	}
1781	args[0] = level;
1782
1783	instance.log.apply(instance, args);
1784	});
1785	};
1786
1787	module.exports = exports['default'];
1788
1789	/***/ }),
1790	/* 67 */
1791	/***/ (function(module, exports) {
1792
1793	'use strict';
1794
1795	exports.__esModule = true;
1796
1797	exports['default'] = function (instance) {
1798	instance.registerHelper('lookup', function (obj, field, options) {
1799	if (!obj) {
1800	// Note for 5.0: Change to "obj == null" in 5.0
1801	return obj;
1802	}
1803	return options.lookupProperty(obj, field);
1804	});
1805	};
1806
1807	module.exports = exports['default'];
1808
1809	/***/ }),
1810	/* 68 */
1811	/***/ (function(module, exports, __webpack_require__) {
1812
1813	'use strict';
1814
1815	var _interopRequireDefault = __webpack_require__(2)['default'];
1816
1817	exports.__esModule = true;
1818
1819	var _utils = __webpack_require__(4);
1820
1821	var _exception = __webpack_require__(5);
1822
1823	var _exception2 = _interopRequireDefault(_exception);
1824
1825	exports['default'] = function (instance) {
1826	instance.registerHelper('with', function (context, options) {
1827	if (arguments.length != 2) {
1828	throw new _exception2['default']('#with requires exactly one argument');
1829	}
1830	if (_utils.isFunction(context)) {
1831	context = context.call(this);
1832	}
1833
1834	var fn = options.fn;
1835
1836	if (!_utils.isEmpty(context)) {
1837	var data = options.data;
1838	if (options.data && options.ids) {
1839	data = _utils.createFrame(options.data);
1840	data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
1841	}
1842
1843	return fn(context, {
1844	data: data,
1845	blockParams: _utils.blockParams([context], [data && data.contextPath])
1846	});
1847	} else {
1848	return options.inverse(this);
1849	}
1850	});
1851	};
1852
1853	module.exports = exports['default'];
1854
1855	/***/ }),
1856	/* 69 */
1857	/***/ (function(module, exports, __webpack_require__) {
1858
1859	'use strict';
1860
1861	var _interopRequireDefault = __webpack_require__(2)['default'];
1862
1863	exports.__esModule = true;
1864	exports.registerDefaultDecorators = registerDefaultDecorators;
1865
1866	var _decoratorsInline = __webpack_require__(70);
1867
1868	var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);
1869
1870	function registerDefaultDecorators(instance) {
1871	_decoratorsInline2['default'](instance);
1872	}
1873
1874	/***/ }),
1875	/* 70 */
1876	/***/ (function(module, exports, __webpack_require__) {
1877
1878	'use strict';
1879
1880	exports.__esModule = true;
1881
1882	var _utils = __webpack_require__(4);
1883
1884	exports['default'] = function (instance) {
1885	instance.registerDecorator('inline', function (fn, props, container, options) {
1886	var ret = fn;
1887	if (!props.partials) {
1888	props.partials = {};
1889	ret = function (context, options) {
1890	// Create a new partials stack frame prior to exec.
1891	var original = container.partials;
1892	container.partials = _utils.extend({}, original, props.partials);
1893	var ret = fn(context, options);
1894	container.partials = original;
1895	return ret;
1896	};
1897	}
1898
1899	props.partials[options.args[0]] = options.fn;
1900
1901	return ret;
1902	});
1903	};
1904
1905	module.exports = exports['default'];
1906
1907	/***/ }),
1908	/* 71 */
1909	/***/ (function(module, exports, __webpack_require__) {
1910
1911	'use strict';
1912
1913	exports.__esModule = true;
1914
1915	var _utils = __webpack_require__(4);
1916
1917	var logger = {
1918	methodMap: ['debug', 'info', 'warn', 'error'],
1919	level: 'info',
1920
1921	// Maps a given level value to the `methodMap` indexes above.
1922	lookupLevel: function lookupLevel(level) {
1923	if (typeof level === 'string') {
1924	var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());
1925	if (levelMap >= 0) {
1926	level = levelMap;
1927	} else {
1928	level = parseInt(level, 10);
1929	}
1930	}
1931
1932	return level;
1933	},
1934
1935	// Can be overridden in the host environment
1936	log: function log(level) {
1937	level = logger.lookupLevel(level);
1938
1939	if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {
1940	var method = logger.methodMap[level];
1941	// eslint-disable-next-line no-console
1942	if (!console[method]) {
1943	method = 'log';
1944	}
1945
1946	for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
1947	message[_key - 1] = arguments[_key];
1948	}
1949
1950	console[method].apply(console, message); // eslint-disable-line no-console
1951	}
1952	}
1953	};
1954
1955	exports['default'] = logger;
1956	module.exports = exports['default'];
1957
1958	/***/ }),
1959	/* 72 */
1960	/***/ (function(module, exports, __webpack_require__) {
1961
1962	'use strict';
1963
1964	var _Object$create = __webpack_require__(73)['default'];
1965
1966	var _Object$keys = __webpack_require__(59)['default'];
1967
1968	var _interopRequireDefault = __webpack_require__(2)['default'];
1969
1970	exports.__esModule = true;
1971	exports.createProtoAccessControl = createProtoAccessControl;
1972	exports.resultIsAllowed = resultIsAllowed;
1973	exports.resetLoggedProperties = resetLoggedProperties;
1974
1975	var _createNewLookupObject = __webpack_require__(75);
1976
1977	var _logger = __webpack_require__(71);
1978
1979	var _logger2 = _interopRequireDefault(_logger);
1980
1981	var loggedProperties = _Object$create(null);
1982
1983	function createProtoAccessControl(runtimeOptions) {
1984	var defaultMethodWhiteList = _Object$create(null);
1985	defaultMethodWhiteList['constructor'] = false;
1986	defaultMethodWhiteList['__defineGetter__'] = false;
1987	defaultMethodWhiteList['__defineSetter__'] = false;
1988	defaultMethodWhiteList['__lookupGetter__'] = false;
1989
1990	var defaultPropertyWhiteList = _Object$create(null);
1991	// eslint-disable-next-line no-proto
1992	defaultPropertyWhiteList['__proto__'] = false;
1993
1994	return {
1995	properties: {
1996	whitelist: _createNewLookupObject.createNewLookupObject(defaultPropertyWhiteList, runtimeOptions.allowedProtoProperties),
1997	defaultValue: runtimeOptions.allowProtoPropertiesByDefault
1998	},
1999	methods: {
2000	whitelist: _createNewLookupObject.createNewLookupObject(defaultMethodWhiteList, runtimeOptions.allowedProtoMethods),
2001	defaultValue: runtimeOptions.allowProtoMethodsByDefault
2002	}
2003	};
2004	}
2005
2006	function resultIsAllowed(result, protoAccessControl, propertyName) {
2007	if (typeof result === 'function') {
2008	return checkWhiteList(protoAccessControl.methods, propertyName);
2009	} else {
2010	return checkWhiteList(protoAccessControl.properties, propertyName);
2011	}
2012	}
2013
2014	function checkWhiteList(protoAccessControlForType, propertyName) {
2015	if (protoAccessControlForType.whitelist[propertyName] !== undefined) {
2016	return protoAccessControlForType.whitelist[propertyName] === true;
2017	}
2018	if (protoAccessControlForType.defaultValue !== undefined) {
2019	return protoAccessControlForType.defaultValue;
2020	}
2021	logUnexpecedPropertyAccessOnce(propertyName);
2022	return false;
2023	}
2024
2025	function logUnexpecedPropertyAccessOnce(propertyName) {
2026	if (loggedProperties[propertyName] !== true) {
2027	loggedProperties[propertyName] = true;
2028	_logger2['default'].log('error', 'Handlebars: Access has been denied to resolve the property "' + propertyName + '" because it is not an "own property" of its parent.\n' + 'You can add a runtime option to disable the check or this warning:\n' + 'See https://handlebarsjs.com/api-reference/runtime-options.html#options-to-control-prototype-access for details');
2029	}
2030	}
2031
2032	function resetLoggedProperties() {
2033	_Object$keys(loggedProperties).forEach(function (propertyName) {
2034	delete loggedProperties[propertyName];
2035	});
2036	}
2037
2038	/***/ }),
2039	/* 73 */
2040	/***/ (function(module, exports, __webpack_require__) {
2041
2042	module.exports = { "default": __webpack_require__(74), __esModule: true };
2043
2044	/***/ }),
2045	/* 74 */
2046	/***/ (function(module, exports, __webpack_require__) {
2047
2048	var $ = __webpack_require__(8);
2049	module.exports = function create(P, D){
2050	return $.create(P, D);
2051	};
2052
2053	/***/ }),
2054	/* 75 */
2055	/***/ (function(module, exports, __webpack_require__) {
2056
2057	'use strict';
2058
2059	var _Object$create = __webpack_require__(73)['default'];
2060
2061	exports.__esModule = true;
2062	exports.createNewLookupObject = createNewLookupObject;
2063
2064	var _utils = __webpack_require__(4);
2065
2066	/**
2067	* Create a new object with "null"-prototype to avoid truthy results on prototype properties.
2068	* The resulting object can be used with "object[property]" to check if a property exists
2069	* @param {...object} sources a varargs parameter of source objects that will be merged
2070	* @returns {object}
2071	*/
2072
2073	function createNewLookupObject() {
2074	for (var _len = arguments.length, sources = Array(_len), _key = 0; _key < _len; _key++) {
2075	sources[_key] = arguments[_key];
2076	}
2077
2078	return _utils.extend.apply(undefined, [_Object$create(null)].concat(sources));
2079	}
2080
2081	/***/ }),
2082	/* 76 */
2083	/***/ (function(module, exports) {
2084
2085	// Build out our basic SafeString type
2086	'use strict';
2087
2088	exports.__esModule = true;
2089	function SafeString(string) {
2090	this.string = string;
2091	}
2092
2093	SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
2094	return '' + this.string;
2095	};
2096
2097	exports['default'] = SafeString;
2098	module.exports = exports['default'];
2099
2100	/***/ }),
2101	/* 77 */
2102	/***/ (function(module, exports, __webpack_require__) {
2103
2104	'use strict';
2105
2106	var _Object$seal = __webpack_require__(78)['default'];
2107
2108	var _Object$keys = __webpack_require__(59)['default'];
2109
2110	var _interopRequireWildcard = __webpack_require__(1)['default'];
2111
2112	var _interopRequireDefault = __webpack_require__(2)['default'];
2113
2114	exports.__esModule = true;
2115	exports.checkRevision = checkRevision;
2116	exports.template = template;
2117	exports.wrapProgram = wrapProgram;
2118	exports.resolvePartial = resolvePartial;
2119	exports.invokePartial = invokePartial;
2120	exports.noop = noop;
2121
2122	var _utils = __webpack_require__(4);
2123
2124	var Utils = _interopRequireWildcard(_utils);
2125
2126	var _exception = __webpack_require__(5);
2127
2128	var _exception2 = _interopRequireDefault(_exception);
2129
2130	var _base = __webpack_require__(3);
2131
2132	var _helpers = __webpack_require__(9);
2133
2134	var _internalWrapHelper = __webpack_require__(81);
2135
2136	var _internalProtoAccess = __webpack_require__(72);
2137
2138	function checkRevision(compilerInfo) {
2139	var compilerRevision = compilerInfo && compilerInfo[0] \|\| 1,
2140	currentRevision = _base.COMPILER_REVISION;
2141
2142	if (compilerRevision >= _base.LAST_COMPATIBLE_COMPILER_REVISION && compilerRevision <= _base.COMPILER_REVISION) {
2143	return;
2144	}
2145
2146	if (compilerRevision < _base.LAST_COMPATIBLE_COMPILER_REVISION) {
2147	var runtimeVersions = _base.REVISION_CHANGES[currentRevision],
2148	compilerVersions = _base.REVISION_CHANGES[compilerRevision];
2149	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 + ').');
2150	} else {
2151	// Use the embedded version info since the runtime doesn't know about this revision yet
2152	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] + ').');
2153	}
2154	}
2155
2156	function template(templateSpec, env) {
2157	/* istanbul ignore next */
2158	if (!env) {
2159	throw new _exception2['default']('No environment passed to template');
2160	}
2161	if (!templateSpec \|\| !templateSpec.main) {
2162	throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);
2163	}
2164
2165	templateSpec.main.decorator = templateSpec.main_d;
2166
2167	// Note: Using env.VM references rather than local var references throughout this section to allow
2168	// for external users to override these as pseudo-supported APIs.
2169	env.VM.checkRevision(templateSpec.compiler);
2170
2171	// backwards compatibility for precompiled templates with compiler-version 7 (<4.3.0)
2172	var templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7;
2173
2174	function invokePartialWrapper(partial, context, options) {
2175	if (options.hash) {
2176	context = Utils.extend({}, context, options.hash);
2177	if (options.ids) {
2178	options.ids[0] = true;
2179	}
2180	}
2181	partial = env.VM.resolvePartial.call(this, partial, context, options);
2182
2183	var extendedOptions = Utils.extend({}, options, {
2184	hooks: this.hooks,
2185	protoAccessControl: this.protoAccessControl
2186	});
2187
2188	var result = env.VM.invokePartial.call(this, partial, context, extendedOptions);
2189
2190	if (result == null && env.compile) {
2191	options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
2192	result = options.partials[options.name](context, extendedOptions);
2193	}
2194	if (result != null) {
2195	if (options.indent) {
2196	var lines = result.split('\n');
2197	for (var i = 0, l = lines.length; i < l; i++) {
2198	if (!lines[i] && i + 1 === l) {
2199	break;
2200	}
2201
2202	lines[i] = options.indent + lines[i];
2203	}
2204	result = lines.join('\n');
2205	}
2206	return result;
2207	} else {
2208	throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
2209	}
2210	}
2211
2212	// Just add water
2213	var container = {
2214	strict: function strict(obj, name, loc) {
2215	if (!obj \|\| !(name in obj)) {
2216	throw new _exception2['default']('"' + name + '" not defined in ' + obj, {
2217	loc: loc
2218	});
2219	}
2220	return container.lookupProperty(obj, name);
2221	},
2222	lookupProperty: function lookupProperty(parent, propertyName) {
2223	var result = parent[propertyName];
2224	if (result == null) {
2225	return result;
2226	}
2227	if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
2228	return result;
2229	}
2230
2231	if (_internalProtoAccess.resultIsAllowed(result, container.protoAccessControl, propertyName)) {
2232	return result;
2233	}
2234	return undefined;
2235	},
2236	lookup: function lookup(depths, name) {
2237	var len = depths.length;
2238	for (var i = 0; i < len; i++) {
2239	var result = depths[i] && container.lookupProperty(depths[i], name);
2240	if (result != null) {
2241	return depths[i][name];
2242	}
2243	}
2244	},
2245	lambda: function lambda(current, context) {
2246	return typeof current === 'function' ? current.call(context) : current;
2247	},
2248
2249	escapeExpression: Utils.escapeExpression,
2250	invokePartial: invokePartialWrapper,
2251
2252	fn: function fn(i) {
2253	var ret = templateSpec[i];
2254	ret.decorator = templateSpec[i + '_d'];
2255	return ret;
2256	},
2257
2258	programs: [],
2259	program: function program(i, data, declaredBlockParams, blockParams, depths) {
2260	var programWrapper = this.programs[i],
2261	fn = this.fn(i);
2262	if (data \|\| depths \|\| blockParams \|\| declaredBlockParams) {
2263	programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
2264	} else if (!programWrapper) {
2265	programWrapper = this.programs[i] = wrapProgram(this, i, fn);
2266	}
2267	return programWrapper;
2268	},
2269
2270	data: function data(value, depth) {
2271	while (value && depth--) {
2272	value = value._parent;
2273	}
2274	return value;
2275	},
2276	mergeIfNeeded: function mergeIfNeeded(param, common) {
2277	var obj = param \|\| common;
2278
2279	if (param && common && param !== common) {
2280	obj = Utils.extend({}, common, param);
2281	}
2282
2283	return obj;
2284	},
2285	// An empty object to use as replacement for null-contexts
2286	nullContext: _Object$seal({}),
2287
2288	noop: env.VM.noop,
2289	compilerInfo: templateSpec.compiler
2290	};
2291
2292	function ret(context) {
2293	var options = arguments.length <= 1 \|\| arguments[1] === undefined ? {} : arguments[1];
2294
2295	var data = options.data;
2296
2297	ret._setup(options);
2298	if (!options.partial && templateSpec.useData) {
2299	data = initData(context, data);
2300	}
2301	var depths = undefined,
2302	blockParams = templateSpec.useBlockParams ? [] : undefined;
2303	if (templateSpec.useDepths) {
2304	if (options.depths) {
2305	depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths;
2306	} else {
2307	depths = [context];
2308	}
2309	}
2310
2311	function main(context /, options/) {
2312	return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
2313	}
2314
2315	main = executeDecorators(templateSpec.main, main, container, options.depths \|\| [], data, blockParams);
2316	return main(context, options);
2317	}
2318
2319	ret.isTop = true;
2320
2321	ret._setup = function (options) {
2322	if (!options.partial) {
2323	var mergedHelpers = Utils.extend({}, env.helpers, options.helpers);
2324	wrapHelpersToPassLookupProperty(mergedHelpers, container);
2325	container.helpers = mergedHelpers;
2326
2327	if (templateSpec.usePartial) {
2328	// Use mergeIfNeeded here to prevent compiling global partials multiple times
2329	container.partials = container.mergeIfNeeded(options.partials, env.partials);
2330	}
2331	if (templateSpec.usePartial \|\| templateSpec.useDecorators) {
2332	container.decorators = Utils.extend({}, env.decorators, options.decorators);
2333	}
2334
2335	container.hooks = {};
2336	container.protoAccessControl = _internalProtoAccess.createProtoAccessControl(options);
2337
2338	var keepHelperInHelpers = options.allowCallsToHelperMissing \|\| templateWasPrecompiledWithCompilerV7;
2339	_helpers.moveHelperToHooks(container, 'helperMissing', keepHelperInHelpers);
2340	_helpers.moveHelperToHooks(container, 'blockHelperMissing', keepHelperInHelpers);
2341	} else {
2342	container.protoAccessControl = options.protoAccessControl; // internal option
2343	container.helpers = options.helpers;
2344	container.partials = options.partials;
2345	container.decorators = options.decorators;
2346	container.hooks = options.hooks;
2347	}
2348	};
2349
2350	ret._child = function (i, data, blockParams, depths) {
2351	if (templateSpec.useBlockParams && !blockParams) {
2352	throw new _exception2['default']('must pass block params');
2353	}
2354	if (templateSpec.useDepths && !depths) {
2355	throw new _exception2['default']('must pass parent depths');
2356	}
2357
2358	return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
2359	};
2360	return ret;
2361	}
2362
2363	function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
2364	function prog(context) {
2365	var options = arguments.length <= 1 \|\| arguments[1] === undefined ? {} : arguments[1];
2366
2367	var currentDepths = depths;
2368	if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) {
2369	currentDepths = [context].concat(depths);
2370	}
2371
2372	return fn(container, context, container.helpers, container.partials, options.data \|\| data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
2373	}
2374
2375	prog = executeDecorators(fn, prog, container, depths, data, blockParams);
2376
2377	prog.program = i;
2378	prog.depth = depths ? depths.length : 0;
2379	prog.blockParams = declaredBlockParams \|\| 0;
2380	return prog;
2381	}
2382
2383	/**
2384	* This is currently part of the official API, therefore implementation details should not be changed.
2385	*/
2386
2387	function resolvePartial(partial, context, options) {
2388	if (!partial) {
2389	if (options.name === '@partial-block') {
2390	partial = options.data['partial-block'];
2391	} else {
2392	partial = options.partials[options.name];
2393	}
2394	} else if (!partial.call && !options.name) {
2395	// This is a dynamic partial that returned a string
2396	options.name = partial;
2397	partial = options.partials[partial];
2398	}
2399	return partial;
2400	}
2401
2402	function invokePartial(partial, context, options) {
2403	// Use the current closure context to save the partial-block if this partial
2404	var currentPartialBlock = options.data && options.data['partial-block'];
2405	options.partial = true;
2406	if (options.ids) {
2407	options.data.contextPath = options.ids[0] \|\| options.data.contextPath;
2408	}
2409
2410	var partialBlock = undefined;
2411	if (options.fn && options.fn !== noop) {
2412	(function () {
2413	options.data = _base.createFrame(options.data);
2414	// Wrapper function to get access to currentPartialBlock from the closure
2415	var fn = options.fn;
2416	partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) {
2417	var options = arguments.length <= 1 \|\| arguments[1] === undefined ? {} : arguments[1];
2418
2419	// Restore the partial-block from the closure for the execution of the block
2420	// i.e. the part inside the block of the partial call.
2421	options.data = _base.createFrame(options.data);
2422	options.data['partial-block'] = currentPartialBlock;
2423	return fn(context, options);
2424	};
2425	if (fn.partials) {
2426	options.partials = Utils.extend({}, options.partials, fn.partials);
2427	}
2428	})();
2429	}
2430
2431	if (partial === undefined && partialBlock) {
2432	partial = partialBlock;
2433	}
2434
2435	if (partial === undefined) {
2436	throw new _exception2['default']('The partial ' + options.name + ' could not be found');
2437	} else if (partial instanceof Function) {
2438	return partial(context, options);
2439	}
2440	}
2441
2442	function noop() {
2443	return '';
2444	}
2445
2446	function initData(context, data) {
2447	if (!data \|\| !('root' in data)) {
2448	data = data ? _base.createFrame(data) : {};
2449	data.root = context;
2450	}
2451	return data;
2452	}
2453
2454	function executeDecorators(fn, prog, container, depths, data, blockParams) {
2455	if (fn.decorator) {
2456	var props = {};
2457	prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
2458	Utils.extend(prog, props);
2459	}
2460	return prog;
2461	}
2462
2463	function wrapHelpersToPassLookupProperty(mergedHelpers, container) {
2464	_Object$keys(mergedHelpers).forEach(function (helperName) {
2465	var helper = mergedHelpers[helperName];
2466	mergedHelpers[helperName] = passLookupPropertyOption(helper, container);
2467	});
2468	}
2469
2470	function passLookupPropertyOption(helper, container) {
2471	var lookupProperty = container.lookupProperty;
2472	return _internalWrapHelper.wrapHelper(helper, function (options) {
2473	return Utils.extend({ lookupProperty: lookupProperty }, options);
2474	});
2475	}
2476
2477	/***/ }),
2478	/* 78 */
2479	/***/ (function(module, exports, __webpack_require__) {
2480
2481	module.exports = { "default": __webpack_require__(79), __esModule: true };
2482
2483	/***/ }),
2484	/* 79 */
2485	/***/ (function(module, exports, __webpack_require__) {
2486
2487	__webpack_require__(80);
2488	module.exports = __webpack_require__(20).Object.seal;
2489
2490	/***/ }),
2491	/* 80 */
2492	/***/ (function(module, exports, __webpack_require__) {
2493
2494	// 19.1.2.17 Object.seal(O)
2495	var isObject = __webpack_require__(39);
2496
2497	__webpack_require__(63)('seal', function($seal){
2498	return function seal(it){
2499	return $seal && isObject(it) ? $seal(it) : it;
2500	};
2501	});
2502
2503	/***/ }),
2504	/* 81 */
2505	/***/ (function(module, exports) {
2506
2507	'use strict';
2508
2509	exports.__esModule = true;
2510	exports.wrapHelper = wrapHelper;
2511
2512	function wrapHelper(helper, transformOptionsFn) {
2513	if (typeof helper !== 'function') {
2514	// This should not happen, but apparently it does in https://github.com/wycats/handlebars.js/issues/1639
2515	// We try to make the wrapper least-invasive by not wrapping it, if the helper is not a function.
2516	return helper;
2517	}
2518	var wrapper = function wrapper() /* dynamic arguments */{
2519	var options = arguments[arguments.length - 1];
2520	arguments[arguments.length - 1] = transformOptionsFn(options);
2521	return helper.apply(this, arguments);
2522	};
2523	return wrapper;
2524	}
2525
2526	/***/ }),
2527	/* 82 */
2528	/***/ (function(module, exports) {
2529
2530	/* global globalThis */
2531	'use strict';
2532
2533	exports.__esModule = true;
2534
2535	exports['default'] = function (Handlebars) {
2536	/* istanbul ignore next */
2537	// https://mathiasbynens.be/notes/globalthis
2538	(function () {
2539	if (typeof globalThis === 'object') return;
2540	Object.prototype.__defineGetter__('__magic__', function () {
2541	return this;
2542	});
2543	__magic__.globalThis = __magic__; // eslint-disable-line no-undef
2544	delete Object.prototype.__magic__;
2545	})();
2546
2547	var $Handlebars = globalThis.Handlebars;
2548
2549	/* istanbul ignore next */
2550	Handlebars.noConflict = function () {
2551	if (globalThis.Handlebars === Handlebars) {
2552	globalThis.Handlebars = $Handlebars;
2553	}
2554	return Handlebars;
2555	};
2556	};
2557
2558	module.exports = exports['default'];
2559
2560	/***/ })
2561	/******/ ])
2562	});
2563	;