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

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

elementor / assets / js / frontend.js

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

2,858 lines 84.9 KB

Raw Download Zip

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