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

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

elementor / assets / js / frontend-modules.js

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

1,201 lines 34.0 KB

Raw Download Zip

1	/! elementor - v3.4.3 - 30-08-2021 /
2	(self["webpackChunkelementor"] = self["webpackChunkelementor"] \|\| []).push([["frontend-modules"],{
3
4	/***/ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js":
5	/!*********************************************************************!\
6	!* ../node_modules/@babel/runtime/helpers/interopRequireDefault.js *!
7	\***********************************************************************/
8	/***/ ((module) => {
9
10	function _interopRequireDefault(obj) {
11	return obj && obj.__esModule ? obj : {
12	"default": obj
13	};
14	}
15
16	module.exports = _interopRequireDefault;
17	module.exports.default = module.exports, module.exports.__esModule = true;
18
19	/***/ }),
20
21	/***/ "../assets/dev/js/frontend/document.js":
22	/!*******************************************!\
23	!* ../assets/dev/js/frontend/document.js *!
24	\*********************************************/
25	/***/ ((__unused_webpack_module, exports) => {
26
27	"use strict";
28
29
30	Object.defineProperty(exports, "__esModule", ({
31	value: true
32	}));
33	exports.default = void 0;
34
35	class _default extends elementorModules.ViewModule {
36	getDefaultSettings() {
37	return {
38	selectors: {
39	elements: '.elementor-element',
40	nestedDocumentElements: '.elementor .elementor-element'
41	},
42	classes: {
43	editMode: 'elementor-edit-mode'
44	}
45	};
46	}
47
48	getDefaultElements() {
49	const selectors = this.getSettings('selectors');
50	return {
51	$elements: this.$element.find(selectors.elements).not(this.$element.find(selectors.nestedDocumentElements))
52	};
53	}
54
55	getDocumentSettings(setting) {
56	let elementSettings;
57
58	if (this.isEdit) {
59	elementSettings = {};
60	const settings = elementor.settings.page.model;
61	jQuery.each(settings.getActiveControls(), controlKey => {
62	elementSettings[controlKey] = settings.attributes[controlKey];
63	});
64	} else {
65	elementSettings = this.$element.data('elementor-settings') \|\| {};
66	}
67
68	return this.getItems(elementSettings, setting);
69	}
70
71	runElementsHandlers() {
72	this.elements.$elements.each((index, element) => elementorFrontend.elementsHandler.runReadyTrigger(element));
73	}
74
75	onInit() {
76	this.$element = this.getSettings('$element');
77	super.onInit();
78	this.isEdit = this.$element.hasClass(this.getSettings('classes.editMode'));
79
80	if (this.isEdit) {
81	elementor.on('document:loaded', () => {
82	elementor.settings.page.model.on('change', this.onSettingsChange.bind(this));
83	});
84	} else {
85	this.runElementsHandlers();
86	}
87	}
88
89	onSettingsChange() {}
90
91	}
92
93	exports.default = _default;
94
95	/***/ }),
96
97	/***/ "../assets/dev/js/frontend/handlers/base-swiper.js":
98	/!*******************************************************!\
99	!* ../assets/dev/js/frontend/handlers/base-swiper.js *!
100	\*********************************************************/
101	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
102
103	"use strict";
104
105
106	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
107
108	Object.defineProperty(exports, "__esModule", ({
109	value: true
110	}));
111	exports.default = void 0;
112
113	var _base = _interopRequireDefault(__webpack_require__(/! ./base / "../assets/dev/js/frontend/handlers/base.js"));
114
115	class SwiperHandlerBase extends _base.default {
116	getInitialSlide() {
117	const editSettings = this.getEditSettings();
118	return editSettings.activeItemIndex ? editSettings.activeItemIndex - 1 : 0;
119	}
120
121	getSlidesCount() {
122	return this.elements.$slides.length;
123	} // This method live-handles the 'Pause On Hover' control's value being changed in the Editor Panel
124
125
126	togglePauseOnHover(toggleOn) {
127	if (toggleOn) {
128	this.elements.$swiperContainer.on({
129	mouseenter: () => {
130	this.swiper.autoplay.stop();
131	},
132	mouseleave: () => {
133	this.swiper.autoplay.start();
134	}
135	});
136	} else {
137	this.elements.$swiperContainer.off('mouseenter mouseleave');
138	}
139	}
140
141	handleKenBurns() {
142	const settings = this.getSettings();
143
144	if (this.$activeImageBg) {
145	this.$activeImageBg.removeClass(settings.classes.kenBurnsActive);
146	}
147
148	this.activeItemIndex = this.swiper ? this.swiper.activeIndex : this.getInitialSlide();
149
150	if (this.swiper) {
151	this.$activeImageBg = jQuery(this.swiper.slides[this.activeItemIndex]).children('.' + settings.classes.slideBackground);
152	} else {
153	this.$activeImageBg = jQuery(this.elements.$slides[0]).children('.' + settings.classes.slideBackground);
154	}
155
156	this.$activeImageBg.addClass(settings.classes.kenBurnsActive);
157	}
158
159	}
160
161	exports.default = SwiperHandlerBase;
162
163	/***/ }),
164
165	/***/ "../assets/dev/js/frontend/handlers/base.js":
166	/!************************************************!\
167	!* ../assets/dev/js/frontend/handlers/base.js *!
168	\**************************************************/
169	/***/ ((module) => {
170
171	"use strict";
172
173
174	module.exports = elementorModules.ViewModule.extend({
175	$element: null,
176	editorListeners: null,
177	onElementChange: null,
178	onEditSettingsChange: null,
179	onPageSettingsChange: null,
180	isEdit: null,
181	__construct: function (settings) {
182	if (!this.isActive(settings)) {
183	return;
184	}
185
186	this.$element = settings.$element;
187	this.isEdit = this.$element.hasClass('elementor-element-edit-mode');
188
189	if (this.isEdit) {
190	this.addEditorListeners();
191	}
192	},
193	isActive: function () {
194	return true;
195	},
196	findElement: function (selector) {
197	var $mainElement = this.$element;
198	return $mainElement.find(selector).filter(function () {
199	return jQuery(this).closest('.elementor-element').is($mainElement);
200	});
201	},
202	getUniqueHandlerID: function (cid, $element) {
203	if (!cid) {
204	cid = this.getModelCID();
205	}
206
207	if (!$element) {
208	$element = this.$element;
209	}
210
211	return cid + $element.attr('data-element_type') + this.getConstructorID();
212	},
213	initEditorListeners: function () {
214	var self = this;
215	self.editorListeners = [{
216	event: 'element:destroy',
217	to: elementor.channels.data,
218	callback: function (removedModel) {
219	if (removedModel.cid !== self.getModelCID()) {
220	return;
221	}
222
223	self.onDestroy();
224	}
225	}];
226
227	if (self.onElementChange) {
228	const elementType = self.getWidgetType() \|\| self.getElementType();
229	let eventName = 'change';
230
231	if ('global' !== elementType) {
232	eventName += ':' + elementType;
233	}
234
235	self.editorListeners.push({
236	event: eventName,
237	to: elementor.channels.editor,
238	callback: function (controlView, elementView) {
239	var elementViewHandlerID = self.getUniqueHandlerID(elementView.model.cid, elementView.$el);
240
241	if (elementViewHandlerID !== self.getUniqueHandlerID()) {
242	return;
243	}
244
245	self.onElementChange(controlView.model.get('name'), controlView, elementView);
246	}
247	});
248	}
249
250	if (self.onEditSettingsChange) {
251	self.editorListeners.push({
252	event: 'change:editSettings',
253	to: elementor.channels.editor,
254	callback: function (changedModel, view) {
255	if (view.model.cid !== self.getModelCID()) {
256	return;
257	}
258
259	self.onEditSettingsChange(Object.keys(changedModel.changed)[0]);
260	}
261	});
262	}
263
264	['page'].forEach(function (settingsType) {
265	var listenerMethodName = 'on' + settingsType[0].toUpperCase() + settingsType.slice(1) + 'SettingsChange';
266
267	if (self[listenerMethodName]) {
268	self.editorListeners.push({
269	event: 'change',
270	to: elementor.settings[settingsType].model,
271	callback: function (model) {
272	self[listenerMethodName](model.changed);
273	}
274	});
275	}
276	});
277	},
278	getEditorListeners: function () {
279	if (!this.editorListeners) {
280	this.initEditorListeners();
281	}
282
283	return this.editorListeners;
284	},
285	addEditorListeners: function () {
286	var uniqueHandlerID = this.getUniqueHandlerID();
287	this.getEditorListeners().forEach(function (listener) {
288	elementorFrontend.addListenerOnce(uniqueHandlerID, listener.event, listener.callback, listener.to);
289	});
290	},
291	removeEditorListeners: function () {
292	var uniqueHandlerID = this.getUniqueHandlerID();
293	this.getEditorListeners().forEach(function (listener) {
294	elementorFrontend.removeListeners(uniqueHandlerID, listener.event, null, listener.to);
295	});
296	},
297	getElementType: function () {
298	return this.$element.data('element_type');
299	},
300	getWidgetType: function () {
301	const widgetType = this.$element.data('widget_type');
302
303	if (!widgetType) {
304	return;
305	}
306
307	return widgetType.split('.')[0];
308	},
309	getID: function () {
310	return this.$element.data('id');
311	},
312	getModelCID: function () {
313	return this.$element.data('model-cid');
314	},
315	getElementSettings: function (setting) {
316	let elementSettings = {};
317	const modelCID = this.getModelCID();
318
319	if (this.isEdit && modelCID) {
320	const settings = elementorFrontend.config.elements.data[modelCID],
321	attributes = settings.attributes;
322	let type = attributes.widgetType \|\| attributes.elType;
323
324	if (attributes.isInner) {
325	type = 'inner-' + type;
326	}
327
328	let settingsKeys = elementorFrontend.config.elements.keys[type];
329
330	if (!settingsKeys) {
331	settingsKeys = elementorFrontend.config.elements.keys[type] = [];
332	jQuery.each(settings.controls, (name, control) => {
333	if (control.frontend_available) {
334	settingsKeys.push(name);
335	}
336	});
337	}
338
339	jQuery.each(settings.getActiveControls(), function (controlKey) {
340	if (-1 !== settingsKeys.indexOf(controlKey)) {
341	let value = attributes[controlKey];
342
343	if (value.toJSON) {
344	value = value.toJSON();
345	}
346
347	elementSettings[controlKey] = value;
348	}
349	});
350	} else {
351	elementSettings = this.$element.data('settings') \|\| {};
352	}
353
354	return this.getItems(elementSettings, setting);
355	},
356	getEditSettings: function (setting) {
357	var attributes = {};
358
359	if (this.isEdit) {
360	attributes = elementorFrontend.config.elements.editSettings[this.getModelCID()].attributes;
361	}
362
363	return this.getItems(attributes, setting);
364	},
365	getCurrentDeviceSetting: function (settingKey) {
366	return elementorFrontend.getCurrentDeviceSetting(this.getElementSettings(), settingKey);
367	},
368	onInit: function () {
369	if (this.isActive(this.getSettings())) {
370	elementorModules.ViewModule.prototype.onInit.apply(this, arguments);
371	}
372	},
373	onDestroy: function () {
374	if (this.isEdit) {
375	this.removeEditorListeners();
376	}
377
378	if (this.unbindEvents) {
379	this.unbindEvents();
380	}
381	}
382	});
383
384	/***/ }),
385
386	/***/ "../assets/dev/js/frontend/modules.js":
387	/!******************************************!\
388	!* ../assets/dev/js/frontend/modules.js *!
389	\********************************************/
390	/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
391
392	"use strict";
393
394
395	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
396
397	var _modules = _interopRequireDefault(__webpack_require__(/! ../modules/modules / "../assets/dev/js/modules/modules.js"));
398
399	var _document = _interopRequireDefault(__webpack_require__(/! ./document / "../assets/dev/js/frontend/document.js"));
400
401	var _stretchElement = _interopRequireDefault(__webpack_require__(/! ./tools/stretch-element / "../assets/dev/js/frontend/tools/stretch-element.js"));
402
403	var _base = _interopRequireDefault(__webpack_require__(/! ./handlers/base / "../assets/dev/js/frontend/handlers/base.js"));
404
405	var _baseSwiper = _interopRequireDefault(__webpack_require__(/! ./handlers/base-swiper / "../assets/dev/js/frontend/handlers/base-swiper.js"));
406
407	_modules.default.frontend = {
408	Document: _document.default,
409	tools: {
410	StretchElement: _stretchElement.default
411	},
412	handlers: {
413	Base: _base.default,
414	SwiperBase: _baseSwiper.default
415	}
416	};
417
418	/***/ }),
419
420	/***/ "../assets/dev/js/frontend/tools/stretch-element.js":
421	/!********************************************************!\
422	!* ../assets/dev/js/frontend/tools/stretch-element.js *!
423	\**********************************************************/
424	/***/ ((module) => {
425
426	"use strict";
427
428
429	module.exports = elementorModules.ViewModule.extend({
430	getDefaultSettings: function () {
431	return {
432	element: null,
433	direction: elementorFrontend.config.is_rtl ? 'right' : 'left',
434	selectors: {
435	container: window
436	}
437	};
438	},
439	getDefaultElements: function () {
440	return {
441	$element: jQuery(this.getSettings('element'))
442	};
443	},
444	stretch: function () {
445	var containerSelector = this.getSettings('selectors.container'),
446	$container;
447
448	try {
449	$container = jQuery(containerSelector);
450	} catch (e) {}
451
452	if (!$container \|\| !$container.length) {
453	$container = jQuery(this.getDefaultSettings().selectors.container);
454	}
455
456	this.reset();
457	var $element = this.elements.$element,
458	containerWidth = $container.innerWidth(),
459	elementOffset = $element.offset().left,
460	isFixed = 'fixed' === $element.css('position'),
461	correctOffset = isFixed ? 0 : elementOffset;
462
463	if (window !== $container[0]) {
464	var containerOffset = $container.offset().left;
465
466	if (isFixed) {
467	correctOffset = containerOffset;
468	}
469
470	if (elementOffset > containerOffset) {
471	correctOffset = elementOffset - containerOffset;
472	}
473	}
474
475	if (!isFixed) {
476	if (elementorFrontend.config.is_rtl) {
477	correctOffset = containerWidth - ($element.outerWidth() + correctOffset);
478	}
479
480	correctOffset = -correctOffset;
481	}
482
483	var css = {};
484	css.width = containerWidth + 'px';
485	css[this.getSettings('direction')] = correctOffset + 'px';
486	$element.css(css);
487	},
488	reset: function () {
489	var css = {};
490	css.width = '';
491	css[this.getSettings('direction')] = '';
492	this.elements.$element.css(css);
493	}
494	});
495
496	/***/ }),
497
498	/***/ "../assets/dev/js/modules/imports/args-object.js":
499	/!*****************************************************!\
500	!* ../assets/dev/js/modules/imports/args-object.js *!
501	\*******************************************************/
502	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
503
504	"use strict";
505
506
507	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
508
509	Object.defineProperty(exports, "__esModule", ({
510	value: true
511	}));
512	exports.default = void 0;
513
514	var _instanceType = _interopRequireDefault(__webpack_require__(/! ./instance-type / "../assets/dev/js/modules/imports/instance-type.js"));
515
516	class ArgsObject extends _instanceType.default {
517	static getInstanceType() {
518	return 'ArgsObject';
519	}
520	/**
521	* Function constructor().
522	*
523	* Create ArgsObject.
524	*
525	* @param {{}} args
526	*/
527
528
529	constructor(args) {
530	super();
531	this.args = args;
532	}
533	/**
534	* Function requireArgument().
535	*
536	* Validate property in args.
537	*
538	* @param {string} property
539	* @param {{}} args
540	*
541	* @throws {Error}
542	*
543	*/
544
545
546	requireArgument(property, args = this.args) {
547	if (!args.hasOwnProperty(property)) {
548	throw Error(`${property} is required.`);
549	}
550	}
551	/**
552	* Function requireArgumentType().
553	*
554	* Validate property in args using `type === typeof(args.whatever)`.
555	*
556	* @param {string} property
557	* @param {string} type
558	* @param {{}} args
559	*
560	* @throws {Error}
561	*
562	*/
563
564
565	requireArgumentType(property, type, args = this.args) {
566	this.requireArgument(property, args);
567
568	if (typeof args[property] !== type) {
569	throw Error(`${property} invalid type: ${type}.`);
570	}
571	}
572	/**
573	* Function requireArgumentInstance().
574	*
575	* Validate property in args using `args.whatever instanceof instance`.
576	*
577	* @param {string} property
578	* @param {instanceof} instance
579	* @param {{}} args
580	*
581	* @throws {Error}
582	*
583	*/
584
585
586	requireArgumentInstance(property, instance, args = this.args) {
587	this.requireArgument(property, args);
588
589	if (!(args[property] instanceof instance)) {
590	throw Error(`${property} invalid instance.`);
591	}
592	}
593	/**
594	* Function requireArgumentConstructor().
595	*
596	* Validate property in args using `type === args.whatever.constructor`.
597	*
598	* @param {string} property
599	* @param {*} type
600	* @param {{}} args
601	*
602	* @throws {Error}
603	*
604	*/
605
606
607	requireArgumentConstructor(property, type, args = this.args) {
608	this.requireArgument(property, args);
609
610	if (args[property].constructor !== type) {
611	throw Error(`${property} invalid constructor type.`);
612	}
613	}
614
615	}
616
617	exports.default = ArgsObject;
618
619	/***/ }),
620
621	/***/ "../assets/dev/js/modules/imports/force-method-implementation.js":
622	/!*********************************************************************!\
623	!* ../assets/dev/js/modules/imports/force-method-implementation.js *!
624	\***********************************************************************/
625	/***/ ((__unused_webpack_module, exports) => {
626
627	"use strict";
628
629
630	Object.defineProperty(exports, "__esModule", ({
631	value: true
632	}));
633	exports.default = exports.ForceMethodImplementation = void 0;
634
635	// TODO: Wrong location used as `elementorModules.ForceMethodImplementation(); should be` `elementorUtils.forceMethodImplementation()`;
636	class ForceMethodImplementation extends Error {
637	constructor(info = {}) {
638	super(`${info.isStatic ? 'static ' : ''}${info.fullName}() should be implemented, please provide '${info.functionName \|\| info.fullName}' functionality.`);
639	Error.captureStackTrace(this, ForceMethodImplementation);
640	}
641
642	}
643
644	exports.ForceMethodImplementation = ForceMethodImplementation;
645
646	var _default = () => {
647	const stack = Error().stack,
648	caller = stack.split('\n')[2].trim(),
649	callerName = caller.startsWith('at new') ? 'constructor' : caller.split(' ')[1],
650	info = {};
651	info.functionName = callerName;
652	info.fullName = callerName;
653
654	if (info.functionName.includes('.')) {
655	const parts = info.functionName.split('.');
656	info.className = parts[0];
657	info.functionName = parts[1];
658	} else {
659	info.isStatic = true;
660	}
661
662	throw new ForceMethodImplementation(info);
663	};
664
665	exports.default = _default;
666
667	/***/ }),
668
669	/***/ "../assets/dev/js/modules/imports/instance-type.js":
670	/!*******************************************************!\
671	!* ../assets/dev/js/modules/imports/instance-type.js *!
672	\*********************************************************/
673	/***/ ((__unused_webpack_module, exports) => {
674
675	"use strict";
676
677
678	Object.defineProperty(exports, "__esModule", ({
679	value: true
680	}));
681	exports.default = void 0;
682
683	class InstanceType {
684	static [Symbol.hasInstance](target) {
685	/**
686	* This is function extending being called each time JS uses instanceOf, since babel use it each time it create new class
687	* its give's opportunity to mange capabilities of instanceOf operator.
688	* saving current class each time will give option later to handle instanceOf manually.
689	*/
690	let result = super[Symbol.hasInstance](target); // Act normal when validate a class, which does not have instance type.
691
692	if (target && !target.constructor.getInstanceType) {
693	return result;
694	}
695
696	if (target) {
697	if (!target.instanceTypes) {
698	target.instanceTypes = [];
699	}
700
701	if (!result) {
702	if (this.getInstanceType() === target.constructor.getInstanceType()) {
703	result = true;
704	}
705	}
706
707	if (result) {
708	const name = this.getInstanceType === InstanceType.getInstanceType ? 'BaseInstanceType' : this.getInstanceType();
709
710	if (-1 === target.instanceTypes.indexOf(name)) {
711	target.instanceTypes.push(name);
712	}
713	}
714	}
715
716	if (!result && target) {
717	// Check if the given 'target', is instance of known types.
718	result = target.instanceTypes && Array.isArray(target.instanceTypes) && -1 !== target.instanceTypes.indexOf(this.getInstanceType());
719	}
720
721	return result;
722	}
723
724	constructor() {
725	// Since anonymous classes sometimes do not get validated by babel, do it manually.
726	let target = new.target;
727	const prototypes = [];
728
729	while (target.__proto__ && target.__proto__.name) {
730	prototypes.push(target.__proto__);
731	target = target.__proto__;
732	}
733
734	prototypes.reverse().forEach(proto => this instanceof proto);
735	}
736
737	static getInstanceType() {
738	elementorModules.ForceMethodImplementation();
739	}
740
741	}
742
743	exports.default = InstanceType;
744
745	/***/ }),
746
747	/***/ "../assets/dev/js/modules/imports/module.js":
748	/!************************************************!\
749	!* ../assets/dev/js/modules/imports/module.js *!
750	\**************************************************/
751	/***/ ((module) => {
752
753	"use strict";
754
755
756	const Module = function () {
757	const $ = jQuery,
758	instanceParams = arguments,
759	self = this,
760	events = {};
761	let settings;
762
763	const ensureClosureMethods = function () {
764	$.each(self, function (methodName) {
765	const oldMethod = self[methodName];
766
767	if ('function' !== typeof oldMethod) {
768	return;
769	}
770
771	self[methodName] = function () {
772	return oldMethod.apply(self, arguments);
773	};
774	});
775	};
776
777	const initSettings = function () {
778	settings = self.getDefaultSettings();
779	const instanceSettings = instanceParams[0];
780
781	if (instanceSettings) {
782	$.extend(true, settings, instanceSettings);
783	}
784	};
785
786	const init = function () {
787	self.__construct.apply(self, instanceParams);
788
789	ensureClosureMethods();
790	initSettings();
791	self.trigger('init');
792	};
793
794	this.getItems = function (items, itemKey) {
795	if (itemKey) {
796	const keyStack = itemKey.split('.'),
797	currentKey = keyStack.splice(0, 1);
798
799	if (!keyStack.length) {
800	return items[currentKey];
801	}
802
803	if (!items[currentKey]) {
804	return;
805	}
806
807	return this.getItems(items[currentKey], keyStack.join('.'));
808	}
809
810	return items;
811	};
812
813	this.getSettings = function (setting) {
814	return this.getItems(settings, setting);
815	};
816
817	this.setSettings = function (settingKey, value, settingsContainer) {
818	if (!settingsContainer) {
819	settingsContainer = settings;
820	}
821
822	if ('object' === typeof settingKey) {
823	$.extend(settingsContainer, settingKey);
824	return self;
825	}
826
827	const keyStack = settingKey.split('.'),
828	currentKey = keyStack.splice(0, 1);
829
830	if (!keyStack.length) {
831	settingsContainer[currentKey] = value;
832	return self;
833	}
834
835	if (!settingsContainer[currentKey]) {
836	settingsContainer[currentKey] = {};
837	}
838
839	return self.setSettings(keyStack.join('.'), value, settingsContainer[currentKey]);
840	};
841
842	this.getErrorMessage = function (type, functionName) {
843	let message;
844
845	switch (type) {
846	case 'forceMethodImplementation':
847	message = `The method '${functionName}' must to be implemented in the inheritor child.`;
848	break;
849
850	default:
851	message = 'An error occurs';
852	}
853
854	return message;
855	}; // TODO: This function should be deleted ?.
856
857
858	this.forceMethodImplementation = function (functionName) {
859	throw new Error(this.getErrorMessage('forceMethodImplementation', functionName));
860	};
861
862	this.on = function (eventName, callback) {
863	if ('object' === typeof eventName) {
864	$.each(eventName, function (singleEventName) {
865	self.on(singleEventName, this);
866	});
867	return self;
868	}
869
870	const eventNames = eventName.split(' ');
871	eventNames.forEach(function (singleEventName) {
872	if (!events[singleEventName]) {
873	events[singleEventName] = [];
874	}
875
876	events[singleEventName].push(callback);
877	});
878	return self;
879	};
880
881	this.off = function (eventName, callback) {
882	if (!events[eventName]) {
883	return self;
884	}
885
886	if (!callback) {
887	delete events[eventName];
888	return self;
889	}
890
891	const callbackIndex = events[eventName].indexOf(callback);
892
893	if (-1 !== callbackIndex) {
894	delete events[eventName][callbackIndex]; // Reset array index (for next off on same event).
895
896	events[eventName] = events[eventName].filter(val => val);
897	}
898
899	return self;
900	};
901
902	this.trigger = function (eventName) {
903	const methodName = 'on' + eventName[0].toUpperCase() + eventName.slice(1),
904	params = Array.prototype.slice.call(arguments, 1);
905
906	if (self[methodName]) {
907	self[methodName].apply(self, params);
908	}
909
910	const callbacks = events[eventName];
911
912	if (!callbacks) {
913	return self;
914	}
915
916	$.each(callbacks, function (index, callback) {
917	callback.apply(self, params);
918	});
919	return self;
920	};
921
922	init();
923	};
924
925	Module.prototype.__construct = function () {};
926
927	Module.prototype.getDefaultSettings = function () {
928	return {};
929	};
930
931	Module.prototype.getConstructorID = function () {
932	return this.constructor.name;
933	};
934
935	Module.extend = function (properties) {
936	const $ = jQuery,
937	parent = this;
938
939	const child = function () {
940	return parent.apply(this, arguments);
941	};
942
943	$.extend(child, parent);
944	child.prototype = Object.create($.extend({}, parent.prototype, properties));
945	child.prototype.constructor = child;
946	child.__super__ = parent.prototype;
947	return child;
948	};
949
950	module.exports = Module;
951
952	/***/ }),
953
954	/***/ "../assets/dev/js/modules/imports/utils/masonry.js":
955	/!*******************************************************!\
956	!* ../assets/dev/js/modules/imports/utils/masonry.js *!
957	\*********************************************************/
958	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
959
960	"use strict";
961
962
963	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
964
965	var _viewModule = _interopRequireDefault(__webpack_require__(/! ../view-module / "../assets/dev/js/modules/imports/view-module.js"));
966
967	module.exports = _viewModule.default.extend({
968	getDefaultSettings: function () {
969	return {
970	container: null,
971	items: null,
972	columnsCount: 3,
973	verticalSpaceBetween: 30
974	};
975	},
976	getDefaultElements: function () {
977	return {
978	$container: jQuery(this.getSettings('container')),
979	$items: jQuery(this.getSettings('items'))
980	};
981	},
982	run: function () {
983	var heights = [],
984	distanceFromTop = this.elements.$container.position().top,
985	settings = this.getSettings(),
986	columnsCount = settings.columnsCount;
987	distanceFromTop += parseInt(this.elements.$container.css('margin-top'), 10);
988	this.elements.$items.each(function (index) {
989	var row = Math.floor(index / columnsCount),
990	$item = jQuery(this),
991	itemHeight = $item[0].getBoundingClientRect().height + settings.verticalSpaceBetween;
992
993	if (row) {
994	var itemPosition = $item.position(),
995	indexAtRow = index % columnsCount,
996	pullHeight = itemPosition.top - distanceFromTop - heights[indexAtRow];
997	pullHeight -= parseInt($item.css('margin-top'), 10);
998	pullHeight *= -1;
999	$item.css('margin-top', pullHeight + 'px');
1000	heights[indexAtRow] += itemHeight;
1001	} else {
1002	heights.push(itemHeight);
1003	}
1004	});
1005	}
1006	});
1007
1008	/***/ }),
1009
1010	/***/ "../assets/dev/js/modules/imports/utils/scroll.js":
1011	/!******************************************************!\
1012	!* ../assets/dev/js/modules/imports/utils/scroll.js *!
1013	\********************************************************/
1014	/***/ ((__unused_webpack_module, exports) => {
1015
1016	"use strict";
1017
1018
1019	Object.defineProperty(exports, "__esModule", ({
1020	value: true
1021	}));
1022	exports.default = void 0;
1023
1024	// Moved from elementor pro: 'assets/dev/js/frontend/utils'
1025	class Scroll {
1026	/**
1027	* @param {object} obj
1028	* @param {number} obj.sensitivity - Value between 0-100 - Will determine the intersection trigger points on the element
1029	* @param {function} obj.callback - Will be triggered on each intersection point between the element and the viewport top/bottom
1030	* @param {string} obj.offset - Offset between the element intersection points and the viewport, written like in CSS: '-50% 0 -25%'
1031	* @param {HTMLElement} obj.root - The element that the events will be relative to, if 'null' will be relative to the viewport
1032	*/
1033	static scrollObserver(obj) {
1034	let lastScrollY = 0; // Generating threshholds points along the animation height
1035	// More threshholds points = more trigger points of the callback
1036
1037	const buildThreshholds = (sensitivityPercentage = 0) => {
1038	const threshholds = [];
1039
1040	if (sensitivityPercentage > 0 && sensitivityPercentage <= 100) {
1041	const increment = 100 / sensitivityPercentage;
1042
1043	for (let i = 0; i <= 100; i += increment) {
1044	threshholds.push(i / 100);
1045	}
1046	} else {
1047	threshholds.push(0);
1048	}
1049
1050	return threshholds;
1051	};
1052
1053	const options = {
1054	root: obj.root \|\| null,
1055	rootMargin: obj.offset \|\| '0px',
1056	threshold: buildThreshholds(obj.sensitivity)
1057	};
1058
1059	function handleIntersect(entries, observer) {
1060	const currentScrollY = entries[0].boundingClientRect.y,
1061	isInViewport = entries[0].isIntersecting,
1062	intersectionScrollDirection = currentScrollY < lastScrollY ? 'down' : 'up',
1063	scrollPercentage = Math.abs(parseFloat((entries[0].intersectionRatio * 100).toFixed(2)));
1064	obj.callback({
1065	sensitivity: obj.sensitivity,
1066	isInViewport,
1067	scrollPercentage,
1068	intersectionScrollDirection
1069	});
1070	lastScrollY = currentScrollY;
1071	}
1072
1073	return new IntersectionObserver(handleIntersect, options);
1074	}
1075	/**
1076	* @param {jQuery Element} $element
1077	* @param {object} offsetObj
1078	* @param {number} offsetObj.start - Offset start value in percentages
1079	* @param {number} offsetObj.end - Offset end value in percentages
1080	*/
1081
1082
1083	static getElementViewportPercentage($element, offsetObj = {}) {
1084	const elementOffset = $element[0].getBoundingClientRect(),
1085	offsetStart = offsetObj.start \|\| 0,
1086	offsetEnd = offsetObj.end \|\| 0,
1087	windowStartOffset = window.innerHeight * offsetStart / 100,
1088	windowEndOffset = window.innerHeight * offsetEnd / 100,
1089	y1 = elementOffset.top - window.innerHeight,
1090	y2 = elementOffset.top + windowStartOffset + $element.height(),
1091	startPosition = 0 - y1 + windowStartOffset,
1092	endPosition = y2 - y1 + windowEndOffset,
1093	percent = Math.max(0, Math.min(startPosition / endPosition, 1));
1094	return parseFloat((percent * 100).toFixed(2));
1095	}
1096	/**
1097	* @param {object} offsetObj
1098	* @param {number} offsetObj.start - Offset start value in percentages
1099	* @param {number} offsetObj.end - Offset end value in percentages
1100	* @param {number} limitPageHeight - Will limit the page height calculation
1101	*/
1102
1103
1104	static getPageScrollPercentage(offsetObj = {}, limitPageHeight) {
1105	const offsetStart = offsetObj.start \|\| 0,
1106	offsetEnd = offsetObj.end \|\| 0,
1107	initialPageHeight = limitPageHeight \|\| document.documentElement.scrollHeight - document.documentElement.clientHeight,
1108	heightOffset = initialPageHeight * offsetStart / 100,
1109	pageRange = initialPageHeight + heightOffset + initialPageHeight * offsetEnd / 100,
1110	scrollPos = document.documentElement.scrollTop + document.body.scrollTop + heightOffset;
1111	return scrollPos / pageRange * 100;
1112	}
1113
1114	}
1115
1116	exports.default = Scroll;
1117
1118	/***/ }),
1119
1120	/***/ "../assets/dev/js/modules/imports/view-module.js":
1121	/!*****************************************************!\
1122	!* ../assets/dev/js/modules/imports/view-module.js *!
1123	\*******************************************************/
1124	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1125
1126	"use strict";
1127
1128
1129	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
1130
1131	var _module = _interopRequireDefault(__webpack_require__(/! ./module / "../assets/dev/js/modules/imports/module.js"));
1132
1133	module.exports = _module.default.extend({
1134	elements: null,
1135	getDefaultElements: function () {
1136	return {};
1137	},
1138	bindEvents: function () {},
1139	onInit: function () {
1140	this.initElements();
1141	this.bindEvents();
1142	},
1143	initElements: function () {
1144	this.elements = this.getDefaultElements();
1145	}
1146	});
1147
1148	/***/ }),
1149
1150	/***/ "../assets/dev/js/modules/modules.js":
1151	/!*****************************************!\
1152	!* ../assets/dev/js/modules/modules.js *!
1153	\*******************************************/
1154	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1155
1156	"use strict";
1157
1158
1159	var _interopRequireDefault = __webpack_require__(/! @babel/runtime/helpers/interopRequireDefault / "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
1160
1161	Object.defineProperty(exports, "__esModule", ({
1162	value: true
1163	}));
1164	exports.default = void 0;
1165
1166	var _module = _interopRequireDefault(__webpack_require__(/! ./imports/module / "../assets/dev/js/modules/imports/module.js"));
1167
1168	var _viewModule = _interopRequireDefault(__webpack_require__(/! ./imports/view-module / "../assets/dev/js/modules/imports/view-module.js"));
1169
1170	var _argsObject = _interopRequireDefault(__webpack_require__(/! ./imports/args-object / "../assets/dev/js/modules/imports/args-object.js"));
1171
1172	var _masonry = _interopRequireDefault(__webpack_require__(/! ./imports/utils/masonry / "../assets/dev/js/modules/imports/utils/masonry.js"));
1173
1174	var _scroll = _interopRequireDefault(__webpack_require__(/! ./imports/utils/scroll / "../assets/dev/js/modules/imports/utils/scroll.js"));
1175
1176	var _forceMethodImplementation = _interopRequireDefault(__webpack_require__(/! ./imports/force-method-implementation / "../assets/dev/js/modules/imports/force-method-implementation.js"));
1177
1178	var _default = window.elementorModules = {
1179	Module: _module.default,
1180	ViewModule: _viewModule.default,
1181	ArgsObject: _argsObject.default,
1182	ForceMethodImplementation: _forceMethodImplementation.default,
1183	utils: {
1184	Masonry: _masonry.default,
1185	Scroll: _scroll.default
1186	}
1187	};
1188
1189	exports.default = _default;
1190
1191	/***/ })
1192
1193	},
1194	/******/ __webpack_require__ => { // webpackRuntimeModules
1195	/******/ "use strict";
1196	/******/
1197	/******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
1198	/******/ var __webpack_exports__ = (__webpack_exec__("../assets/dev/js/frontend/modules.js"));
1199	/******/ }
1200	]);
1201	//# sourceMappingURL=frontend-modules.js.map