Elementor Website Builder – more than just a page builder / 3.4.6

Elementor Website Builder – more than just a page builder v3.4.6

elementor / assets / js / frontend.js

frontend.js in Elementor Website Builder – more than just a page builder 3.4.6, at assets/js/frontend.js

2,886 lines 85.8 KB

Raw Download Zip

1	/! elementor - v3.4.6 - 19-10-2021 /
2	(self["webpackChunkelementor"] = self["webpackChunkelementor"] \|\| []).push([["frontend"],{
3
4	/***/ "../assets/dev/js/frontend/documents-manager.js":
5	/!****************************************************!\
6	!* ../assets/dev/js/frontend/documents-manager.js *!
7	\******************************************************/
8	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
9
10	"use strict";
11
12
13	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
14
15	Object.defineProperty(exports, "__esModule", ({
16	value: true
17	}));
18	exports.default = void 0;
19
20	var _document = _interopRequireDefault(__webpack_require__(/! ./document / "../assets/dev/js/frontend/document.js"));
21
22	class _default extends elementorModules.ViewModule {
23	constructor(...args) {
24	super(...args);
25	this.documents = {};
26	this.initDocumentClasses();
27	this.attachDocumentsClasses();
28	}
29
30	getDefaultSettings() {
31	return {
32	selectors: {
33	document: '.elementor'
34	}
35	};
36	}
37
38	getDefaultElements() {
39	const selectors = this.getSettings('selectors');
40	return {
41	$documents: jQuery(selectors.document)
42	};
43	}
44
45	initDocumentClasses() {
46	this.documentClasses = {
47	base: _document.default
48	};
49	elementorFrontend.hooks.doAction('elementor/frontend/documents-manager/init-classes', this);
50	}
51
52	addDocumentClass(documentType, documentClass) {
53	this.documentClasses[documentType] = documentClass;
54	}
55
56	attachDocumentsClasses() {
57	this.elements.$documents.each((index, document) => this.attachDocumentClass(jQuery(document)));
58	}
59
60	attachDocumentClass($document) {
61	const documentData = $document.data(),
62	documentID = documentData.elementorId,
63	documentType = documentData.elementorType,
64	DocumentClass = this.documentClasses[documentType] \|\| this.documentClasses.base;
65	this.documents[documentID] = new DocumentClass({
66	$element: $document,
67	id: documentID
68	});
69	}
70
71	}
72
73	exports.default = _default;
74
75	/***/ }),
76
77	/***/ "../assets/dev/js/frontend/elements-handlers-manager.js":
78	/!************************************************************!\
79	!* ../assets/dev/js/frontend/elements-handlers-manager.js *!
80	\**************************************************************/
81	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
82
83	"use strict";
84
85
86	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
87
88	var _global = _interopRequireDefault(__webpack_require__(/! ./handlers/global / "../assets/dev/js/frontend/handlers/global.js"));
89
90	var _section = _interopRequireDefault(__webpack_require__(/! ./handlers/section/section / "../assets/dev/js/frontend/handlers/section/section.js"));
91
92	var _column = _interopRequireDefault(__webpack_require__(/! ./handlers/column / "../assets/dev/js/frontend/handlers/column.js"));
93
94	module.exports = function ($) {
95	const handlersInstances = {};
96	this.elementsHandlers = {
97	'accordion.default': () => __webpack_require__.e(/! import() \| accordion / "accordion").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/accordion / "../assets/dev/js/frontend/handlers/accordion.js")),
98	'alert.default': () => __webpack_require__.e(/! import() \| alert / "alert").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/alert / "../assets/dev/js/frontend/handlers/alert.js")),
99	'counter.default': () => __webpack_require__.e(/! import() \| counter / "counter").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/counter / "../assets/dev/js/frontend/handlers/counter.js")),
100	'progress.default': () => __webpack_require__.e(/! import() \| progress / "progress").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/progress / "../assets/dev/js/frontend/handlers/progress.js")),
101	'tabs.default': () => __webpack_require__.e(/! import() \| tabs / "tabs").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/tabs / "../assets/dev/js/frontend/handlers/tabs.js")),
102	'toggle.default': () => __webpack_require__.e(/! import() \| toggle / "toggle").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/toggle / "../assets/dev/js/frontend/handlers/toggle.js")),
103	'video.default': () => __webpack_require__.e(/! import() \| video / "video").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/video / "../assets/dev/js/frontend/handlers/video.js")),
104	'image-carousel.default': () => __webpack_require__.e(/! import() \| image-carousel / "image-carousel").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/image-carousel / "../assets/dev/js/frontend/handlers/image-carousel.js")),
105	'text-editor.default': () => __webpack_require__.e(/! import() \| text-editor / "text-editor").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/text-editor / "../assets/dev/js/frontend/handlers/text-editor.js")),
106	'wp-widget-media_audio.default': () => __webpack_require__.e(/! import() \| wp-audio / "wp-audio").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/wp-audio / "../assets/dev/js/frontend/handlers/wp-audio.js"))
107	};
108
109	const addGlobalHandlers = () => elementorFrontend.hooks.addAction('frontend/element_ready/global', _global.default);
110
111	const addElementsHandlers = () => {
112	this.elementsHandlers.section = _section.default;
113	this.elementsHandlers.column = _column.default;
114	$.each(this.elementsHandlers, (elementName, Handlers) => {
115	const elementData = elementName.split('.');
116	elementName = elementData[0];
117	const skin = elementData[1] \|\| null;
118	this.attachHandler(elementName, Handlers, skin);
119	});
120	};
121
122	const isClassHandler = Handler => {
123	var _Handler$prototype;
124
125	return (_Handler$prototype = Handler.prototype) === null \|\| _Handler$prototype === void 0 ? void 0 : _Handler$prototype.getUniqueHandlerID;
126	};
127
128	const addHandlerWithHook = (elementName, Handler, skin = 'default') => {
129	skin = skin ? '.' + skin : '';
130	elementorFrontend.hooks.addAction(`frontend/element_ready/${elementName}${skin}`, $element => {
131	if (isClassHandler(Handler)) {
132	this.addHandler(Handler, {
133	$element
134	}, true);
135	} else {
136	const handlerValue = Handler();
137
138	if (handlerValue instanceof Promise) {
139	handlerValue.then(({
140	default: dynamicHandler
141	}) => {
142	this.addHandler(dynamicHandler, {
143	$element
144	}, true);
145	});
146	} else {
147	this.addHandler(handlerValue, {
148	$element
149	}, true);
150	}
151	}
152	});
153	};
154
155	this.addHandler = function (HandlerClass, options) {
156	const elementID = options.$element.data('model-cid');
157	let handlerID; // If element is in edit mode
158
159	if (elementID) {
160	handlerID = HandlerClass.prototype.getConstructorID();
161
162	if (!handlersInstances[elementID]) {
163	handlersInstances[elementID] = {};
164	}
165
166	const oldHandler = handlersInstances[elementID][handlerID];
167
168	if (oldHandler) {
169	oldHandler.onDestroy();
170	}
171	}
172
173	const newHandler = new HandlerClass(options);
174
175	if (elementID) {
176	handlersInstances[elementID][handlerID] = newHandler;
177	}
178	};
179
180	this.attachHandler = (elementName, Handlers, skin) => {
181	if (!Array.isArray(Handlers)) {
182	Handlers = [Handlers];
183	}
184
185	Handlers.forEach(Handler => addHandlerWithHook(elementName, Handler, skin));
186	};
187
188	this.getHandler = function (handlerName) {
189	if (!handlerName) {
190	return;
191	}
192
193	const elementHandler = this.elementsHandlers[handlerName];
194
195	if (isClassHandler(elementHandler)) {
196	return elementHandler;
197	}
198
199	return new Promise(res => {
200	elementHandler().then(({
201	default: dynamicHandler
202	}) => {
203	res(dynamicHandler);
204	});
205	});
206	};
207
208	this.getHandlers = function (handlerName) {
209	elementorCommon.helpers.softDeprecated('getHandlers', '3.1.0', 'elementorFrontend.elementsHandler.getHandler');
210
211	if (handlerName) {
212	return this.getHandler(handlerName);
213	}
214
215	return this.elementsHandlers;
216	};
217
218	this.runReadyTrigger = function (scope) {
219	if (elementorFrontend.config.is_static) {
220	return;
221	} // Initializing the `$scope` as frontend jQuery instance
222
223
224	const $scope = jQuery(scope),
225	elementType = $scope.attr('data-element_type');
226
227	if (!elementType) {
228	return;
229	}
230
231	elementorFrontend.hooks.doAction('frontend/element_ready/global', $scope, $);
232	elementorFrontend.hooks.doAction(`frontend/element_ready/${elementType}`, $scope, $);
233
234	if ('widget' === elementType) {
235	const widgetType = $scope.attr('data-widget_type');
236	elementorFrontend.hooks.doAction(`frontend/element_ready/${widgetType}`, $scope, $);
237	}
238	};
239
240	this.init = () => {
241	addGlobalHandlers();
242	addElementsHandlers();
243	};
244	};
245
246	/***/ }),
247
248	/***/ "../assets/dev/js/frontend/frontend.js":
249	/!*******************************************!\
250	!* ../assets/dev/js/frontend/frontend.js *!
251	\*********************************************/
252	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
253
254	"use strict";
255
256
257	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
258
259	Object.defineProperty(exports, "__esModule", ({
260	value: true
261	}));
262	exports.default = void 0;
263
264	__webpack_require__(/! ../public-path / "../assets/dev/js/public-path.js");
265
266	var _documentsManager = _interopRequireDefault(__webpack_require__(/! ./documents-manager / "../assets/dev/js/frontend/documents-manager.js"));
267
268	var _storage = _interopRequireDefault(__webpack_require__(/! elementor-common/utils/storage / "../core/common/assets/js/utils/storage.js"));
269
270	var _environment = _interopRequireDefault(__webpack_require__(/! elementor-common/utils/environment / "../core/common/assets/js/utils/environment.js"));
271
272	var _youtubeLoader = _interopRequireDefault(__webpack_require__(/! ./utils/video-api/youtube-loader / "../assets/dev/js/frontend/utils/video-api/youtube-loader.js"));
273
274	var _vimeoLoader = _interopRequireDefault(__webpack_require__(/! ./utils/video-api/vimeo-loader / "../assets/dev/js/frontend/utils/video-api/vimeo-loader.js"));
275
276	var _baseLoader = _interopRequireDefault(__webpack_require__(/! ./utils/video-api/base-loader / "../assets/dev/js/frontend/utils/video-api/base-loader.js"));
277
278	var _urlActions = _interopRequireDefault(__webpack_require__(/! ./utils/url-actions / "../assets/dev/js/frontend/utils/url-actions.js"));
279
280	var _swiperBc = _interopRequireDefault(__webpack_require__(/! ./utils/swiper-bc / "../assets/dev/js/frontend/utils/swiper-bc.js"));
281
282	var _lightboxManager = _interopRequireDefault(__webpack_require__(/! ./utils/lightbox/lightbox-manager / "../assets/dev/js/frontend/utils/lightbox/lightbox-manager.js"));
283
284	var _assetsLoader = _interopRequireDefault(__webpack_require__(/! ./utils/assets-loader / "../assets/dev/js/frontend/utils/assets-loader.js"));
285
286	var _breakpoints = _interopRequireDefault(__webpack_require__(/! elementor-utils/breakpoints / "../assets/dev/js/utils/breakpoints.js"));
287
288	var _frontend = _interopRequireDefault(__webpack_require__(/! elementor/modules/shapes/assets/js/frontend/frontend / "../modules/shapes/assets/js/frontend/frontend.js"));
289
290	var _utils = __webpack_require__(/! elementor-frontend/utils/utils / "../assets/dev/js/frontend/utils/utils.js");
291
292	/* global elementorFrontendConfig */
293	const EventManager = __webpack_require__(/! elementor-utils/hooks / "../assets/dev/js/utils/hooks.js"),
294	ElementsHandler = __webpack_require__(/! elementor-frontend/elements-handlers-manager / "../assets/dev/js/frontend/elements-handlers-manager.js"),
295	AnchorsModule = __webpack_require__(/! elementor-frontend/utils/anchors / "../assets/dev/js/frontend/utils/anchors.js");
296
297	class Frontend extends elementorModules.ViewModule {
298	constructor(...args) {
299	super(...args);
300	this.config = elementorFrontendConfig;
301	this.config.legacyMode = {
302	get elementWrappers() {
303	if (elementorFrontend.isEditMode()) {
304	elementorCommon.helpers.hardDeprecated('elementorFrontend.config.legacyMode.elementWrappers', '3.1.0', 'elementorFrontend.config.experimentalFeatures.e_dom_optimization');
305	}
306
307	return !elementorFrontend.config.experimentalFeatures.e_dom_optimization;
308	}
309
310	};
311	this.populateActiveBreakpointsConfig();
312	} // TODO: BC since 2.5.0
313
314
315	get Module() {
316	if (this.isEditMode()) {
317	parent.elementorCommon.helpers.hardDeprecated('elementorFrontend.Module', '2.5.0', 'elementorModules.frontend.handlers.Base');
318	}
319
320	return elementorModules.frontend.handlers.Base;
321	}
322
323	getDefaultSettings() {
324	return {
325	selectors: {
326	elementor: '.elementor',
327	adminBar: '#wpadminbar'
328	}
329	};
330	}
331
332	getDefaultElements() {
333	const defaultElements = {
334	window: window,
335	$window: jQuery(window),
336	$document: jQuery(document),
337	$head: jQuery(document.head),
338	$body: jQuery(document.body),
339	$deviceMode: jQuery('<span>', {
340	id: 'elementor-device-mode',
341	class: 'elementor-screen-only'
342	})
343	};
344	defaultElements.$body.append(defaultElements.$deviceMode);
345	return defaultElements;
346	}
347
348	bindEvents() {
349	this.elements.$window.on('resize', () => this.setDeviceModeData());
350	}
351	/**
352	* @deprecated 2.4.0 Use just `this.elements` instead
353	*/
354
355
356	getElements(elementName) {
357	return this.getItems(this.elements, elementName);
358	}
359	/**
360	* @deprecated 2.4.0 This method was never in use
361	*/
362
363
364	getPageSettings(settingName) {
365	const settingsObject = this.isEditMode() ? elementor.settings.page.model.attributes : this.config.settings.page;
366	return this.getItems(settingsObject, settingName);
367	}
368
369	getGeneralSettings(settingName) {
370	if (this.isEditMode()) {
371	parent.elementorCommon.helpers.softDeprecated('getGeneralSettings', '3.0.0', 'getKitSettings and remove the `elementor_` prefix');
372	}
373
374	return this.getKitSettings(`elementor_${settingName}`);
375	}
376
377	getKitSettings(settingName) {
378	// TODO: use Data API.
379	return this.getItems(this.config.kit, settingName);
380	}
381
382	getCurrentDeviceMode() {
383	return getComputedStyle(this.elements.$deviceMode[0], ':after').content.replace(/"/g, '');
384	}
385
386	getDeviceSetting(deviceMode, settings, settingKey) {
387	// Add specific handling for widescreen since it is larger than desktop.
388	if ('widescreen' === deviceMode) {
389	return this.getWidescreenSetting(settings, settingKey);
390	}
391
392	const devices = elementorFrontend.breakpoints.getActiveBreakpointsList({
393	largeToSmall: true,
394	withDesktop: true
395	});
396	let deviceIndex = devices.indexOf(deviceMode);
397
398	while (deviceIndex > 0) {
399	const currentDevice = devices[deviceIndex],
400	fullSettingKey = settingKey + '_' + currentDevice,
401	deviceValue = settings[fullSettingKey]; // Accept 0 as value.
402
403	if (deviceValue \|\| 0 === deviceValue) {
404	return deviceValue;
405	}
406
407	deviceIndex--;
408	}
409
410	return settings[settingKey];
411	}
412
413	getWidescreenSetting(settings, settingKey) {
414	const deviceMode = 'widescreen',
415	widescreenSettingKey = settingKey + '_' + deviceMode;
416	let settingToReturn; // If the device mode is 'widescreen', and the setting exists - return it.
417
418	if (settings[widescreenSettingKey]) {
419	settingToReturn = settings[widescreenSettingKey];
420	} else {
421	// Otherwise, return the desktop setting
422	settingToReturn = settings[settingKey];
423	}
424
425	return settingToReturn;
426	}
427
428	getCurrentDeviceSetting(settings, settingKey) {
429	return this.getDeviceSetting(elementorFrontend.getCurrentDeviceMode(), settings, settingKey);
430	}
431
432	isEditMode() {
433	return this.config.environmentMode.edit;
434	}
435
436	isWPPreviewMode() {
437	return this.config.environmentMode.wpPreview;
438	}
439
440	initDialogsManager() {
441	let dialogsManager;
442
443	this.getDialogsManager = () => {
444	if (!dialogsManager) {
445	dialogsManager = new DialogsManager.Instance();
446	}
447
448	return dialogsManager;
449	};
450	}
451
452	initOnReadyComponents() {
453	this.utils = {
454	youtube: new _youtubeLoader.default(),
455	vimeo: new _vimeoLoader.default(),
456	baseVideoLoader: new _baseLoader.default(),
457	anchors: new AnchorsModule(),
458
459	get lightbox() {
460	return _lightboxManager.default.getLightbox();
461	},
462
463	urlActions: new _urlActions.default(),
464	swiper: _swiperBc.default,
465	environment: _environment.default,
466	assetsLoader: new _assetsLoader.default(),
467	escapeHTML: _utils.escapeHTML
468	}; // TODO: BC since 2.4.0
469
470	this.modules = {
471	StretchElement: elementorModules.frontend.tools.StretchElement,
472	Masonry: elementorModules.utils.Masonry
473	};
474	this.elementsHandler.init();
475
476	if (this.isEditMode()) {
477	elementor.once('document:loaded', () => this.onDocumentLoaded());
478	} else {
479	this.onDocumentLoaded();
480	}
481	}
482
483	initOnReadyElements() {
484	this.elements.$wpAdminBar = this.elements.$document.find(this.getSettings('selectors.adminBar'));
485	}
486
487	addUserAgentClasses() {
488	for (const [key, value] of Object.entries(_environment.default)) {
489	if (value) {
490	this.elements.$body.addClass('e--ua-' + key);
491	}
492	}
493	}
494
495	setDeviceModeData() {
496	this.elements.$body.attr('data-elementor-device-mode', this.getCurrentDeviceMode());
497	}
498
499	addListenerOnce(listenerID, event, callback, to) {
500	if (!to) {
501	to = this.elements.$window;
502	}
503
504	if (!this.isEditMode()) {
505	to.on(event, callback);
506	return;
507	}
508
509	this.removeListeners(listenerID, event, to);
510
511	if (to instanceof jQuery) {
512	const eventNS = event + '.' + listenerID;
513	to.on(eventNS, callback);
514	} else {
515	to.on(event, callback, listenerID);
516	}
517	}
518
519	removeListeners(listenerID, event, callback, from) {
520	if (!from) {
521	from = this.elements.$window;
522	}
523
524	if (from instanceof jQuery) {
525	const eventNS = event + '.' + listenerID;
526	from.off(eventNS, callback);
527	} else {
528	from.off(event, callback, listenerID);
529	}
530	} // Based on underscore function
531
532
533	debounce(func, wait) {
534	let timeout;
535	return function () {
536	const context = this,
537	args = arguments;
538
539	const later = () => {
540	timeout = null;
541	func.apply(context, args);
542	};
543
544	const callNow = !timeout;
545	clearTimeout(timeout);
546	timeout = setTimeout(later, wait);
547
548	if (callNow) {
549	func.apply(context, args);
550	}
551	};
552	}
553
554	waypoint($element, callback, options) {
555	const defaultOptions = {
556	offset: '100%',
557	triggerOnce: true
558	};
559	options = jQuery.extend(defaultOptions, options);
560
561	const correctCallback = function () {
562	const element = this.element \|\| this,
563	result = callback.apply(element, arguments); // If is Waypoint new API and is frontend
564
565	if (options.triggerOnce && this.destroy) {
566	this.destroy();
567	}
568
569	return result;
570	};
571
572	return $element.elementorWaypoint(correctCallback, options);
573	}
574
575	muteMigrationTraces() {
576	jQuery.migrateMute = true;
577	jQuery.migrateTrace = false;
578	}
579	/**
580	* Initialize the modules' widgets handlers.
581	*/
582
583
584	initModules() {
585	const handlers = {
586	shapes: _frontend.default
587	};
588	elementorFrontend.trigger('elementor/modules/init:before');
589	Object.entries(handlers).forEach(([moduleName, ModuleClass]) => {
590	this.modulesHandlers[moduleName] = new ModuleClass();
591	});
592	}
593
594	populateActiveBreakpointsConfig() {
595	this.config.responsive.activeBreakpoints = {};
596	Object.entries(this.config.responsive.breakpoints).forEach(([breakpointKey, breakpointData]) => {
597	if (breakpointData.is_enabled) {
598	this.config.responsive.activeBreakpoints[breakpointKey] = breakpointData;
599	}
600	});
601	}
602
603	init() {
604	this.hooks = new EventManager();
605	this.breakpoints = new _breakpoints.default(this.config.responsive);
606	this.storage = new _storage.default();
607	this.elementsHandler = new ElementsHandler(jQuery);
608	this.modulesHandlers = {};
609	this.addUserAgentClasses();
610	this.setDeviceModeData();
611	this.initDialogsManager();
612
613	if (this.isEditMode()) {
614	this.muteMigrationTraces();
615	} // Keep this line before `initOnReadyComponents` call
616
617
618	this.elements.$window.trigger('elementor/frontend/init');
619	this.initModules();
620	this.initOnReadyElements();
621	this.initOnReadyComponents();
622	}
623
624	onDocumentLoaded() {
625	this.documentsManager = new _documentsManager.default();
626	this.trigger('components:init');
627	new _lightboxManager.default();
628	}
629
630	}
631
632	exports.default = Frontend;
633	window.elementorFrontend = new Frontend();
634
635	if (!elementorFrontend.isEditMode()) {
636	jQuery(() => elementorFrontend.init());
637	}
638
639	/***/ }),
640
641	/***/ "../assets/dev/js/frontend/handlers/background-slideshow.js":
642	/!****************************************************************!\
643	!* ../assets/dev/js/frontend/handlers/background-slideshow.js *!
644	\******************************************************************/
645	/***/ ((__unused_webpack_module, exports) => {
646
647	"use strict";
648
649
650	Object.defineProperty(exports, "__esModule", ({
651	value: true
652	}));
653	exports.default = void 0;
654
655	class BackgroundSlideshow extends elementorModules.frontend.handlers.SwiperBase {
656	getDefaultSettings() {
657	return {
658	classes: {
659	swiperContainer: 'elementor-background-slideshow swiper-container',
660	swiperWrapper: 'swiper-wrapper',
661	swiperSlide: 'elementor-background-slideshow__slide swiper-slide',
662	slideBackground: 'elementor-background-slideshow__slide__image',
663	kenBurns: 'elementor-ken-burns',
664	kenBurnsActive: 'elementor-ken-burns--active',
665	kenBurnsIn: 'elementor-ken-burns--in',
666	kenBurnsOut: 'elementor-ken-burns--out'
667	}
668	};
669	}
670
671	getSwiperOptions() {
672	const elementSettings = this.getElementSettings();
673	const swiperOptions = {
674	grabCursor: false,
675	slidesPerView: 1,
676	slidesPerGroup: 1,
677	loop: 'yes' === elementSettings.background_slideshow_loop,
678	speed: elementSettings.background_slideshow_transition_duration,
679	autoplay: {
680	delay: elementSettings.background_slideshow_slide_duration,
681	stopOnLastSlide: !elementSettings.background_slideshow_loop
682	},
683	handleElementorBreakpoints: true,
684	on: {
685	slideChange: () => {
686	if (elementSettings.background_slideshow_ken_burns) {
687	this.handleKenBurns();
688	}
689	}
690	}
691	};
692
693	if ('yes' === elementSettings.background_slideshow_loop) {
694	swiperOptions.loopedSlides = this.getSlidesCount();
695	}
696
697	switch (elementSettings.background_slideshow_slide_transition) {
698	case 'fade':
699	swiperOptions.effect = 'fade';
700	swiperOptions.fadeEffect = {
701	crossFade: true
702	};
703	break;
704
705	case 'slide_down':
706	swiperOptions.autoplay.reverseDirection = true;
707
708	case 'slide_up':
709	swiperOptions.direction = 'vertical';
710	break;
711	}
712
713	return swiperOptions;
714	}
715
716	buildSwiperElements() {
717	const classes = this.getSettings('classes'),
718	elementSettings = this.getElementSettings(),
719	direction = 'slide_left' === elementSettings.background_slideshow_slide_transition ? 'ltr' : 'rtl',
720	$container = jQuery('<div>', {
721	class: classes.swiperContainer,
722	dir: direction
723	}),
724	$wrapper = jQuery('<div>', {
725	class: classes.swiperWrapper
726	}),
727	kenBurnsActive = elementSettings.background_slideshow_ken_burns;
728	let slideInnerClass = classes.slideBackground;
729
730	if (kenBurnsActive) {
731	slideInnerClass += ' ' + classes.kenBurns;
732	const kenBurnsDirection = 'in' === elementSettings.background_slideshow_ken_burns_zoom_direction ? 'kenBurnsIn' : 'kenBurnsOut';
733	slideInnerClass += ' ' + classes[kenBurnsDirection];
734	}
735
736	this.elements.$slides = jQuery();
737	elementSettings.background_slideshow_gallery.forEach(slide => {
738	const $slide = jQuery('<div>', {
739	class: classes.swiperSlide
740	}),
741	$slidebg = jQuery('<div>', {
742	class: slideInnerClass,
743	style: 'background-image: url("' + slide.url + '");'
744	});
745	$slide.append($slidebg);
746	$wrapper.append($slide);
747	this.elements.$slides = this.elements.$slides.add($slide);
748	});
749	$container.append($wrapper);
750	this.$element.prepend($container);
751	this.elements.$backgroundSlideShowContainer = $container;
752	}
753
754	async initSlider() {
755	if (1 >= this.getSlidesCount()) {
756	return;
757	}
758
759	const elementSettings = this.getElementSettings();
760	const Swiper = elementorFrontend.utils.swiper;
761	this.swiper = await new Swiper(this.elements.$backgroundSlideShowContainer, this.getSwiperOptions()); // Expose the swiper instance in the frontend
762
763	this.elements.$backgroundSlideShowContainer.data('swiper', this.swiper);
764
765	if (elementSettings.background_slideshow_ken_burns) {
766	this.handleKenBurns();
767	}
768	}
769
770	activate() {
771	this.buildSwiperElements();
772	this.initSlider();
773	}
774
775	deactivate() {
776	if (this.swiper) {
777	this.swiper.destroy();
778	this.elements.$backgroundSlideShowContainer.remove();
779	}
780	}
781
782	run() {
783	if ('slideshow' === this.getElementSettings('background_background')) {
784	this.activate();
785	} else {
786	this.deactivate();
787	}
788	}
789
790	onInit() {
791	super.onInit();
792
793	if (this.getElementSettings('background_slideshow_gallery')) {
794	this.run();
795	}
796	}
797
798	onDestroy() {
799	super.onDestroy();
800	this.deactivate();
801	}
802
803	onElementChange(propertyName) {
804	if ('background_background' === propertyName) {
805	this.run();
806	}
807	}
808
809	}
810
811	exports.default = BackgroundSlideshow;
812
813	/***/ }),
814
815	/***/ "../assets/dev/js/frontend/handlers/column.js":
816	/!**************************************************!\
817	!* ../assets/dev/js/frontend/handlers/column.js *!
818	\****************************************************/
819	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
820
821	"use strict";
822
823
824	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
825
826	Object.defineProperty(exports, "__esModule", ({
827	value: true
828	}));
829	exports.default = void 0;
830
831	var _backgroundSlideshow = _interopRequireDefault(__webpack_require__(/! ./background-slideshow / "../assets/dev/js/frontend/handlers/background-slideshow.js"));
832
833	var _default = [_backgroundSlideshow.default];
834	exports.default = _default;
835
836	/***/ }),
837
838	/***/ "../assets/dev/js/frontend/handlers/global.js":
839	/!**************************************************!\
840	!* ../assets/dev/js/frontend/handlers/global.js *!
841	\****************************************************/
842	/***/ ((__unused_webpack_module, exports) => {
843
844	"use strict";
845
846
847	Object.defineProperty(exports, "__esModule", ({
848	value: true
849	}));
850	exports.default = void 0;
851
852	class GlobalHandler extends elementorModules.frontend.handlers.Base {
853	getWidgetType() {
854	return 'global';
855	}
856
857	animate() {
858	const $element = this.$element,
859	animation = this.getAnimation();
860
861	if ('none' === animation) {
862	$element.removeClass('elementor-invisible');
863	return;
864	}
865
866	const elementSettings = this.getElementSettings(),
867	animationDelay = elementSettings._animation_delay \|\| elementSettings.animation_delay \|\| 0;
868	$element.removeClass(animation);
869
870	if (this.currentAnimation) {
871	$element.removeClass(this.currentAnimation);
872	}
873
874	this.currentAnimation = animation;
875	setTimeout(() => {
876	$element.removeClass('elementor-invisible').addClass('animated ' + animation);
877	}, animationDelay);
878	}
879
880	getAnimation() {
881	return this.getCurrentDeviceSetting('animation') \|\| this.getCurrentDeviceSetting('_animation');
882	}
883
884	onInit(...args) {
885	super.onInit(...args);
886
887	if (this.getAnimation()) {
888	const observer = elementorModules.utils.Scroll.scrollObserver({
889	callback: event => {
890	if (event.isInViewport) {
891	this.animate();
892	observer.unobserve(this.$element[0]);
893	}
894	}
895	});
896	observer.observe(this.$element[0]);
897	}
898	}
899
900	onElementChange(propertyName) {
901	if (/^_?animation/.test(propertyName)) {
902	this.animate();
903	}
904	}
905
906	}
907
908	var _default = $scope => {
909	elementorFrontend.elementsHandler.addHandler(GlobalHandler, {
910	$element: $scope
911	});
912	};
913
914	exports.default = _default;
915
916	/***/ }),
917
918	/***/ "../assets/dev/js/frontend/handlers/section/background-video.js":
919	/!********************************************************************!\
920	!* ../assets/dev/js/frontend/handlers/section/background-video.js *!
921	\**********************************************************************/
922	/***/ ((__unused_webpack_module, exports) => {
923
924	"use strict";
925
926
927	Object.defineProperty(exports, "__esModule", ({
928	value: true
929	}));
930	exports.default = void 0;
931
932	class BackgroundVideo extends elementorModules.frontend.handlers.Base {
933	getDefaultSettings() {
934	return {
935	selectors: {
936	backgroundVideoContainer: '.elementor-background-video-container',
937	backgroundVideoEmbed: '.elementor-background-video-embed',
938	backgroundVideoHosted: '.elementor-background-video-hosted'
939	}
940	};
941	}
942
943	getDefaultElements() {
944	const selectors = this.getSettings('selectors'),
945	elements = {
946	$backgroundVideoContainer: this.$element.find(selectors.backgroundVideoContainer)
947	};
948	elements.$backgroundVideoEmbed = elements.$backgroundVideoContainer.children(selectors.backgroundVideoEmbed);
949	elements.$backgroundVideoHosted = elements.$backgroundVideoContainer.children(selectors.backgroundVideoHosted);
950	return elements;
951	}
952
953	calcVideosSize($video) {
954	let aspectRatioSetting = '16:9';
955
956	if ('vimeo' === this.videoType) {
957	aspectRatioSetting = $video[0].width + ':' + $video[0].height;
958	}
959
960	const containerWidth = this.elements.$backgroundVideoContainer.outerWidth(),
961	containerHeight = this.elements.$backgroundVideoContainer.outerHeight(),
962	aspectRatioArray = aspectRatioSetting.split(':'),
963	aspectRatio = aspectRatioArray[0] / aspectRatioArray[1],
964	ratioWidth = containerWidth / aspectRatio,
965	ratioHeight = containerHeight * aspectRatio,
966	isWidthFixed = containerWidth / containerHeight > aspectRatio;
967	return {
968	width: isWidthFixed ? containerWidth : ratioHeight,
969	height: isWidthFixed ? ratioWidth : containerHeight
970	};
971	}
972
973	changeVideoSize() {
974	if (!('hosted' === this.videoType) && !this.player) {
975	return;
976	}
977
978	let $video;
979
980	if ('youtube' === this.videoType) {
981	$video = jQuery(this.player.getIframe());
982	} else if ('vimeo' === this.videoType) {
983	$video = jQuery(this.player.element);
984	} else if ('hosted' === this.videoType) {
985	$video = this.elements.$backgroundVideoHosted;
986	}
987
988	if (!$video) {
989	return;
990	}
991
992	const size = this.calcVideosSize($video);
993	$video.width(size.width).height(size.height);
994	}
995
996	startVideoLoop(firstTime) {
997	// If the section has been removed
998	if (!this.player.getIframe().contentWindow) {
999	return;
1000	}
1001
1002	const elementSettings = this.getElementSettings(),
1003	startPoint = elementSettings.background_video_start \|\| 0,
1004	endPoint = elementSettings.background_video_end;
1005
1006	if (elementSettings.background_play_once && !firstTime) {
1007	this.player.stopVideo();
1008	return;
1009	}
1010
1011	this.player.seekTo(startPoint);
1012
1013	if (endPoint) {
1014	const durationToEnd = endPoint - startPoint + 1;
1015	setTimeout(() => {
1016	this.startVideoLoop(false);
1017	}, durationToEnd * 1000);
1018	}
1019	}
1020
1021	prepareVimeoVideo(Vimeo, videoId) {
1022	const elementSettings = this.getElementSettings(),
1023	startTime = elementSettings.background_video_start ? elementSettings.background_video_start : 0,
1024	videoSize = this.elements.$backgroundVideoContainer.outerWidth(),
1025	vimeoOptions = {
1026	id: videoId,
1027	width: videoSize.width,
1028	autoplay: true,
1029	loop: !elementSettings.background_play_once,
1030	transparent: false,
1031	background: true,
1032	muted: true
1033	};
1034	this.player = new Vimeo.Player(this.elements.$backgroundVideoContainer, vimeoOptions); // Handle user-defined start/end times
1035
1036	this.handleVimeoStartEndTimes(elementSettings);
1037	this.player.ready().then(() => {
1038	jQuery(this.player.element).addClass('elementor-background-video-embed');
1039	this.changeVideoSize();
1040	});
1041	}
1042
1043	handleVimeoStartEndTimes(elementSettings) {
1044	// If a start time is defined, set the start time
1045	if (elementSettings.background_video_start) {
1046	this.player.on('play', data => {
1047	if (0 === data.seconds) {
1048	this.player.setCurrentTime(elementSettings.background_video_start);
1049	}
1050	});
1051	}
1052
1053	this.player.on('timeupdate', data => {
1054	// If an end time is defined, handle ending the video
1055	if (elementSettings.background_video_end && elementSettings.background_video_end < data.seconds) {
1056	if (elementSettings.background_play_once) {
1057	// Stop at user-defined end time if not loop
1058	this.player.pause();
1059	} else {
1060	// Go to start time if loop
1061	this.player.setCurrentTime(elementSettings.background_video_start);
1062	}
1063	} // If start time is defined but an end time is not, go to user-defined start time at video end.
1064	// Vimeo JS API has an 'ended' event, but it never fires when infinite loop is defined, so we
1065	// get the video duration (returns a promise) then use duration-0.5s as end time
1066
1067
1068	this.player.getDuration().then(duration => {
1069	if (elementSettings.background_video_start && !elementSettings.background_video_end && data.seconds > duration - 0.5) {
1070	this.player.setCurrentTime(elementSettings.background_video_start);
1071	}
1072	});
1073	});
1074	}
1075
1076	prepareYTVideo(YT, videoID) {
1077	const $backgroundVideoContainer = this.elements.$backgroundVideoContainer,
1078	elementSettings = this.getElementSettings();
1079	let startStateCode = YT.PlayerState.PLAYING; // Since version 67, Chrome doesn't fire the `PLAYING` state at start time
1080
1081	if (window.chrome) {
1082	startStateCode = YT.PlayerState.UNSTARTED;
1083	}
1084
1085	const playerOptions = {
1086	videoId: videoID,
1087	events: {
1088	onReady: () => {
1089	this.player.mute();
1090	this.changeVideoSize();
1091	this.startVideoLoop(true);
1092	this.player.playVideo();
1093	},
1094	onStateChange: event => {
1095	switch (event.data) {
1096	case startStateCode:
1097	$backgroundVideoContainer.removeClass('elementor-invisible elementor-loading');
1098	break;
1099
1100	case YT.PlayerState.ENDED:
1101	this.player.seekTo(elementSettings.background_video_start \|\| 0);
1102
1103	if (elementSettings.background_play_once) {
1104	this.player.destroy();
1105	}
1106
1107	}
1108	}
1109	},
1110	playerVars: {
1111	controls: 0,
1112	rel: 0,
1113	playsinline: 1
1114	}
1115	}; // To handle CORS issues, when the default host is changed, the origin parameter has to be set.
1116
1117	if (elementSettings.background_privacy_mode) {
1118	playerOptions.host = 'https://www.youtube-nocookie.com';
1119	playerOptions.origin = window.location.hostname;
1120	}
1121
1122	$backgroundVideoContainer.addClass('elementor-loading elementor-invisible');
1123	this.player = new YT.Player(this.elements.$backgroundVideoEmbed[0], playerOptions);
1124	}
1125
1126	activate() {
1127	let videoLink = this.getElementSettings('background_video_link'),
1128	videoID;
1129	const playOnce = this.getElementSettings('background_play_once');
1130
1131	if (-1 !== videoLink.indexOf('vimeo.com')) {
1132	this.videoType = 'vimeo';
1133	this.apiProvider = elementorFrontend.utils.vimeo;
1134	} else if (videoLink.match(/^(?:https?:\/\/)?(?:www\.)?(?:m\.)?(?:youtu\.be\/\|youtube\.com)/)) {
1135	this.videoType = 'youtube';
1136	this.apiProvider = elementorFrontend.utils.youtube;
1137	}
1138
1139	if (this.apiProvider) {
1140	videoID = this.apiProvider.getVideoIDFromURL(videoLink);
1141	this.apiProvider.onApiReady(apiObject => {
1142	if ('youtube' === this.videoType) {
1143	this.prepareYTVideo(apiObject, videoID);
1144	}
1145
1146	if ('vimeo' === this.videoType) {
1147	this.prepareVimeoVideo(apiObject, videoID);
1148	}
1149	});
1150	} else {
1151	this.videoType = 'hosted';
1152	const startTime = this.getElementSettings('background_video_start'),
1153	endTime = this.getElementSettings('background_video_end');
1154
1155	if (startTime \|\| endTime) {
1156	videoLink += '#t=' + (startTime \|\| 0) + (endTime ? ',' + endTime : '');
1157	}
1158
1159	this.elements.$backgroundVideoHosted.attr('src', videoLink).one('canplay', this.changeVideoSize.bind(this));
1160
1161	if (playOnce) {
1162	this.elements.$backgroundVideoHosted.on('ended', () => {
1163	this.elements.$backgroundVideoHosted.hide();
1164	});
1165	}
1166	}
1167
1168	elementorFrontend.elements.$window.on('resize', this.changeVideoSize);
1169	}
1170
1171	deactivate() {
1172	if ('youtube' === this.videoType && this.player.getIframe() \|\| 'vimeo' === this.videoType) {
1173	this.player.destroy();
1174	} else {
1175	this.elements.$backgroundVideoHosted.removeAttr('src').off('ended');
1176	}
1177
1178	elementorFrontend.elements.$window.off('resize', this.changeVideoSize);
1179	}
1180
1181	run() {
1182	const elementSettings = this.getElementSettings();
1183
1184	if (!elementSettings.background_play_on_mobile && 'mobile' === elementorFrontend.getCurrentDeviceMode()) {
1185	return;
1186	}
1187
1188	if ('video' === elementSettings.background_background && elementSettings.background_video_link) {
1189	this.activate();
1190	} else {
1191	this.deactivate();
1192	}
1193	}
1194
1195	onInit(...args) {
1196	super.onInit(...args);
1197	this.changeVideoSize = this.changeVideoSize.bind(this);
1198	this.run();
1199	}
1200
1201	onElementChange(propertyName) {
1202	if ('background_background' === propertyName) {
1203	this.run();
1204	}
1205	}
1206
1207	}
1208
1209	exports.default = BackgroundVideo;
1210
1211	/***/ }),
1212
1213	/***/ "../assets/dev/js/frontend/handlers/section/handles-position.js":
1214	/!********************************************************************!\
1215	!* ../assets/dev/js/frontend/handlers/section/handles-position.js *!
1216	\**********************************************************************/
1217	/***/ ((__unused_webpack_module, exports) => {
1218
1219	"use strict";
1220
1221
1222	Object.defineProperty(exports, "__esModule", ({
1223	value: true
1224	}));
1225	exports.default = void 0;
1226
1227	class HandlesPosition extends elementorModules.frontend.handlers.Base {
1228	isActive() {
1229	return elementorFrontend.isEditMode();
1230	}
1231
1232	isFirstSection() {
1233	return this.$element[0] === document.querySelector('.elementor-edit-mode .elementor-top-section');
1234	}
1235
1236	isOverflowHidden() {
1237	return 'hidden' === this.$element.css('overflow');
1238	}
1239
1240	getOffset() {
1241	if ('body' === elementor.config.document.container) {
1242	return this.$element.offset().top;
1243	}
1244
1245	const $container = jQuery(elementor.config.document.container);
1246	return this.$element.offset().top - $container.offset().top;
1247	}
1248
1249	setHandlesPosition() {
1250	const document = elementor.documents.getCurrent();
1251
1252	if (!document \|\| !document.container.isEditable()) {
1253	return;
1254	}
1255
1256	const insideHandleClass = 'elementor-section--handles-inside',
1257	$handlesElement = this.$element.find('> .elementor-element-overlay > .elementor-editor-section-settings');
1258
1259	if (elementor.settings.page.model.attributes.scroll_snap) {
1260	this.$element.addClass(insideHandleClass);
1261	return;
1262	}
1263
1264	const isOverflowHidden = this.isOverflowHidden();
1265
1266	if (!isOverflowHidden && !this.isFirstSection()) {
1267	return;
1268	}
1269
1270	const offset = isOverflowHidden ? 0 : this.getOffset();
1271
1272	if (offset < 25) {
1273	this.$element.addClass(insideHandleClass);
1274
1275	if (offset < -5) {
1276	$handlesElement.css('top', -offset);
1277	} else {
1278	$handlesElement.css('top', '');
1279	}
1280	} else {
1281	this.$element.removeClass(insideHandleClass);
1282	}
1283	}
1284
1285	onInit() {
1286	if (!this.isActive()) {
1287	return;
1288	}
1289
1290	this.setHandlesPosition();
1291	this.$element.on('mouseenter', this.setHandlesPosition.bind(this));
1292	}
1293
1294	}
1295
1296	exports.default = HandlesPosition;
1297
1298	/***/ }),
1299
1300	/***/ "../assets/dev/js/frontend/handlers/section/section.js":
1301	/!***********************************************************!\
1302	!* ../assets/dev/js/frontend/handlers/section/section.js *!
1303	\*************************************************************/
1304	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1305
1306	"use strict";
1307
1308
1309	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
1310
1311	Object.defineProperty(exports, "__esModule", ({
1312	value: true
1313	}));
1314	exports.default = void 0;
1315
1316	var _backgroundSlideshow = _interopRequireDefault(__webpack_require__(/! ../background-slideshow / "../assets/dev/js/frontend/handlers/background-slideshow.js"));
1317
1318	var _backgroundVideo = _interopRequireDefault(__webpack_require__(/! ./background-video / "../assets/dev/js/frontend/handlers/section/background-video.js"));
1319
1320	var _handlesPosition = _interopRequireDefault(__webpack_require__(/! ./handles-position / "../assets/dev/js/frontend/handlers/section/handles-position.js"));
1321
1322	var _stretchedSection = _interopRequireDefault(__webpack_require__(/! ./stretched-section / "../assets/dev/js/frontend/handlers/section/stretched-section.js"));
1323
1324	var _shapes = _interopRequireDefault(__webpack_require__(/! ./shapes / "../assets/dev/js/frontend/handlers/section/shapes.js"));
1325
1326	var _default = [_stretchedSection.default, // Must run before BackgroundSlideshow to init the slideshow only after the stretch.
1327	_backgroundSlideshow.default, _backgroundVideo.default, _handlesPosition.default, _shapes.default];
1328	exports.default = _default;
1329
1330	/***/ }),
1331
1332	/***/ "../assets/dev/js/frontend/handlers/section/shapes.js":
1333	/!**********************************************************!\
1334	!* ../assets/dev/js/frontend/handlers/section/shapes.js *!
1335	\************************************************************/
1336	/***/ ((__unused_webpack_module, exports) => {
1337
1338	"use strict";
1339
1340
1341	Object.defineProperty(exports, "__esModule", ({
1342	value: true
1343	}));
1344	exports.default = void 0;
1345
1346	class Shapes extends elementorModules.frontend.handlers.Base {
1347	getDefaultSettings() {
1348	return {
1349	selectors: {
1350	container: '> .elementor-shape-%s'
1351	},
1352	svgURL: elementorFrontend.config.urls.assets + 'shapes/'
1353	};
1354	}
1355
1356	getDefaultElements() {
1357	const elements = {},
1358	selectors = this.getSettings('selectors');
1359	elements.$topContainer = this.$element.find(selectors.container.replace('%s', 'top'));
1360	elements.$bottomContainer = this.$element.find(selectors.container.replace('%s', 'bottom'));
1361	return elements;
1362	}
1363
1364	isActive() {
1365	return elementorFrontend.isEditMode();
1366	}
1367
1368	getSvgURL(shapeType, fileName) {
1369	let svgURL = this.getSettings('svgURL') + fileName + '.svg';
1370
1371	if (elementor.config.additional_shapes && shapeType in elementor.config.additional_shapes) {
1372	svgURL = elementor.config.additional_shapes[shapeType];
1373
1374	if (-1 < fileName.indexOf('-negative')) {
1375	svgURL = svgURL.replace('.svg', '-negative.svg');
1376	}
1377	}
1378
1379	return svgURL;
1380	}
1381
1382	buildSVG(side) {
1383	const baseSettingKey = 'shape_divider_' + side,
1384	shapeType = this.getElementSettings(baseSettingKey),
1385	$svgContainer = this.elements['$' + side + 'Container'];
1386	$svgContainer.attr('data-shape', shapeType);
1387
1388	if (!shapeType) {
1389	$svgContainer.empty(); // Shape-divider set to 'none'
1390
1391	return;
1392	}
1393
1394	let fileName = shapeType;
1395
1396	if (this.getElementSettings(baseSettingKey + '_negative')) {
1397	fileName += '-negative';
1398	}
1399
1400	const svgURL = this.getSvgURL(shapeType, fileName);
1401	jQuery.get(svgURL, data => {
1402	$svgContainer.empty().append(data.childNodes[0]);
1403	});
1404	this.setNegative(side);
1405	}
1406
1407	setNegative(side) {
1408	this.elements['$' + side + 'Container'].attr('data-negative', !!this.getElementSettings('shape_divider_' + side + '_negative'));
1409	}
1410
1411	onInit(...args) {
1412	if (!this.isActive(this.getSettings())) {
1413	return;
1414	}
1415
1416	super.onInit(...args);
1417	['top', 'bottom'].forEach(side => {
1418	if (this.getElementSettings('shape_divider_' + side)) {
1419	this.buildSVG(side);
1420	}
1421	});
1422	}
1423
1424	onElementChange(propertyName) {
1425	const shapeChange = propertyName.match(/^shape_divider_(top\|bottom)$/);
1426
1427	if (shapeChange) {
1428	this.buildSVG(shapeChange[1]);
1429	return;
1430	}
1431
1432	const negativeChange = propertyName.match(/^shape_divider_(top\|bottom)_negative$/);
1433
1434	if (negativeChange) {
1435	this.buildSVG(negativeChange[1]);
1436	this.setNegative(negativeChange[1]);
1437	}
1438	}
1439
1440	}
1441
1442	exports.default = Shapes;
1443
1444	/***/ }),
1445
1446	/***/ "../assets/dev/js/frontend/handlers/section/stretched-section.js":
1447	/!*********************************************************************!\
1448	!* ../assets/dev/js/frontend/handlers/section/stretched-section.js *!
1449	\***********************************************************************/
1450	/***/ ((__unused_webpack_module, exports) => {
1451
1452	"use strict";
1453
1454
1455	Object.defineProperty(exports, "__esModule", ({
1456	value: true
1457	}));
1458	exports.default = void 0;
1459
1460	class StretchedSection extends elementorModules.frontend.handlers.Base {
1461	bindEvents() {
1462	const handlerID = this.getUniqueHandlerID();
1463	elementorFrontend.addListenerOnce(handlerID, 'resize', this.stretch);
1464	elementorFrontend.addListenerOnce(handlerID, 'sticky:stick', this.stretch, this.$element);
1465	elementorFrontend.addListenerOnce(handlerID, 'sticky:unstick', this.stretch, this.$element);
1466
1467	if (elementorFrontend.isEditMode()) {
1468	this.onKitChangeStretchContainerChange = this.onKitChangeStretchContainerChange.bind(this);
1469	elementor.channels.editor.on('kit:change:stretchContainer', this.onKitChangeStretchContainerChange);
1470	}
1471	}
1472
1473	unbindEvents() {
1474	elementorFrontend.removeListeners(this.getUniqueHandlerID(), 'resize', this.stretch);
1475
1476	if (elementorFrontend.isEditMode()) {
1477	elementor.channels.editor.off('kit:change:stretchContainer', this.onKitChangeStretchContainerChange);
1478	}
1479	}
1480
1481	isActive(settings) {
1482	return elementorFrontend.isEditMode() \|\| settings.$element.hasClass('elementor-section-stretched');
1483	}
1484
1485	initStretch() {
1486	this.stretch = this.stretch.bind(this);
1487	this.stretchElement = new elementorModules.frontend.tools.StretchElement({
1488	element: this.$element,
1489	selectors: {
1490	container: this.getStretchContainer()
1491	}
1492	});
1493	}
1494
1495	getStretchContainer() {
1496	return elementorFrontend.getKitSettings('stretched_section_container') \|\| window;
1497	}
1498
1499	stretch() {
1500	if (!this.getElementSettings('stretch_section')) {
1501	return;
1502	}
1503
1504	this.stretchElement.stretch();
1505	}
1506
1507	onInit(...args) {
1508	if (!this.isActive(this.getSettings())) {
1509	return;
1510	}
1511
1512	this.initStretch();
1513	super.onInit(...args);
1514	this.stretch();
1515	}
1516
1517	onElementChange(propertyName) {
1518	if ('stretch_section' === propertyName) {
1519	if (this.getElementSettings('stretch_section')) {
1520	this.stretch();
1521	} else {
1522	this.stretchElement.reset();
1523	}
1524	}
1525	}
1526
1527	onKitChangeStretchContainerChange() {
1528	this.stretchElement.setSettings('selectors.container', this.getStretchContainer());
1529	this.stretch();
1530	}
1531
1532	}
1533
1534	exports.default = StretchedSection;
1535
1536	/***/ }),
1537
1538	/***/ "../assets/dev/js/frontend/utils/anchors.js":
1539	/!************************************************!\
1540	!* ../assets/dev/js/frontend/utils/anchors.js *!
1541	\**************************************************/
1542	/***/ ((module) => {
1543
1544	"use strict";
1545
1546
1547	module.exports = elementorModules.ViewModule.extend({
1548	getDefaultSettings: function () {
1549	return {
1550	scrollDuration: 500,
1551	selectors: {
1552	links: 'a[href*="#"]',
1553	targets: '.elementor-element, .elementor-menu-anchor',
1554	scrollable: 'html, body'
1555	}
1556	};
1557	},
1558	getDefaultElements: function () {
1559	var $ = jQuery,
1560	selectors = this.getSettings('selectors');
1561	return {
1562	$scrollable: $(selectors.scrollable)
1563	};
1564	},
1565	bindEvents: function () {
1566	elementorFrontend.elements.$document.on('click', this.getSettings('selectors.links'), this.handleAnchorLinks);
1567	},
1568	handleAnchorLinks: function (event) {
1569	var clickedLink = event.currentTarget,
1570	isSamePathname = location.pathname === clickedLink.pathname,
1571	isSameHostname = location.hostname === clickedLink.hostname,
1572	$anchor;
1573
1574	if (!isSameHostname \|\| !isSamePathname \|\| clickedLink.hash.length < 2) {
1575	return;
1576	}
1577
1578	try {
1579	$anchor = jQuery(clickedLink.hash).filter(this.getSettings('selectors.targets'));
1580	} catch (e) {
1581	return;
1582	}
1583
1584	if (!$anchor.length) {
1585	return;
1586	}
1587
1588	var scrollTop = $anchor.offset().top,
1589	$wpAdminBar = elementorFrontend.elements.$wpAdminBar,
1590	$activeStickies = jQuery('.elementor-section.elementor-sticky--active:visible'),
1591	maxStickyHeight = 0;
1592
1593	if ($wpAdminBar.length > 0) {
1594	scrollTop -= $wpAdminBar.height();
1595	} // Offset height of tallest sticky
1596
1597
1598	if ($activeStickies.length > 0) {
1599	maxStickyHeight = Math.max.apply(null, $activeStickies.map(function () {
1600	return jQuery(this).outerHeight();
1601	}).get());
1602	scrollTop -= maxStickyHeight;
1603	}
1604
1605	event.preventDefault();
1606	scrollTop = elementorFrontend.hooks.applyFilters('frontend/handlers/menu_anchor/scroll_top_distance', scrollTop);
1607	this.elements.$scrollable.animate({
1608	scrollTop: scrollTop
1609	}, this.getSettings('scrollDuration'), 'linear');
1610	},
1611	onInit: function () {
1612	elementorModules.ViewModule.prototype.onInit.apply(this, arguments);
1613	this.bindEvents();
1614	}
1615	});
1616
1617	/***/ }),
1618
1619	/***/ "../assets/dev/js/frontend/utils/assets-loader.js":
1620	/!******************************************************!\
1621	!* ../assets/dev/js/frontend/utils/assets-loader.js *!
1622	\********************************************************/
1623	/***/ ((__unused_webpack_module, exports) => {
1624
1625	"use strict";
1626
1627
1628	Object.defineProperty(exports, "__esModule", ({
1629	value: true
1630	}));
1631	exports.default = void 0;
1632
1633	class AssetsLoader {
1634	getScriptElement(src) {
1635	const scriptElement = document.createElement('script');
1636	scriptElement.src = src;
1637	return scriptElement;
1638	}
1639
1640	getStyleElement(src) {
1641	const styleElement = document.createElement('link');
1642	styleElement.rel = 'stylesheet';
1643	styleElement.href = src;
1644	return styleElement;
1645	}
1646
1647	load(type, key) {
1648	const assetData = AssetsLoader.assets[type][key];
1649
1650	if (!assetData.loader) {
1651	assetData.loader = new Promise(resolve => {
1652	const element = 'style' === type ? this.getStyleElement(assetData.src) : this.getScriptElement(assetData.src);
1653
1654	element.onload = () => resolve(true);
1655
1656	const parent = 'head' === assetData.parent ? assetData.parent : 'body';
1657	document[parent].appendChild(element);
1658	});
1659	}
1660
1661	return assetData.loader;
1662	}
1663
1664	}
1665
1666	exports.default = AssetsLoader;
1667	const fileSuffix = elementorFrontendConfig.environmentMode.isScriptDebug ? '' : '.min';
1668	AssetsLoader.assets = {
1669	script: {
1670	dialog: {
1671	src: `${elementorFrontendConfig.urls.assets}lib/dialog/dialog${fileSuffix}.js?ver=4.8.1`
1672	},
1673	'share-link': {
1674	src: `${elementorFrontendConfig.urls.assets}lib/share-link/share-link${fileSuffix}.js?ver=${elementorFrontendConfig.version}`
1675	},
1676	swiper: {
1677	src: `${elementorFrontendConfig.urls.assets}lib/swiper/swiper${fileSuffix}.js?ver=5.3.6`
1678	}
1679	},
1680	style: {}
1681	};
1682
1683	/***/ }),
1684
1685	/***/ "../assets/dev/js/frontend/utils/lightbox/lightbox-manager.js":
1686	/!******************************************************************!\
1687	!* ../assets/dev/js/frontend/utils/lightbox/lightbox-manager.js *!
1688	\********************************************************************/
1689	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1690
1691	"use strict";
1692
1693
1694	Object.defineProperty(exports, "__esModule", ({
1695	value: true
1696	}));
1697	exports.default = void 0;
1698
1699	class LightboxManager extends elementorModules.ViewModule {
1700	static getLightbox() {
1701	const lightboxPromise = new Promise(resolveLightbox => {
1702	__webpack_require__.e(/! import() \| lightbox / "lightbox").then(__webpack_require__.t.bind(__webpack_require__, /! elementor-frontend/utils/lightbox/lightbox / "../assets/dev/js/frontend/utils/lightbox/lightbox.js", 23)).then(({
1703	default: LightboxModule
1704	}) => resolveLightbox(new LightboxModule()));
1705	}),
1706	dialogPromise = elementorFrontend.utils.assetsLoader.load('script', 'dialog'),
1707	shareLinkPromise = elementorFrontend.utils.assetsLoader.load('script', 'share-link');
1708	return Promise.all([lightboxPromise, dialogPromise, shareLinkPromise]).then(() => lightboxPromise);
1709	}
1710
1711	getDefaultSettings() {
1712	return {
1713	selectors: {
1714	links: 'a, [data-elementor-lightbox]'
1715	}
1716	};
1717	}
1718
1719	getDefaultElements() {
1720	return {
1721	$links: jQuery(this.getSettings('selectors.links'))
1722	};
1723	}
1724
1725	isLightboxLink(element) {
1726	// Check for lowercase `a` to make sure it works also for links inside SVGs.
1727	if ('a' === element.tagName.toLowerCase() && (element.hasAttribute('download') \|\| !/^[^?]+\.(png\|jpe?g\|gif\|svg\|webp)(\?.*)?$/i.test(element.href)) && !element.dataset.elementorLightboxVideo) {
1728	return false;
1729	}
1730
1731	const generalOpenInLightbox = elementorFrontend.getKitSettings('global_image_lightbox'),
1732	currentLinkOpenInLightbox = element.dataset.elementorOpenLightbox;
1733	return 'yes' === currentLinkOpenInLightbox \|\| generalOpenInLightbox && 'no' !== currentLinkOpenInLightbox;
1734	}
1735
1736	async onLinkClick(event) {
1737	const element = event.currentTarget,
1738	$target = jQuery(event.target),
1739	editMode = elementorFrontend.isEditMode(),
1740	isColorPickingMode = editMode && elementor.$previewContents.find('body').hasClass('elementor-editor__ui-state__color-picker'),
1741	isClickInsideElementor = !!$target.closest('.elementor-edit-area').length;
1742
1743	if (!this.isLightboxLink(element)) {
1744	if (editMode && isClickInsideElementor) {
1745	event.preventDefault();
1746	}
1747
1748	return;
1749	}
1750
1751	event.preventDefault();
1752
1753	if (editMode && !elementor.getPreferences('lightbox_in_editor')) {
1754	return;
1755	} // Disable lightbox on color picking mode.
1756
1757
1758	if (isColorPickingMode) {
1759	return;
1760	}
1761
1762	const lightbox = this.isOptimizedAssetsLoading() ? await LightboxManager.getLightbox() : elementorFrontend.utils.lightbox;
1763	lightbox.createLightbox(element);
1764	}
1765
1766	isOptimizedAssetsLoading() {
1767	return elementorFrontend.config.experimentalFeatures.e_optimized_assets_loading;
1768	}
1769
1770	bindEvents() {
1771	elementorFrontend.elements.$document.on('click', this.getSettings('selectors.links'), event => this.onLinkClick(event));
1772	}
1773
1774	onInit(...args) {
1775	super.onInit(...args);
1776
1777	if (!this.isOptimizedAssetsLoading() \|\| elementorFrontend.isEditMode()) {
1778	return;
1779	} // Detecting lightbox links on init will reduce the time of waiting to the lightbox to be display on slow connections.
1780
1781
1782	this.elements.$links.each((index, element) => {
1783	if (this.isLightboxLink(element)) {
1784	LightboxManager.getLightbox(); // Breaking the iteration when the library loading has already been triggered.
1785
1786	return false;
1787	}
1788	});
1789	}
1790
1791	}
1792
1793	exports.default = LightboxManager;
1794
1795	/***/ }),
1796
1797	/***/ "../assets/dev/js/frontend/utils/swiper-bc.js":
1798	/!**************************************************!\
1799	!* ../assets/dev/js/frontend/utils/swiper-bc.js *!
1800	\****************************************************/
1801	/***/ ((__unused_webpack_module, exports) => {
1802
1803	"use strict";
1804
1805
1806	Object.defineProperty(exports, "__esModule", ({
1807	value: true
1808	}));
1809	exports.default = void 0;
1810
1811	class SwiperBC {
1812	constructor(container, config) {
1813	this.config = config;
1814
1815	if (this.config.breakpoints) {
1816	// The config is passed as a param to allow adjustConfig to be called outside of this wrapper
1817	this.config = this.adjustConfig(config);
1818	} // In case of a legacy behaviour the constructor should return a new Swiper instance instead of a Promise.
1819
1820
1821	if (config.legacy) {
1822	return this.createSwiperInstance(container, this.config);
1823	}
1824
1825	return new Promise(resolve => {
1826	if (!elementorFrontend.config.experimentalFeatures.e_optimized_assets_loading) {
1827	return resolve(this.createSwiperInstance(container, this.config));
1828	}
1829
1830	elementorFrontend.utils.assetsLoader.load('script', 'swiper').then(() => resolve(this.createSwiperInstance(container, this.config)));
1831	});
1832	}
1833
1834	createSwiperInstance(container, config) {
1835	// The condition should run only once to prevent an additional overwrite of the SwiperSource.
1836	if (!SwiperBC.isSwiperLoaded && elementorFrontend.config.experimentalFeatures.e_optimized_assets_loading) {
1837	SwiperSource = window.Swiper;
1838	SwiperBC.isSwiperLoaded = true; // Once the SwiperSource has the Swiper lib function, we need to overwrite window.Swiper with the legacySwiper class.
1839
1840	legacySwiper();
1841	}
1842
1843	SwiperSource.prototype.adjustConfig = this.adjustConfig;
1844	return new SwiperSource(container, config);
1845	} // Backwards compatibility for Elementor Pro <2.9.0 (old Swiper version - <5.0.0)
1846	// In Swiper 5.0.0 and up, breakpoints changed from acting as max-width to acting as min-width
1847
1848
1849	adjustConfig(config) {
1850	// Only reverse the breakpoints if the handle param has been defined
1851	if (!config.handleElementorBreakpoints) {
1852	return config;
1853	}
1854
1855	const elementorBreakpoints = elementorFrontend.config.responsive.activeBreakpoints,
1856	elementorBreakpointValues = elementorFrontend.breakpoints.getBreakpointValues();
1857	Object.keys(config.breakpoints).forEach(configBPKey => {
1858	const configBPKeyInt = parseInt(configBPKey);
1859	let breakpointToUpdate; // The `configBPKeyInt + 1` is a BC Fix for Elementor Pro Carousels from 2.8.0-2.8.3 used with Elementor >= 2.9.0
1860
1861	if (configBPKeyInt === elementorBreakpoints.mobile.value \|\| configBPKeyInt + 1 === elementorBreakpoints.mobile.value) {
1862	// This handles the mobile breakpoint. Elementor's default sm breakpoint is never actually used,
1863	// so the mobile breakpoint (md) needs to be handled separately and set to the 0 breakpoint (xs)
1864	breakpointToUpdate = 0;
1865	} else if (elementorBreakpoints.widescreen && (configBPKeyInt === elementorBreakpoints.widescreen.value \|\| configBPKeyInt + 1 === elementorBreakpoints.widescreen.value)) {
1866	// Widescreen is a min-width breakpoint. Since in Swiper >5.0 the breakpoint system is min-width based,
1867	// the value we pass to the Swiper instance in this case is the breakpoint from the user, unchanged.
1868	breakpointToUpdate = configBPKeyInt;
1869	} else {
1870	// Find the index of the current config breakpoint in the Elementor Breakpoints array
1871	const currentBPIndexInElementorBPs = elementorBreakpointValues.findIndex(elementorBP => {
1872	// BC Fix for Elementor Pro Carousels from 2.8.0-2.8.3 used with Elementor >= 2.9.0
1873	return configBPKeyInt === elementorBP \|\| configBPKeyInt + 1 === elementorBP;
1874	}); // For all other Swiper config breakpoints, move them one breakpoint down on the breakpoint list,
1875	// according to the array of Elementor's global breakpoints
1876
1877	breakpointToUpdate = elementorBreakpointValues[currentBPIndexInElementorBPs - 1];
1878	}
1879
1880	config.breakpoints[breakpointToUpdate] = config.breakpoints[configBPKey]; // Then reset the settings in the original breakpoint key to the default values
1881
1882	config.breakpoints[configBPKey] = {
1883	slidesPerView: config.slidesPerView,
1884	slidesPerGroup: config.slidesPerGroup ? config.slidesPerGroup : 1
1885	};
1886	});
1887	return config;
1888	}
1889
1890	} // The following code is needed to support Pro version < 3.1.0.
1891
1892
1893	exports.default = SwiperBC;
1894	SwiperBC.isSwiperLoaded = false; // In the legacy behavior, window.Swiper was a class that returns an instance of the Swiper lib function after config adjustments.
1895
1896	function legacySwiper() {
1897	window.Swiper = class {
1898	constructor(container, config) {
1899	config.legacy = true;
1900	return new SwiperBC(container, config);
1901	}
1902
1903	};
1904	}
1905
1906	let SwiperSource = window.Swiper; // In case that the Swiper lib exists (meaning not in optimized mode) we overwrite the window.Swiper with a class that supports legacy behavior.
1907
1908	if (SwiperSource) {
1909	legacySwiper();
1910	}
1911
1912	/***/ }),
1913
1914	/***/ "../assets/dev/js/frontend/utils/url-actions.js":
1915	/!****************************************************!\
1916	!* ../assets/dev/js/frontend/utils/url-actions.js *!
1917	\******************************************************/
1918	/***/ ((__unused_webpack_module, exports) => {
1919
1920	"use strict";
1921
1922
1923	Object.defineProperty(exports, "__esModule", ({
1924	value: true
1925	}));
1926	exports.default = void 0;
1927
1928	class _default extends elementorModules.ViewModule {
1929	getDefaultSettings() {
1930	return {
1931	selectors: {
1932	links: 'a[href^="%23elementor-action"], a[href^="#elementor-action"]'
1933	}
1934	};
1935	}
1936
1937	bindEvents() {
1938	elementorFrontend.elements.$document.on('click', this.getSettings('selectors.links'), this.runLinkAction.bind(this));
1939	}
1940
1941	initActions() {
1942	this.actions = {
1943	lightbox: async settings => {
1944	const lightbox = await elementorFrontend.utils.lightbox;
1945
1946	if (settings.id) {
1947	lightbox.openSlideshow(settings.id, settings.url);
1948	} else {
1949	lightbox.showModal(settings);
1950	}
1951	}
1952	};
1953	}
1954
1955	addAction(name, callback) {
1956	this.actions[name] = callback;
1957	}
1958
1959	runAction(url, ...restArgs) {
1960	url = decodeURIComponent(url);
1961	const actionMatch = url.match(/action=(.+?)&/),
1962	settingsMatch = url.match(/settings=(.+)/);
1963
1964	if (!actionMatch) {
1965	return;
1966	}
1967
1968	const action = this.actions[actionMatch[1]];
1969
1970	if (!action) {
1971	return;
1972	}
1973
1974	let settings = {};
1975
1976	if (settingsMatch) {
1977	settings = JSON.parse(atob(settingsMatch[1]));
1978	}
1979
1980	action(settings, ...restArgs);
1981	}
1982
1983	runLinkAction(event) {
1984	event.preventDefault();
1985	this.runAction(jQuery(event.currentTarget).attr('href'), event);
1986	}
1987
1988	runHashAction() {
1989	if (location.hash) {
1990	this.runAction(location.hash);
1991	}
1992	}
1993
1994	createActionHash(action, settings) {
1995	// We need to encode the hash tag (#) here, in order to support share links for a variety of providers
1996	return encodeURIComponent(`#elementor-action:action=${action}&settings=${btoa(JSON.stringify(settings))}`);
1997	}
1998
1999	onInit() {
2000	super.onInit();
2001	this.initActions();
2002	elementorFrontend.on('components:init', this.runHashAction.bind(this));
2003	}
2004
2005	}
2006
2007	exports.default = _default;
2008
2009	/***/ }),
2010
2011	/***/ "../assets/dev/js/frontend/utils/utils.js":
2012	/!**********************************************!\
2013	!* ../assets/dev/js/frontend/utils/utils.js *!
2014	\************************************************/
2015	/***/ ((__unused_webpack_module, exports) => {
2016
2017	"use strict";
2018
2019
2020	Object.defineProperty(exports, "__esModule", ({
2021	value: true
2022	}));
2023	exports.escapeHTML = void 0;
2024
2025	// Escape HTML special chars to prevent XSS.
2026	const escapeHTML = str => {
2027	const specialChars = {
2028	'&': '&',
2029	'<': '<',
2030	'>': '>',
2031	"'": ''',
2032	'"': '"'
2033	};
2034	return str.replace(/[&<>'"]/g, tag => specialChars[tag] \|\| tag);
2035	};
2036
2037	exports.escapeHTML = escapeHTML;
2038
2039	/***/ }),
2040
2041	/***/ "../assets/dev/js/frontend/utils/video-api/base-loader.js":
2042	/!**************************************************************!\
2043	!* ../assets/dev/js/frontend/utils/video-api/base-loader.js *!
2044	\****************************************************************/
2045	/***/ ((__unused_webpack_module, exports) => {
2046
2047	"use strict";
2048
2049
2050	Object.defineProperty(exports, "__esModule", ({
2051	value: true
2052	}));
2053	exports.default = void 0;
2054
2055	class BaseLoader extends elementorModules.ViewModule {
2056	getDefaultSettings() {
2057	return {
2058	isInserted: false,
2059	selectors: {
2060	firstScript: 'script:first'
2061	}
2062	};
2063	}
2064
2065	getDefaultElements() {
2066	return {
2067	$firstScript: jQuery(this.getSettings('selectors.firstScript'))
2068	};
2069	}
2070
2071	insertAPI() {
2072	this.elements.$firstScript.before(jQuery('<script>', {
2073	src: this.getApiURL()
2074	}));
2075	this.setSettings('isInserted', true);
2076	}
2077
2078	getVideoIDFromURL(url) {
2079	const videoIDParts = url.match(this.getURLRegex());
2080	return videoIDParts && videoIDParts[1];
2081	}
2082
2083	onApiReady(callback) {
2084	if (!this.getSettings('isInserted')) {
2085	this.insertAPI();
2086	}
2087
2088	if (this.isApiLoaded()) {
2089	callback(this.getApiObject());
2090	} else {
2091	// If not ready check again by timeout..
2092	setTimeout(() => {
2093	this.onApiReady(callback);
2094	}, 350);
2095	}
2096	}
2097
2098	getAutoplayURL(videoURL) {
2099	return videoURL.replace('&autoplay=0', '') + '&autoplay=1';
2100	}
2101
2102	}
2103
2104	exports.default = BaseLoader;
2105
2106	/***/ }),
2107
2108	/***/ "../assets/dev/js/frontend/utils/video-api/vimeo-loader.js":
2109	/!***************************************************************!\
2110	!* ../assets/dev/js/frontend/utils/video-api/vimeo-loader.js *!
2111	\*****************************************************************/
2112	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
2113
2114	"use strict";
2115
2116
2117	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
2118
2119	Object.defineProperty(exports, "__esModule", ({
2120	value: true
2121	}));
2122	exports.default = void 0;
2123
2124	var _baseLoader = _interopRequireDefault(__webpack_require__(/! ./base-loader / "../assets/dev/js/frontend/utils/video-api/base-loader.js"));
2125
2126	class VimeoLoader extends _baseLoader.default {
2127	getApiURL() {
2128	return 'https://player.vimeo.com/api/player.js';
2129	}
2130
2131	getURLRegex() {
2132	return /^(?:https?:\/\/)?(?:www\|player\.)?(?:vimeo\.com\/)?(?:video\/\|external\/)?(\d+)([^.?&#"'>]?)/;
2133	}
2134
2135	isApiLoaded() {
2136	return window.Vimeo;
2137	}
2138
2139	getApiObject() {
2140	return Vimeo;
2141	}
2142
2143	getAutoplayURL(videoURL) {
2144	videoURL = super.getAutoplayURL(videoURL); // Vimeo requires the '#t=' param to be last in the URL.
2145
2146	const timeMatch = videoURL.match(/#t=[^&]*/);
2147	return videoURL.replace(timeMatch[0], '') + timeMatch;
2148	}
2149
2150	}
2151
2152	exports.default = VimeoLoader;
2153
2154	/***/ }),
2155
2156	/***/ "../assets/dev/js/frontend/utils/video-api/youtube-loader.js":
2157	/!*****************************************************************!\
2158	!* ../assets/dev/js/frontend/utils/video-api/youtube-loader.js *!
2159	\*******************************************************************/
2160	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
2161
2162	"use strict";
2163
2164
2165	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
2166
2167	Object.defineProperty(exports, "__esModule", ({
2168	value: true
2169	}));
2170	exports.default = void 0;
2171
2172	var _baseLoader = _interopRequireDefault(__webpack_require__(/! ./base-loader / "../assets/dev/js/frontend/utils/video-api/base-loader.js"));
2173
2174	class YoutubeLoader extends _baseLoader.default {
2175	getApiURL() {
2176	return 'https://www.youtube.com/iframe_api';
2177	}
2178
2179	getURLRegex() {
2180	return /^(?:https?:\/\/)?(?:www\.)?(?:m\.)?(?:youtu\.be\/\|youtube\.com\/(?:(?:watch)?\?(?:.*&)?vi?=\|(?:embed\|v\|vi\|user)\/))([^?&"'>]+)/;
2181	}
2182
2183	isApiLoaded() {
2184	return window.YT && YT.loaded;
2185	}
2186
2187	getApiObject() {
2188	return YT;
2189	}
2190
2191	}
2192
2193	exports.default = YoutubeLoader;
2194
2195	/***/ }),
2196
2197	/***/ "../assets/dev/js/public-path.js":
2198	/!*************************************!\
2199	!* ../assets/dev/js/public-path.js *!
2200	\***************************************/
2201	/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
2202
2203	"use strict";
2204
2205
2206	/* eslint-disable camelcase */
2207	__webpack_require__.p = elementorFrontendConfig.urls.assets + 'js/';
2208
2209	/***/ }),
2210
2211	/***/ "../assets/dev/js/utils/breakpoints.js":
2212	/!*******************************************!\
2213	!* ../assets/dev/js/utils/breakpoints.js *!
2214	\*********************************************/
2215	/***/ ((__unused_webpack_module, exports) => {
2216
2217	"use strict";
2218
2219
2220	Object.defineProperty(exports, "__esModule", ({
2221	value: true
2222	}));
2223	exports.default = void 0;
2224
2225	/**
2226	* Breakpoints
2227	*
2228	* This utility class contains helper functions relating to Elementor's breakpoints system.
2229	*
2230	* @since 3.4.0
2231	*/
2232	class Breakpoints extends elementorModules.Module {
2233	constructor(responsiveConfig) {
2234	super(); // The passed config is either `elementor.config.responsive` or `elementorFrontend.config.responsive`
2235
2236	this.responsiveConfig = responsiveConfig;
2237	}
2238	/**
2239	* Get Active Breakpoints List
2240	*
2241	* Returns a flat array containing the active breakpoints/devices. By default, it returns the li
2242	* the list ordered from smallest to largest breakpoint. If `true` is passed as a parameter, it reverses the order.
2243	*
2244	* @since 3.4.0
2245	*
2246	* @param {Object} args
2247	*/
2248
2249
2250	getActiveBreakpointsList(args = {}) {
2251	const defaultArgs = {
2252	largeToSmall: false,
2253	withDesktop: false
2254	};
2255	args = { ...defaultArgs,
2256	...args
2257	};
2258	const breakpointKeys = Object.keys(this.responsiveConfig.activeBreakpoints);
2259
2260	if (args.withDesktop) {
2261	// If there is an active 'widescreen' breakpoint, insert the artificial 'desktop' device below it.
2262	const widescreenIndex = breakpointKeys.indexOf('widescreen'),
2263	indexToInsertDesktopDevice = -1 === widescreenIndex ? breakpointKeys.length : breakpointKeys.length - 1;
2264	breakpointKeys.splice(indexToInsertDesktopDevice, 0, 'desktop');
2265	}
2266
2267	if (args.largeToSmall) {
2268	breakpointKeys.reverse();
2269	}
2270
2271	return breakpointKeys;
2272	}
2273	/**
2274	* Get Active Breakpoint Values
2275	*
2276	* Returns a flat array containing the list of active breakpoint values, from smallest to largest.
2277	*
2278	* @since 3.4.0
2279	*/
2280
2281
2282	getBreakpointValues() {
2283	const {
2284	activeBreakpoints
2285	} = this.responsiveConfig,
2286	breakpointValues = [];
2287	Object.values(activeBreakpoints).forEach(breakpointConfig => {
2288	breakpointValues.push(breakpointConfig.value);
2289	});
2290	return breakpointValues;
2291	}
2292	/**
2293	* Get Desktop Previous Device Key
2294	*
2295	* Returns the key of the device directly under desktop (can be 'tablet', 'tablet_extra', 'laptop').
2296	*
2297	* @since 3.4.0
2298	*
2299	* @returns {string}
2300	*/
2301
2302
2303	getDesktopPreviousDeviceKey() {
2304	let desktopPreviousDevice = '';
2305	const {
2306	activeBreakpoints
2307	} = this.responsiveConfig,
2308	breakpointKeys = Object.keys(activeBreakpoints),
2309	numOfDevices = breakpointKeys.length;
2310
2311	if ('min' === activeBreakpoints[breakpointKeys[numOfDevices - 1]].direction) {
2312	// If the widescreen breakpoint is active, the device that's previous to desktop is the last one before
2313	// widescreen.
2314	desktopPreviousDevice = breakpointKeys[numOfDevices - 2];
2315	} else {
2316	// If the widescreen breakpoint isn't active, we just take the last device returned by the config.
2317	desktopPreviousDevice = breakpointKeys[numOfDevices - 1];
2318	}
2319
2320	return desktopPreviousDevice;
2321	}
2322	/**
2323	* Get Device Minimum Breakpoint
2324	*
2325	* Returns the minimum point in the device's display range. For each device, the minimum point of its display range
2326	* is the max point of the device below it + 1px. For example, if the active devices are mobile, tablet,
2327	* and desktop, and the mobile breakpoint is 767px, the minimum display point for tablet devices is 768px.
2328	*
2329	* @since 3.4.0
2330	*
2331	* @returns {number\|*}
2332	*/
2333
2334
2335	getDesktopMinPoint() {
2336	const {
2337	activeBreakpoints
2338	} = this.responsiveConfig,
2339	desktopPreviousDevice = this.getDesktopPreviousDeviceKey();
2340	return activeBreakpoints[desktopPreviousDevice].value + 1;
2341	}
2342	/**
2343	* Get Device Minimum Breakpoint
2344	*
2345	* Returns the minimum point in the device's display range. For each device, the minimum point of its display range
2346	* is the max point of the device below it + 1px. For example, if the active devices are mobile, tablet,
2347	* and desktop, and the mobile breakpoint is 767px, the minimum display point for tablet devices is 768px.
2348	*
2349	* @since 3.4.0
2350	*
2351	* @param device
2352	* @returns {number\|*}
2353	*/
2354
2355
2356	getDeviceMinBreakpoint(device) {
2357	if ('desktop' === device) {
2358	return this.getDesktopMinPoint();
2359	}
2360
2361	const {
2362	activeBreakpoints
2363	} = this.responsiveConfig,
2364	breakpointNames = Object.keys(activeBreakpoints);
2365	let minBreakpoint;
2366
2367	if (breakpointNames[0] === device) {
2368	// For the lowest breakpoint, the min point is always 320.
2369	minBreakpoint = 320;
2370	} else if ('widescreen' === device) {
2371	// Widescreen only has a minimum point. In this case, the breakpoint
2372	// value in the Breakpoints config is itself the device min point.
2373	if (activeBreakpoints[device]) {
2374	minBreakpoint = activeBreakpoints[device].value;
2375	} else {
2376	// If the widescreen breakpoint does not exist in the active breakpoints config (for example, in the
2377	// case this method runs as the breakpoint is being added), get the value from the full config.
2378	minBreakpoint = this.responsiveConfig.breakpoints.widescreen;
2379	}
2380	} else {
2381	const deviceNameIndex = breakpointNames.indexOf(device),
2382	previousIndex = deviceNameIndex - 1;
2383	minBreakpoint = activeBreakpoints[breakpointNames[previousIndex]].value + 1;
2384	}
2385
2386	return minBreakpoint;
2387	}
2388	/**
2389	* Get Active Match Regex
2390	*
2391	* Returns a regular expression containing all active breakpoints prefixed with an underscore.
2392	*
2393	* @returns {RegExp}
2394	*/
2395
2396
2397	getActiveMatchRegex() {
2398	return new RegExp(this.getActiveBreakpointsList().map(device => '_' + device).join('\|') + '$');
2399	}
2400
2401	}
2402
2403	exports.default = Breakpoints;
2404
2405	/***/ }),
2406
2407	/***/ "../assets/dev/js/utils/hooks.js":
2408	/!*************************************!\
2409	!* ../assets/dev/js/utils/hooks.js *!
2410	\***************************************/
2411	/***/ ((module) => {
2412
2413	"use strict";
2414
2415	/**
2416	* Handles managing all events for whatever you plug it into. Priorities for hooks are based on lowest to highest in
2417	* that, lowest priority hooks are fired first.
2418	*/
2419
2420	var EventManager = function () {
2421	var slice = Array.prototype.slice,
2422	MethodsAvailable;
2423	/**
2424	* Contains the hooks that get registered with this EventManager. The array for storage utilizes a "flat"
2425	* object literal such that looking up the hook utilizes the native object literal hash.
2426	*/
2427
2428	var STORAGE = {
2429	actions: {},
2430	filters: {}
2431	};
2432	/**
2433	* Removes the specified hook by resetting the value of it.
2434	*
2435	* @param type Type of hook, either 'actions' or 'filters'
2436	* @param hook The hook (namespace.identifier) to remove
2437	*
2438	* @private
2439	*/
2440
2441	function _removeHook(type, hook, callback, context) {
2442	var handlers, handler, i;
2443
2444	if (!STORAGE[type][hook]) {
2445	return;
2446	}
2447
2448	if (!callback) {
2449	STORAGE[type][hook] = [];
2450	} else {
2451	handlers = STORAGE[type][hook];
2452
2453	if (!context) {
2454	for (i = handlers.length; i--;) {
2455	if (handlers[i].callback === callback) {
2456	handlers.splice(i, 1);
2457	}
2458	}
2459	} else {
2460	for (i = handlers.length; i--;) {
2461	handler = handlers[i];
2462
2463	if (handler.callback === callback && handler.context === context) {
2464	handlers.splice(i, 1);
2465	}
2466	}
2467	}
2468	}
2469	}
2470	/**
2471	* Use an insert sort for keeping our hooks organized based on priority. This function is ridiculously faster
2472	* than bubble sort, etc: http://jsperf.com/javascript-sort
2473	*
2474	* @param hooks The custom array containing all of the appropriate hooks to perform an insert sort on.
2475	* @private
2476	*/
2477
2478
2479	function _hookInsertSort(hooks) {
2480	var tmpHook, j, prevHook;
2481
2482	for (var i = 1, len = hooks.length; i < len; i++) {
2483	tmpHook = hooks[i];
2484	j = i;
2485
2486	while ((prevHook = hooks[j - 1]) && prevHook.priority > tmpHook.priority) {
2487	hooks[j] = hooks[j - 1];
2488	--j;
2489	}
2490
2491	hooks[j] = tmpHook;
2492	}
2493
2494	return hooks;
2495	}
2496	/**
2497	* Adds the hook to the appropriate storage container
2498	*
2499	* @param type 'actions' or 'filters'
2500	* @param hook The hook (namespace.identifier) to add to our event manager
2501	* @param callback The function that will be called when the hook is executed.
2502	* @param priority The priority of this hook. Must be an integer.
2503	* @param [context] A value to be used for this
2504	* @private
2505	*/
2506
2507
2508	function _addHook(type, hook, callback, priority, context) {
2509	var hookObject = {
2510	callback: callback,
2511	priority: priority,
2512	context: context
2513	}; // Utilize 'prop itself' : http://jsperf.com/hasownproperty-vs-in-vs-undefined/19
2514
2515	var hooks = STORAGE[type][hook];
2516
2517	if (hooks) {
2518	// TEMP FIX BUG
2519	var hasSameCallback = false;
2520	jQuery.each(hooks, function () {
2521	if (this.callback === callback) {
2522	hasSameCallback = true;
2523	return false;
2524	}
2525	});
2526
2527	if (hasSameCallback) {
2528	return;
2529	} // END TEMP FIX BUG
2530
2531
2532	hooks.push(hookObject);
2533	hooks = _hookInsertSort(hooks);
2534	} else {
2535	hooks = [hookObject];
2536	}
2537
2538	STORAGE[type][hook] = hooks;
2539	}
2540	/**
2541	* Runs the specified hook. If it is an action, the value is not modified but if it is a filter, it is.
2542	*
2543	* @param type 'actions' or 'filters'
2544	* @param hook The hook ( namespace.identifier ) to be ran.
2545	* @param args Arguments to pass to the action/filter. If it's a filter, args is actually a single parameter.
2546	* @private
2547	*/
2548
2549
2550	function _runHook(type, hook, args) {
2551	var handlers = STORAGE[type][hook],
2552	i,
2553	len;
2554
2555	if (!handlers) {
2556	return 'filters' === type ? args[0] : false;
2557	}
2558
2559	len = handlers.length;
2560
2561	if ('filters' === type) {
2562	for (i = 0; i < len; i++) {
2563	args[0] = handlers[i].callback.apply(handlers[i].context, args);
2564	}
2565	} else {
2566	for (i = 0; i < len; i++) {
2567	handlers[i].callback.apply(handlers[i].context, args);
2568	}
2569	}
2570
2571	return 'filters' === type ? args[0] : true;
2572	}
2573	/**
2574	* Adds an action to the event manager.
2575	*
2576	* @param action Must contain namespace.identifier
2577	* @param callback Must be a valid callback function before this action is added
2578	* @param [priority=10] Used to control when the function is executed in relation to other callbacks bound to the same hook
2579	* @param [context] Supply a value to be used for this
2580	*/
2581
2582
2583	function addAction(action, callback, priority, context) {
2584	if ('string' === typeof action && 'function' === typeof callback) {
2585	priority = parseInt(priority \|\| 10, 10);
2586
2587	_addHook('actions', action, callback, priority, context);
2588	}
2589
2590	return MethodsAvailable;
2591	}
2592	/**
2593	* Performs an action if it exists. You can pass as many arguments as you want to this function; the only rule is
2594	* that the first argument must always be the action.
2595	*/
2596
2597
2598	function doAction() {
2599	var args = slice.call(arguments);
2600	var action = args.shift();
2601
2602	if ('string' === typeof action) {
2603	_runHook('actions', action, args);
2604	}
2605
2606	return MethodsAvailable;
2607	}
2608	/**
2609	* Removes the specified action if it contains a namespace.identifier & exists.
2610	*
2611	* @param action The action to remove
2612	* @param [callback] Callback function to remove
2613	*/
2614
2615
2616	function removeAction(action, callback) {
2617	if ('string' === typeof action) {
2618	_removeHook('actions', action, callback);
2619	}
2620
2621	return MethodsAvailable;
2622	}
2623	/**
2624	* Adds a filter to the event manager.
2625	*
2626	* @param filter Must contain namespace.identifier
2627	* @param callback Must be a valid callback function before this action is added
2628	* @param [priority=10] Used to control when the function is executed in relation to other callbacks bound to the same hook
2629	* @param [context] Supply a value to be used for this
2630	*/
2631
2632
2633	function addFilter(filter, callback, priority, context) {
2634	if ('string' === typeof filter && 'function' === typeof callback) {
2635	priority = parseInt(priority \|\| 10, 10);
2636
2637	_addHook('filters', filter, callback, priority, context);
2638	}
2639
2640	return MethodsAvailable;
2641	}
2642	/**
2643	* Performs a filter if it exists. You should only ever pass 1 argument to be filtered. The only rule is that
2644	* the first argument must always be the filter.
2645	*/
2646
2647
2648	function applyFilters() {
2649	var args = slice.call(arguments);
2650	var filter = args.shift();
2651
2652	if ('string' === typeof filter) {
2653	return _runHook('filters', filter, args);
2654	}
2655
2656	return MethodsAvailable;
2657	}
2658	/**
2659	* Removes the specified filter if it contains a namespace.identifier & exists.
2660	*
2661	* @param filter The action to remove
2662	* @param [callback] Callback function to remove
2663	*/
2664
2665
2666	function removeFilter(filter, callback) {
2667	if ('string' === typeof filter) {
2668	_removeHook('filters', filter, callback);
2669	}
2670
2671	return MethodsAvailable;
2672	}
2673	/**
2674	* Maintain a reference to the object scope so our public methods never get confusing.
2675	*/
2676
2677
2678	MethodsAvailable = {
2679	removeFilter: removeFilter,
2680	applyFilters: applyFilters,
2681	addFilter: addFilter,
2682	removeAction: removeAction,
2683	doAction: doAction,
2684	addAction: addAction
2685	}; // return all of the publicly available methods
2686
2687	return MethodsAvailable;
2688	};
2689
2690	module.exports = EventManager;
2691
2692	/***/ }),
2693
2694	/***/ "../core/common/assets/js/utils/environment.js":
2695	/!***************************************************!\
2696	!* ../core/common/assets/js/utils/environment.js *!
2697	\*****************************************************/
2698	/***/ ((__unused_webpack_module, exports) => {
2699
2700	"use strict";
2701
2702
2703	Object.defineProperty(exports, "__esModule", ({
2704	value: true
2705	}));
2706	exports.default = void 0;
2707
2708	const matchUserAgent = UserAgentStr => {
2709	return userAgent.indexOf(UserAgentStr) >= 0;
2710	},
2711	userAgent = navigator.userAgent,
2712	// Solution influenced by https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
2713	// Opera 8.0+
2714	isOpera = !!window.opr && !!opr.addons \|\| !!window.opera \|\| matchUserAgent(' OPR/'),
2715	// Firefox 1.0+
2716	isFirefox = matchUserAgent('Firefox'),
2717	// Safari 3.0+ "[object HTMLElementConstructor]"
2718	isSafari = /^((?!chrome\|android).)*safari/i.test(userAgent) \|\| /constructor/i.test(window.HTMLElement) \|\| (p => {
2719	return '[object SafariRemoteNotification]' === p.toString();
2720	})(!window.safari \|\| typeof safari !== 'undefined' && safari.pushNotification),
2721	// Internet Explorer 6-11
2722	isIE = /Trident\|MSIE/.test(userAgent) && (
2723	/@cc_on!@/
2724	false \|\| !!document.documentMode),
2725	// Edge 20+
2726	isEdge = !isIE && !!window.StyleMedia \|\| matchUserAgent('Edg'),
2727	// Google Chrome (Not accurate)
2728	isChrome = !!window.chrome && matchUserAgent('Chrome') && !(isEdge \|\| isOpera),
2729	// Blink engine
2730	isBlink = matchUserAgent('Chrome') && !!window.CSS,
2731	// Apple Webkit engine
2732	isAppleWebkit = matchUserAgent('AppleWebKit') && !isBlink,
2733	environment = {
2734	appleWebkit: isAppleWebkit,
2735	blink: isBlink,
2736	chrome: isChrome,
2737	edge: isEdge,
2738	firefox: isFirefox,
2739	ie: isIE,
2740	mac: matchUserAgent('Macintosh'),
2741	opera: isOpera,
2742	safari: isSafari,
2743	webkit: matchUserAgent('AppleWebKit')
2744	};
2745
2746	var _default = environment;
2747	exports.default = _default;
2748
2749	/***/ }),
2750
2751	/***/ "../core/common/assets/js/utils/storage.js":
2752	/!***********************************************!\
2753	!* ../core/common/assets/js/utils/storage.js *!
2754	\*************************************************/
2755	/***/ ((__unused_webpack_module, exports) => {
2756
2757	"use strict";
2758
2759
2760	Object.defineProperty(exports, "__esModule", ({
2761	value: true
2762	}));
2763	exports.default = void 0;
2764
2765	class _default extends elementorModules.Module {
2766	get(key, options) {
2767	options = options \|\| {};
2768	let storage;
2769
2770	try {
2771	storage = options.session ? sessionStorage : localStorage;
2772	} catch (e) {
2773	return key ? undefined : {};
2774	}
2775
2776	let elementorStorage = storage.getItem('elementor');
2777
2778	if (elementorStorage) {
2779	elementorStorage = JSON.parse(elementorStorage);
2780	} else {
2781	elementorStorage = {};
2782	}
2783
2784	if (!elementorStorage.__expiration) {
2785	elementorStorage.__expiration = {};
2786	}
2787
2788	const expiration = elementorStorage.__expiration;
2789	let expirationToCheck = [];
2790
2791	if (key) {
2792	if (expiration[key]) {
2793	expirationToCheck = [key];
2794	}
2795	} else {
2796	expirationToCheck = Object.keys(expiration);
2797	}
2798
2799	let entryExpired = false;
2800	expirationToCheck.forEach(expirationKey => {
2801	if (new Date(expiration[expirationKey]) < new Date()) {
2802	delete elementorStorage[expirationKey];
2803	delete expiration[expirationKey];
2804	entryExpired = true;
2805	}
2806	});
2807
2808	if (entryExpired) {
2809	this.save(elementorStorage, options.session);
2810	}
2811
2812	if (key) {
2813	return elementorStorage[key];
2814	}
2815
2816	return elementorStorage;
2817	}
2818
2819	set(key, value, options) {
2820	options = options \|\| {};
2821	const elementorStorage = this.get(null, options);
2822	elementorStorage[key] = value;
2823
2824	if (options.lifetimeInSeconds) {
2825	const date = new Date();
2826	date.setTime(date.getTime() + options.lifetimeInSeconds * 1000);
2827	elementorStorage.__expiration[key] = date.getTime();
2828	}
2829
2830	this.save(elementorStorage, options.session);
2831	}
2832
2833	save(object, session) {
2834	let storage;
2835
2836	try {
2837	storage = session ? sessionStorage : localStorage;
2838	} catch (e) {
2839	return;
2840	}
2841
2842	storage.setItem('elementor', JSON.stringify(object));
2843	}
2844
2845	}
2846
2847	exports.default = _default;
2848
2849	/***/ }),
2850
2851	/***/ "../modules/shapes/assets/js/frontend/frontend.js":
2852	/!******************************************************!\
2853	!* ../modules/shapes/assets/js/frontend/frontend.js *!
2854	\********************************************************/
2855	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
2856
2857	"use strict";
2858
2859
2860	Object.defineProperty(exports, "__esModule", ({
2861	value: true
2862	}));
2863	exports.default = void 0;
2864
2865	class _default extends elementorModules.Module {
2866	constructor() {
2867	super();
2868	elementorFrontend.elementsHandler.attachHandler('text-path', () => __webpack_require__.e(/! import() \| text-path / "text-path").then(__webpack_require__.bind(__webpack_require__, /! ./handlers/text-path / "../modules/shapes/assets/js/frontend/handlers/text-path.js")));
2869	}
2870
2871	}
2872
2873	exports.default = _default;
2874
2875	/***/ })
2876
2877	},
2878	/******/ __webpack_require__ => { // webpackRuntimeModules
2879	/******/ "use strict";
2880	/******/
2881	/******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
2882	/******/ __webpack_require__.O(0, ["frontend-modules"], () => (__webpack_exec__("../assets/dev/js/frontend/frontend.js")));
2883	/******/ var __webpack_exports__ = __webpack_require__.O();
2884	/******/ }
2885	]);
2886	//# sourceMappingURL=frontend.js.map