frontend.js?ver=4.2.2

js riaz.ch collected 2026-10-01 13:01:12 UTC 54,018 bytes, 1,459 lines download raw bytes

1/*! elementor-pro - v4.2.0 - 19-08-2026 */
2(self["webpackChunkelementor_pro"] = self["webpackChunkelementor_pro"] || []).push([["frontend"],{
3
4/***/ "../../elementor/assets/dev/js/frontend/utils/utils.js"
5/*!*************************************************************!*\
6  !*** ../../elementor/assets/dev/js/frontend/utils/utils.js ***!
7  \*************************************************************/
8(__unused_webpack_module, exports) {
9
10"use strict";
11
12
13Object.defineProperty(exports, "__esModule", ({
14  value: true
15}));
16exports.isScrollSnapActive = exports.escapeHTML = void 0;
17// Escape HTML special chars to prevent XSS.
18const escapeHTML = str => {
19  const specialChars = {
20    '&': '&amp;',
21    '<': '&lt;',
22    '>': '&gt;',
23    "'": '&#39;',
24    '"': '&quot;'
25  };
26  return str.replace(/[&<>'"]/g, tag => specialChars[tag] || tag);
27};
28
29// Check if Scroll-Snap is active.
30exports.escapeHTML = escapeHTML;
31const isScrollSnapActive = () => {
32  const scrollSnapStatus = elementorFrontend.isEditMode() ? elementor.settings.page.model.attributes?.scroll_snap : elementorFrontend.config.settings.page?.scroll_snap;
33  return 'yes' === scrollSnapStatus ? true : false;
34};
35exports.isScrollSnapActive = isScrollSnapActive;
36
37/***/ },
38
39/***/ "../assets/dev/js/frontend/frontend.js"
40/*!*********************************************!*\
41  !*** ../assets/dev/js/frontend/frontend.js ***!
42  \*********************************************/
43(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
44
45"use strict";
46
47
48var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
49__webpack_require__(/*! ../public-path */ "../assets/dev/js/public-path.js");
50var _frontend = _interopRequireDefault(__webpack_require__(/*! ../../../../modules/motion-fx/assets/js/frontend/frontend */ "../modules/motion-fx/assets/js/frontend/frontend.js"));
51var _frontend2 = _interopRequireDefault(__webpack_require__(/*! ../../../../modules/sticky/assets/js/frontend/frontend */ "../modules/sticky/assets/js/frontend/frontend.js"));
52var _frontend3 = _interopRequireDefault(__webpack_require__(/*! ../../../../modules/code-highlight/assets/js/frontend/frontend */ "../modules/code-highlight/assets/js/frontend/frontend.js"));
53var _frontend4 = _interopRequireDefault(__webpack_require__(/*! ../../../../modules/video-playlist/assets/js/frontend/frontend */ "../modules/video-playlist/assets/js/frontend/frontend.js"));
54var _frontend5 = _interopRequireDefault(__webpack_require__(/*! ../../../../modules/payments/assets/js/frontend/frontend */ "../modules/payments/assets/js/frontend/frontend.js"));
55var _frontend6 = _interopRequireDefault(__webpack_require__(/*! ../../../../modules/progress-tracker/assets/js/frontend/frontend */ "../modules/progress-tracker/assets/js/frontend/frontend.js"));
56var _controls = _interopRequireDefault(__webpack_require__(/*! ./utils/controls */ "../assets/dev/js/frontend/utils/controls.js"));
57var _dropdownMenuHeightController = _interopRequireDefault(__webpack_require__(/*! ./utils/dropdown-menu-height-controller */ "../assets/dev/js/frontend/utils/dropdown-menu-height-controller.js"));
58class ElementorProFrontend extends elementorModules.ViewModule {
59  onInit() {
60    super.onInit();
61    this.config = ElementorProFrontendConfig;
62    this.modules = {};
63    this.initOnReadyComponents();
64  }
65  bindEvents() {
66    jQuery(window).on('elementor/frontend/init', this.onElementorFrontendInit.bind(this));
67  }
68  initModules() {
69    // Handlers that should be available by default for sections usage.
70    let handlers = {
71      motionFX: _frontend.default,
72      sticky: _frontend2.default,
73      codeHighlight: _frontend3.default,
74      videoPlaylist: _frontend4.default,
75      payments: _frontend5.default,
76      progressTracker: _frontend6.default
77    };
78
79    // Keep this line before applying filter on the handlers.
80    elementorProFrontend.trigger('elementor-pro/modules/init/before');
81    handlers = elementorFrontend.hooks.applyFilters('elementor-pro/frontend/handlers', handlers);
82    jQuery.each(handlers, (moduleName, ModuleClass) => {
83      this.modules[moduleName] = new ModuleClass();
84    });
85
86    // TODO: BC Since 2.9.0
87    this.modules.linkActions = {
88      addAction: (...args) => {
89        elementorFrontend.utils.urlActions.addAction(...args);
90      }
91    };
92  }
93  onElementorFrontendInit() {
94    this.initModules();
95  }
96  initOnReadyComponents() {
97    this.utils = {
98      controls: new _controls.default(),

99      DropdownMenuHeightController: _dropdownMenuHeightController.default
100    };
101  }
102}
103window.elementorProFrontend = new ElementorProFrontend();
104
105/***/ },
106
107/***/ "../assets/dev/js/frontend/utils/controls.js"
108/*!***************************************************!*\
109  !*** ../assets/dev/js/frontend/utils/controls.js ***!
110  \***************************************************/
111(__unused_webpack_module, exports) {
112
113"use strict";
114
115
116Object.defineProperty(exports, "__esModule", ({
117  value: true
118}));
119exports["default"] = void 0;
120class Controls {
121  /**
122   * Get Control Value
123   *
124   * Retrieves a control value.
125   * This function has been copied from `elementor/assets/dev/js/editor/utils/conditions.js`.
126   *
127   * @since 3.11.0
128   *
129   * @param {{}}     controlSettings A settings object (e.g. element settings - keys and values)
130   * @param {string} controlKey      The control key name
131   * @param {string} controlSubKey   A specific property of the control object.
132   * @return {*} Control Value
133   */
134  getControlValue(controlSettings, controlKey, controlSubKey) {
135    let value;
136    if ('object' === typeof controlSettings[controlKey] && controlSubKey) {
137      value = controlSettings[controlKey][controlSubKey];
138    } else {
139      value = controlSettings[controlKey];
140    }
141    return value;
142  }
143
144  /**
145   * Get the value of a responsive control.
146   *
147   * Retrieves the value of a responsive control for the current device or for this first parent device which has a control value.
148   *
149   * @since 3.11.0
150   *
151   * @param {{}}     controlSettings A settings object (e.g. element settings - keys and values)
152   * @param {string} controlKey      The control key name
153   * @param {string} controlSubKey   A specific property of the control object.
154   * @return {*} Control Value
155   */
156  getResponsiveControlValue(controlSettings, controlKey, controlSubKey = '') {
157    const currentDeviceMode = elementorFrontend.getCurrentDeviceMode(),
158      controlValueDesktop = this.getControlValue(controlSettings, controlKey, controlSubKey);
159
160    // Set the control value for the current device mode.
161    // First check the widescreen device mode.
162    if ('widescreen' === currentDeviceMode) {
163      const controlValueWidescreen = this.getControlValue(controlSettings, `${controlKey}_widescreen`, controlSubKey);
164      return !!controlValueWidescreen || 0 === controlValueWidescreen ? controlValueWidescreen : controlValueDesktop;
165    }
166
167    // Loop through all responsive and desktop device modes.
168    const activeBreakpoints = elementorFrontend.breakpoints.getActiveBreakpointsList({
169      withDesktop: true
170    });
171    let parentDeviceMode = currentDeviceMode,
172      deviceIndex = activeBreakpoints.indexOf(currentDeviceMode),
173      controlValue = '';
174    while (deviceIndex <= activeBreakpoints.length) {
175      if ('desktop' === parentDeviceMode) {
176        controlValue = controlValueDesktop;
177        break;
178      }
179      const responsiveControlKey = `${controlKey}_${parentDeviceMode}`,
180        responsiveControlValue = this.getControlValue(controlSettings, responsiveControlKey, controlSubKey);
181      if (!!responsiveControlValue || 0 === responsiveControlValue) {
182        controlValue = responsiveControlValue;
183        break;
184      }
185
186      // If no control value has been set for the current device mode, then check the parent device mode.
187      deviceIndex++;
188      parentDeviceMode = activeBreakpoints[deviceIndex];
189    }
190    return controlValue;
191  }
192}
193exports["default"] = Controls;
194
195/***/ },
196
197/***/ "../assets/dev/js/frontend/utils/dropdown-menu-height-controller.js"
198/*!**************************************************************************!*\
199  !*** ../assets/dev/js/frontend/utils/dropdown-menu-height-controller.js ***!
200  \**************************************************************************/
201(__unused_webpack_module, exports) {
202
203"use strict";
204
205
206Object.defineProperty(exports, "__esModule", ({
207  value: true
208}));
209exports["default"] = void 0;
210class DropdownMenuHeightController {
211  constructor(widgetConfig) {
212    this.widgetConfig = widgetConfig;
213  }
214  calculateStickyMenuNavHeight() {
215    this.widgetConfig.elements.$dropdownMenuContainer.css(this.widgetConfig.settings.menuHeight

215CssVarName, '');
216    const menuToggleHeight = this.widgetConfig.elements.$dropdownMenuContainer.offset().top - jQuery(window).scrollTop();
217    return elementorFrontend.elements.$window.height() - menuToggleHeight;
218  }
219  calculateMenuTabContentHeight($tab) {
220    return elementorFrontend.elements.$window.height() - $tab[0].getBoundingClientRect().top;
221  }
222  isElementSticky() {
223    return this.widgetConfig.elements.$element.hasClass('elementor-sticky') || this.widgetConfig.elements.$element.parents('.elementor-sticky').length;
224  }
225  getMenuHeight() {
226    return this.isElementSticky() ? this.calculateStickyMenuNavHeight() + 'px' : this.widgetConfig.settings.dropdownMenuContainerMaxHeight;
227  }
228  setMenuHeight(menuHeight) {
229    this.widgetConfig.elements.$dropdownMenuContainer.css(this.widgetConfig.settings.menuHeightCssVarName, menuHeight);
230  }
231  reassignMobileMenuHeight() {
232    const menuHeight = this.isToggleActive() ? this.getMenuHeight() : 0;
233    return this.setMenuHeight(menuHeight);
234  }
235  reassignMenuHeight($activeTabContent) {
236    if (!this.isElementSticky() || 0 === $activeTabContent.length) {
237      return;
238    }
239    const offsetBottom = elementorFrontend.elements.$window.height() - $activeTabContent[0].getBoundingClientRect().top,
240      isContentHeightBiggerThanWindow = $activeTabContent.height() > offsetBottom;
241    if (!isContentHeightBiggerThanWindow) {
242      return;
243    }
244    $activeTabContent.css('height', this.calculateMenuTabContentHeight($activeTabContent) + 'px');
245    $activeTabContent.css('overflow-y', 'scroll');
246  }
247  resetMenuHeight($activeTabContent) {
248    if (!this.isElementSticky()) {
249      return;
250    }
251    $activeTabContent.css('height', 'initial');
252    $activeTabContent.css('overflow-y', 'visible');
253  }
254  isToggleActive() {
255    const $menuToggle = this.widgetConfig.elements.$menuToggle;
256
257    // New approach.
258    // Aria attributes instead of css classes.
259    if (!!this.widgetConfig.attributes?.menuToggleState) {
260      return 'true' === $menuToggle.attr(this.widgetConfig.attributes.menuToggleState);
261    }
262
263    // This can be removed once the new markup of the Mega Menu has been implemented.
264    // Previously we used state classes to indicate the active state of the menu toggle.
265    return $menuToggle.hasClass(this.widgetConfig.classes.menuToggleActiveClass);
266  }
267}
268exports["default"] = DropdownMenuHeightController;
269
270/***/ },
271
272/***/ "../assets/dev/js/public-path.js"
273/*!***************************************!*\
274  !*** ../assets/dev/js/public-path.js ***!
275  \***************************************/
276(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
277
278"use strict";
279
280
281/* eslint-disable camelcase */
282__webpack_require__.p = ElementorProFrontendConfig.urls.assets + 'js/';
283
284/***/ },
285
286/***/ "../modules/code-highlight/assets/js/frontend/frontend.js"
287/*!****************************************************************!*\
288  !*** ../modules/code-highlight/assets/js/frontend/frontend.js ***!
289  \****************************************************************/
290(__unused_webpack_module, exports, __webpack_require__) {
291
292"use strict";
293
294
295Object.defineProperty(exports, "__esModule", ({
296  value: true
297}));
298exports["default"] = void 0;
299class _default extends elementorModules.Module {
300  constructor() {
301    super();
302    elementorFrontend.elementsHandler.attachHandler('code-highlight', () => __webpack_require__.e(/*! import() | code-highlight */ "code-highlight").then(__webpack_require__.bind(__webpack_require__, /*! ./handler */ "../modules/code-highlight/assets/js/frontend/handler.js")));
303  }
304}
305exports["default"] = _default;
306
307/***/ },
308
309/***/ "../modules/motion-fx/assets/js/frontend/frontend.js"
310/*!***********************************************************!*\
311  !*** ../modules/motion-fx/assets/js/frontend/frontend.js ***!
312  \***********************************************************/
313(__unused_webpack_module, exports, __webpack_require__) {
314
315"use strict";
316
317
318var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
319Object.defineProperty(exports, "__esModule", ({
320  value: true
321}));
322exports["default"] = void 0;
323var _handler = _interopRequireDefault(__webpack_require__(/*! ./handler */ "../modules/motion-fx/assets/js/frontend/handler.js"));
324class _default extends elementorModules.Module {
325  constructor() {
326    super();
327    elementorFrontend.elementsHandler.attachHandler('global', _handler.default, null);
328  }
329}
330exports["default"] = _default;
331
332/***/ },
333
334/***/ "../modules/motion-fx/assets/js/frontend/handler.js"
335/*!**********************************************************!*\
336  !*** ../modules/motion-fx/assets/js/frontend/handler.js ***!
337  \**********************************************************/
338(__unused_webpack_module, exports, __webpack_require__) {
339
340"use strict";
341
342
343var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
344Object.defineProperty(exports, "__esModule", ({
345  value: true
346}));
347exports["default"] = void 0;
348var _motionFx = _interopRequireDefault(__webpack_require__(/*! ./motion-fx/motion-fx */ "../modules/motion-fx/assets/js/frontend/motion-fx/motion-fx.js"));
349class _default extends elementorModules.frontend.handlers.Base {
350  __construct(...args) {
351    super.__construct(...args);
352    this.toggle = elementorFrontend.debounce(this.toggle, 200);
353  }
354  getDefaultSettings() {
355    return {
356      selectors: {
357        container: '.elementor-widget-container'
358      }
359    };
360  }
361  getDefaultElements() {

362    const selectors = this.getSettings('selectors');
363    let container = this.$element.find(selectors.container);
364    if (0 === container.length) {
365      container = this.$element;
366    }
367    return {
368      $container: container
369    };
370  }
371  bindEvents() {
372    elementorFrontend.elements.$window.on('resize', this.toggle);
373  }
374  unbindEvents() {
375    elementorFrontend.elements.$window.off('resize', this.toggle);
376  }
377  addCSSTransformEvents() {
378    // Remove CSS transition variable that assigned from scroll.js in order to allow the transition of the CSS-Transform.
379    const motionFxScrolling = this.getElementSettings('motion_fx_motion_fx_scrolling');
380    if (motionFxScrolling && !this.isTransitionEventAdded) {
381      this.isTransitionEventAdded = true;
382      this.elements.$container.on('mouseenter', () => {
383        this.elements.$container.css('--e-transform-transition-duration', '');
384      });
385    }
386  }
387  initEffects() {
388    this.effects = {
389      translateY: {
390        interaction: 'scroll',
391        actions: ['translateY']
392      },
393      translateX: {
394        interaction: 'scroll',
395        actions: ['translateX']
396      },
397      rotateZ: {
398        interaction: 'scroll',
399        actions: ['rotateZ']
400      },
401      scale: {
402        interaction: 'scroll',
403        actions: ['scale']
404      },
405      opacity: {
406        interaction: 'scroll',
407        actions: ['opacity']
408      },
409      blur: {
410        interaction: 'scroll',
411        actions: ['blur']
412      },
413      mouseTrack: {
414        interaction: 'mouseMove',
415        actions: ['translateXY']
416      },
417      tilt: {
418        interaction: 'mouseMove',
419        actions: ['tilt']
420      }
421    };
422  }
423  prepareOptions(name) {
424    const elementSettings = this.getElementSettings(),
425      type = 'motion_fx' === name ? 'element' : 'background',
426      interactions = {};
427    jQuery.each(elementSettings, (key, value) => {
428      const keyRegex = new RegExp('^' + name + '_(.+?)_effect'),
429        keyMatches = key.match(keyRegex);
430      if (!keyMatches || !value) {
431        return;
432      }
433      const options = {},
434        effectName = keyMatches[1];
435      jQuery.each(elementSettings, (subKey, subValue) => {
436        const subKeyRegex = new RegExp(name + '_' + effectName + '_(.+)'),
437          subKeyMatches = subKey.match(subKeyRegex);
438        if (!subKeyMatches) {
439          return;
440        }
441        const subFieldName = subKeyMatches[1];
442        if ('effect' === subFieldName) {
443          return;
444        }
445        if ('object' === typeof subValue) {
446          subValue = Object.keys(subValue.sizes).length ? subValue.sizes : subValue.size;
447        }
448        options[subKeyMatches[1]] = subValue;
449      });
450      const effect = this.effects[effectName],
451        interactionName = effect.interaction;
452      if (!interactions[interactionName]) {
453        interactions[interactionName] = {};
454      }
455      effect.actions.forEach(action => interactions[interactionName][action] = options);
456    });
457    let $element = this.$element,
458      $dimensionsElement,
459      $childElement;
460    const elementType = this.getElementType();
461    if ('element' === type && !['section', 'container'].includes(elementType)) {
462      $dimensionsElement = $element;
463      let childElementSelector;
464      if ('column' === elementType) {
465        childElementSelector = '.elementor-widget-wrap';
466      } else {
467        childElementSelector = '.elementor-widget-container';
468      }
469      $childElement = $element.find('> ' + childElementSelector);
470      $element = 0 === $childElement.length ? this.$element : $childElement;
471    }
472    const options = {
473      type,
474      interactions,
475      elementSettings,
476      $element,
477      $dimensionsElement,
478      refreshDimensions: this.isEdit,
479      range: elementSettings[name + '_range'],
480      classes: {
481        element: 'elementor-motion-effects-element',
482        parent: 'elementor-motion-effects-parent',
483        backgroundType: 'elementor-motion-effects-element-type-background',
484        container: 'elementor-motion-effects-container',
485        layer: 'elementor-motion-effects-layer',
486        perspective: 'elementor-motion-effects-perspective'
487      }
488    };
489    if (!options.range && 'fixed' === this.getCurrentDeviceSetting('_position')) {
490      options.range = 'page';
491    }
492    if ('fixed' === this.getCurrentDeviceSetting('_position')) {
493      options.isFixedPosition = true;
494    }
495    if ('background' === type && 'column' === this.getElementType()) {

496      options.addBackgroundLayerTo = ' > .elementor-element-populated';
497    }
498    return options;
499  }
500  activate(name) {
501    const options = this.prepareOptions(name);
502    if (jQuery.isEmptyObject(options.interactions)) {
503      return;
504    }
505    this[name] = new _motionFx.default(options);
506  }
507  deactivate(name) {
508    if (this[name]) {
509      this[name].destroy();
510      delete this[name];
511    }
512  }
513  toggle() {
514    const currentDeviceMode = elementorFrontend.getCurrentDeviceMode(),
515      elementSettings = this.getElementSettings();
516    ['motion_fx', 'background_motion_fx'].forEach(name => {
517      const devices = elementSettings[name + '_devices'],
518        isCurrentModeActive = !devices || -1 !== devices.indexOf(currentDeviceMode);
519      if (isCurrentModeActive && (elementSettings[name + '_motion_fx_scrolling'] || elementSettings[name + '_motion_fx_mouse'])) {
520        if (this[name]) {
521          this.refreshInstance(name);
522        } else {
523          this.activate(name);
524        }
525      } else {
526        this.deactivate(name);
527      }
528    });
529  }
530  refreshInstance(instanceName) {
531    const instance = this[instanceName];
532    if (!instance) {
533      return;
534    }
535    const preparedOptions = this.prepareOptions(instanceName);
536    instance.setSettings(preparedOptions);
537    instance.refresh();
538  }
539  onInit() {
540    super.onInit();
541    const prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)');
542    if (prefersReducedMotion && prefersReducedMotion.matches) {
543      return;
544    }
545    this.initEffects();
546    this.addCSSTransformEvents();
547    this.toggle();
548  }
549  onElementChange(propertyName) {
550    if (/motion_fx_((scrolling)|(mouse)|(devices))$/.test(propertyName)) {
551      if ('motion_fx_motion_fx_scrolling' === propertyName) {
552        this.addCSSTransformEvents();
553      }
554      this.toggle();
555      return;
556    }
557    const propertyMatches = propertyName.match('.*?(motion_fx|_transform)');
558    if (propertyMatches) {
559      const instanceName = propertyMatches[0].match('(_transform)') ? 'motion_fx' : propertyMatches[0];
560      this.refreshInstance(instanceName);
561      if (!this[instanceName]) {
562        this.activate(instanceName);
563      }
564    }
565    if (/^_position/.test(propertyName)) {
566      ['motion_fx', 'background_motion_fx'].forEach(instanceName => {
567        this.refreshInstance(instanceName);
568      });
569    }
570  }
571  onDestroy() {
572    super.onDestroy();
573    ['motion_fx', 'background_motion_fx'].forEach(name => {
574      this.deactivate(name);
575    });
576  }
577}
578exports["default"] = _default;
579
580/***/ },
581
582/***/ "../modules/motion-fx/assets/js/frontend/motion-fx/actions.js"
583/*!********************************************************************!*\
584  !*** ../modules/motion-fx/assets/js/frontend/motion-fx/actions.js ***!
585  \********************************************************************/
586(__unused_webpack_module, exports) {
587
588"use strict";
589
590
591Object.defineProperty(exports, "__esModule", ({
592  value: true
593}));
594exports["default"] = void 0;
595class _default extends elementorModules.Module {
596  getMovePointFromPassedPercents(movableRange, passedPercents) {
597    const movePoint = passedPercents / movableRange * 100;
598    return +movePoint.toFixed(2);
599  }
600  getEffectValueFromMovePoint(range, movePoint) {
601    return range * movePoint / 100;
602  }
603  getStep(passedPercents, options) {
604    if ('element' === this.getSettings('type')) {
605      return this.getElementStep(passedPercents, options);
606    }
607    return this.getBackgroundStep(passedPercents, options);
608  }
609  getElementStep(passedPercents, options) {
610    return -(passedPercents - 50) * options.speed;
611  }
612  getBackgroundStep(passedPercents, options) {
613    const movableRange = this.getSettings('dimensions.movable' + options.axis.toUpperCase());
614    return -this.getEffectValueFromMovePoint(movableRange, passedPercents);
615  }
616  getDirectionMovePoint(passedPercents, direction, range) {
617    let movePoint;
618    if (passedPercents < range.start) {
619      if ('out-in' === direction) {
620        movePoint = 0;
621      } else if ('in-out' === direction) {
622        movePoint = 100;
623      } else {
624        movePoint = this.getMovePointFromPassedPercents(range.start, passedPercents);
625        if ('in-out-in' === direction) {
626          movePoint = 100 - movePoint;
627        }
628      }
629    } else if (passedPercents < range.end) {
630      if ('in-out-in' === direction) {
631        movePoint = 0;
632      } else if ('out-in-out' === direction) {
633        movePoint = 100;
634      } else {
635        movePoint = this.getMovePointFromPassedPercents(range.end - range.start, passedPercents - range.start);
636        if ('in-out' === direction) {
637          movePoint = 100 - movePoint;
638        }
639      }
640    } else if ('in-out' === direction) {
641      movePoint = 0;
642    } else if ('out-in' === direction) {
643      movePoint = 100;
644    } else {
645      movePoint = this.getMovePointFromPassedPercents(100 - range.end, 100 - passedPercents);
646      if ('in-out-in' === direction) {
647        movePoint = 100 - movePoint;
648      }
649    }
650    return movePoint;
651  }
652  translateX(actionData, passedPercents) {
653    actionData.axis = 'x';
654    actionData.unit = 'px';
655    this.transform('translateX', passedPercents, actionData);
656  }
657  translateY(actionData, passedPercents) {
658    actionData.axis = 'y';
659    actionData.unit = 'px';
660    this.transform('translateY', passedPercents, actionData);
661  }
662  translateXY(actionData, passedPercentsX, passedPercentsY) {
663    this.translateX(actionData, passedPercentsX);
664    this.translateY(actionData, passedPercentsY);
665  }
666  tilt(actionData, passedPercentsX, passedPercentsY) {
667    const options = {
668      speed: actionData.speed / 10,
669      direction: actionData.direction
670    };
671    this.rotateX(options, passedPercentsY);
672    this.rotateY(options, 100 - passedPercentsX);
673  }
674  rotateX(actionData, passedPercents) {
675    actionData.axis = 'x';
676    actionData.unit = 'deg';
677    this.transform('rotateX', passedPercents, actionData);
678  }
679  rotateY(actionData, passedPercents) {
680    actionData.axis = 'y';
681    actionData.unit = 'deg';
682    this.transform('rotateY', passedPercents, actionData);
683  }
684  rotateZ(actionData, passedPercents) {
685    actionData.unit = 'deg';
686    this.transform('rotateZ', passedPercents, actionData);
687  }
688  scale(actionData, passedPercents) {
689    const movePoint = this.getDirectionMovePoint(passedPercents, actionData.direction, actionData.range);
690    this.updateRulePart('transform', 'scale', 1 + actionData.speed * movePoint / 1000);
691  }
692  transform(action, passedPercents, actionData) {
693    if (actionData.direction) {
694      passedPercents = 100 - passedPercents;
695    }

696    this.updateRulePart('transform', action, this.getStep(passedPercents, actionData) + actionData.unit);
697  }
698  setCSSTransformVariables(elementSettings) {
699    this.CSSTransformVariables = [];
700    jQuery.each(elementSettings, (settingKey, settingValue) => {
701      const transformKeyMatches = settingKey.match(/_transform_(.+?)_effect/m);
702      if (transformKeyMatches && settingValue) {
703        if ('perspective' === transformKeyMatches[1]) {
704          this.CSSTransformVariables.unshift(transformKeyMatches[1]);
705          return;
706        }
707        if (this.CSSTransformVariables.includes(transformKeyMatches[1])) {
708          return;
709        }
710        this.CSSTransformVariables.push(transformKeyMatches[1]);
711      }
712    });
713  }
714  opacity(actionData, passedPercents) {
715    const movePoint = this.getDirectionMovePoint(passedPercents, actionData.direction, actionData.range),
716      level = actionData.level / 10,
717      opacity = 1 - level + this.getEffectValueFromMovePoint(level, movePoint);
718    this.$element.css({
719      opacity,
720      'will-change': 'opacity'
721    });
722  }
723  blur(actionData, passedPercents) {
724    const movePoint = this.getDirectionMovePoint(passedPercents, actionData.direction, actionData.range),
725      blur = actionData.level - this.getEffectValueFromMovePoint(actionData.level, movePoint);
726    this.updateRulePart('filter', 'blur', blur + 'px');
727  }
728  updateRulePart(ruleName, key, value) {
729    if (!this.rulesVariables[ruleName]) {
730      this.rulesVariables[ruleName] = {};
731    }
732    if (!this.rulesVariables[ruleName][key]) {
733      this.rulesVariables[ruleName][key] = true;
734      this.updateRule(ruleName);
735    }
736    const cssVarKey = `--${key}`;
737    this.$element[0].style.setProperty(cssVarKey, value);
738  }
739  updateRule(ruleName) {
740    let value = '';
741    value += this.concatTransformCSSProperties(ruleName);
742    value += this.concatTransformMotionEffectCSSProperties(ruleName);
743    this.$element.css(ruleName, value);
744  }
745  concatTransformCSSProperties(ruleName) {
746    let value = '';
747    if ('transform' === ruleName) {
748      jQuery.each(this.CSSTransformVariables, (index, variableKey) => {
749        const variableName = variableKey;
750        if (variableKey.startsWith('flip')) {
751          variableKey = variableKey.replace('flip', 'scale');
752        }
753
754        // Adding default value because of the hover state. if there is no default the transform will break.
755        const defaultUnit = variableKey.startsWith('rotate') || variableKey.startsWith('skew') ? 'deg' : 'px',
756          defaultValue = variableKey.startsWith('scale') ? 1 : 0 + defaultUnit;
757        value += `${variableKey}(var(--e-transform-${variableName}, ${defaultValue}))`;
758      });
759    }
760    return value;
761  }
762  concatTransformMotionEffectCSSProperties(ruleName) {
763    let value = '';
764    jQuery.each(this.rulesVariables[ruleName], variableKey => {
765      value += `${variableKey}(var(--${variableKey}))`;
766    });
767    return value;
768  }
769  runAction(actionName, actionData, passedPercents, ...args) {
770    if (actionData.affectedRange) {
771      if (actionData.affectedRange.start > passedPercents) {
772        passedPercents = actionData.affectedRange.start;
773      }
774      if (actionData.affectedRange.end < passedPercents) {
775        passedPercents = actionData.affectedRange.end;
776      }
777    }
778    this[actionName](actionData, passedPercents, ...args);
779  }
780  refresh() {
781    this.rulesVariables = {};
782    this.CSSTransformVariables = [];
783    this.$element.css({
784      transform: '',
785      filter: '',
786      opacity: '',
787      'will-change': ''
788    });
789  }
790  onInit() {
791    this.$element = this.getSettings('$targetElement');
792    this.refresh();
793  }
794}
795exports["default"] = _default;
796
797/***/ },
798
799/***/ "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/base.js"
800/*!******************************************************************************!*\
801  !*** ../modules/motion-fx/assets/js/frontend/motion-fx/interactions/base.js ***!
802  \******************************************************************************/
803(__unused_webpack_module, exports) {
804
805"use strict";
806
807
808Object.defineProperty(exports, "__esModule", ({
809  value: true
810}));
811exports["default"] = void 0;
812class _default extends elementorModules.ViewModule {
813  __construct(options) {
814    this.motionFX = options.motionFX;
815    if (!this.intersectionObservers) {
816      this.setElementInViewportObserver();
817    }
818  }
819  setElementInViewportObserver() {

820    this.intersectionObserver = elementorModules.utils.Scroll.scrollObserver({
821      callback: event => {
822        if (event.isInViewport) {
823          this.onInsideViewport();
824        } else {
825          this.removeAnimationFrameRequest();
826        }
827      }
828    });
829
830    // Determine which element we should observe.
831    const observedElement = 'page' === this.motionFX.getSettings('range') ? elementorFrontend.elements.$body[0] : this.motionFX.elements.$parent[0];
832    this.intersectionObserver.observe(observedElement);
833  }
834  onInsideViewport = () => {
835    this.run();
836    this.animationFrameRequest = requestAnimationFrame(this.onInsideViewport);
837  };
838  runCallback(...args) {
839    const callback = this.getSettings('callback');
840    callback(...args);
841  }
842  removeIntersectionObserver() {
843    if (this.intersectionObserver) {
844      this.intersectionObserver.unobserve(this.motionFX.elements.$parent[0]);
845    }
846  }
847  removeAnimationFrameRequest() {
848    if (this.animationFrameRequest) {
849      cancelAnimationFrame(this.animationFrameRequest);
850    }
851  }
852  destroy() {
853    this.removeAnimationFrameRequest();
854    this.removeIntersectionObserver();
855  }
856  onInit() {
857    super.onInit();
858  }
859}
860exports["default"] = _default;
861
862/***/ },
863
864/***/ "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/mouse-move.js"
865/*!************************************************************************************!*\
866  !*** ../modules/motion-fx/assets/js/frontend/motion-fx/interactions/mouse-move.js ***!
867  \************************************************************************************/
868(__unused_webpack_module, exports, __webpack_require__) {
869
870"use strict";
871
872
873var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
874Object.defineProperty(exports, "__esModule", ({
875  value: true
876}));
877exports["default"] = void 0;
878var _base = _interopRequireDefault(__webpack_require__(/*! ./base */ "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/base.js"));
879class MouseMoveInteraction extends _base.default {
880  bindEvents() {
881    if (!MouseMoveInteraction.mouseTracked) {
882      elementorFrontend.elements.$window.on('mousemove', MouseMoveInteraction.updateMousePosition);
883      MouseMoveInteraction.mouseTracked = true;
884    }
885  }
886  run() {
887    const mousePosition = MouseMoveInteraction.mousePosition,
888      oldMousePosition = this.oldMousePosition;
889    if (oldMousePosition.x === mousePosition.x && oldMousePosition.y === mousePosition.y) {
890      return;
891    }
892    this.oldMousePosition = {
893      x: mousePosition.x,
894      y: mousePosition.y
895    };
896    const passedPercentsX = 100 / innerWidth * mousePosition.x,
897      passedPercentsY = 100 / innerHeight * mousePosition.y;
898    this.runCallback(passedPercentsX, passedPercentsY);
899  }
900  onInit() {
901    this.oldMousePosition = {};
902    super.onInit();
903  }
904}
905exports["default"] = MouseMoveInteraction;
906MouseMoveInteraction.mousePosition = {};
907MouseMoveInteraction.updateMousePosition = event => {
908  MouseMoveInteraction.mousePosition = {
909    x: event.clientX,
910    y: event.clientY
911  };
912};
913
914/***/ },
915
916/***/ "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/scroll.js"
917/*!********************************************************************************!*\
918  !*** ../modules/motion-fx/assets/js/frontend/motion-fx/interactions/scroll.js ***!
919  \********************************************************************************/
920(__unused_webpack_module, exports, __webpack_require__) {
921
922"use strict";
923
924
925var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
926Object.defineProperty(exports, "__esModule", ({
927  value: true
928}));
929exports["default"] = void 0;
930var _base = _interopRequireDefault(__webpack_require__(/*! ./base */ "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/base.js"));
931class _default extends _base.default {
932  run() {
933    if (pageYOffset === this.windowScrollTop) {
934      return false;

935    }
936    this.onScrollMovement();
937    this.windowScrollTop = pageYOffset;
938  }
939  onScrollMovement() {
940    this.updateMotionFxDimensions();
941    this.updateAnimation();
942    this.resetTransitionVariable();
943  }
944  resetTransitionVariable() {
945    this.motionFX.$element.css('--e-transform-transition-duration', '100ms');
946  }
947  updateMotionFxDimensions() {
948    const motionFXSettings = this.motionFX.getSettings();
949    if (motionFXSettings.refreshDimensions) {
950      this.motionFX.defineDimensions();
951    }
952  }
953  updateAnimation() {
954    let passedRangePercents;
955    if ('page' === this.motionFX.getSettings('range')) {
956      passedRangePercents = elementorModules.utils.Scroll.getPageScrollPercentage();
957    } else if (this.motionFX.getSettings('isFixedPosition')) {
958      passedRangePercents = elementorModules.utils.Scroll.getPageScrollPercentage({}, window.innerHeight);
959    } else {
960      passedRangePercents = elementorModules.utils.Scroll.getElementViewportPercentage(this.motionFX.elements.$parent);
961    }
962    this.runCallback(passedRangePercents);
963  }
964}
965exports["default"] = _default;
966
967/***/ },
968
969/***/ "../modules/motion-fx/assets/js/frontend/motion-fx/motion-fx.js"
970/*!**********************************************************************!*\
971  !*** ../modules/motion-fx/assets/js/frontend/motion-fx/motion-fx.js ***!
972  \**********************************************************************/
973(__unused_webpack_module, exports, __webpack_require__) {
974
975"use strict";
976
977
978var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
979Object.defineProperty(exports, "__esModule", ({
980  value: true
981}));
982exports["default"] = void 0;
983var _scroll = _interopRequireDefault(__webpack_require__(/*! ./interactions/scroll */ "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/scroll.js"));
984var _mouseMove = _interopRequireDefault(__webpack_require__(/*! ./interactions/mouse-move */ "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/mouse-move.js"));
985var _actions = _interopRequireDefault(__webpack_require__(/*! ./actions */ "../modules/motion-fx/assets/js/frontend/motion-fx/actions.js"));
986class _default extends elementorModules.ViewModule {
987  getDefaultSettings() {
988    return {
989      type: 'element',
990      $element: null,
991      $dimensionsElement: null,
992      addBackgroundLayerTo: null,
993      interactions: {},
994      refreshDimensions: false,
995      range: 'viewport',
996      classes: {
997        element: 'motion-fx-element',
998        parent: 'motion-fx-parent',
999        backgroundType: 'motion-fx-element-type-background',
1000        container: 'motion-fx-container',
1001        layer: 'motion-fx-layer',
1002        perspective: 'motion-fx-perspective'
1003      }
1004    };
1005  }
1006  bindEvents() {
1007    this.defineDimensions = this.defineDimensions.bind(this);
1008    elementorFrontend.elements.$window.on('resize elementor-pro/motion-fx/recalc', this.defineDimensions);
1009  }
1010  unbindEvents() {
1011    elementorFrontend.elements.$window.off('resize elementor-pro/motion-fx/recalc', this.defineDimensions);
1012  }
1013  addBackgroundLayer() {
1014    const settings = this.getSettings();
1015    this.elements.$motionFXContainer = jQuery('<div>', {
1016      class: settings.classes.container
1017    });
1018    this.elements.$motionFXLayer = jQuery('<div>', {
1019      class: settings.classes.layer
1020    });

1021    this.updateBackgroundLayerSize();
1022    this.elements.$motionFXContainer.prepend(this.elements.$motionFXLayer);
1023    const $addBackgroundLayerTo = settings.addBackgroundLayerTo ? this.$element.find(settings.addBackgroundLayerTo) : this.$element;
1024    $addBackgroundLayerTo.prepend(this.elements.$motionFXContainer);
1025  }
1026  removeBackgroundLayer() {
1027    this.elements.$motionFXContainer.remove();
1028  }
1029  updateBackgroundLayerSize() {
1030    const settings = this.getSettings(),
1031      speed = {
1032        x: 0,
1033        y: 0
1034      },
1035      mouseInteraction = settings.interactions.mouseMove,
1036      scrollInteraction = settings.interactions.scroll;
1037    if (mouseInteraction && mouseInteraction.translateXY) {
1038      speed.x = mouseInteraction.translateXY.speed * 10;
1039      speed.y = mouseInteraction.translateXY.speed * 10;
1040    }
1041    if (scrollInteraction) {
1042      if (scrollInteraction.translateX) {
1043        speed.x = scrollInteraction.translateX.speed * 10;
1044      }
1045      if (scrollInteraction.translateY) {
1046        speed.y = scrollInteraction.translateY.speed * 10;
1047      }
1048    }
1049    this.elements.$motionFXLayer.css({
1050      width: 100 + speed.x + '%',
1051      height: 100 + speed.y + '%'
1052    });
1053  }
1054  defineDimensions() {
1055    const $dimensionsElement = this.getSettings('$dimensionsElement') || this.$element,
1056      elementOffset = $dimensionsElement.offset();
1057    const dimensions = {
1058      elementHeight: $dimensionsElement.outerHeight(),
1059      elementWidth: $dimensionsElement.outerWidth(),
1060      elementTop: elementOffset.top,
1061      elementLeft: elementOffset.left
1062    };
1063    dimensions.elementRange = dimensions.elementHeight + innerHeight;
1064    this.setSettings('dimensions', dimensions);
1065    if ('background' === this.getSettings('type')) {
1066      this.defineBackgroundLayerDimensions();
1067    }
1068  }
1069  defineBackgroundLayerDimensions() {
1070    const dimensions = this.getSettings('dimensions');
1071    dimensions.layerHeight = this.elements.$motionFXLayer.height();
1072    dimensions.layerWidth = this.elements.$motionFXLayer.width();
1073    dimensions.movableX = dimensions.layerWidth - dimensions.elementWidth;
1074    dimensions.movableY = dimensions.layerHeight - dimensions.elementHeight;
1075    this.setSettings('dimensions', dimensions);
1076  }
1077  initInteractionsTypes() {
1078    this.interactionsTypes = {
1079      scroll: _scroll.default,
1080      mouseMove: _mouseMove.default
1081    };
1082  }
1083  prepareSpecialActions() {
1084    const settings = this.getSettings(),
1085      hasTiltEffect = !!(settings.interactions.mouseMove && settings.interactions.mouseMove.tilt);
1086    this.elements.$parent.toggleClass(settings.classes.perspective, hasTiltEffect);
1087  }
1088  cleanSpecialActions() {
1089    const settings = this.getSettings();
1090    this.elements.$parent.removeClass(settings.classes.perspective);
1091  }
1092  runInteractions() {
1093    const settings = this.getSettings();
1094    this.actions.setCSSTransformVariables(settings.elementSettings);
1095    this.prepareSpecialActions();
1096    jQuery.each(settings.interactions, (interactionName, actions) => {
1097      this.interactions[interactionName] = new this.interactionsTypes[interactionName]({
1098        motionFX: this,
1099        callback: (...args) => {
1100          jQuery.each(actions, (actionName, actionData) => this.actions.runAction(actionName, actionData, ...args));
1101        }
1102      });
1103      this.interactions[interactionName].run();
1104    });
1105  }
1106  destroyInteractions() {
1107    this.cleanSpecialActions();
1108    jQuery.each(this.interactions, (interactionName, interaction) => interaction.destroy());
1109    this.interactions = {};
1110  }
1111  refresh() {
1112    this.actions.setSettings(this.getSettings());
1113    if ('background' === this.getSettings('type')) {

1114      this.updateBackgroundLayerSize();
1115      this.defineBackgroundLayerDimensions();
1116    }
1117    this.actions.refresh();
1118    this.destroyInteractions();
1119    this.runInteractions();
1120  }
1121  destroy() {
1122    this.destroyInteractions();
1123    this.actions.refresh();
1124    const settings = this.getSettings();
1125    this.$element.removeClass(settings.classes.element);
1126    this.elements.$parent.removeClass(settings.classes.parent);
1127    if ('background' === settings.type) {
1128      this.$element.removeClass(settings.classes.backgroundType);
1129      this.removeBackgroundLayer();
1130    }
1131  }
1132  onInit() {
1133    super.onInit();
1134    const settings = this.getSettings();
1135    this.$element = settings.$element;
1136    this.elements.$parent = this.$element.parent();
1137    this.$element.addClass(settings.classes.element);
1138    this.elements.$parent = this.$element.parent();
1139    this.elements.$parent.addClass(settings.classes.parent);
1140    if ('background' === settings.type) {
1141      this.$element.addClass(settings.classes.backgroundType);
1142      this.addBackgroundLayer();
1143    }
1144    this.defineDimensions();
1145    settings.$targetElement = 'element' === settings.type ? this.$element : this.elements.$motionFXLayer;
1146    this.interactions = {};
1147    this.actions = new _actions.default(settings);
1148    this.initInteractionsTypes();
1149    this.runInteractions();
1150  }
1151}
1152exports["default"] = _default;
1153
1154/***/ },
1155
1156/***/ "../modules/payments/assets/js/frontend/frontend.js"
1157/*!**********************************************************!*\
1158  !*** ../modules/payments/assets/js/frontend/frontend.js ***!
1159  \**********************************************************/
1160(__unused_webpack_module, exports, __webpack_require__) {
1161
1162"use strict";
1163
1164
1165Object.defineProperty(exports, "__esModule", ({
1166  value: true
1167}));
1168exports["default"] = void 0;
1169class _default extends elementorModules.Module {
1170  constructor() {
1171    super();
1172    elementorFrontend.elementsHandler.attachHandler('paypal-button', () => __webpack_require__.e(/*! import() | paypal-button */ "paypal-button").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/paypal-button */ "../modules/payments/assets/js/frontend/handlers/paypal-button.js")));
1173    elementorFrontend.elementsHandler.attachHandler('stripe-button', () => Promise.all(/*! import() | stripe-button */[__webpack_require__.e("vendors-node_modules_dompurify_dist_purify_cjs_js"), __webpack_require__.e("stripe-button")]).then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/stripe-button */ "../modules/payments/assets/js/frontend/handlers/stripe-button.js")));
1174  }
1175}
1176exports["default"] = _default;
1177
1178/***/ },
1179
1180/***/ "../modules/progress-tracker/assets/js/frontend/frontend.js"
1181/*!******************************************************************!*\
1182  !*** ../modules/progress-tracker/assets/js/frontend/frontend.js ***!
1183  \******************************************************************/
1184(__unused_webpack_module, exports, __webpack_require__) {
1185
1186"use strict";
1187
1188
1189Object.defineProperty(exports, "__esModule", ({
1190  value: true
1191}));
1192exports["default"] = void 0;
1193class _default extends elementorModules.Module {
1194  constructor() {
1195    super();
1196    elementorFrontend.elementsHandler.attachHandler('progress-tracker', () => __webpack_require__.e(/*! import() | progress-tracker */ "progress-tracker").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/progress-tracker */ "../modules/progress-tracker/assets/js/frontend/handlers/progress-tracker.js")));
1197  }
1198}
1199exports["default"] = _default;
1200
1201/***/ },
1202
1203/***/ "../modules/sticky/assets/js/frontend/frontend.js"
1204/*!********************************************************!*\
1205  !*** ../modules/sticky/assets/js/frontend/frontend.js ***!
1206  \********************************************************/
1207(__unused_webpack_module, exports, __webpack_require__) {
1208
1209"use strict";
1210
1211
1212var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
1213Object.defineProperty(exports, "__esModule", ({
1214  value: true
1215}));
1216exports["default"] = void 0;
1217var _sticky = _interopRequireDefault(__webpack_require__(/*! ./handlers/sticky */ "../modules/sticky/assets/js/frontend/handlers/sticky.js"));
1218class _default extends elementorModules.Module {
1219  constructor() {
1220    super();
1221    elementorFrontend.elementsHandler.attachHandler('section', _sticky.default, null);
1222    elementorFrontend.elementsHandler.attachHandler('container', _sticky.default, null);
1223    elementorFrontend.elementsHandler.attachHandler('widget', _sticky.default, null);
1224  }
1225}
1226exports["default"] = _default;
1227
1228/***/ },
1229
1230/***/ "../modules/sticky/assets/js/frontend/handlers/sticky.js"
1231/*!***************************************************************!*\
1232  !*** ../modules/sticky/assets/js/frontend/handlers/sticky.js ***!
1233  \***************************************************************/
1234(__unused_webpack_module, exports, __webpack_require__) {
1235
1236"use strict";
1237
1238
1239Object.defineProperty(exports, "__esModule", ({
1240  value: true
1241}));
1242exports["default"] = void 0;
1243var _utils = __webpack_require__(/*! elementor-frontend/utils/utils */ "../../elementor/assets/dev/js/frontend/utils/utils.js");
1244var _default = exports["default"] = elementorModules.frontend.handlers.Base.extend({
1245  currentConfig: {},
1246  debouncedReactivate: null,
1247  bindEvents() {
1248    elementorFrontend.addListenerOnce(this.getUniqueHandlerID() + 'sticky', 'resize', this.reactivateOnResize);
1249  },
1250  unbindEvents() {
1251    elementorFrontend.removeListeners(this.getUniqueHandlerID() + 'sticky', 'resize', this.reactivateOnResize);
1252  },
1253  isStickyInstanceActive() {
1254    return undefined !== this.$element.data('sticky');
1255  },
1256  /**
1257   * Get the current active setting value for a responsive control.
1258   *
1259   * @param {string} setting
1260   * @return {any} - Setting value.
1261   */
1262  getResponsiveSetting(setting) {
1263    const elementSettings = this.getElementSettings();
1264    return elementorFrontend.getCurrentDeviceSetting(elementSettings, setting);
1265  },
1266  /**
1267   * Return an array of settings names for responsive control (e.g. `settings`, `setting_tablet`, `setting_mobile` ).
1268   *
1269   * @param {string} setting
1270   * @return {string[]} - List of settings.
1271   */
1272  getResponsiveSettingList(setting) {
1273    const breakpoints = Object.keys(elementorFrontend.config.responsive.activeBreakpoints);
1274    return ['', ...breakpoints].map(suffix => {
1275      return suffix ? `${setting}_${suffix}` : setting;
1276    });
1277  },
1278  getConfig() {
1279    const elementSettings = this.getElementSettings(),
1280      stickyOptions = {
1281        to: elementSettings.sticky,
1282        offset: this.getResponsiveSetting('sticky_offset'),
1283        effectsOffset: this.getResponsiveSetting('sticky_effects_offset'),
1284        classes: {
1285          sticky: 'elementor-sticky',
1286          stickyActive: 'elementor-sticky--active elementor-section--handles-inside',
1287          stickyEffects: 'elementor-sticky--effects',
1288          spacer: 'elementor-sticky__spacer'
1289        },
1290        isRTL: elementorFrontend.config.is_rtl,
1291        isScrollSnapActive: (0, _utils.isScrollSnapActive)(),
1292        // In edit mode, since the preview is an iframe, the scrollbar is on the left. The scrollbar width is
1293        // compensated for in this case.
1294        handleScrollbarWidth: elementorFrontend.isEditMode()
1295      },
1296      $wpAdminBar = elementorFrontend.elements.$wpAdminBar,
1297      isParentContainer = this.isContainerElement(this.$element[0]) && !this.isContainerElement(this.$element[0].parentElement);
1298    if ($wpAdminBar.length && 'top' === elementSettings.sticky && 'fixed' === $wpAdminBar.css('position')) {

1299      stickyOptions.offset += $wpAdminBar.height();
1300    }
1301
1302    // The `stickyOptions.parent` value should only be applied to inner elements, and not to top level containers.
1303    if (elementSettings.sticky_parent && !isParentContainer) {
1304      stickyOptions.parent = '.e-con, .e-con-inner, .elementor-widget-wrap';
1305    }
1306    return stickyOptions;
1307  },
1308  activate() {
1309    this.currentConfig = this.getConfig();
1310    this.$element.sticky(this.currentConfig);
1311  },
1312  deactivate() {
1313    if (!this.isStickyInstanceActive()) {
1314      return;
1315    }
1316    this.$element.sticky('destroy');
1317  },
1318  run(refresh) {
1319    if (!this.getElementSettings('sticky')) {
1320      this.deactivate();
1321      return;
1322    }
1323    var currentDeviceMode = elementorFrontend.getCurrentDeviceMode(),
1324      activeDevices = this.getElementSettings('sticky_on');
1325    if (-1 !== activeDevices.indexOf(currentDeviceMode)) {
1326      if (true === refresh) {
1327        this.reactivate();
1328      } else if (!this.isStickyInstanceActive()) {
1329        this.activate();
1330      }
1331    } else {
1332      this.deactivate();
1333    }
1334  },
1335  /**
1336   * Reactivate the sticky instance on resize only if the new sticky config is different from the current active one,
1337   * in order to avoid re-initializing the sticky when not needed, and avoid layout shifts.
1338   * The config can be different between devices, so this need to be checked on each screen resize to make sure that
1339   * the current screen size uses the appropriate Sticky config.
1340   *
1341   * @return {void}
1342   */
1343  reactivateOnResize() {
1344    clearTimeout(this.debouncedReactivate);
1345    this.debouncedReactivate = setTimeout(() => {
1346      const config = this.getConfig(),
1347        isDifferentConfig = JSON.stringify(config) !== JSON.stringify(this.currentConfig);
1348      if (isDifferentConfig) {
1349        this.run(true);
1350      }
1351    }, 300);
1352  },
1353  reactivate() {
1354    this.deactivate();
1355    this.activate();
1356  },
1357  onElementChange(settingKey) {
1358    if (-1 !== ['sticky', 'sticky_on'].indexOf(settingKey)) {
1359      this.run(true);
1360    }
1361
1362    // Settings that trigger a re-activation when changed.
1363    const settings = [...this.getResponsiveSettingList('sticky_offset'), ...this.getResponsiveSettingList('sticky_effects_offset'), 'sticky_parent'];
1364    if (-1 !== settings.indexOf(settingKey)) {
1365      this.reactivate();
1366    }
1367  },
1368  /**
1369   * Listen to device mode changes and re-initialize the sticky.
1370   *
1371   * @return {void}
1372   */
1373  onDeviceModeChange() {
1374    // Wait for the call stack to be empty.
1375    // The `run` function requests the current device mode from the CSS so it's not ready immediately.
1376    // (need to wait for the `deviceMode` event to change the CSS).
1377    // See `elementorFrontend.getCurrentDeviceMode()` for reference.
1378    setTimeout(() => this.run(true));
1379  },
1380  onInit() {
1381    elementorModules.frontend.handlers.Base.prototype.onInit.apply(this, arguments);
1382    if (elementorFrontend.isEditMode()) {
1383      elementor.listenTo(elementor.channels.deviceMode, 'change', () => this.onDeviceModeChange());
1384    }
1385    this.run();
1386  },
1387  onDestroy() {
1388    elementorModules.frontend.handlers.Base.prototype.onDestroy.apply(this, arguments);
1389    this.deactivate();
1390  },
1391  /**
1392   *
1393   * @param {HTMLElement|null|undefined} element
1394   * @return {boolean} Is the passed element a container.
1395   */
1396  isContainerElement(element) {
1397    const containerClasses = ['e-con', 'e-con-inner'];
1398    return containerClasses.some(containerClass => {
1399      return element?.classList.contains(containerClass);
1400    });
1401  }
1402});
1403
1404/***/ },
1405
1406/***/ "../modules/video-playlist/assets/js/frontend/frontend.js"
1407/*!****************************************************************!*\
1408  !*** ../modules/video-playlist/assets/js/frontend/frontend.js ***!
1409  \****************************************************************/
1410(__unused_webpack_module, exports, __webpack_require__) {
1411
1412"use strict";
1413
1414
1415Object.defineProperty(exports, "__esModule", ({
1416  value: true
1417}));
1418exports["default"] = void 0;
1419class _default extends elementorModules.Module {
1420  constructor() {
1421    super();
1422    elementorFrontend.hooks.addAction('frontend/element_ready/video-playlist.default', $element => {
1423      __webpack_require__.e(/*! import() | video-playlist */ "video-playlist").then(__webpack_require__.bind(__webpack_require__, /*! ./handler */ "../modules/video-playlist/assets/js/frontend/handler.js")).then(({
1424        default: dynamicHandler
1425      }) => {
1426        elementorFrontend.elementsHandler.addHandler(dynamicHandler, {
1427          $element,
1428          toggleSelf: false
1429        });
1430      });
1431    });
1432  }
1433}
1434exports["default"] = _default;
1435
1436/***/ },
1437
1438/***/ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js"
1439/*!***********************************************************************!*\
1440  !*** ../node_modules/@babel/runtime/helpers/interopRequireDefault.js ***!
1441  \***********************************************************************/
1442(module) {
1443
1444function _interopRequireDefault(e) {

1445  return e && e.__esModule ? e : {
1446    "default": e
1447  };
1448}
1449module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
1450
1451/***/ }
1452
1453},
1454/******/ __webpack_require__ => { // webpackRuntimeModules
1455/******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
1456/******/ var __webpack_exports__ = (__webpack_exec__("../assets/dev/js/frontend/frontend.js"));
1457/******/ }
1458]);
1459//# sourceMappingURL=frontend.js.map

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.