WP-Optimize – Cache, Compress images, Minify & Clean database to boost page speed & performance / 4.5.2

WP-Optimize – Cache, Compress images, Minify & Clean database to boost page speed & performance v4.5.2

wp-optimize / js / handlebars / handlebars.runtime.js

handlebars.runtime.js in WP-Optimize – Cache, Compress images, Minify & Clean database to boost page speed & performance 4.5.2, at js/handlebars/handlebars.runtime.js

2,548 lines 72.6 KB

Raw Download Zip

1	/**!
2
3	@license
4	handlebars v4.7.9
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__(75);
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__(76);
111
112	var runtime = _interopRequireWildcard(_handlebarsRuntime);
113
114	var _handlebarsNoConflict = __webpack_require__(81);
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.9';
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	// Using delete is slow
590	instance.helpers[helperName] = undefined;
591	}
592	}
593	}
594
595	/***/ }),
596	/* 10 */
597	/***/ (function(module, exports, __webpack_require__) {
598
599	'use strict';
600
601	exports.__esModule = true;
602
603	var _utils = __webpack_require__(4);
604
605	exports['default'] = function (instance) {
606	instance.registerHelper('blockHelperMissing', function (context, options) {
607	var inverse = options.inverse,
608	fn = options.fn;
609
610	if (context === true) {
611	return fn(this);
612	} else if (context === false \|\| context == null) {
613	return inverse(this);
614	} else if (_utils.isArray(context)) {
615	if (context.length > 0) {
616	if (options.ids) {
617	options.ids = [options.name];
618	}
619
620	return instance.helpers.each(context, options);
621	} else {
622	return inverse(this);
623	}
624	} else {
625	if (options.data && options.ids) {
626	var data = _utils.createFrame(options.data);
627	data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
628	options = { data: data };
629	}
630
631	return fn(context, options);
632	}
633	});
634	};
635
636	module.exports = exports['default'];
637
638	/***/ }),
639	/* 11 */
640	/***/ (function(module, exports, __webpack_require__) {
641
642	'use strict';
643
644	var _Symbol = __webpack_require__(12)['default'];
645
646	var _Symbol$iterator = __webpack_require__(42)['default'];
647
648	var _getIterator = __webpack_require__(54)['default'];
649
650	var _Object$keys = __webpack_require__(59)['default'];
651
652	var _interopRequireDefault = __webpack_require__(2)['default'];
653
654	exports.__esModule = true;
655
656	var _utils = __webpack_require__(4);
657
658	var _exception = __webpack_require__(5);
659
660	var _exception2 = _interopRequireDefault(_exception);
661
662	exports['default'] = function (instance) {
663	instance.registerHelper('each', function (context, options) {
664	if (!options) {
665	throw new _exception2['default']('Must pass iterator to #each');
666	}
667
668	var fn = options.fn,
669	inverse = options.inverse,
670	i = 0,
671	ret = '',
672	data = undefined,
673	contextPath = undefined;
674
675	if (options.data && options.ids) {
676	contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
677	}
678
679	if (_utils.isFunction(context)) {
680	context = context.call(this);
681	}
682
683	if (options.data) {
684	data = _utils.createFrame(options.data);
685	}
686
687	function execIteration(field, index, last) {
688	if (data) {
689	data.key = field;
690	data.index = index;
691	data.first = index === 0;
692	data.last = !!last;
693
694	if (contextPath) {
695	data.contextPath = contextPath + field;
696	}
697	}
698
699	ret = ret + fn(context[field], {
700	data: data,
701	blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])
702	});
703	}
704
705	if (context && typeof context === 'object') {
706	if (_utils.isArray(context)) {
707	for (var j = context.length; i < j; i++) {
708	if (i in context) {
709	execIteration(i, i, i === context.length - 1);
710	}
711	}
712	} else if (typeof _Symbol === 'function' && context[_Symbol$iterator]) {
713	var newContext = [];
714	var iterator = _getIterator(context);
715	for (var it = iterator.next(); !it.done; it = iterator.next()) {
716	newContext.push(it.value);
717	}
718	context = newContext;
719	for (var j = context.length; i < j; i++) {
720	execIteration(i, i, i === context.length - 1);
721	}
722	} else {
723	(function () {
724	var priorKey = undefined;
725
726	_Object$keys(context).forEach(function (key) {
727	// We're running the iterations one step out of sync so we can detect
728	// the last iteration without have to scan the object twice and create
729	// an itermediate keys array.
730	if (priorKey !== undefined) {
731	execIteration(priorKey, i - 1);
732	}
733	priorKey = key;
734	i++;
735	});
736	if (priorKey !== undefined) {
737	execIteration(priorKey, i - 1, true);
738	}
739	})();
740	}
741	}
742
743	if (i === 0) {
744	ret = inverse(this);
745	}
746
747	return ret;
748	});
749	};
750
751	module.exports = exports['default'];
752
753	/***/ }),
754	/* 12 */
755	/***/ (function(module, exports, __webpack_require__) {
756
757	module.exports = { "default": __webpack_require__(13), __esModule: true };
758
759	/***/ }),
760	/* 13 */
761	/***/ (function(module, exports, __webpack_require__) {
762
763	__webpack_require__(14);
764	__webpack_require__(41);
765	module.exports = __webpack_require__(20).Symbol;
766
767	/***/ }),
768	/* 14 */
769	/***/ (function(module, exports, __webpack_require__) {
770
771	'use strict';
772	// ECMAScript 6 symbols shim
773	var $ = __webpack_require__(8)
774	, global = __webpack_require__(15)
775	, has = __webpack_require__(16)
776	, DESCRIPTORS = __webpack_require__(17)
777	, $export = __webpack_require__(19)
778	, redefine = __webpack_require__(23)
779	, $fails = __webpack_require__(18)
780	, shared = __webpack_require__(26)
781	, setToStringTag = __webpack_require__(27)
782	, uid = __webpack_require__(29)
783	, wks = __webpack_require__(28)
784	, keyOf = __webpack_require__(30)
785	, $names = __webpack_require__(35)
786	, enumKeys = __webpack_require__(36)
787	, isArray = __webpack_require__(37)
788	, anObject = __webpack_require__(38)
789	, toIObject = __webpack_require__(31)
790	, createDesc = __webpack_require__(25)
791	, getDesc = $.getDesc
792	, setDesc = $.setDesc
793	, _create = $.create
794	, getNames = $names.get
795	, $Symbol = global.Symbol
796	, $JSON = global.JSON
797	, _stringify = $JSON && $JSON.stringify
798	, setter = false
799	, HIDDEN = wks('_hidden')
800	, isEnum = $.isEnum
801	, SymbolRegistry = shared('symbol-registry')
802	, AllSymbols = shared('symbols')
803	, useNative = typeof $Symbol == 'function'
804	, ObjectProto = Object.prototype;
805
806	// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
807	var setSymbolDesc = DESCRIPTORS && $fails(function(){
808	return _create(setDesc({}, 'a', {
809	get: function(){ return setDesc(this, 'a', {value: 7}).a; }
810	})).a != 7;
811	}) ? function(it, key, D){
812	var protoDesc = getDesc(ObjectProto, key);
813	if(protoDesc)delete ObjectProto[key];
814	setDesc(it, key, D);
815	if(protoDesc && it !== ObjectProto)setDesc(ObjectProto, key, protoDesc);
816	} : setDesc;
817
818	var wrap = function(tag){
819	var sym = AllSymbols[tag] = _create($Symbol.prototype);
820	sym._k = tag;
821	DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, {
822	configurable: true,
823	set: function(value){
824	if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
825	setSymbolDesc(this, tag, createDesc(1, value));
826	}
827	});
828	return sym;
829	};
830
831	var isSymbol = function(it){
832	return typeof it == 'symbol';
833	};
834
835	var $defineProperty = function defineProperty(it, key, D){
836	if(D && has(AllSymbols, key)){
837	if(!D.enumerable){
838	if(!has(it, HIDDEN))setDesc(it, HIDDEN, createDesc(1, {}));
839	it[HIDDEN][key] = true;
840	} else {
841	if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
842	D = _create(D, {enumerable: createDesc(0, false)});
843	} return setSymbolDesc(it, key, D);
844	} return setDesc(it, key, D);
845	};
846	var $defineProperties = function defineProperties(it, P){
847	anObject(it);
848	var keys = enumKeys(P = toIObject(P))
849	, i = 0
850	, l = keys.length
851	, key;
852	while(l > i)$defineProperty(it, key = keys[i++], P[key]);
853	return it;
854	};
855	var $create = function create(it, P){
856	return P === undefined ? _create(it) : $defineProperties(_create(it), P);
857	};
858	var $propertyIsEnumerable = function propertyIsEnumerable(key){
859	var E = isEnum.call(this, key);
860	return E \|\| !has(this, key) \|\| !has(AllSymbols, key) \|\| has(this, HIDDEN) && this[HIDDEN][key]
861	? E : true;
862	};
863	var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
864	var D = getDesc(it = toIObject(it), key);
865	if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
866	return D;
867	};
868	var $getOwnPropertyNames = function getOwnPropertyNames(it){
869	var names = getNames(toIObject(it))
870	, result = []
871	, i = 0
872	, key;
873	while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);
874	return result;
875	};
876	var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
877	var names = getNames(toIObject(it))
878	, result = []
879	, i = 0
880	, key;
881	while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);
882	return result;
883	};
884	var $stringify = function stringify(it){
885	if(it === undefined \|\| isSymbol(it))return; // IE8 returns string on undefined
886	var args = [it]
887	, i = 1
888	, $$ = arguments
889	, replacer, $replacer;
890	while($$.length > i)args.push($$[i++]);
891	replacer = args[1];
892	if(typeof replacer == 'function')$replacer = replacer;
893	if($replacer \|\| !isArray(replacer))replacer = function(key, value){
894	if($replacer)value = $replacer.call(this, key, value);
895	if(!isSymbol(value))return value;
896	};
897	args[1] = replacer;
898	return _stringify.apply($JSON, args);
899	};
900	var buggyJSON = $fails(function(){
901	var S = $Symbol();
902	// MS Edge converts symbol values to JSON as {}
903	// WebKit converts symbol values to JSON as null
904	// V8 throws on boxed symbols
905	return _stringify([S]) != '[null]' \|\| _stringify({a: S}) != '{}' \|\| _stringify(Object(S)) != '{}';
906	});
907
908	// 19.4.1.1 Symbol([description])
909	if(!useNative){
910	$Symbol = function Symbol(){
911	if(isSymbol(this))throw TypeError('Symbol is not a constructor');
912	return wrap(uid(arguments.length > 0 ? arguments[0] : undefined));
913	};
914	redefine($Symbol.prototype, 'toString', function toString(){
915	return this._k;
916	});
917
918	isSymbol = function(it){
919	return it instanceof $Symbol;
920	};
921
922	$.create = $create;
923	$.isEnum = $propertyIsEnumerable;
924	$.getDesc = $getOwnPropertyDescriptor;
925	$.setDesc = $defineProperty;
926	$.setDescs = $defineProperties;
927	$.getNames = $names.get = $getOwnPropertyNames;
928	$.getSymbols = $getOwnPropertySymbols;
929
930	if(DESCRIPTORS && !__webpack_require__(40)){
931	redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
932	}
933	}
934
935	var symbolStatics = {
936	// 19.4.2.1 Symbol.for(key)
937	'for': function(key){
938	return has(SymbolRegistry, key += '')
939	? SymbolRegistry[key]
940	: SymbolRegistry[key] = $Symbol(key);
941	},
942	// 19.4.2.5 Symbol.keyFor(sym)
943	keyFor: function keyFor(key){
944	return keyOf(SymbolRegistry, key);
945	},
946	useSetter: function(){ setter = true; },
947	useSimple: function(){ setter = false; }
948	};
949	// 19.4.2.2 Symbol.hasInstance
950	// 19.4.2.3 Symbol.isConcatSpreadable
951	// 19.4.2.4 Symbol.iterator
952	// 19.4.2.6 Symbol.match
953	// 19.4.2.8 Symbol.replace
954	// 19.4.2.9 Symbol.search
955	// 19.4.2.10 Symbol.species
956	// 19.4.2.11 Symbol.split
957	// 19.4.2.12 Symbol.toPrimitive
958	// 19.4.2.13 Symbol.toStringTag
959	// 19.4.2.14 Symbol.unscopables
960	$.each.call((
961	'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +
962	'species,split,toPrimitive,toStringTag,unscopables'
963	).split(','), function(it){
964	var sym = wks(it);
965	symbolStatics[it] = useNative ? sym : wrap(sym);
966	});
967
968	setter = true;
969
970	$export($export.G + $export.W, {Symbol: $Symbol});
971
972	$export($export.S, 'Symbol', symbolStatics);
973
974	$export($export.S + $export.F * !useNative, 'Object', {
975	// 19.1.2.2 Object.create(O [, Properties])
976	create: $create,
977	// 19.1.2.4 Object.defineProperty(O, P, Attributes)
978	defineProperty: $defineProperty,
979	// 19.1.2.3 Object.defineProperties(O, Properties)
980	defineProperties: $defineProperties,
981	// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
982	getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
983	// 19.1.2.7 Object.getOwnPropertyNames(O)
984	getOwnPropertyNames: $getOwnPropertyNames,
985	// 19.1.2.8 Object.getOwnPropertySymbols(O)
986	getOwnPropertySymbols: $getOwnPropertySymbols
987	});
988
989	// 24.3.2 JSON.stringify(value [, replacer [, space]])
990	$JSON && $export($export.S + $export.F * (!useNative \|\| buggyJSON), 'JSON', {stringify: $stringify});
991
992	// 19.4.3.5 Symbol.prototype[@@toStringTag]
993	setToStringTag($Symbol, 'Symbol');
994	// 20.2.1.9 Math[@@toStringTag]
995	setToStringTag(Math, 'Math', true);
996	// 24.3.3 JSON[@@toStringTag]
997	setToStringTag(global.JSON, 'JSON', true);
998
999	/***/ }),
1000	/* 15 */
1001	/***/ (function(module, exports) {
1002
1003	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
1004	var global = module.exports = typeof window != 'undefined' && window.Math == Math
1005	? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
1006	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
1007
1008	/***/ }),
1009	/* 16 */
1010	/***/ (function(module, exports) {
1011
1012	var hasOwnProperty = {}.hasOwnProperty;
1013	module.exports = function(it, key){
1014	return hasOwnProperty.call(it, key);
1015	};
1016
1017	/***/ }),
1018	/* 17 */
1019	/***/ (function(module, exports, __webpack_require__) {
1020
1021	// Thank's IE8 for his funny defineProperty
1022	module.exports = !__webpack_require__(18)(function(){
1023	return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
1024	});
1025
1026	/***/ }),
1027	/* 18 */
1028	/***/ (function(module, exports) {
1029
1030	module.exports = function(exec){
1031	try {
1032	return !!exec();
1033	} catch(e){
1034	return true;
1035	}
1036	};
1037
1038	/***/ }),
1039	/* 19 */
1040	/***/ (function(module, exports, __webpack_require__) {
1041
1042	var global = __webpack_require__(15)
1043	, core = __webpack_require__(20)
1044	, ctx = __webpack_require__(21)
1045	, PROTOTYPE = 'prototype';
1046
1047	var $export = function(type, name, source){
1048	var IS_FORCED = type & $export.F
1049	, IS_GLOBAL = type & $export.G
1050	, IS_STATIC = type & $export.S
1051	, IS_PROTO = type & $export.P
1052	, IS_BIND = type & $export.B
1053	, IS_WRAP = type & $export.W
1054	, exports = IS_GLOBAL ? core : core[name] \|\| (core[name] = {})
1055	, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] \|\| {})[PROTOTYPE]
1056	, key, own, out;
1057	if(IS_GLOBAL)source = name;
1058	for(key in source){
1059	// contains in native
1060	own = !IS_FORCED && target && key in target;
1061	if(own && key in exports)continue;
1062	// export native or passed
1063	out = own ? target[key] : source[key];
1064	// prevent global pollution for namespaces
1065	exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
1066	// bind timers to global for call from export context
1067	: IS_BIND && own ? ctx(out, global)
1068	// wrap global constructors for prevent change them in library
1069	: IS_WRAP && target[key] == out ? (function(C){
1070	var F = function(param){
1071	return this instanceof C ? new C(param) : C(param);
1072	};
1073	F[PROTOTYPE] = C[PROTOTYPE];
1074	return F;
1075	// make static versions for prototype methods
1076	})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
1077	if(IS_PROTO)(exports[PROTOTYPE] \|\| (exports[PROTOTYPE] = {}))[key] = out;
1078	}
1079	};
1080	// type bitmap
1081	$export.F = 1; // forced
1082	$export.G = 2; // global
1083	$export.S = 4; // static
1084	$export.P = 8; // proto
1085	$export.B = 16; // bind
1086	$export.W = 32; // wrap
1087	module.exports = $export;
1088
1089	/***/ }),
1090	/* 20 */
1091	/***/ (function(module, exports) {
1092
1093	var core = module.exports = {version: '1.2.6'};
1094	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
1095
1096	/***/ }),
1097	/* 21 */
1098	/***/ (function(module, exports, __webpack_require__) {
1099
1100	// optional / simple context binding
1101	var aFunction = __webpack_require__(22);
1102	module.exports = function(fn, that, length){
1103	aFunction(fn);
1104	if(that === undefined)return fn;
1105	switch(length){
1106	case 1: return function(a){
1107	return fn.call(that, a);
1108	};
1109	case 2: return function(a, b){
1110	return fn.call(that, a, b);
1111	};
1112	case 3: return function(a, b, c){
1113	return fn.call(that, a, b, c);
1114	};
1115	}
1116	return function(/* ...args */){
1117	return fn.apply(that, arguments);
1118	};
1119	};
1120
1121	/***/ }),
1122	/* 22 */
1123	/***/ (function(module, exports) {
1124
1125	module.exports = function(it){
1126	if(typeof it != 'function')throw TypeError(it + ' is not a function!');
1127	return it;
1128	};
1129
1130	/***/ }),
1131	/* 23 */
1132	/***/ (function(module, exports, __webpack_require__) {
1133
1134	module.exports = __webpack_require__(24);
1135
1136	/***/ }),
1137	/* 24 */
1138	/***/ (function(module, exports, __webpack_require__) {
1139
1140	var $ = __webpack_require__(8)
1141	, createDesc = __webpack_require__(25);
1142	module.exports = __webpack_require__(17) ? function(object, key, value){
1143	return $.setDesc(object, key, createDesc(1, value));
1144	} : function(object, key, value){
1145	object[key] = value;
1146	return object;
1147	};
1148
1149	/***/ }),
1150	/* 25 */
1151	/***/ (function(module, exports) {
1152
1153	module.exports = function(bitmap, value){
1154	return {
1155	enumerable : !(bitmap & 1),
1156	configurable: !(bitmap & 2),
1157	writable : !(bitmap & 4),
1158	value : value
1159	};
1160	};
1161
1162	/***/ }),
1163	/* 26 */
1164	/***/ (function(module, exports, __webpack_require__) {
1165
1166	var global = __webpack_require__(15)
1167	, SHARED = '__core-js_shared__'
1168	, store = global[SHARED] \|\| (global[SHARED] = {});
1169	module.exports = function(key){
1170	return store[key] \|\| (store[key] = {});
1171	};
1172
1173	/***/ }),
1174	/* 27 */
1175	/***/ (function(module, exports, __webpack_require__) {
1176
1177	var def = __webpack_require__(8).setDesc
1178	, has = __webpack_require__(16)
1179	, TAG = __webpack_require__(28)('toStringTag');
1180
1181	module.exports = function(it, tag, stat){
1182	if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
1183	};
1184
1185	/***/ }),
1186	/* 28 */
1187	/***/ (function(module, exports, __webpack_require__) {
1188
1189	var store = __webpack_require__(26)('wks')
1190	, uid = __webpack_require__(29)
1191	, Symbol = __webpack_require__(15).Symbol;
1192	module.exports = function(name){
1193	return store[name] \|\| (store[name] =
1194	Symbol && Symbol[name] \|\| (Symbol \|\| uid)('Symbol.' + name));
1195	};
1196
1197	/***/ }),
1198	/* 29 */
1199	/***/ (function(module, exports) {
1200
1201	var id = 0
1202	, px = Math.random();
1203	module.exports = function(key){
1204	return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
1205	};
1206
1207	/***/ }),
1208	/* 30 */
1209	/***/ (function(module, exports, __webpack_require__) {
1210
1211	var $ = __webpack_require__(8)
1212	, toIObject = __webpack_require__(31);
1213	module.exports = function(object, el){
1214	var O = toIObject(object)
1215	, keys = $.getKeys(O)
1216	, length = keys.length
1217	, index = 0
1218	, key;
1219	while(length > index)if(O[key = keys[index++]] === el)return key;
1220	};
1221
1222	/***/ }),
1223	/* 31 */
1224	/***/ (function(module, exports, __webpack_require__) {
1225
1226	// to indexed object, toObject with fallback for non-array-like ES3 strings
1227	var IObject = __webpack_require__(32)
1228	, defined = __webpack_require__(34);
1229	module.exports = function(it){
1230	return IObject(defined(it));
1231	};
1232
1233	/***/ }),
1234	/* 32 */
1235	/***/ (function(module, exports, __webpack_require__) {
1236
1237	// fallback for non-array-like ES3 and non-enumerable old V8 strings
1238	var cof = __webpack_require__(33);
1239	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
1240	return cof(it) == 'String' ? it.split('') : Object(it);
1241	};
1242
1243	/***/ }),
1244	/* 33 */
1245	/***/ (function(module, exports) {
1246
1247	var toString = {}.toString;
1248
1249	module.exports = function(it){
1250	return toString.call(it).slice(8, -1);
1251	};
1252
1253	/***/ }),
1254	/* 34 */
1255	/***/ (function(module, exports) {
1256
1257	// 7.2.1 RequireObjectCoercible(argument)
1258	module.exports = function(it){
1259	if(it == undefined)throw TypeError("Can't call method on " + it);
1260	return it;
1261	};
1262
1263	/***/ }),
1264	/* 35 */
1265	/***/ (function(module, exports, __webpack_require__) {
1266
1267	// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
1268	var toIObject = __webpack_require__(31)
1269	, getNames = __webpack_require__(8).getNames
1270	, toString = {}.toString;
1271
1272	var windowNames = typeof window == 'object' && Object.getOwnPropertyNames
1273	? Object.getOwnPropertyNames(window) : [];
1274
1275	var getWindowNames = function(it){
1276	try {
1277	return getNames(it);
1278	} catch(e){
1279	return windowNames.slice();
1280	}
1281	};
1282
1283	module.exports.get = function getOwnPropertyNames(it){
1284	if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);
1285	return getNames(toIObject(it));
1286	};
1287
1288	/***/ }),
1289	/* 36 */
1290	/***/ (function(module, exports, __webpack_require__) {
1291
1292	// all enumerable object keys, includes symbols
1293	var $ = __webpack_require__(8);
1294	module.exports = function(it){
1295	var keys = $.getKeys(it)
1296	, getSymbols = $.getSymbols;
1297	if(getSymbols){
1298	var symbols = getSymbols(it)
1299	, isEnum = $.isEnum
1300	, i = 0
1301	, key;
1302	while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);
1303	}
1304	return keys;
1305	};
1306
1307	/***/ }),
1308	/* 37 */
1309	/***/ (function(module, exports, __webpack_require__) {
1310
1311	// 7.2.2 IsArray(argument)
1312	var cof = __webpack_require__(33);
1313	module.exports = Array.isArray \|\| function(arg){
1314	return cof(arg) == 'Array';
1315	};
1316
1317	/***/ }),
1318	/* 38 */
1319	/***/ (function(module, exports, __webpack_require__) {
1320
1321	var isObject = __webpack_require__(39);
1322	module.exports = function(it){
1323	if(!isObject(it))throw TypeError(it + ' is not an object!');
1324	return it;
1325	};
1326
1327	/***/ }),
1328	/* 39 */
1329	/***/ (function(module, exports) {
1330
1331	module.exports = function(it){
1332	return typeof it === 'object' ? it !== null : typeof it === 'function';
1333	};
1334
1335	/***/ }),
1336	/* 40 */
1337	/***/ (function(module, exports) {
1338
1339	module.exports = true;
1340
1341	/***/ }),
1342	/* 41 */
1343	/***/ (function(module, exports) {
1344
1345
1346
1347	/***/ }),
1348	/* 42 */
1349	/***/ (function(module, exports, __webpack_require__) {
1350
1351	module.exports = { "default": __webpack_require__(43), __esModule: true };
1352
1353	/***/ }),
1354	/* 43 */
1355	/***/ (function(module, exports, __webpack_require__) {
1356
1357	__webpack_require__(44);
1358	__webpack_require__(50);
1359	module.exports = __webpack_require__(28)('iterator');
1360
1361	/***/ }),
1362	/* 44 */
1363	/***/ (function(module, exports, __webpack_require__) {
1364
1365	'use strict';
1366	var $at = __webpack_require__(45)(true);
1367
1368	// 21.1.3.27 String.prototype[@@iterator]()
1369	__webpack_require__(47)(String, 'String', function(iterated){
1370	this._t = String(iterated); // target
1371	this._i = 0; // next index
1372	// 21.1.5.2.1 %StringIteratorPrototype%.next()
1373	}, function(){
1374	var O = this._t
1375	, index = this._i
1376	, point;
1377	if(index >= O.length)return {value: undefined, done: true};
1378	point = $at(O, index);
1379	this._i += point.length;
1380	return {value: point, done: false};
1381	});
1382
1383	/***/ }),
1384	/* 45 */
1385	/***/ (function(module, exports, __webpack_require__) {
1386
1387	var toInteger = __webpack_require__(46)
1388	, defined = __webpack_require__(34);
1389	// true -> String#at
1390	// false -> String#codePointAt
1391	module.exports = function(TO_STRING){
1392	return function(that, pos){
1393	var s = String(defined(that))
1394	, i = toInteger(pos)
1395	, l = s.length
1396	, a, b;
1397	if(i < 0 \|\| i >= l)return TO_STRING ? '' : undefined;
1398	a = s.charCodeAt(i);
1399	return a < 0xd800 \|\| a > 0xdbff \|\| i + 1 === l \|\| (b = s.charCodeAt(i + 1)) < 0xdc00 \|\| b > 0xdfff
1400	? TO_STRING ? s.charAt(i) : a
1401	: TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
1402	};
1403	};
1404
1405	/***/ }),
1406	/* 46 */
1407	/***/ (function(module, exports) {
1408
1409	// 7.1.4 ToInteger
1410	var ceil = Math.ceil
1411	, floor = Math.floor;
1412	module.exports = function(it){
1413	return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
1414	};
1415
1416	/***/ }),
1417	/* 47 */
1418	/***/ (function(module, exports, __webpack_require__) {
1419
1420	'use strict';
1421	var LIBRARY = __webpack_require__(40)
1422	, $export = __webpack_require__(19)
1423	, redefine = __webpack_require__(23)
1424	, hide = __webpack_require__(24)
1425	, has = __webpack_require__(16)
1426	, Iterators = __webpack_require__(48)
1427	, $iterCreate = __webpack_require__(49)
1428	, setToStringTag = __webpack_require__(27)
1429	, getProto = __webpack_require__(8).getProto
1430	, ITERATOR = __webpack_require__(28)('iterator')
1431	, BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
1432	, FF_ITERATOR = '@@iterator'
1433	, KEYS = 'keys'
1434	, VALUES = 'values';
1435
1436	var returnThis = function(){ return this; };
1437
1438	module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
1439	$iterCreate(Constructor, NAME, next);
1440	var getMethod = function(kind){
1441	if(!BUGGY && kind in proto)return proto[kind];
1442	switch(kind){
1443	case KEYS: return function keys(){ return new Constructor(this, kind); };
1444	case VALUES: return function values(){ return new Constructor(this, kind); };
1445	} return function entries(){ return new Constructor(this, kind); };
1446	};
1447	var TAG = NAME + ' Iterator'
1448	, DEF_VALUES = DEFAULT == VALUES
1449	, VALUES_BUG = false
1450	, proto = Base.prototype
1451	, $native = proto[ITERATOR] \|\| proto[FF_ITERATOR] \|\| DEFAULT && proto[DEFAULT]
1452	, $default = $native \|\| getMethod(DEFAULT)
1453	, methods, key;
1454	// Fix native
1455	if($native){
1456	var IteratorPrototype = getProto($default.call(new Base));
1457	// Set @@toStringTag to native iterators
1458	setToStringTag(IteratorPrototype, TAG, true);
1459	// FF fix
1460	if(!LIBRARY && has(proto, FF_ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
1461	// fix Array#{values, @@iterator}.name in V8 / FF
1462	if(DEF_VALUES && $native.name !== VALUES){
1463	VALUES_BUG = true;
1464	$default = function values(){ return $native.call(this); };
1465	}
1466	}
1467	// Define iterator
1468	if((!LIBRARY \|\| FORCED) && (BUGGY \|\| VALUES_BUG \|\| !proto[ITERATOR])){
1469	hide(proto, ITERATOR, $default);
1470	}
1471	// Plug for library
1472	Iterators[NAME] = $default;
1473	Iterators[TAG] = returnThis;
1474	if(DEFAULT){
1475	methods = {
1476	values: DEF_VALUES ? $default : getMethod(VALUES),
1477	keys: IS_SET ? $default : getMethod(KEYS),
1478	entries: !DEF_VALUES ? $default : getMethod('entries')
1479	};
1480	if(FORCED)for(key in methods){
1481	if(!(key in proto))redefine(proto, key, methods[key]);
1482	} else $export($export.P + $export.F * (BUGGY \|\| VALUES_BUG), NAME, methods);
1483	}
1484	return methods;
1485	};
1486
1487	/***/ }),
1488	/* 48 */
1489	/***/ (function(module, exports) {
1490
1491	module.exports = {};
1492
1493	/***/ }),
1494	/* 49 */
1495	/***/ (function(module, exports, __webpack_require__) {
1496
1497	'use strict';
1498	var $ = __webpack_require__(8)
1499	, descriptor = __webpack_require__(25)
1500	, setToStringTag = __webpack_require__(27)
1501	, IteratorPrototype = {};
1502
1503	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
1504	__webpack_require__(24)(IteratorPrototype, __webpack_require__(28)('iterator'), function(){ return this; });
1505
1506	module.exports = function(Constructor, NAME, next){
1507	Constructor.prototype = $.create(IteratorPrototype, {next: descriptor(1, next)});
1508	setToStringTag(Constructor, NAME + ' Iterator');
1509	};
1510
1511	/***/ }),
1512	/* 50 */
1513	/***/ (function(module, exports, __webpack_require__) {
1514
1515	__webpack_require__(51);
1516	var Iterators = __webpack_require__(48);
1517	Iterators.NodeList = Iterators.HTMLCollection = Iterators.Array;
1518
1519	/***/ }),
1520	/* 51 */
1521	/***/ (function(module, exports, __webpack_require__) {
1522
1523	'use strict';
1524	var addToUnscopables = __webpack_require__(52)
1525	, step = __webpack_require__(53)
1526	, Iterators = __webpack_require__(48)
1527	, toIObject = __webpack_require__(31);
1528
1529	// 22.1.3.4 Array.prototype.entries()
1530	// 22.1.3.13 Array.prototype.keys()
1531	// 22.1.3.29 Array.prototype.values()
1532	// 22.1.3.30 Array.prototype[@@iterator]()
1533	module.exports = __webpack_require__(47)(Array, 'Array', function(iterated, kind){
1534	this._t = toIObject(iterated); // target
1535	this._i = 0; // next index
1536	this._k = kind; // kind
1537	// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
1538	}, function(){
1539	var O = this._t
1540	, kind = this._k
1541	, index = this._i++;
1542	if(!O \|\| index >= O.length){
1543	this._t = undefined;
1544	return step(1);
1545	}
1546	if(kind == 'keys' )return step(0, index);
1547	if(kind == 'values')return step(0, O[index]);
1548	return step(0, [index, O[index]]);
1549	}, 'values');
1550
1551	// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
1552	Iterators.Arguments = Iterators.Array;
1553
1554	addToUnscopables('keys');
1555	addToUnscopables('values');
1556	addToUnscopables('entries');
1557
1558	/***/ }),
1559	/* 52 */
1560	/***/ (function(module, exports) {
1561
1562	module.exports = function(){ /* empty */ };
1563
1564	/***/ }),
1565	/* 53 */
1566	/***/ (function(module, exports) {
1567
1568	module.exports = function(done, value){
1569	return {value: value, done: !!done};
1570	};
1571
1572	/***/ }),
1573	/* 54 */
1574	/***/ (function(module, exports, __webpack_require__) {
1575
1576	module.exports = { "default": __webpack_require__(55), __esModule: true };
1577
1578	/***/ }),
1579	/* 55 */
1580	/***/ (function(module, exports, __webpack_require__) {
1581
1582	__webpack_require__(50);
1583	__webpack_require__(44);
1584	module.exports = __webpack_require__(56);
1585
1586	/***/ }),
1587	/* 56 */
1588	/***/ (function(module, exports, __webpack_require__) {
1589
1590	var anObject = __webpack_require__(38)
1591	, get = __webpack_require__(57);
1592	module.exports = __webpack_require__(20).getIterator = function(it){
1593	var iterFn = get(it);
1594	if(typeof iterFn != 'function')throw TypeError(it + ' is not iterable!');
1595	return anObject(iterFn.call(it));
1596	};
1597
1598	/***/ }),
1599	/* 57 */
1600	/***/ (function(module, exports, __webpack_require__) {
1601
1602	var classof = __webpack_require__(58)
1603	, ITERATOR = __webpack_require__(28)('iterator')
1604	, Iterators = __webpack_require__(48);
1605	module.exports = __webpack_require__(20).getIteratorMethod = function(it){
1606	if(it != undefined)return it[ITERATOR]
1607	\|\| it['@@iterator']
1608	\|\| Iterators[classof(it)];
1609	};
1610
1611	/***/ }),
1612	/* 58 */
1613	/***/ (function(module, exports, __webpack_require__) {
1614
1615	// getting tag from 19.1.3.6 Object.prototype.toString()
1616	var cof = __webpack_require__(33)
1617	, TAG = __webpack_require__(28)('toStringTag')
1618	// ES3 wrong here
1619	, ARG = cof(function(){ return arguments; }()) == 'Arguments';
1620
1621	module.exports = function(it){
1622	var O, T, B;
1623	return it === undefined ? 'Undefined' : it === null ? 'Null'
1624	// @@toStringTag case
1625	: typeof (T = (O = Object(it))[TAG]) == 'string' ? T
1626	// builtinTag case
1627	: ARG ? cof(O)
1628	// ES3 arguments fallback
1629	: (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
1630	};
1631
1632	/***/ }),
1633	/* 59 */
1634	/***/ (function(module, exports, __webpack_require__) {
1635
1636	module.exports = { "default": __webpack_require__(60), __esModule: true };
1637
1638	/***/ }),
1639	/* 60 */
1640	/***/ (function(module, exports, __webpack_require__) {
1641
1642	__webpack_require__(61);
1643	module.exports = __webpack_require__(20).Object.keys;
1644
1645	/***/ }),
1646	/* 61 */
1647	/***/ (function(module, exports, __webpack_require__) {
1648
1649	// 19.1.2.14 Object.keys(O)
1650	var toObject = __webpack_require__(62);
1651
1652	__webpack_require__(63)('keys', function($keys){
1653	return function keys(it){
1654	return $keys(toObject(it));
1655	};
1656	});
1657
1658	/***/ }),
1659	/* 62 */
1660	/***/ (function(module, exports, __webpack_require__) {
1661
1662	// 7.1.13 ToObject(argument)
1663	var defined = __webpack_require__(34);
1664	module.exports = function(it){
1665	return Object(defined(it));
1666	};
1667
1668	/***/ }),
1669	/* 63 */
1670	/***/ (function(module, exports, __webpack_require__) {
1671
1672	// most Object methods by ES6 should accept primitives
1673	var $export = __webpack_require__(19)
1674	, core = __webpack_require__(20)
1675	, fails = __webpack_require__(18);
1676	module.exports = function(KEY, exec){
1677	var fn = (core.Object \|\| {})[KEY] \|\| Object[KEY]
1678	, exp = {};
1679	exp[KEY] = exec(fn);
1680	$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
1681	};
1682
1683	/***/ }),
1684	/* 64 */
1685	/***/ (function(module, exports, __webpack_require__) {
1686
1687	'use strict';
1688
1689	var _interopRequireDefault = __webpack_require__(2)['default'];
1690
1691	exports.__esModule = true;
1692
1693	var _exception = __webpack_require__(5);
1694
1695	var _exception2 = _interopRequireDefault(_exception);
1696
1697	exports['default'] = function (instance) {
1698	instance.registerHelper('helperMissing', function () /* [args, ]options */{
1699	if (arguments.length === 1) {
1700	// A missing field in a {{foo}} construct.
1701	return undefined;
1702	} else {
1703	// Someone is actually trying to call something, blow up.
1704	throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
1705	}
1706	});
1707	};
1708
1709	module.exports = exports['default'];
1710
1711	/***/ }),
1712	/* 65 */
1713	/***/ (function(module, exports, __webpack_require__) {
1714
1715	'use strict';
1716
1717	var _interopRequireDefault = __webpack_require__(2)['default'];
1718
1719	exports.__esModule = true;
1720
1721	var _utils = __webpack_require__(4);
1722
1723	var _exception = __webpack_require__(5);
1724
1725	var _exception2 = _interopRequireDefault(_exception);
1726
1727	exports['default'] = function (instance) {
1728	instance.registerHelper('if', function (conditional, options) {
1729	if (arguments.length != 2) {
1730	throw new _exception2['default']('#if requires exactly one argument');
1731	}
1732	if (_utils.isFunction(conditional)) {
1733	conditional = conditional.call(this);
1734	}
1735
1736	// Default behavior is to render the positive path if the value is truthy and not empty.
1737	// The `includeZero` option may be set to treat the condtional as purely not empty based on the
1738	// behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
1739	if (!options.hash.includeZero && !conditional \|\| _utils.isEmpty(conditional)) {
1740	return options.inverse(this);
1741	} else {
1742	return options.fn(this);
1743	}
1744	});
1745
1746	instance.registerHelper('unless', function (conditional, options) {
1747	if (arguments.length != 2) {
1748	throw new _exception2['default']('#unless requires exactly one argument');
1749	}
1750	return instance.helpers['if'].call(this, conditional, {
1751	fn: options.inverse,
1752	inverse: options.fn,
1753	hash: options.hash
1754	});
1755	});
1756	};
1757
1758	module.exports = exports['default'];
1759
1760	/***/ }),
1761	/* 66 */
1762	/***/ (function(module, exports) {
1763
1764	'use strict';
1765
1766	exports.__esModule = true;
1767
1768	exports['default'] = function (instance) {
1769	instance.registerHelper('log', function () /* message, options */{
1770	var args = [undefined],
1771	options = arguments[arguments.length - 1];
1772	for (var i = 0; i < arguments.length - 1; i++) {
1773	args.push(arguments[i]);
1774	}
1775
1776	var level = 1;
1777	if (options.hash.level != null) {
1778	level = options.hash.level;
1779	} else if (options.data && options.data.level != null) {
1780	level = options.data.level;
1781	}
1782	args[0] = level;
1783
1784	instance.log.apply(instance, args);
1785	});
1786	};
1787
1788	module.exports = exports['default'];
1789
1790	/***/ }),
1791	/* 67 */
1792	/***/ (function(module, exports) {
1793
1794	'use strict';
1795
1796	exports.__esModule = true;
1797
1798	exports['default'] = function (instance) {
1799	instance.registerHelper('lookup', function (obj, field, options) {
1800	if (!obj) {
1801	// Note for 5.0: Change to "obj == null" in 5.0
1802	return obj;
1803	}
1804	return options.lookupProperty(obj, field);
1805	});
1806	};
1807
1808	module.exports = exports['default'];
1809
1810	/***/ }),
1811	/* 68 */
1812	/***/ (function(module, exports, __webpack_require__) {
1813
1814	'use strict';
1815
1816	var _interopRequireDefault = __webpack_require__(2)['default'];
1817
1818	exports.__esModule = true;
1819
1820	var _utils = __webpack_require__(4);
1821
1822	var _exception = __webpack_require__(5);
1823
1824	var _exception2 = _interopRequireDefault(_exception);
1825
1826	exports['default'] = function (instance) {
1827	instance.registerHelper('with', function (context, options) {
1828	if (arguments.length != 2) {
1829	throw new _exception2['default']('#with requires exactly one argument');
1830	}
1831	if (_utils.isFunction(context)) {
1832	context = context.call(this);
1833	}
1834
1835	var fn = options.fn;
1836
1837	if (!_utils.isEmpty(context)) {
1838	var data = options.data;
1839	if (options.data && options.ids) {
1840	data = _utils.createFrame(options.data);
1841	data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
1842	}
1843
1844	return fn(context, {
1845	data: data,
1846	blockParams: _utils.blockParams([context], [data && data.contextPath])
1847	});
1848	} else {
1849	return options.inverse(this);
1850	}
1851	});
1852	};
1853
1854	module.exports = exports['default'];
1855
1856	/***/ }),
1857	/* 69 */
1858	/***/ (function(module, exports, __webpack_require__) {
1859
1860	'use strict';
1861
1862	var _interopRequireDefault = __webpack_require__(2)['default'];
1863
1864	exports.__esModule = true;
1865	exports.registerDefaultDecorators = registerDefaultDecorators;
1866
1867	var _decoratorsInline = __webpack_require__(70);
1868
1869	var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);
1870
1871	function registerDefaultDecorators(instance) {
1872	_decoratorsInline2['default'](instance);
1873	}
1874
1875	/***/ }),
1876	/* 70 */
1877	/***/ (function(module, exports, __webpack_require__) {
1878
1879	'use strict';
1880
1881	exports.__esModule = true;
1882
1883	var _utils = __webpack_require__(4);
1884
1885	exports['default'] = function (instance) {
1886	instance.registerDecorator('inline', function (fn, props, container, options) {
1887	var ret = fn;
1888	if (!props.partials) {
1889	props.partials = {};
1890	ret = function (context, options) {
1891	// Create a new partials stack frame prior to exec.
1892	var original = container.partials;
1893	container.partials = _utils.extend({}, original, props.partials);
1894	var ret = fn(context, options);
1895	container.partials = original;
1896	return ret;
1897	};
1898	}
1899
1900	props.partials[options.args[0]] = options.fn;
1901
1902	return ret;
1903	});
1904	};
1905
1906	module.exports = exports['default'];
1907
1908	/***/ }),
1909	/* 71 */
1910	/***/ (function(module, exports, __webpack_require__) {
1911
1912	'use strict';
1913
1914	exports.__esModule = true;
1915
1916	var _utils = __webpack_require__(4);
1917
1918	var logger = {
1919	methodMap: ['debug', 'info', 'warn', 'error'],
1920	level: 'info',
1921
1922	// Maps a given level value to the `methodMap` indexes above.
1923	lookupLevel: function lookupLevel(level) {
1924	if (typeof level === 'string') {
1925	var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());
1926	if (levelMap >= 0) {
1927	level = levelMap;
1928	} else {
1929	level = parseInt(level, 10);
1930	}
1931	}
1932
1933	return level;
1934	},
1935
1936	// Can be overridden in the host environment
1937	log: function log(level) {
1938	level = logger.lookupLevel(level);
1939
1940	if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {
1941	var method = logger.methodMap[level];
1942	// eslint-disable-next-line no-console
1943	if (!console[method]) {
1944	method = 'log';
1945	}
1946
1947	for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
1948	message[_key - 1] = arguments[_key];
1949	}
1950
1951	console[method].apply(console, message); // eslint-disable-line no-console
1952	}
1953	}
1954	};
1955
1956	exports['default'] = logger;
1957	module.exports = exports['default'];
1958
1959	/***/ }),
1960	/* 72 */
1961	/***/ (function(module, exports, __webpack_require__) {
1962
1963	'use strict';
1964
1965	var _Object$create = __webpack_require__(73)['default'];
1966
1967	var _Object$keys = __webpack_require__(59)['default'];
1968
1969	var _interopRequireDefault = __webpack_require__(2)['default'];
1970
1971	exports.__esModule = true;
1972	exports.createProtoAccessControl = createProtoAccessControl;
1973	exports.resultIsAllowed = resultIsAllowed;
1974	exports.resetLoggedProperties = resetLoggedProperties;
1975
1976	var _utils = __webpack_require__(4);
1977
1978	var _logger = __webpack_require__(71);
1979
1980	var _logger2 = _interopRequireDefault(_logger);
1981
1982	var loggedProperties = _Object$create(null);
1983
1984	function createProtoAccessControl(runtimeOptions) {
1985	// Create an object with "null"-prototype to avoid truthy results on
1986	// prototype properties.
1987	var propertyWhiteList = _Object$create(null);
1988	// eslint-disable-next-line no-proto
1989	propertyWhiteList['__proto__'] = false;
1990	_utils.extend(propertyWhiteList, runtimeOptions.allowedProtoProperties);
1991
1992	var methodWhiteList = _Object$create(null);
1993	methodWhiteList['constructor'] = false;
1994	methodWhiteList['__defineGetter__'] = false;
1995	methodWhiteList['__defineSetter__'] = false;
1996	methodWhiteList['__lookupGetter__'] = false;
1997	methodWhiteList['__lookupSetter__'] = false;
1998	_utils.extend(methodWhiteList, runtimeOptions.allowedProtoMethods);
1999
2000	return {
2001	properties: {
2002	whitelist: propertyWhiteList,
2003	defaultValue: runtimeOptions.allowProtoPropertiesByDefault
2004	},
2005	methods: {
2006	whitelist: methodWhiteList,
2007	defaultValue: runtimeOptions.allowProtoMethodsByDefault
2008	}
2009	};
2010	}
2011
2012	function resultIsAllowed(result, protoAccessControl, propertyName) {
2013	if (typeof result === 'function') {
2014	return checkWhiteList(protoAccessControl.methods, propertyName);
2015	} else {
2016	return checkWhiteList(protoAccessControl.properties, propertyName);
2017	}
2018	}
2019
2020	function checkWhiteList(protoAccessControlForType, propertyName) {
2021	if (protoAccessControlForType.whitelist[propertyName] !== undefined) {
2022	return protoAccessControlForType.whitelist[propertyName] === true;
2023	}
2024	if (protoAccessControlForType.defaultValue !== undefined) {
2025	return protoAccessControlForType.defaultValue;
2026	}
2027	logUnexpecedPropertyAccessOnce(propertyName);
2028	return false;
2029	}
2030
2031	function logUnexpecedPropertyAccessOnce(propertyName) {
2032	if (loggedProperties[propertyName] !== true) {
2033	loggedProperties[propertyName] = true;
2034	_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');
2035	}
2036	}
2037
2038	function resetLoggedProperties() {
2039	_Object$keys(loggedProperties).forEach(function (propertyName) {
2040	delete loggedProperties[propertyName];
2041	});
2042	}
2043
2044	/***/ }),
2045	/* 73 */
2046	/***/ (function(module, exports, __webpack_require__) {
2047
2048	module.exports = { "default": __webpack_require__(74), __esModule: true };
2049
2050	/***/ }),
2051	/* 74 */
2052	/***/ (function(module, exports, __webpack_require__) {
2053
2054	var $ = __webpack_require__(8);
2055	module.exports = function create(P, D){
2056	return $.create(P, D);
2057	};
2058
2059	/***/ }),
2060	/* 75 */
2061	/***/ (function(module, exports) {
2062
2063	// Build out our basic SafeString type
2064	'use strict';
2065
2066	exports.__esModule = true;
2067	function SafeString(string) {
2068	this.string = string;
2069	}
2070
2071	SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
2072	return '' + this.string;
2073	};
2074
2075	exports['default'] = SafeString;
2076	module.exports = exports['default'];
2077
2078	/***/ }),
2079	/* 76 */
2080	/***/ (function(module, exports, __webpack_require__) {
2081
2082	'use strict';
2083
2084	var _Object$seal = __webpack_require__(77)['default'];
2085
2086	var _Object$keys = __webpack_require__(59)['default'];
2087
2088	var _interopRequireWildcard = __webpack_require__(1)['default'];
2089
2090	var _interopRequireDefault = __webpack_require__(2)['default'];
2091
2092	exports.__esModule = true;
2093	exports.checkRevision = checkRevision;
2094	exports.template = template;
2095	exports.wrapProgram = wrapProgram;
2096	exports.resolvePartial = resolvePartial;
2097	exports.invokePartial = invokePartial;
2098	exports.noop = noop;
2099
2100	var _utils = __webpack_require__(4);
2101
2102	var Utils = _interopRequireWildcard(_utils);
2103
2104	var _exception = __webpack_require__(5);
2105
2106	var _exception2 = _interopRequireDefault(_exception);
2107
2108	var _base = __webpack_require__(3);
2109
2110	var _helpers = __webpack_require__(9);
2111
2112	var _internalWrapHelper = __webpack_require__(80);
2113
2114	var _internalProtoAccess = __webpack_require__(72);
2115
2116	function checkRevision(compilerInfo) {
2117	var compilerRevision = compilerInfo && compilerInfo[0] \|\| 1,
2118	currentRevision = _base.COMPILER_REVISION;
2119
2120	if (compilerRevision >= _base.LAST_COMPATIBLE_COMPILER_REVISION && compilerRevision <= _base.COMPILER_REVISION) {
2121	return;
2122	}
2123
2124	if (compilerRevision < _base.LAST_COMPATIBLE_COMPILER_REVISION) {
2125	var runtimeVersions = _base.REVISION_CHANGES[currentRevision],
2126	compilerVersions = _base.REVISION_CHANGES[compilerRevision];
2127	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 + ').');
2128	} else {
2129	// Use the embedded version info since the runtime doesn't know about this revision yet
2130	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] + ').');
2131	}
2132	}
2133
2134	function template(templateSpec, env) {
2135	/* istanbul ignore next */
2136	if (!env) {
2137	throw new _exception2['default']('No environment passed to template');
2138	}
2139	if (!templateSpec \|\| !templateSpec.main) {
2140	throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);
2141	}
2142
2143	templateSpec.main.decorator = templateSpec.main_d;
2144
2145	// Note: Using env.VM references rather than local var references throughout this section to allow
2146	// for external users to override these as pseudo-supported APIs.
2147	env.VM.checkRevision(templateSpec.compiler);
2148
2149	// backwards compatibility for precompiled templates with compiler-version 7 (<4.3.0)
2150	var templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7;
2151
2152	function invokePartialWrapper(partial, context, options) {
2153	if (options.hash) {
2154	context = Utils.extend({}, context, options.hash);
2155	if (options.ids) {
2156	options.ids[0] = true;
2157	}
2158	}
2159	partial = env.VM.resolvePartial.call(this, partial, context, options);
2160
2161	options.hooks = this.hooks;
2162	options.protoAccessControl = this.protoAccessControl;
2163
2164	var result = env.VM.invokePartial.call(this, partial, context, options);
2165
2166	if (result == null && env.compile) {
2167	options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
2168	result = options.partials[options.name](context, options);
2169	}
2170	if (result != null) {
2171	if (options.indent) {
2172	var lines = result.split('\n');
2173	for (var i = 0, l = lines.length; i < l; i++) {
2174	if (!lines[i] && i + 1 === l) {
2175	break;
2176	}
2177
2178	lines[i] = options.indent + lines[i];
2179	}
2180	result = lines.join('\n');
2181	}
2182	return result;
2183	} else {
2184	throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
2185	}
2186	}
2187
2188	// Just add water
2189	var container = {
2190	strict: function strict(obj, name, loc) {
2191	if (!obj \|\| !(name in obj)) {
2192	throw new _exception2['default']('"' + name + '" not defined in ' + obj, {
2193	loc: loc
2194	});
2195	}
2196	return container.lookupProperty(obj, name);
2197	},
2198	lookupProperty: function lookupProperty(parent, propertyName) {
2199	var result = parent[propertyName];
2200	if (result == null) {
2201	return result;
2202	}
2203	if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
2204	return result;
2205	}
2206
2207	if (_internalProtoAccess.resultIsAllowed(result, container.protoAccessControl, propertyName)) {
2208	return result;
2209	}
2210	return undefined;
2211	},
2212	lookup: function lookup(depths, name) {
2213	var len = depths.length;
2214	for (var i = 0; i < len; i++) {
2215	var result = depths[i] && container.lookupProperty(depths[i], name);
2216	if (result != null) {
2217	return result;
2218	}
2219	}
2220	},
2221	lambda: function lambda(current, context) {
2222	return typeof current === 'function' ? current.call(context) : current;
2223	},
2224
2225	escapeExpression: Utils.escapeExpression,
2226	invokePartial: invokePartialWrapper,
2227
2228	fn: function fn(i) {
2229	var ret = templateSpec[i];
2230	ret.decorator = templateSpec[i + '_d'];
2231	return ret;
2232	},
2233
2234	programs: [],
2235	program: function program(i, data, declaredBlockParams, blockParams, depths) {
2236	var programWrapper = this.programs[i],
2237	fn = this.fn(i);
2238	if (data \|\| depths \|\| blockParams \|\| declaredBlockParams) {
2239	programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
2240	} else if (!programWrapper) {
2241	programWrapper = this.programs[i] = wrapProgram(this, i, fn);
2242	}
2243	return programWrapper;
2244	},
2245
2246	data: function data(value, depth) {
2247	while (value && depth--) {
2248	value = value._parent;
2249	}
2250	return value;
2251	},
2252	mergeIfNeeded: function mergeIfNeeded(param, common) {
2253	var obj = param \|\| common;
2254
2255	if (param && common && param !== common) {
2256	obj = Utils.extend({}, common, param);
2257	}
2258
2259	return obj;
2260	},
2261	// An empty object to use as replacement for null-contexts
2262	nullContext: _Object$seal({}),
2263
2264	noop: env.VM.noop,
2265	compilerInfo: templateSpec.compiler
2266	};
2267
2268	function ret(context) {
2269	var options = arguments.length <= 1 \|\| arguments[1] === undefined ? {} : arguments[1];
2270
2271	var data = options.data;
2272
2273	ret._setup(options);
2274	if (!options.partial && templateSpec.useData) {
2275	data = initData(context, data);
2276	}
2277	var depths = undefined,
2278	blockParams = templateSpec.useBlockParams ? [] : undefined;
2279	if (templateSpec.useDepths) {
2280	if (options.depths) {
2281	depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths;
2282	} else {
2283	depths = [context];
2284	}
2285	}
2286
2287	function main(context /, options/) {
2288	return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
2289	}
2290
2291	main = executeDecorators(templateSpec.main, main, container, options.depths \|\| [], data, blockParams);
2292	return main(context, options);
2293	}
2294
2295	ret.isTop = true;
2296
2297	ret._setup = function (options) {
2298	if (!options.partial) {
2299	var mergedHelpers = {};
2300	addHelpers(mergedHelpers, env.helpers, container);
2301	addHelpers(mergedHelpers, options.helpers, container);
2302	container.helpers = mergedHelpers;
2303
2304	if (templateSpec.usePartial) {
2305	// Use mergeIfNeeded here to prevent compiling global partials multiple times
2306	container.partials = container.mergeIfNeeded(options.partials, env.partials);
2307	}
2308	if (templateSpec.usePartial \|\| templateSpec.useDecorators) {
2309	container.decorators = Utils.extend({}, env.decorators, options.decorators);
2310	}
2311
2312	container.hooks = {};
2313	container.protoAccessControl = _internalProtoAccess.createProtoAccessControl(options);
2314
2315	var keepHelperInHelpers = options.allowCallsToHelperMissing \|\| templateWasPrecompiledWithCompilerV7;
2316	_helpers.moveHelperToHooks(container, 'helperMissing', keepHelperInHelpers);
2317	_helpers.moveHelperToHooks(container, 'blockHelperMissing', keepHelperInHelpers);
2318	} else {
2319	container.protoAccessControl = options.protoAccessControl; // internal option
2320	container.helpers = options.helpers;
2321	container.partials = options.partials;
2322	container.decorators = options.decorators;
2323	container.hooks = options.hooks;
2324	}
2325	};
2326
2327	ret._child = function (i, data, blockParams, depths) {
2328	if (templateSpec.useBlockParams && !blockParams) {
2329	throw new _exception2['default']('must pass block params');
2330	}
2331	if (templateSpec.useDepths && !depths) {
2332	throw new _exception2['default']('must pass parent depths');
2333	}
2334
2335	return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
2336	};
2337	return ret;
2338	}
2339
2340	function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
2341	function prog(context) {
2342	var options = arguments.length <= 1 \|\| arguments[1] === undefined ? {} : arguments[1];
2343
2344	var currentDepths = depths;
2345	if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) {
2346	currentDepths = [context].concat(depths);
2347	}
2348
2349	return fn(container, context, container.helpers, container.partials, options.data \|\| data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
2350	}
2351
2352	prog = executeDecorators(fn, prog, container, depths, data, blockParams);
2353
2354	prog.program = i;
2355	prog.depth = depths ? depths.length : 0;
2356	prog.blockParams = declaredBlockParams \|\| 0;
2357	return prog;
2358	}
2359
2360	/**
2361	* This is currently part of the official API, therefore implementation details should not be changed.
2362	*/
2363
2364	function resolvePartial(partial, context, options) {
2365	if (!partial) {
2366	if (options.name === '@partial-block') {
2367	partial = lookupOwnProperty(options.data, 'partial-block');
2368	} else {
2369	partial = lookupOwnProperty(options.partials, options.name);
2370	}
2371	} else if (!partial.call && !options.name) {
2372	// This is a dynamic partial that returned a string
2373	options.name = partial;
2374	partial = lookupOwnProperty(options.partials, partial);
2375	}
2376	return partial;
2377	}
2378
2379	function invokePartial(partial, context, options) {
2380	// Use the current closure context to save the partial-block if this partial
2381	var currentPartialBlock = lookupOwnProperty(options.data, 'partial-block');
2382	options.partial = true;
2383	if (options.ids) {
2384	options.data.contextPath = options.ids[0] \|\| options.data.contextPath;
2385	}
2386
2387	var partialBlock = undefined;
2388	if (options.fn && options.fn !== noop) {
2389	(function () {
2390	options.data = _base.createFrame(options.data);
2391	// Wrapper function to get access to currentPartialBlock from the closure
2392	var fn = options.fn;
2393	partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) {
2394	var options = arguments.length <= 1 \|\| arguments[1] === undefined ? {} : arguments[1];
2395
2396	// Restore the partial-block from the closure for the execution of the block
2397	// i.e. the part inside the block of the partial call.
2398	options.data = _base.createFrame(options.data);
2399	options.data['partial-block'] = currentPartialBlock;
2400	return fn(context, options);
2401	};
2402	if (fn.partials) {
2403	options.partials = Utils.extend({}, options.partials, fn.partials);
2404	}
2405	})();
2406	}
2407
2408	if (partial === undefined && partialBlock) {
2409	partial = partialBlock;
2410	}
2411
2412	if (partial === undefined) {
2413	throw new _exception2['default']('The partial ' + options.name + ' could not be found');
2414	} else if (partial instanceof Function) {
2415	return partial(context, options);
2416	}
2417	}
2418
2419	function noop() {
2420	return '';
2421	}
2422
2423	function lookupOwnProperty(obj, name) {
2424	if (obj && Object.prototype.hasOwnProperty.call(obj, name)) {
2425	return obj[name];
2426	}
2427	}
2428
2429	function initData(context, data) {
2430	if (!data \|\| !('root' in data)) {
2431	data = data ? _base.createFrame(data) : {};
2432	data.root = context;
2433	}
2434	return data;
2435	}
2436
2437	function executeDecorators(fn, prog, container, depths, data, blockParams) {
2438	if (fn.decorator) {
2439	var props = {};
2440	prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
2441	Utils.extend(prog, props);
2442	}
2443	return prog;
2444	}
2445
2446	function addHelpers(mergedHelpers, helpers, container) {
2447	if (!helpers) return;
2448	_Object$keys(helpers).forEach(function (helperName) {
2449	var helper = helpers[helperName];
2450	mergedHelpers[helperName] = passLookupPropertyOption(helper, container);
2451	});
2452	}
2453
2454	function passLookupPropertyOption(helper, container) {
2455	var lookupProperty = container.lookupProperty;
2456	return _internalWrapHelper.wrapHelper(helper, function (options) {
2457	options.lookupProperty = lookupProperty;
2458	return options;
2459	});
2460	}
2461
2462	/***/ }),
2463	/* 77 */
2464	/***/ (function(module, exports, __webpack_require__) {
2465
2466	module.exports = { "default": __webpack_require__(78), __esModule: true };
2467
2468	/***/ }),
2469	/* 78 */
2470	/***/ (function(module, exports, __webpack_require__) {
2471
2472	__webpack_require__(79);
2473	module.exports = __webpack_require__(20).Object.seal;
2474
2475	/***/ }),
2476	/* 79 */
2477	/***/ (function(module, exports, __webpack_require__) {
2478
2479	// 19.1.2.17 Object.seal(O)
2480	var isObject = __webpack_require__(39);
2481
2482	__webpack_require__(63)('seal', function($seal){
2483	return function seal(it){
2484	return $seal && isObject(it) ? $seal(it) : it;
2485	};
2486	});
2487
2488	/***/ }),
2489	/* 80 */
2490	/***/ (function(module, exports) {
2491
2492	'use strict';
2493
2494	exports.__esModule = true;
2495	exports.wrapHelper = wrapHelper;
2496
2497	function wrapHelper(helper, transformOptionsFn) {
2498	if (typeof helper !== 'function') {
2499	// This should not happen, but apparently it does in https://github.com/wycats/handlebars.js/issues/1639
2500	// We try to make the wrapper least-invasive by not wrapping it, if the helper is not a function.
2501	return helper;
2502	}
2503	var wrapper = function wrapper() /* dynamic arguments */{
2504	var options = arguments[arguments.length - 1];
2505	arguments[arguments.length - 1] = transformOptionsFn(options);
2506	return helper.apply(this, arguments);
2507	};
2508	return wrapper;
2509	}
2510
2511	/***/ }),
2512	/* 81 */
2513	/***/ (function(module, exports) {
2514
2515	/* global globalThis */
2516	'use strict';
2517
2518	exports.__esModule = true;
2519
2520	exports['default'] = function (Handlebars) {
2521	/* istanbul ignore next */
2522	// https://mathiasbynens.be/notes/globalthis
2523	(function () {
2524	if (typeof globalThis === 'object') return;
2525	Object.prototype.__defineGetter__('__magic__', function () {
2526	return this;
2527	});
2528	__magic__.globalThis = __magic__; // eslint-disable-line no-undef
2529	delete Object.prototype.__magic__;
2530	})();
2531
2532	var $Handlebars = globalThis.Handlebars;
2533
2534	/* istanbul ignore next */
2535	Handlebars.noConflict = function () {
2536	if (globalThis.Handlebars === Handlebars) {
2537	globalThis.Handlebars = $Handlebars;
2538	}
2539	return Handlebars;
2540	};
2541	};
2542
2543	module.exports = exports['default'];
2544
2545	/***/ })
2546	/******/ ])
2547	});
2548	;