frontend.js?ver=3.6.5

js quayfm.gg collected 2026-10-06 20:37:47 UTC 91,937 bytes, 2,976 lines download raw bytes

1/*! elementor - v3.6.5 - 27-04-2022 */
2"use strict";
3(self["webpackChunkelementor"] = self["webpackChunkelementor"] || []).push([["frontend"],{
4

5/***/ "../assets/dev/js/frontend/documents-manager.js":
6/*!******************************************************!*\
7  !*** ../assets/dev/js/frontend/documents-manager.js ***!
8  \******************************************************/
9/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
10
11
12
13var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
14
15Object.defineProperty(exports, "__esModule", ({
16  value: true
17}));
18exports["default"] = void 0;
19
20var _document = _interopRequireDefault(__webpack_require__(/*! ./document */ "../assets/dev/js/frontend/document.js"));
21
22class _default extends elementorModules.ViewModule {
23  constructor(...args) {
24    super(...args);
25    this.documents = {};
26    this.initDocumentClasses();
27    this.attachDocumentsClasses();
28  }
29
30  getDefaultSettings() {
31    return {
32      selectors: {
33        document: '.elementor'
34      }
35    };
36  }
37
38  getDefaultElements() {
39    const selectors = this.getSettings('selectors');
40    return {
41      $documents: jQuery(selectors.document)
42    };
43  }
44
45  initDocumentClasses() {
46    this.documentClasses = {
47      base: _document.default
48    };
49    elementorFrontend.hooks.doAction('elementor/frontend/documents-manager/init-classes', this);
50  }
51
52  addDocumentClass(documentType, documentClass) {
53    this.documentClasses[documentType] = documentClass;
54  }
55
56  attachDocumentsClasses() {
57    this.elements.$documents.each((index, document) => this.attachDocumentClass(jQuery(document)));
58  }
59
60  attachDocumentClass($document) {
61    const documentData = $document.data(),
62          documentID = documentData.elementorId,
63          documentType = documentData.elementorType,
64          DocumentClass = this.documentClasses[documentType] || this.documentClasses.base;
65    this.documents[documentID] = new DocumentClass({
66      $element: $document,
67      id: documentID
68    });
69  }
70
71}
72
73exports["default"] = _default;
74
75/***/ }),
76

77/***/ "../assets/dev/js/frontend/elements-handlers-manager.js":
78/*!**************************************************************!*\
79  !*** ../assets/dev/js/frontend/elements-handlers-manager.js ***!
80  \**************************************************************/
81/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
82
83
84
85var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
86
87var _global = _interopRequireDefault(__webpack_require__(/*! ./handlers/global */ "../assets/dev/js/frontend/handlers/global.js"));
88
89var _background = _interopRequireDefault(__webpack_require__(/*! ./handlers/background */ "../assets/dev/js/frontend/handlers/background.js"));
90
91var _container = _interopRequireDefault(__webpack_require__(/*! ./handlers/container/container */ "../assets/dev/js/frontend/handlers/container/container.js"));
92
93var _column = _interopRequireDefault(__webpack_require__(/*! ./handlers/column */ "../assets/dev/js/frontend/handlers/column.js"));
94
95var _handlesPosition = _interopRequireDefault(__webpack_require__(/*! ./handlers/section/handles-position */ "../assets/dev/js/frontend/handlers/section/handles-position.js"));
96
97var _stretchedSection = _interopRequireDefault(__webpack_require__(/*! ./handlers/section/stretched-section */ "../assets/dev/js/frontend/handlers/section/stretched-section.js"));
98
99var _shapes = _interopRequireDefault(__webpack_require__(/*! ./handlers/section/shapes */ "../assets/dev/js/frontend/handlers/section/shapes.js"));
100
101// Section handlers.
102module.exports = function ($) {
103  const handlersInstances = {};
104  this.elementsHandlers = {
105    'accordion.default': () => __webpack_require__.e(/*! import() | accordion */ "accordion").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/accordion */ "../assets/dev/js/frontend/handlers/accordion.js")),
106    'alert.default': () => __webpack_require__.e(/*! import() | alert */ "alert").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/alert */ "../assets/dev/js/frontend/handlers/alert.js")),
107    'counter.default': () => __webpack_require__.e(/*! import() | counter */ "counter").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/counter */ "../assets/dev/js/frontend/handlers/counter.js")),
108    'progress.default': () => __webpack_require__.e(/*! import() | progress */ "progress").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/progress */ "../assets/dev/js/frontend/handlers/progress.js")),
109    'tabs.default': () => __webpack_require__.e(/*! import() | tabs */ "tabs").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/tabs */ "../assets/dev/js/frontend/handlers/tabs.js")),
110    'toggle.default': () => __webpack_require__.e(/*! import() | toggle */ "toggle").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/toggle */ "../assets/dev/js/frontend/handlers/toggle.js")),
111    'video.default': () => __webpack_require__.e(/*! import() | video */ "video").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/video */ "../assets/dev/js/frontend/handlers/video.js")),
112    'image-carousel.default': () => __webpack_require__.e(/*! import() | image-carousel */ "image-carousel").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/image-carousel */ "../assets/dev/js/frontend/handlers/image-carousel.js")),
113    'text-editor.default': () => __webpack_require__.e(/*! import() | text-editor */ "text-editor").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/text-editor */ "../assets/dev/js/frontend/handlers/text-editor.js")),
114    'wp-widget-media_audio.default': () => __webpack_require__.e(/*! import() | wp-audio */ "wp-audio").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/wp-audio */ "../assets/dev/js/frontend/handlers/wp-audio.js"))
115  };
116
117  const addGlobalHandlers = () => elementorFrontend.hooks.addAction('frontend/element_ready/global', _global.default);
118
119  const addElementsHandlers = () => {
120    this.elementsHandlers.section = [_stretchedSection.default, // Must run before background handlers to init the slideshow only after the stretch.
121    ..._background.default, _handlesPosition.default, _shapes.default];
122    this.elementsHandlers.container = [..._background.default]; // Add editor-only handlers.
123
124    if (elementorFrontend.isEditMode()) {
125      this.elementsHandlers.container.push(..._container.default);
126    }
127
128    this.elementsHandlers.column = _column.default;
129    $.each(this.elementsHandlers, (elementName, Handlers) => {
130      const elementData = elementName.split('.');
131      elementName = elementData[0];
132      const skin = elementData[1] || null;
133      this.attachHandler(elementName, Handlers, skin);
134    });
135  };
136
137  const isClassHandler = Handler => {
138    var _Handler$prototype;
139
140    return (_Handler$prototype = Handler.prototype) === null || _Handler$prototype === void 0 ? void 0 : _Handler$prototype.getUniqueHandlerID;
141  };
142
143  const addHandlerWithHook = (elementName, Handler, skin = 'default') => {
144    skin = skin ? '.' + skin : '';
145    elementorFrontend.hooks.addAction(`frontend/element_ready/${elementName}${skin}`, $element => {
146      if (isClassHandler(Handler)) {
147        this.addHandler(Handler, {
148          $element
149        }, true);
150      } else {
151        const handlerValue = Handler();
152
153        if (!handlerValue) {
154          return;
155        }
156
157        if (handlerValue instanceof Promise) {
158          handlerValue.then(({
159            default: dynamicHandler
160          }) => {
161            this.addHandler(dynamicHandler, {
162              $element
163            }, true);
164          });
165        } else {
166          this.addHandler(handlerValue, {
167            $element
168          }, true);
169        }
170      }
171    });
172  };
173
174  this.addHandler = function (HandlerClass, options) {
175    const elementID = options.$element.data('model-cid');
176    let handlerID; // If element is in edit mode
177
178    if (elementID) {
179      handlerID = HandlerClass.prototype.getConstructorID();
180
181      if (!handlersInstances[elementID]) {
182        handlersInstances[elementID] = {};
183      }
184
185      const oldHandler = handlersInstances[elementID][handlerID];
186
187      if (oldHandler) {
188        oldHandler.onDestroy();
189      }
190    }
191
192    const newHandler = new HandlerClass(options);
193
194    if (elementID) {
195      handlersInstances[elementID][handlerID] = newHandler;
196    }
197  };
198
199  this.attachHandler = (elementName, Handlers, skin) => {
200    if (!Array.isArray(Handlers)) {
201      Handlers = [Handlers];
202    }
203

204    Handlers.forEach(Handler => addHandlerWithHook(elementName, Handler, skin));
205  };
206
207  this.getHandler = function (handlerName) {
208    const elementHandler = this.elementsHandlers[handlerName];
209
210    if (isClassHandler(elementHandler)) {
211      return elementHandler;
212    }
213
214    return new Promise(res => {
215      elementHandler().then(({
216        default: dynamicHandler
217      }) => {
218        res(dynamicHandler);
219      });
220    });
221  };
222
223  this.getHandlers = function (handlerName) {
224    elementorCommon.helpers.softDeprecated('getHandlers', '3.1.0', 'elementorFrontend.elementsHandler.getHandler');
225
226    if (handlerName) {
227      return this.getHandler(handlerName);
228    }
229
230    return this.elementsHandlers;
231  };
232
233  this.runReadyTrigger = function (scope) {
234    if (elementorFrontend.config.is_static) {
235      return;
236    } // Initializing the `$scope` as frontend jQuery instance
237
238
239    const $scope = jQuery(scope),
240          elementType = $scope.attr('data-element_type');
241
242    if (!elementType) {
243      return;
244    }
245
246    elementorFrontend.hooks.doAction('frontend/element_ready/global', $scope, $);
247    elementorFrontend.hooks.doAction(`frontend/element_ready/${elementType}`, $scope, $);
248
249    if ('widget' === elementType) {
250      const widgetType = $scope.attr('data-widget_type');
251      elementorFrontend.hooks.doAction(`frontend/element_ready/${widgetType}`, $scope, $);
252    }
253  };
254
255  this.init = () => {
256    addGlobalHandlers();
257    addElementsHandlers();
258  };
259};
260
261/***/ }),
262

263/***/ "../assets/dev/js/frontend/frontend.js":
264/*!*********************************************!*\
265  !*** ../assets/dev/js/frontend/frontend.js ***!
266  \*********************************************/
267/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
268
269
270
271var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
272
273Object.defineProperty(exports, "__esModule", ({
274  value: true
275}));
276exports["default"] = void 0;
277
278__webpack_require__(/*! ../public-path */ "../assets/dev/js/public-path.js");
279
280var _documentsManager = _interopRequireDefault(__webpack_require__(/*! ./documents-manager */ "../assets/dev/js/frontend/documents-manager.js"));
281
282var _storage = _interopRequireDefault(__webpack_require__(/*! elementor-common/utils/storage */ "../core/common/assets/js/utils/storage.js"));
283
284var _environment = _interopRequireDefault(__webpack_require__(/*! elementor-common/utils/environment */ "../core/common/assets/js/utils/environment.js"));
285
286var _youtubeLoader = _interopRequireDefault(__webpack_require__(/*! ./utils/video-api/youtube-loader */ "../assets/dev/js/frontend/utils/video-api/youtube-loader.js"));
287
288var _vimeoLoader = _interopRequireDefault(__webpack_require__(/*! ./utils/video-api/vimeo-loader */ "../assets/dev/js/frontend/utils/video-api/vimeo-loader.js"));
289
290var _baseLoader = _interopRequireDefault(__webpack_require__(/*! ./utils/video-api/base-loader */ "../assets/dev/js/frontend/utils/video-api/base-loader.js"));
291
292var _urlActions = _interopRequireDefault(__webpack_require__(/*! ./utils/url-actions */ "../assets/dev/js/frontend/utils/url-actions.js"));
293
294var _swiper = _interopRequireDefault(__webpack_require__(/*! ./utils/swiper */ "../assets/dev/js/frontend/utils/swiper.js"));
295
296var _lightboxManager = _interopRequireDefault(__webpack_require__(/*! ./utils/lightbox/lightbox-manager */ "../assets/dev/js/frontend/utils/lightbox/lightbox-manager.js"));
297
298var _assetsLoader = _interopRequireDefault(__webpack_require__(/*! ./utils/assets-loader */ "../assets/dev/js/frontend/utils/assets-loader.js"));
299
300var _breakpoints = _interopRequireDefault(__webpack_require__(/*! elementor-utils/breakpoints */ "../assets/dev/js/utils/breakpoints.js"));
301
302var _events = _interopRequireDefault(__webpack_require__(/*! elementor-utils/events */ "../assets/dev/js/utils/events.js"));
303
304var _frontend = _interopRequireDefault(__webpack_require__(/*! elementor/modules/shapes/assets/js/frontend/frontend */ "../modules/shapes/assets/js/frontend/frontend.js"));
305
306var _utils = __webpack_require__(/*! elementor-frontend/utils/utils */ "../assets/dev/js/frontend/utils/utils.js");
307
308/* global elementorFrontendConfig */
309const EventManager = __webpack_require__(/*! elementor-utils/hooks */ "../assets/dev/js/utils/hooks.js"),
310      ElementsHandler = __webpack_require__(/*! elementor-frontend/elements-handlers-manager */ "../assets/dev/js/frontend/elements-handlers-manager.js"),
311      AnchorsModule = __webpack_require__(/*! elementor-frontend/utils/anchors */ "../assets/dev/js/frontend/utils/anchors.js");
312
313class Frontend extends elementorModules.ViewModule {
314  constructor(...args) {
315    super(...args);
316    this.config = elementorFrontendConfig;
317    this.config.legacyMode = {
318      get elementWrappers() {
319        if (elementorFrontend.isEditMode()) {
320          elementorCommon.helpers.hardDeprecated('elementorFrontend.config.legacyMode.elementWrappers', '3.1.0', 'elementorFrontend.config.experimentalFeatures.e_dom_optimization');
321        }
322
323        return !elementorFrontend.config.experimentalFeatures.e_dom_optimization;
324      }
325
326    };
327    this.populateActiveBreakpointsConfig();
328  } // TODO: BC since 2.5.0
329
330
331  get Module() {
332    if (this.isEditMode()) {
333      parent.elementorCommon.helpers.hardDeprecated('elementorFrontend.Module', '2.5.0', 'elementorModules.frontend.handlers.Base');
334    }
335
336    return elementorModules.frontend.handlers.Base;
337  }
338
339  getDefaultSettings() {
340    return {
341      selectors: {
342        elementor: '.elementor',
343        adminBar: '#wpadminbar'
344      }
345    };
346  }
347
348  getDefaultElements() {
349    const defaultElements = {
350      window: window,
351      $window: jQuery(window),
352      $document: jQuery(document),
353      $head: jQuery(document.head),
354      $body: jQuery(document.body),
355      $deviceMode: jQuery('<span>', {
356        id: 'elementor-device-mode',
357        class: 'elementor-screen-only'
358      })
359    };
360    defaultElements.$body.append(defaultElements.$deviceMode);
361    return defaultElements;
362  }
363
364  bindEvents() {
365    this.elements.$window.on('resize', () => this.setDeviceModeData());
366  }
367  /**
368   * @deprecated 2.4.0 Use just `this.elements` instead
369   */
370
371
372  getElements(elementName) {
373    return this.getItems(this.elements, elementName);
374  }
375  /**
376   * @deprecated 2.4.0 This method was never in use
377   */
378
379
380  getPageSettings(settingName) {
381    const settingsObject = this.isEditMode() ? elementor.settings.page.model.attributes : this.config.settings.page;
382    return this.getItems(settingsObject, settingName);
383  }
384
385  getGeneralSettings(settingName) {
386    if (this.isEditMode()) {
387      parent.elementorCommon.helpers.softDeprecated('getGeneralSettings', '3.0.0', 'getKitSettings and remove the `elementor_` prefix');
388    }
389
390    return this.getKitSettings(`elementor_${settingName}`);
391  }
392
393  getKitSettings(settingName) {
394    // TODO: use Data API.
395    return this.getItems(this.config.kit, settingName);
396  }
397
398  getCurrentDeviceMode() {
399    return getComputedStyle(this.elements.$deviceMode[0], ':after').content.replace(/"/g, '');
400  }
401
402  getDeviceSetting(deviceMode, settings, settingKey) {
403    // Add specific handling for widescreen since it is larger than desktop.
404    if ('widescreen' === deviceMode) {
405      return this.getWidescreenSetting(settings, settingKey);
406    }
407
408    const devices = elementorFrontend.breakpoints.getActiveBreakpointsList({
409      largeToSmall: true,
410      withDesktop: true
411    });
412    let deviceIndex = devices.indexOf(deviceMode);
413
414    while (deviceIndex > 0) {
415      const currentDevice = devices[deviceIndex],
416            fullSettingKey = settingKey + '_' + currentDevice,
417            deviceValue = settings[fullSettingKey]; // Accept 0 as value.
418
419      if (deviceValue || 0 === deviceValue) {
420        return deviceValue;
421      }
422
423      deviceIndex--;
424    }
425
426    return settings[settingKey];
427  }
428
429  getWidescreenSetting(settings, settingKey) {
430    const deviceMode = 'widescreen',
431          widescreenSettingKey = settingKey + '_' + deviceMode;
432    let settingToReturn; // If the device mode is 'widescreen', and the setting exists - return it.
433
434    if (settings[widescreenSettingKey]) {
435      settingToReturn = settings[widescreenSettingKey];
436    } else {
437      // Otherwise, return the desktop setting
438      settingToReturn = settings[settingKey];
439    }
440
441    return settingToReturn;
442  }
443
444  getCurrentDeviceSetting(settings, settingKey) {
445    return this.getDeviceSetting(elementorFrontend.getCurrentDeviceMode(), settings, settingKey);
446  }
447
448  isEditMode() {
449    return this.config.environmentMode.edit;
450  }
451
452  isWPPreviewMode() {
453    return this.config.environmentMode.wpPreview;
454  }
455
456  initDialogsManager() {
457    let dialogsManager;
458
459    this.getDialogsManager = () => {
460      if (!dialogsManager) {
461        dialogsManager = new DialogsManager.Instance();
462      }
463
464      return dialogsManager;
465    };
466  }
467
468  initOnReadyComponents() {
469    this.utils = {
470      youtube: new _youtubeLoader.default(),
471      vimeo: new _vimeoLoader.default(),
472      baseVideoLoader: new _baseLoader.default(),
473      anchors: new AnchorsModule(),
474
475      get lightbox() {
476        return _lightboxManager.default.getLightbox();
477      },
478
479      urlActions: new _urlActions.default(),
480      swiper: _swiper.default,
481      environment: _environment.default,
482      assetsLoader: new _assetsLoader.default(),
483      escapeHTML: _utils.escapeHTML
484    }; // TODO: BC since 2.4.0
485
486    this.modules = {
487      StretchElement: elementorModules.frontend.tools.StretchElement,
488      Masonry: elementorModules.utils.Masonry
489    };
490    this.elementsHandler.init();
491
492    if (this.isEditMode()) {
493      elementor.once('document:loaded', () => this.onDocumentLoaded());
494    } else {
495      this.onDocumentLoaded();
496    }
497  }
498
499  initOnReadyElements() {
500    this.elements.$wpAdminBar = this.elements.$document.find(this.getSettings('selectors.adminBar'));
501  }
502
503  addUserAgentClasses() {
504    for (const [key, value] of Object.entries(_environment.default)) {
505      if (value) {
506        this.elements.$body.addClass('e--ua-' + key);
507      }
508    }
509  }
510
511  setDeviceModeData() {
512    this.elements.$body.attr('data-elementor-device-mode', this.getCurrentDeviceMode());
513  }
514
515  addListenerOnce(listenerID, event, callback, to) {
516    if (!to) {
517      to = this.elements.$window;
518    }
519
520    if (!this.isEditMode()) {
521      to.on(event, callback);
522      return;
523    }
524
525    this.removeListeners(listenerID, event, to);
526
527    if (to instanceof jQuery) {
528      const eventNS = event + '.' + listenerID;
529      to.on(eventNS, callback);
530    } else {
531      to.on(event, callback, listenerID);
532    }
533  }
534
535  removeListeners(listenerID, event, callback, from) {
536    if (!from) {
537      from = this.elements.$window;
538    }
539
540    if (from instanceof jQuery) {
541      const eventNS = event + '.' + listenerID;
542      from.off(eventNS, callback);
543    } else {
544      from.off(event, callback, listenerID);
545    }
546  } // Based on underscore function
547
548
549  debounce(func, wait) {
550    let timeout;
551    return function () {
552      const context = this,
553            args = arguments;
554
555      const later = () => {
556        timeout = null;

557        func.apply(context, args);
558      };
559
560      const callNow = !timeout;
561      clearTimeout(timeout);
562      timeout = setTimeout(later, wait);
563
564      if (callNow) {
565        func.apply(context, args);
566      }
567    };
568  }
569
570  waypoint($element, callback, options) {
571    const defaultOptions = {
572      offset: '100%',
573      triggerOnce: true
574    };
575    options = jQuery.extend(defaultOptions, options);
576
577    const correctCallback = function () {
578      const element = this.element || this,
579            result = callback.apply(element, arguments); // If is Waypoint new API and is frontend
580
581      if (options.triggerOnce && this.destroy) {
582        this.destroy();
583      }
584
585      return result;
586    };
587
588    return $element.elementorWaypoint(correctCallback, options);
589  }
590
591  muteMigrationTraces() {
592    jQuery.migrateMute = true;
593    jQuery.migrateTrace = false;
594  }
595  /**
596   * Initialize the modules' widgets handlers.
597   */
598
599
600  initModules() {
601    const handlers = {
602      shapes: _frontend.default
603    }; // TODO: BC - Deprecated since 3.5.0
604
605    elementorFrontend.trigger('elementor/modules/init:before'); // TODO: Use this instead.
606
607    elementorFrontend.trigger('elementor/modules/init/before');
608    Object.entries(handlers).forEach(([moduleName, ModuleClass]) => {
609      this.modulesHandlers[moduleName] = new ModuleClass();
610    });
611  }
612
613  populateActiveBreakpointsConfig() {
614    this.config.responsive.activeBreakpoints = {};
615    Object.entries(this.config.responsive.breakpoints).forEach(([breakpointKey, breakpointData]) => {
616      if (breakpointData.is_enabled) {
617        this.config.responsive.activeBreakpoints[breakpointKey] = breakpointData;
618      }
619    });
620  }
621
622  init() {
623    this.hooks = new EventManager();
624    this.breakpoints = new _breakpoints.default(this.config.responsive);
625    this.storage = new _storage.default();
626    this.elementsHandler = new ElementsHandler(jQuery);
627    this.modulesHandlers = {};
628    this.addUserAgentClasses();
629    this.setDeviceModeData();
630    this.initDialogsManager();
631
632    if (this.isEditMode()) {
633      this.muteMigrationTraces();
634    } // Keep this line before `initOnReadyComponents` call
635
636
637    _events.default.dispatch(this.elements.$window, 'elementor/frontend/init');
638
639    this.initModules();
640    this.initOnReadyElements();
641    this.initOnReadyComponents();
642  }
643
644  onDocumentLoaded() {
645    this.documentsManager = new _documentsManager.default();
646    this.trigger('components:init');
647    new _lightboxManager.default();
648  }
649
650}
651
652exports["default"] = Frontend;
653window.elementorFrontend = new Frontend();
654
655if (!elementorFrontend.isEditMode()) {
656  jQuery(() => elementorFrontend.init());
657}
658
659/***/ }),
660

661/***/ "../assets/dev/js/frontend/handlers/background-slideshow.js":
662/*!******************************************************************!*\
663  !*** ../assets/dev/js/frontend/handlers/background-slideshow.js ***!
664  \******************************************************************/
665/***/ ((__unused_webpack_module, exports) => {
666
667
668
669Object.defineProperty(exports, "__esModule", ({
670  value: true
671}));
672exports["default"] = void 0;
673
674class BackgroundSlideshow extends elementorModules.frontend.handlers.SwiperBase {
675  getDefaultSettings() {
676    return {
677      classes: {
678        swiperContainer: 'elementor-background-slideshow swiper-container',
679        swiperWrapper: 'swiper-wrapper',
680        swiperSlide: 'elementor-background-slideshow__slide swiper-slide',
681        swiperPreloader: 'swiper-lazy-preloader',
682        slideBackground: 'elementor-background-slideshow__slide__image',
683        kenBurns: 'elementor-ken-burns',
684        kenBurnsActive: 'elementor-ken-burns--active',
685        kenBurnsIn: 'elementor-ken-burns--in',
686        kenBurnsOut: 'elementor-ken-burns--out'
687      }
688    };
689  }
690
691  getSwiperOptions() {
692    const elementSettings = this.getElementSettings(),
693          swiperOptions = {
694      grabCursor: false,
695      slidesPerView: 1,
696      slidesPerGroup: 1,
697      loop: 'yes' === elementSettings.background_slideshow_loop,
698      speed: elementSettings.background_slideshow_transition_duration,
699      autoplay: {
700        delay: elementSettings.background_slideshow_slide_duration,
701        stopOnLastSlide: !elementSettings.background_slideshow_loop
702      },
703      handleElementorBreakpoints: true,
704      on: {
705        slideChange: () => {
706          if (elementSettings.background_slideshow_ken_burns) {
707            this.handleKenBurns();
708          }
709        }
710      }
711    };
712
713    if ('yes' === elementSettings.background_slideshow_loop) {
714      swiperOptions.loopedSlides = this.getSlidesCount();
715    }
716
717    switch (elementSettings.background_slideshow_slide_transition) {
718      case 'fade':
719        swiperOptions.effect = 'fade';
720        swiperOptions.fadeEffect = {
721          crossFade: true
722        };
723        break;
724
725      case 'slide_down':
726        swiperOptions.autoplay.reverseDirection = true;
727
728      case 'slide_up':
729        swiperOptions.direction = 'vertical';
730        break;
731    }
732
733    if ('yes' === elementSettings.background_slideshow_lazyload) {
734      swiperOptions.lazy = {
735        loadPrevNext: true,
736        loadPrevNextAmount: 1
737      };
738    }
739
740    return swiperOptions;
741  }
742
743  buildSwiperElements() {
744    const classes = this.getSettings('classes'),
745          elementSettings = this.getElementSettings(),
746          direction = 'slide_left' === elementSettings.background_slideshow_slide_transition ? 'ltr' : 'rtl',
747          $container = jQuery('<div>', {
748      class: classes.swiperContainer,
749      dir: direction
750    }),
751          $wrapper = jQuery('<div>', {
752      class: classes.swiperWrapper
753    }),
754          kenBurnsActive = elementSettings.background_slideshow_ken_burns,
755          lazyload = 'yes' === elementSettings.background_slideshow_lazyload;
756    let slideInnerClass = classes.slideBackground;
757
758    if (kenBurnsActive) {
759      slideInnerClass += ' ' + classes.kenBurns;
760      const kenBurnsDirection = 'in' === elementSettings.background_slideshow_ken_burns_zoom_direction ? 'kenBurnsIn' : 'kenBurnsOut';
761      slideInnerClass += ' ' + classes[kenBurnsDirection];
762    }
763
764    if (lazyload) {
765      slideInnerClass += ' swiper-lazy';
766    }
767
768    this.elements.$slides = jQuery();

769    elementSettings.background_slideshow_gallery.forEach(slide => {
770      const $slide = jQuery('<div>', {
771        class: classes.swiperSlide
772      });
773      let $slidebg;
774
775      if (lazyload) {
776        const $slideloader = jQuery('<div>', {
777          class: classes.swiperPreloader
778        });
779        $slidebg = jQuery('<div>', {
780          class: slideInnerClass,
781          'data-background': slide.url
782        });
783        $slidebg.append($slideloader);
784      } else {
785        $slidebg = jQuery('<div>', {
786          class: slideInnerClass,
787          style: 'background-image: url("' + slide.url + '");'
788        });
789      }
790
791      $slide.append($slidebg);
792      $wrapper.append($slide);
793      this.elements.$slides = this.elements.$slides.add($slide);
794    });
795    $container.append($wrapper);
796    this.$element.prepend($container);
797    this.elements.$backgroundSlideShowContainer = $container;
798  }
799
800  async initSlider() {
801    if (1 >= this.getSlidesCount()) {
802      return;
803    }
804
805    const elementSettings = this.getElementSettings();
806    const Swiper = elementorFrontend.utils.swiper;
807    this.swiper = await new Swiper(this.elements.$backgroundSlideShowContainer, this.getSwiperOptions()); // Expose the swiper instance in the frontend
808
809    this.elements.$backgroundSlideShowContainer.data('swiper', this.swiper);
810
811    if (elementSettings.background_slideshow_ken_burns) {
812      this.handleKenBurns();
813    }
814  }
815
816  activate() {
817    this.buildSwiperElements();
818    this.initSlider();
819  }
820
821  deactivate() {
822    if (this.swiper) {
823      this.swiper.destroy();
824      this.elements.$backgroundSlideShowContainer.remove();
825    }
826  }
827
828  run() {
829    if ('slideshow' === this.getElementSettings('background_background')) {
830      this.activate();
831    } else {
832      this.deactivate();
833    }
834  }
835
836  onInit() {
837    super.onInit();
838
839    if (this.getElementSettings('background_slideshow_gallery')) {
840      this.run();
841    }
842  }
843
844  onDestroy() {
845    super.onDestroy();
846    this.deactivate();
847  }
848
849  onElementChange(propertyName) {
850    if ('background_background' === propertyName) {
851      this.run();
852    }
853  }
854
855}
856
857exports["default"] = BackgroundSlideshow;
858
859/***/ }),
860

861/***/ "../assets/dev/js/frontend/handlers/background-video.js":
862/*!**************************************************************!*\
863  !*** ../assets/dev/js/frontend/handlers/background-video.js ***!
864  \**************************************************************/
865/***/ ((__unused_webpack_module, exports) => {
866
867
868
869Object.defineProperty(exports, "__esModule", ({
870  value: true
871}));
872exports["default"] = void 0;
873
874class BackgroundVideo extends elementorModules.frontend.handlers.Base {
875  getDefaultSettings() {
876    return {
877      selectors: {
878        backgroundVideoContainer: '.elementor-background-video-container',
879        backgroundVideoEmbed: '.elementor-background-video-embed',
880        backgroundVideoHosted: '.elementor-background-video-hosted'
881      }
882    };
883  }
884
885  getDefaultElements() {
886    const selectors = this.getSettings('selectors'),
887          elements = {
888      $backgroundVideoContainer: this.$element.find(selectors.backgroundVideoContainer)
889    };
890    elements.$backgroundVideoEmbed = elements.$backgroundVideoContainer.children(selectors.backgroundVideoEmbed);
891    elements.$backgroundVideoHosted = elements.$backgroundVideoContainer.children(selectors.backgroundVideoHosted);
892    return elements;
893  }
894
895  calcVideosSize($video) {
896    let aspectRatioSetting = '16:9';
897
898    if ('vimeo' === this.videoType) {
899      aspectRatioSetting = $video[0].width + ':' + $video[0].height;
900    }
901
902    const containerWidth = this.elements.$backgroundVideoContainer.outerWidth(),
903          containerHeight = this.elements.$backgroundVideoContainer.outerHeight(),
904          aspectRatioArray = aspectRatioSetting.split(':'),
905          aspectRatio = aspectRatioArray[0] / aspectRatioArray[1],
906          ratioWidth = containerWidth / aspectRatio,
907          ratioHeight = containerHeight * aspectRatio,
908          isWidthFixed = containerWidth / containerHeight > aspectRatio;
909    return {
910      width: isWidthFixed ? containerWidth : ratioHeight,
911      height: isWidthFixed ? ratioWidth : containerHeight
912    };
913  }
914
915  changeVideoSize() {
916    if (!('hosted' === this.videoType) && !this.player) {
917      return;
918    }
919
920    let $video;
921
922    if ('youtube' === this.videoType) {
923      $video = jQuery(this.player.getIframe());
924    } else if ('vimeo' === this.videoType) {
925      $video = jQuery(this.player.element);
926    } else if ('hosted' === this.videoType) {
927      $video = this.elements.$backgroundVideoHosted;
928    }
929
930    if (!$video) {
931      return;
932    }
933
934    const size = this.calcVideosSize($video);
935    $video.width(size.width).height(size.height);
936  }
937
938  startVideoLoop(firstTime) {
939    // If the section has been removed
940    if (!this.player.getIframe().contentWindow) {
941      return;
942    }
943
944    const elementSettings = this.getElementSettings(),
945          startPoint = elementSettings.background_video_start || 0,
946          endPoint = elementSettings.background_video_end;
947
948    if (elementSettings.background_play_once && !firstTime) {
949      this.player.stopVideo();
950      return;
951    }
952
953    this.player.seekTo(startPoint);
954
955    if (endPoint) {
956      const durationToEnd = endPoint - startPoint + 1;
957      setTimeout(() => {
958        this.startVideoLoop(false);
959      }, durationToEnd * 1000);
960    }
961  }
962
963  prepareVimeoVideo(Vimeo, videoLink) {
964    const elementSettings = this.getElementSettings(),
965          videoSize = this.elements.$backgroundVideoContainer.outerWidth(),
966          vimeoOptions = {
967      url: videoLink,
968      width: videoSize.width,
969      autoplay: true,
970      loop: !elementSettings.background_play_once,
971      transparent: false,
972      background: true,
973      muted: true
974    };
975    this.player = new Vimeo.Player(this.elements.$backgroundVideoContainer, vimeoOptions); // Handle user-defined start/end times
976
977    this.handleVimeoStartEndTimes(elementSettings);
978    this.player.ready().then(() => {
979      jQuery(this.player.element).addClass('elementor-background-video-embed');
980      this.changeVideoSize();
981    });
982  }
983
984  handleVimeoStartEndTimes(elementSettings) {
985    // If a start time is defined, set the start time
986    if (elementSettings.background_video_start) {
987      this.player.on('play', data => {
988        if (0 === data.seconds) {
989          this.player.setCurrentTime(elementSettings.background_video_start);
990        }
991      });
992    }
993
994    this.player.on('timeupdate', data => {
995      // If an end time is defined, handle ending the video
996      if (elementSettings.background_video_end && elementSettings.background_video_end < data.seconds) {
997        if (elementSettings.background_play_once) {
998          // Stop at user-defined end time if not loop
999          this.player.pause();
1000        } else {
1001          // Go to start time if loop
1002          this.player.setCurrentTime(elementSettings.background_video_start);
1003        }
1004      } // If start time is defined but an end time is not, go to user-defined start time at video end.
1005      // Vimeo JS API has an 'ended' event, but it never fires when infinite loop is defined, so we
1006      // get the video duration (returns a promise) then use duration-0.5s as end time
1007
1008
1009      this.player.getDuration().then(duration => {
1010        if (elementSettings.background_video_start && !elementSettings.background_video_end && data.seconds > duration - 0.5) {
1011          this.player.setCurrentTime(elementSettings.background_video_start);
1012        }
1013      });
1014    });
1015  }
1016
1017  prepareYTVideo(YT, videoID) {
1018    const $backgroundVideoContainer = this.elements.$backgroundVideoContainer,
1019          elementSettings = this.getElementSettings();
1020    let startStateCode = YT.PlayerState.PLAYING; // Since version 67, Chrome doesn't fire the `PLAYING` state at start time
1021
1022    if (window.chrome) {
1023      startStateCode = YT.PlayerState.UNSTARTED;
1024    }
1025
1026    const playerOptions = {
1027      videoId: videoID,
1028      events: {
1029        onReady: () => {
1030          this.player.mute();
1031          this.changeVideoSize();
1032          this.startVideoLoop(true);
1033          this.player.playVideo();
1034        },
1035        onStateChange: event => {
1036          switch (event.data) {
1037            case startStateCode:
1038              $backgroundVideoContainer.removeClass('elementor-invisible elementor-loading');
1039              break;
1040
1041            case YT.PlayerState.ENDED:
1042              this.player.seekTo(elementSettings.background_video_start || 0);
1043
1044              if (elementSettings.background_play_once) {
1045                this.player.destroy();
1046              }
1047
1048          }
1049        }
1050      },
1051      playerVars: {
1052        controls: 0,
1053        rel: 0,
1054        playsinline: 1
1055      }
1056    }; // To handle CORS issues, when the default host is changed, the origin parameter has to be set.
1057
1058    if (elementSettings.background_privacy_mode) {
1059      playerOptions.host = 'https://www.youtube-nocookie.com';
1060      playerOptions.origin = window.location.hostname;
1061    }
1062
1063    $backgroundVideoContainer.addClass('elementor-loading elementor-invisible');
1064    this.player = new YT.Player(this.elements.$backgroundVideoEmbed[0], playerOptions);
1065  }
1066
1067  activate() {
1068    let videoLink = this.getElementSettings('background_video_link'),
1069        videoID;
1070    const playOnce = this.getElementSettings('background_play_once');
1071
1072    if (-1 !== videoLink.indexOf('vimeo.com')) {
1073      this.videoType = 'vimeo';
1074      this.apiProvider = elementorFrontend.utils.vimeo;
1075    } else if (videoLink.match(/^(?:https?:\/\/)?(?:www\.)?(?:m\.)?(?:youtu\.be\/|youtube\.com)/)) {
1076      this.videoType = 'youtube';
1077      this.apiProvider = elementorFrontend.utils.youtube;
1078    }
1079
1080    if (this.apiProvider) {
1081      videoID = this.apiProvider.getVideoIDFromURL(videoLink);
1082      this.apiProvider.onApiReady(apiObject => {
1083        if ('youtube' === this.videoType) {
1084          this.prepareYTVideo(apiObject, videoID);
1085        }
1086
1087        if ('vimeo' === this.videoType) {
1088          this.prepareVimeoVideo(apiObject, videoLink);
1089        }
1090      });
1091    } else {
1092      this.videoType = 'hosted';
1093      const startTime = this.getElementSettings('background_video_start'),
1094            endTime = this.getElementSettings('background_video_end');
1095
1096      if (startTime || endTime) {
1097        videoLink += '#t=' + (startTime || 0) + (endTime ? ',' + endTime : '');
1098      }
1099
1100      this.elements.$backgroundVideoHosted.attr('src', videoLink).one('canplay', this.changeVideoSize.bind(this));
1101
1102      if (playOnce) {
1103        this.elements.$backgroundVideoHosted.on('ended', () => {
1104          this.elements.$backgroundVideoHosted.hide();
1105        });
1106      }
1107    }
1108
1109    elementorFrontend.elements.$window.on('resize', this.changeVideoSize);
1110  }
1111
1112  deactivate() {
1113    if ('youtube' === this.videoType && this.player.getIframe() || 'vimeo' === this.videoType) {
1114      this.player.destroy();
1115    } else {
1116      this.elements.$backgroundVideoHosted.removeAttr('src').off('ended');
1117    }
1118
1119    elementorFrontend.elements.$window.off('resize', this.changeVideoSize);
1120  }
1121
1122  run() {
1123    const elementSettings = this.getElementSettings();
1124
1125    if (!elementSettings.background_play_on_mobile && 'mobile' === elementorFrontend.getCurrentDeviceMode()) {
1126      return;
1127    }
1128
1129    if ('video' === elementSettings.background_background && elementSettings.background_video_link) {
1130      this.activate();
1131    } else {
1132      this.deactivate();
1133    }
1134  }
1135
1136  onInit(...args) {
1137    super.onInit(...args);
1138    this.changeVideoSize = this.changeVideoSize.bind(this);
1139    this.run();
1140  }
1141
1142  onElementChange(propertyName) {
1143    if ('background_background' === propertyName) {
1144      this.run();
1145    }
1146  }
1147
1148}
1149

1150exports["default"] = BackgroundVideo;
1151
1152/***/ }),
1153

1154/***/ "../assets/dev/js/frontend/handlers/background.js":
1155/*!********************************************************!*\
1156  !*** ../assets/dev/js/frontend/handlers/background.js ***!
1157  \********************************************************/
1158/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1159
1160
1161
1162var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
1163
1164Object.defineProperty(exports, "__esModule", ({
1165  value: true
1166}));
1167exports["default"] = void 0;
1168
1169var _backgroundSlideshow = _interopRequireDefault(__webpack_require__(/*! ./background-slideshow */ "../assets/dev/js/frontend/handlers/background-slideshow.js"));
1170
1171var _backgroundVideo = _interopRequireDefault(__webpack_require__(/*! ./background-video */ "../assets/dev/js/frontend/handlers/background-video.js"));
1172
1173var _default = [_backgroundSlideshow.default, _backgroundVideo.default];
1174exports["default"] = _default;
1175
1176/***/ }),
1177

1178/***/ "../assets/dev/js/frontend/handlers/column.js":
1179/*!****************************************************!*\
1180  !*** ../assets/dev/js/frontend/handlers/column.js ***!
1181  \****************************************************/
1182/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1183
1184
1185
1186var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
1187
1188Object.defineProperty(exports, "__esModule", ({
1189  value: true
1190}));
1191exports["default"] = void 0;
1192
1193var _backgroundSlideshow = _interopRequireDefault(__webpack_require__(/*! ./background-slideshow */ "../assets/dev/js/frontend/handlers/background-slideshow.js"));
1194
1195var _default = [_backgroundSlideshow.default];
1196exports["default"] = _default;
1197
1198/***/ }),
1199

1200/***/ "../assets/dev/js/frontend/handlers/container/container.js":
1201/*!*****************************************************************!*\
1202  !*** ../assets/dev/js/frontend/handlers/container/container.js ***!
1203  \*****************************************************************/
1204/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1205
1206
1207
1208Object.defineProperty(exports, "__esModule", ({
1209  value: true
1210}));
1211exports["default"] = void 0;
1212var _default = [() => __webpack_require__.e(/*! import() | container */ "container").then(__webpack_require__.bind(__webpack_require__, /*! ./handles-position */ "../assets/dev/js/frontend/handlers/container/handles-position.js")), () => __webpack_require__.e(/*! import() | container */ "container").then(__webpack_require__.bind(__webpack_require__, /*! ./shapes */ "../assets/dev/js/frontend/handlers/container/shapes.js"))];
1213exports["default"] = _default;
1214
1215/***/ }),
1216

1217/***/ "../assets/dev/js/frontend/handlers/global.js":
1218/*!****************************************************!*\
1219  !*** ../assets/dev/js/frontend/handlers/global.js ***!
1220  \****************************************************/
1221/***/ ((__unused_webpack_module, exports) => {
1222
1223
1224
1225Object.defineProperty(exports, "__esModule", ({
1226  value: true
1227}));
1228exports["default"] = void 0;
1229
1230class GlobalHandler extends elementorModules.frontend.handlers.Base {
1231  getWidgetType() {
1232    return 'global';
1233  }
1234
1235  animate() {
1236    const $element = this.$element,
1237          animation = this.getAnimation();
1238
1239    if ('none' === animation) {
1240      $element.removeClass('elementor-invisible');
1241      return;
1242    }
1243
1244    const elementSettings = this.getElementSettings(),
1245          animationDelay = elementSettings._animation_delay || elementSettings.animation_delay || 0;
1246    $element.removeClass(animation);
1247
1248    if (this.currentAnimation) {
1249      $element.removeClass(this.currentAnimation);
1250    }
1251
1252    this.currentAnimation = animation;
1253    setTimeout(() => {
1254      $element.removeClass('elementor-invisible').addClass('animated ' + animation);
1255    }, animationDelay);
1256  }
1257
1258  getAnimation() {
1259    return this.getCurrentDeviceSetting('animation') || this.getCurrentDeviceSetting('_animation');
1260  }
1261
1262  onInit(...args) {
1263    super.onInit(...args);
1264
1265    if (this.getAnimation()) {
1266      const observer = elementorModules.utils.Scroll.scrollObserver({
1267        callback: event => {
1268          if (event.isInViewport) {
1269            this.animate();
1270            observer.unobserve(this.$element[0]);
1271          }
1272        }
1273      });
1274      observer.observe(this.$element[0]);
1275    }
1276  }
1277
1278  onElementChange(propertyName) {
1279    if (/^_?animation/.test(propertyName)) {
1280      this.animate();
1281    }
1282  }
1283
1284}
1285
1286var _default = $scope => {
1287  elementorFrontend.elementsHandler.addHandler(GlobalHandler, {
1288    $element: $scope
1289  });
1290};
1291
1292exports["default"] = _default;
1293
1294/***/ }),
1295

1296/***/ "../assets/dev/js/frontend/handlers/section/handles-position.js":
1297/*!**********************************************************************!*\
1298  !*** ../assets/dev/js/frontend/handlers/section/handles-position.js ***!
1299  \**********************************************************************/
1300/***/ ((__unused_webpack_module, exports) => {
1301
1302
1303
1304Object.defineProperty(exports, "__esModule", ({
1305  value: true
1306}));
1307exports["default"] = void 0;
1308
1309class HandlesPosition extends elementorModules.frontend.handlers.Base {
1310  isActive() {
1311    return elementorFrontend.isEditMode();
1312  }
1313
1314  isFirstSection() {
1315    return this.$element[0] === document.querySelector('.elementor-edit-mode .elementor-top-section');
1316  }
1317
1318  isOverflowHidden() {
1319    return 'hidden' === this.$element.css('overflow');
1320  }
1321
1322  getOffset() {
1323    if ('body' === elementor.config.document.container) {
1324      return this.$element.offset().top;
1325    }
1326
1327    const $container = jQuery(elementor.config.document.container);
1328    return this.$element.offset().top - $container.offset().top;
1329  }
1330
1331  setHandlesPosition() {
1332    const document = elementor.documents.getCurrent();
1333
1334    if (!document || !document.container.isEditable()) {
1335      return;
1336    }
1337
1338    const insideHandleClass = 'elementor-section--handles-inside',
1339          $handlesElement = this.$element.find('> .elementor-element-overlay > .elementor-editor-section-settings');
1340
1341    if (elementor.settings.page.model.attributes.scroll_snap) {
1342      this.$element.addClass(insideHandleClass);
1343      return;
1344    }
1345
1346    const isOverflowHidden = this.isOverflowHidden();
1347
1348    if (!isOverflowHidden && !this.isFirstSection()) {
1349      return;
1350    }
1351
1352    const offset = isOverflowHidden ? 0 : this.getOffset();
1353
1354    if (offset < 25) {
1355      this.$element.addClass(insideHandleClass);
1356
1357      if (offset < -5) {
1358        $handlesElement.css('top', -offset);
1359      } else {
1360        $handlesElement.css('top', '');
1361      }
1362    } else {
1363      this.$element.removeClass(insideHandleClass);
1364    }
1365  }
1366
1367  onInit() {
1368    if (!this.isActive()) {
1369      return;
1370    }
1371
1372    this.setHandlesPosition();
1373    this.$element.on('mouseenter', this.setHandlesPosition.bind(this));
1374  }
1375
1376}
1377
1378exports["default"] = HandlesPosition;
1379
1380/***/ }),
1381

1382/***/ "../assets/dev/js/frontend/handlers/section/shapes.js":
1383/*!************************************************************!*\
1384  !*** ../assets/dev/js/frontend/handlers/section/shapes.js ***!
1385  \************************************************************/
1386/***/ ((__unused_webpack_module, exports) => {
1387
1388
1389
1390Object.defineProperty(exports, "__esModule", ({
1391  value: true
1392}));
1393exports["default"] = void 0;
1394
1395class Shapes extends elementorModules.frontend.handlers.Base {
1396  getDefaultSettings() {
1397    return {
1398      selectors: {
1399        container: '> .elementor-shape-%s'
1400      },
1401      svgURL: elementorFrontend.config.urls.assets + 'shapes/'
1402    };
1403  }
1404
1405  getDefaultElements() {
1406    const elements = {},
1407          selectors = this.getSettings('selectors');
1408    elements.$topContainer = this.$element.find(selectors.container.replace('%s', 'top'));
1409    elements.$bottomContainer = this.$element.find(selectors.container.replace('%s', 'bottom'));
1410    return elements;
1411  }
1412
1413  isActive() {
1414    return elementorFrontend.isEditMode();
1415  }
1416
1417  getSvgURL(shapeType, fileName) {
1418    let svgURL = this.getSettings('svgURL') + fileName + '.svg';
1419
1420    if (elementor.config.additional_shapes && shapeType in elementor.config.additional_shapes) {
1421      svgURL = elementor.config.additional_shapes[shapeType];
1422
1423      if (-1 < fileName.indexOf('-negative')) {
1424        svgURL = svgURL.replace('.svg', '-negative.svg');
1425      }
1426    }
1427
1428    return svgURL;
1429  }
1430
1431  buildSVG(side) {
1432    const baseSettingKey = 'shape_divider_' + side,
1433          shapeType = this.getElementSettings(baseSettingKey),
1434          $svgContainer = this.elements['$' + side + 'Container'];
1435    $svgContainer.attr('data-shape', shapeType);
1436
1437    if (!shapeType) {
1438      $svgContainer.empty(); // Shape-divider set to 'none'
1439
1440      return;
1441    }
1442
1443    let fileName = shapeType;
1444
1445    if (this.getElementSettings(baseSettingKey + '_negative')) {
1446      fileName += '-negative';
1447    }
1448
1449    const svgURL = this.getSvgURL(shapeType, fileName);
1450    jQuery.get(svgURL, data => {
1451      $svgContainer.empty().append(data.childNodes[0]);
1452    });
1453    this.setNegative(side);
1454  }
1455
1456  setNegative(side) {
1457    this.elements['$' + side + 'Container'].attr('data-negative', !!this.getElementSettings('shape_divider_' + side + '_negative'));
1458  }
1459
1460  onInit(...args) {
1461    if (!this.isActive(this.getSettings())) {
1462      return;
1463    }
1464
1465    super.onInit(...args);
1466    ['top', 'bottom'].forEach(side => {
1467      if (this.getElementSettings('shape_divider_' + side)) {
1468        this.buildSVG(side);
1469      }
1470    });
1471  }
1472
1473  onElementChange(propertyName) {
1474    const shapeChange = propertyName.match(/^shape_divider_(top|bottom)$/);
1475
1476    if (shapeChange) {
1477      this.buildSVG(shapeChange[1]);
1478      return;
1479    }
1480
1481    const negativeChange = propertyName.match(/^shape_divider_(top|bottom)_negative$/);
1482
1483    if (negativeChange) {
1484      this.buildSVG(negativeChange[1]);
1485      this.setNegative(negativeChange[1]);
1486    }
1487  }
1488
1489}
1490
1491exports["default"] = Shapes;
1492
1493/***/ }),
1494

1495/***/ "../assets/dev/js/frontend/handlers/section/stretched-section.js":
1496/*!***********************************************************************!*\
1497  !*** ../assets/dev/js/frontend/handlers/section/stretched-section.js ***!
1498  \***********************************************************************/
1499/***/ ((__unused_webpack_module, exports) => {
1500
1501
1502
1503Object.defineProperty(exports, "__esModule", ({
1504  value: true
1505}));
1506exports["default"] = void 0;
1507
1508class StretchedSection extends elementorModules.frontend.handlers.Base {
1509  bindEvents() {
1510    const handlerID = this.getUniqueHandlerID();
1511    elementorFrontend.addListenerOnce(handlerID, 'resize', this.stretch);
1512    elementorFrontend.addListenerOnce(handlerID, 'sticky:stick', this.stretch, this.$element);
1513    elementorFrontend.addListenerOnce(handlerID, 'sticky:unstick', this.stretch, this.$element);
1514
1515    if (elementorFrontend.isEditMode()) {
1516      this.onKitChangeStretchContainerChange = this.onKitChangeStretchContainerChange.bind(this);
1517      elementor.channels.editor.on('kit:change:stretchContainer', this.onKitChangeStretchContainerChange);
1518    }
1519  }
1520
1521  unbindEvents() {
1522    elementorFrontend.removeListeners(this.getUniqueHandlerID(), 'resize', this.stretch);
1523
1524    if (elementorFrontend.isEditMode()) {
1525      elementor.channels.editor.off('kit:change:stretchContainer', this.onKitChangeStretchContainerChange);
1526    }
1527  }
1528
1529  isActive(settings) {
1530    return elementorFrontend.isEditMode() || settings.$element.hasClass('elementor-section-stretched');
1531  }
1532
1533  initStretch() {
1534    this.stretch = this.stretch.bind(this);
1535    this.stretchElement = new elementorModules.frontend.tools.StretchElement({
1536      element: this.$element,
1537      selectors: {
1538        container: this.getStretchContainer()
1539      }
1540    });
1541  }
1542
1543  getStretchContainer() {
1544    return elementorFrontend.getKitSettings('stretched_section_container') || window;
1545  }
1546
1547  stretch() {
1548    if (!this.getElementSettings('stretch_section')) {
1549      return;
1550    }
1551
1552    this.stretchElement.stretch();
1553  }
1554
1555  onInit(...args) {
1556    if (!this.isActive(this.getSettings())) {
1557      return;
1558    }
1559
1560    this.initStretch();
1561    super.onInit(...args);
1562    this.stretch();
1563  }
1564
1565  onElementChange(propertyName) {
1566    if ('stretch_section' === propertyName) {
1567      if (this.getElementSettings('stretch_section')) {
1568        this.stretch();
1569      } else {
1570        this.stretchElement.reset();
1571      }
1572    }
1573  }
1574
1575  onKitChangeStretchContainerChange() {
1576    this.stretchElement.setSettings('selectors.container', this.getStretchContainer());
1577    this.stretch();
1578  }
1579
1580}
1581
1582exports["default"] = StretchedSection;
1583
1584/***/ }),
1585

1586/***/ "../assets/dev/js/frontend/utils/anchors.js":
1587/*!**************************************************!*\
1588  !*** ../assets/dev/js/frontend/utils/anchors.js ***!
1589  \**************************************************/
1590/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1591
1592
1593
1594var _utils = __webpack_require__(/*! ./utils */ "../assets/dev/js/frontend/utils/utils.js");
1595
1596module.exports = elementorModules.ViewModule.extend({
1597  getDefaultSettings: function () {
1598    return {
1599      scrollDuration: 500,
1600      selectors: {
1601        links: 'a[href*="#"]',
1602        targets: '.elementor-element, .elementor-menu-anchor',
1603        scrollable: (0, _utils.isScrollSnapActive)() ? 'body' : 'html, body'
1604      }
1605    };
1606  },
1607  getDefaultElements: function () {
1608    var $ = jQuery,
1609        selectors = this.getSettings('selectors');
1610    return {
1611      $scrollable: $(selectors.scrollable)
1612    };
1613  },
1614  bindEvents: function () {
1615    elementorFrontend.elements.$document.on('click', this.getSettings('selectors.links'), this.handleAnchorLinks);
1616  },
1617  handleAnchorLinks: function (event) {
1618    var clickedLink = event.currentTarget,
1619        isSamePathname = location.pathname === clickedLink.pathname,
1620        isSameHostname = location.hostname === clickedLink.hostname,
1621        $anchor;
1622
1623    if (!isSameHostname || !isSamePathname || clickedLink.hash.length < 2) {
1624      return;
1625    }
1626
1627    try {
1628      $anchor = jQuery(clickedLink.hash).filter(this.getSettings('selectors.targets'));
1629    } catch (e) {
1630      return;
1631    }
1632
1633    if (!$anchor.length) {
1634      return;
1635    }
1636
1637    var scrollTop = $anchor.offset().top,
1638        $wpAdminBar = elementorFrontend.elements.$wpAdminBar,
1639        $activeStickies = jQuery('.elementor-section.elementor-sticky--active:visible'),
1640        maxStickyHeight = 0;
1641
1642    if ($wpAdminBar.length > 0) {
1643      scrollTop -= $wpAdminBar.height();
1644    } // Offset height of tallest sticky
1645
1646
1647    if ($activeStickies.length > 0) {
1648      maxStickyHeight = Math.max.apply(null, $activeStickies.map(function () {
1649        return jQuery(this).outerHeight();
1650      }).get());
1651      scrollTop -= maxStickyHeight;
1652    }
1653
1654    event.preventDefault();
1655    scrollTop = elementorFrontend.hooks.applyFilters('frontend/handlers/menu_anchor/scroll_top_distance', scrollTop); // on scroll animation start: remove scroll-snap.
1656
1657    if ((0, _utils.isScrollSnapActive)()) {
1658      elementorFrontend.elements.$body.css('scroll-snap-type', 'none');
1659    }
1660
1661    this.elements.$scrollable.animate({
1662      scrollTop: scrollTop
1663    }, this.getSettings('scrollDuration'), 'linear', () => {
1664      // on scroll animation complete: add scroll-snap back.
1665      if ((0, _utils.isScrollSnapActive)()) {
1666        elementorFrontend.elements.$body.css('scroll-snap-type', '');
1667      }
1668    });
1669  },
1670  onInit: function () {
1671    elementorModules.ViewModule.prototype.onInit.apply(this, arguments);
1672  }
1673});
1674
1675/***/ }),
1676

1677/***/ "../assets/dev/js/frontend/utils/assets-loader.js":
1678/*!********************************************************!*\
1679  !*** ../assets/dev/js/frontend/utils/assets-loader.js ***!
1680  \********************************************************/
1681/***/ ((__unused_webpack_module, exports) => {
1682
1683
1684
1685Object.defineProperty(exports, "__esModule", ({
1686  value: true
1687}));
1688exports["default"] = void 0;
1689
1690class AssetsLoader {
1691  getScriptElement(src) {
1692    const scriptElement = document.createElement('script');
1693    scriptElement.src = src;
1694    return scriptElement;
1695  }
1696
1697  getStyleElement(src) {
1698    const styleElement = document.createElement('link');
1699    styleElement.rel = 'stylesheet';
1700    styleElement.href = src;
1701    return styleElement;
1702  }
1703
1704  load(type, key) {
1705    const assetData = AssetsLoader.assets[type][key];
1706
1707    if (!assetData.loader) {
1708      assetData.loader = new Promise(resolve => {
1709        const element = 'style' === type ? this.getStyleElement(assetData.src) : this.getScriptElement(assetData.src);
1710
1711        element.onload = () => resolve(true);
1712
1713        const parent = 'head' === assetData.parent ? assetData.parent : 'body';
1714        document[parent].appendChild(element);
1715      });
1716    }
1717
1718    return assetData.loader;
1719  }
1720
1721}
1722
1723exports["default"] = AssetsLoader;
1724const fileSuffix = elementorFrontendConfig.environmentMode.isScriptDebug ? '' : '.min';
1725AssetsLoader.assets = {
1726  script: {
1727    dialog: {
1728      src: `${elementorFrontendConfig.urls.assets}lib/dialog/dialog${fileSuffix}.js?ver=4.9.0`
1729    },
1730    'share-link': {
1731      src: `${elementorFrontendConfig.urls.assets}lib/share-link/share-link${fileSuffix}.js?ver=${elementorFrontendConfig.version}`
1732    },
1733    swiper: {
1734      src: `${elementorFrontendConfig.urls.assets}lib/swiper/swiper${fileSuffix}.js?ver=5.3.6`
1735    }
1736  },
1737  style: {}
1738};
1739
1740/***/ }),
1741

1742/***/ "../assets/dev/js/frontend/utils/lightbox/lightbox-manager.js":
1743/*!********************************************************************!*\
1744  !*** ../assets/dev/js/frontend/utils/lightbox/lightbox-manager.js ***!
1745  \********************************************************************/
1746/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1747
1748
1749
1750Object.defineProperty(exports, "__esModule", ({
1751  value: true
1752}));
1753exports["default"] = void 0;
1754
1755class LightboxManager extends elementorModules.ViewModule {
1756  static getLightbox() {
1757    const lightboxPromise = new Promise(resolveLightbox => {
1758      __webpack_require__.e(/*! import() | lightbox */ "lightbox").then(__webpack_require__.t.bind(__webpack_require__, /*! elementor-frontend/utils/lightbox/lightbox */ "../assets/dev/js/frontend/utils/lightbox/lightbox.js", 23)).then(({
1759        default: LightboxModule
1760      }) => resolveLightbox(new LightboxModule()));
1761    }),
1762          dialogPromise = elementorFrontend.utils.assetsLoader.load('script', 'dialog'),
1763          shareLinkPromise = elementorFrontend.utils.assetsLoader.load('script', 'share-link');
1764    return Promise.all([lightboxPromise, dialogPromise, shareLinkPromise]).then(() => lightboxPromise);
1765  }
1766
1767  getDefaultSettings() {
1768    return {
1769      selectors: {
1770        links: 'a, [data-elementor-lightbox]'
1771      }
1772    };
1773  }
1774
1775  getDefaultElements() {
1776    return {
1777      $links: jQuery(this.getSettings('selectors.links'))
1778    };
1779  }
1780
1781  isLightboxLink(element) {
1782    // Check for lowercase `a` to make sure it works also for links inside SVGs.
1783    if ('a' === element.tagName.toLowerCase() && (element.hasAttribute('download') || !/^[^?]+\.(png|jpe?g|gif|svg|webp)(\?.*)?$/i.test(element.href)) && !element.dataset.elementorLightboxVideo) {
1784      return false;
1785    }
1786
1787    const generalOpenInLightbox = elementorFrontend.getKitSettings('global_image_lightbox'),
1788          currentLinkOpenInLightbox = element.dataset.elementorOpenLightbox;
1789    return 'yes' === currentLinkOpenInLightbox || generalOpenInLightbox && 'no' !== currentLinkOpenInLightbox;
1790  }
1791
1792  async onLinkClick(event) {
1793    const element = event.currentTarget,
1794          $target = jQuery(event.target),
1795          editMode = elementorFrontend.isEditMode(),
1796          isColorPickingMode = editMode && elementor.$previewContents.find('body').hasClass('elementor-editor__ui-state__color-picker'),
1797          isClickInsideElementor = !!$target.closest('.elementor-edit-area').length;
1798
1799    if (!this.isLightboxLink(element)) {
1800      if (editMode && isClickInsideElementor) {
1801        event.preventDefault();
1802      }
1803
1804      return;
1805    }
1806
1807    event.preventDefault();
1808
1809    if (editMode && !elementor.getPreferences('lightbox_in_editor')) {
1810      return;
1811    } // Disable lightbox on color picking mode.
1812
1813
1814    if (isColorPickingMode) {
1815      return;
1816    }
1817
1818    const lightbox = this.isOptimizedAssetsLoading() ? await LightboxManager.getLightbox() : elementorFrontend.utils.lightbox;
1819    lightbox.createLightbox(element);
1820  }
1821
1822  isOptimizedAssetsLoading() {
1823    return elementorFrontend.config.experimentalFeatures.e_optimized_assets_loading;
1824  }
1825
1826  bindEvents() {
1827    elementorFrontend.elements.$document.on('click', this.getSettings('selectors.links'), event => this.onLinkClick(event));
1828  }
1829
1830  onInit(...args) {
1831    super.onInit(...args);
1832
1833    if (!this.isOptimizedAssetsLoading() || elementorFrontend.isEditMode()) {
1834      return;
1835    } // Detecting lightbox links on init will reduce the time of waiting to the lightbox to be display on slow connections.
1836
1837
1838    this.elements.$links.each((index, element) => {
1839      if (this.isLightboxLink(element)) {
1840        LightboxManager.getLightbox(); // Breaking the iteration when the library loading has already been triggered.
1841
1842        return false;
1843      }
1844    });
1845  }
1846
1847}
1848
1849exports["default"] = LightboxManager;
1850
1851/***/ }),
1852

1853/***/ "../assets/dev/js/frontend/utils/swiper.js":
1854/*!*************************************************!*\
1855  !*** ../assets/dev/js/frontend/utils/swiper.js ***!
1856  \*************************************************/
1857/***/ ((__unused_webpack_module, exports) => {
1858
1859
1860
1861Object.defineProperty(exports, "__esModule", ({
1862  value: true
1863}));
1864exports["default"] = void 0;
1865
1866class Swiper {
1867  constructor(container, config) {
1868    this.config = config;
1869
1870    if (this.config.breakpoints) {
1871      // The config is passed as a param to allow adjustConfig to be called outside of this wrapper
1872      this.config = this.adjustConfig(config);
1873    } // The Swiper will overlap the column width when applying custom margin values on the column.
1874
1875
1876    jQuery(container).closest('.elementor-widget-wrap').addClass('e-swiper-container');
1877    jQuery(container).closest('.elementor-widget').addClass('e-widget-swiper');
1878    return new Promise(resolve => {
1879      if (!elementorFrontend.config.experimentalFeatures.e_optimized_assets_loading) {
1880        return resolve(this.createSwiperInstance(container, this.config));
1881      }
1882
1883      elementorFrontend.utils.assetsLoader.load('script', 'swiper').then(() => resolve(this.createSwiperInstance(container, this.config)));
1884    });
1885  }
1886
1887  createSwiperInstance(container, config) {
1888    const SwiperSource = window.Swiper;
1889    SwiperSource.prototype.adjustConfig = this.adjustConfig;
1890    return new SwiperSource(container, config);
1891  } // Backwards compatibility for Elementor Pro <2.9.0 (old Swiper version - <5.0.0)
1892  // In Swiper 5.0.0 and up, breakpoints changed from acting as max-width to acting as min-width
1893
1894
1895  adjustConfig(config) {
1896    // Only reverse the breakpoints if the handle param has been defined
1897    if (!config.handleElementorBreakpoints) {
1898      return config;
1899    }
1900
1901    const elementorBreakpoints = elementorFrontend.config.responsive.activeBreakpoints,
1902          elementorBreakpointValues = elementorFrontend.breakpoints.getBreakpointValues();
1903    Object.keys(config.breakpoints).forEach(configBPKey => {
1904      const configBPKeyInt = parseInt(configBPKey);
1905      let breakpointToUpdate; // The `configBPKeyInt + 1` is a BC Fix for Elementor Pro Carousels from 2.8.0-2.8.3 used with Elementor >= 2.9.0
1906
1907      if (configBPKeyInt === elementorBreakpoints.mobile.value || configBPKeyInt + 1 === elementorBreakpoints.mobile.value) {
1908        // This handles the mobile breakpoint. Elementor's default sm breakpoint is never actually used,
1909        // so the mobile breakpoint (md) needs to be handled separately and set to the 0 breakpoint (xs)
1910        breakpointToUpdate = 0;
1911      } else if (elementorBreakpoints.widescreen && (configBPKeyInt === elementorBreakpoints.widescreen.value || configBPKeyInt + 1 === elementorBreakpoints.widescreen.value)) {
1912        // Widescreen is a min-width breakpoint. Since in Swiper >5.0 the breakpoint system is min-width based,
1913        // the value we pass to the Swiper instance in this case is the breakpoint from the user, unchanged.
1914        breakpointToUpdate = configBPKeyInt;
1915      } else {
1916        // Find the index of the current config breakpoint in the Elementor Breakpoints array
1917        const currentBPIndexInElementorBPs = elementorBreakpointValues.findIndex(elementorBP => {
1918          // BC Fix for Elementor Pro Carousels from 2.8.0-2.8.3 used with Elementor >= 2.9.0
1919          return configBPKeyInt === elementorBP || configBPKeyInt + 1 === elementorBP;
1920        }); // For all other Swiper config breakpoints, move them one breakpoint down on the breakpoint list,
1921        // according to the array of Elementor's global breakpoints
1922
1923        breakpointToUpdate = elementorBreakpointValues[currentBPIndexInElementorBPs - 1];
1924      }
1925
1926      config.breakpoints[breakpointToUpdate] = config.breakpoints[configBPKey]; // Then reset the settings in the original breakpoint key to the default values
1927
1928      config.breakpoints[configBPKey] = {
1929        slidesPerView: config.slidesPerView,
1930        slidesPerGroup: config.slidesPerGroup ? config.slidesPerGroup : 1
1931      };
1932    });
1933    return config;
1934  }
1935
1936}
1937
1938exports["default"] = Swiper;
1939
1940/***/ }),
1941

1942/***/ "../assets/dev/js/frontend/utils/url-actions.js":
1943/*!******************************************************!*\
1944  !*** ../assets/dev/js/frontend/utils/url-actions.js ***!
1945  \******************************************************/
1946/***/ ((__unused_webpack_module, exports) => {
1947
1948
1949
1950Object.defineProperty(exports, "__esModule", ({
1951  value: true
1952}));
1953exports["default"] = void 0;
1954
1955class _default extends elementorModules.ViewModule {
1956  getDefaultSettings() {
1957    return {
1958      selectors: {
1959        links: 'a[href^="%23elementor-action"], a[href^="#elementor-action"]'
1960      }
1961    };
1962  }
1963
1964  bindEvents() {
1965    elementorFrontend.elements.$document.on('click', this.getSettings('selectors.links'), this.runLinkAction.bind(this));
1966  }
1967
1968  initActions() {
1969    this.actions = {
1970      lightbox: async settings => {
1971        const lightbox = await elementorFrontend.utils.lightbox;
1972
1973        if (settings.slideshow) {
1974          // Handle slideshow display
1975          lightbox.openSlideshow(settings.slideshow, settings.url);
1976        } else {
1977          // If the settings has an ID - the lightbox target content is an image - the ID is an attachment ID.
1978          if (settings.id) {
1979            settings.type = 'image';
1980          }
1981
1982          lightbox.showModal(settings);
1983        }
1984      }
1985    };
1986  }
1987
1988  addAction(name, callback) {
1989    this.actions[name] = callback;
1990  }
1991
1992  runAction(url, ...restArgs) {
1993    url = decodeURIComponent(url);
1994    const actionMatch = url.match(/action=(.+?)&/),
1995          settingsMatch = url.match(/settings=(.+)/);
1996
1997    if (!actionMatch) {
1998      return;
1999    }
2000
2001    const action = this.actions[actionMatch[1]];
2002
2003    if (!action) {
2004      return;
2005    }
2006
2007    let settings = {};
2008
2009    if (settingsMatch) {
2010      settings = JSON.parse(atob(settingsMatch[1]));
2011    }
2012
2013    action(settings, ...restArgs);
2014  }
2015
2016  runLinkAction(event) {
2017    event.preventDefault();
2018    this.runAction(jQuery(event.currentTarget).attr('href'), event);
2019  }
2020
2021  runHashAction() {
2022    if (!location.hash) {
2023      return;
2024    } // Only if an element with this action hash exists on the page do we allow running the action.
2025
2026
2027    const elementWithHash = document.querySelector(`[e-action-hash="${location.hash}"], a[href*="${location.hash}"]`);
2028
2029    if (elementWithHash) {
2030      this.runAction(elementWithHash.getAttribute('e-action-hash'));
2031    }
2032  }
2033
2034  createActionHash(action, settings) {
2035    // We need to encode the hash tag (#) here, in order to support share links for a variety of providers
2036    return encodeURIComponent(`#elementor-action:action=${action}&settings=${btoa(JSON.stringify(settings))}`);
2037  }
2038
2039  onInit() {
2040    super.onInit();
2041    this.initActions();
2042    elementorFrontend.on('components:init', this.runHashAction.bind(this));
2043  }
2044
2045}
2046
2047exports["default"] = _default;
2048
2049/***/ }),
2050

2051/***/ "../assets/dev/js/frontend/utils/utils.js":
2052/*!************************************************!*\
2053  !*** ../assets/dev/js/frontend/utils/utils.js ***!
2054  \************************************************/
2055/***/ ((__unused_webpack_module, exports) => {
2056
2057
2058
2059Object.defineProperty(exports, "__esModule", ({
2060  value: true
2061}));
2062exports.isScrollSnapActive = exports.escapeHTML = void 0;
2063
2064// Escape HTML special chars to prevent XSS.
2065const escapeHTML = str => {
2066  const specialChars = {
2067    '&': '&amp;',
2068    '<': '&lt;',
2069    '>': '&gt;',
2070    "'": '&#39;',
2071    '"': '&quot;'
2072  };
2073  return str.replace(/[&<>'"]/g, tag => specialChars[tag] || tag);
2074}; // Check if Scroll-Snap is active.
2075
2076
2077exports.escapeHTML = escapeHTML;
2078
2079const isScrollSnapActive = () => {
2080  var _elementor$settings$p, _elementorFrontend$co;
2081
2082  const scrollSnapStatus = elementorFrontend.isEditMode() ? (_elementor$settings$p = elementor.settings.page.model.attributes) === null || _elementor$settings$p === void 0 ? void 0 : _elementor$settings$p['scroll_snap'] : (_elementorFrontend$co = elementorFrontend.config.settings.page) === null || _elementorFrontend$co === void 0 ? void 0 : _elementorFrontend$co['scroll_snap'];
2083  return 'yes' === scrollSnapStatus ? true : false;
2084};
2085
2086exports.isScrollSnapActive = isScrollSnapActive;
2087
2088/***/ }),
2089

2090/***/ "../assets/dev/js/frontend/utils/video-api/base-loader.js":
2091/*!****************************************************************!*\
2092  !*** ../assets/dev/js/frontend/utils/video-api/base-loader.js ***!
2093  \****************************************************************/
2094/***/ ((__unused_webpack_module, exports) => {
2095
2096
2097
2098Object.defineProperty(exports, "__esModule", ({
2099  value: true
2100}));
2101exports["default"] = void 0;
2102
2103class BaseLoader extends elementorModules.ViewModule {
2104  getDefaultSettings() {
2105    return {
2106      isInserted: false,
2107      selectors: {
2108        firstScript: 'script:first'
2109      }
2110    };
2111  }
2112
2113  getDefaultElements() {
2114    return {
2115      $firstScript: jQuery(this.getSettings('selectors.firstScript'))
2116    };
2117  }
2118
2119  insertAPI() {
2120    this.elements.$firstScript.before(jQuery('<script>', {
2121      src: this.getApiURL()
2122    }));
2123    this.setSettings('isInserted', true);
2124  }
2125
2126  getVideoIDFromURL(url) {
2127    const videoIDParts = url.match(this.getURLRegex());
2128    return videoIDParts && videoIDParts[1];
2129  }
2130
2131  onApiReady(callback) {
2132    if (!this.getSettings('isInserted')) {
2133      this.insertAPI();
2134    }
2135
2136    if (this.isApiLoaded()) {
2137      callback(this.getApiObject());
2138    } else {
2139      // If not ready check again by timeout..
2140      setTimeout(() => {
2141        this.onApiReady(callback);
2142      }, 350);
2143    }
2144  }
2145
2146  getAutoplayURL(videoURL) {
2147    return videoURL.replace('&autoplay=0', '') + '&autoplay=1';
2148  }
2149
2150}
2151
2152exports["default"] = BaseLoader;
2153
2154/***/ }),
2155

2156/***/ "../assets/dev/js/frontend/utils/video-api/vimeo-loader.js":
2157/*!*****************************************************************!*\
2158  !*** ../assets/dev/js/frontend/utils/video-api/vimeo-loader.js ***!
2159  \*****************************************************************/
2160/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
2161
2162
2163
2164var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
2165
2166Object.defineProperty(exports, "__esModule", ({
2167  value: true
2168}));
2169exports["default"] = void 0;
2170
2171var _baseLoader = _interopRequireDefault(__webpack_require__(/*! ./base-loader */ "../assets/dev/js/frontend/utils/video-api/base-loader.js"));
2172
2173class VimeoLoader extends _baseLoader.default {
2174  getApiURL() {
2175    return 'https://player.vimeo.com/api/player.js';
2176  }
2177
2178  getURLRegex() {
2179    return /^(?:https?:\/\/)?(?:www|player\.)?(?:vimeo\.com\/)?(?:video\/|external\/)?(\d+)([^.?&#"'>]?)/;
2180  }
2181
2182  isApiLoaded() {
2183    return window.Vimeo;
2184  }
2185
2186  getApiObject() {
2187    return Vimeo;
2188  }
2189
2190  getAutoplayURL(videoURL) {
2191    videoURL = super.getAutoplayURL(videoURL); // Vimeo requires the '#t=' param to be last in the URL.
2192
2193    const timeMatch = videoURL.match(/#t=[^&]*/);
2194    return videoURL.replace(timeMatch[0], '') + timeMatch;
2195  }
2196
2197}
2198
2199exports["default"] = VimeoLoader;
2200
2201/***/ }),
2202

2203/***/ "../assets/dev/js/frontend/utils/video-api/youtube-loader.js":
2204/*!*******************************************************************!*\
2205  !*** ../assets/dev/js/frontend/utils/video-api/youtube-loader.js ***!
2206  \*******************************************************************/
2207/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
2208
2209
2210
2211var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
2212
2213Object.defineProperty(exports, "__esModule", ({
2214  value: true
2215}));
2216exports["default"] = void 0;
2217
2218var _baseLoader = _interopRequireDefault(__webpack_require__(/*! ./base-loader */ "../assets/dev/js/frontend/utils/video-api/base-loader.js"));
2219
2220class YoutubeLoader extends _baseLoader.default {
2221  getApiURL() {
2222    return 'https://www.youtube.com/iframe_api';
2223  }
2224
2225  getURLRegex() {
2226    return /^(?:https?:\/\/)?(?:www\.)?(?:m\.)?(?:youtu\.be\/|youtube\.com\/(?:(?:watch)?\?(?:.*&)?vi?=|(?:embed|v|vi|user)\/))([^?&"'>]+)/;
2227  }
2228
2229  isApiLoaded() {
2230    return window.YT && YT.loaded;
2231  }
2232
2233  getApiObject() {
2234    return YT;
2235  }
2236
2237}
2238
2239exports["default"] = YoutubeLoader;
2240
2241/***/ }),
2242

2243/***/ "../assets/dev/js/public-path.js":
2244/*!***************************************!*\
2245  !*** ../assets/dev/js/public-path.js ***!
2246  \***************************************/
2247/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
2248
2249
2250
2251/* eslint-disable camelcase */
2252__webpack_require__.p = elementorFrontendConfig.urls.assets + 'js/';
2253
2254/***/ }),
2255

2256/***/ "../assets/dev/js/utils/breakpoints.js":
2257/*!*********************************************!*\
2258  !*** ../assets/dev/js/utils/breakpoints.js ***!
2259  \*********************************************/
2260/***/ ((__unused_webpack_module, exports) => {
2261
2262
2263
2264Object.defineProperty(exports, "__esModule", ({
2265  value: true
2266}));
2267exports["default"] = void 0;
2268
2269/**
2270 * Breakpoints
2271 *
2272 * This utility class contains helper functions relating to Elementor's breakpoints system.
2273 *
2274 * @since 3.4.0
2275 */
2276class Breakpoints extends elementorModules.Module {
2277  constructor(responsiveConfig) {
2278    super(); // The passed config is either `elementor.config.responsive` or `elementorFrontend.config.responsive`
2279
2280    this.responsiveConfig = responsiveConfig;
2281  }
2282  /**
2283   * Get Active Breakpoints List
2284   *
2285   * Returns a flat array containing the active breakpoints/devices. By default, it returns the li
2286   * the list ordered from smallest to largest breakpoint. If `true` is passed as a parameter, it reverses the order.
2287   *
2288   * @since 3.4.0
2289   *
2290   * @param {Object} args
2291   */
2292
2293
2294  getActiveBreakpointsList(args = {}) {
2295    const defaultArgs = {
2296      largeToSmall: false,
2297      withDesktop: false
2298    };
2299    args = { ...defaultArgs,
2300      ...args
2301    };
2302    const breakpointKeys = Object.keys(this.responsiveConfig.activeBreakpoints);
2303
2304    if (args.withDesktop) {
2305      // If there is an active 'widescreen' breakpoint, insert the artificial 'desktop' device below it.
2306      const widescreenIndex = breakpointKeys.indexOf('widescreen'),
2307            indexToInsertDesktopDevice = -1 === widescreenIndex ? breakpointKeys.length : breakpointKeys.length - 1;
2308      breakpointKeys.splice(indexToInsertDesktopDevice, 0, 'desktop');
2309    }
2310
2311    if (args.largeToSmall) {
2312      breakpointKeys.reverse();
2313    }
2314
2315    return breakpointKeys;
2316  }
2317  /**
2318   * Get Active Breakpoint Values
2319   *
2320   * Returns a flat array containing the list of active breakpoint values, from smallest to largest.
2321   *
2322   * @since 3.4.0
2323   */
2324
2325
2326  getBreakpointValues() {
2327    const {
2328      activeBreakpoints
2329    } = this.responsiveConfig,
2330          breakpointValues = [];
2331    Object.values(activeBreakpoints).forEach(breakpointConfig => {
2332      breakpointValues.push(breakpointConfig.value);
2333    });
2334    return breakpointValues;
2335  }
2336  /**
2337   * Get Desktop Previous Device Key
2338   *
2339   * Returns the key of the device directly under desktop (can be 'tablet', 'tablet_extra', 'laptop').
2340   *
2341   * @since 3.4.0
2342   *
2343   * @returns {string}
2344   */
2345
2346
2347  getDesktopPreviousDeviceKey() {
2348    let desktopPreviousDevice = '';
2349    const {
2350      activeBreakpoints
2351    } = this.responsiveConfig,
2352          breakpointKeys = Object.keys(activeBreakpoints),
2353          numOfDevices = breakpointKeys.length;
2354
2355    if ('min' === activeBreakpoints[breakpointKeys[numOfDevices - 1]].direction) {
2356      // If the widescreen breakpoint is active, the device that's previous to desktop is the last one before
2357      // widescreen.
2358      desktopPreviousDevice = breakpointKeys[numOfDevices - 2];
2359    } else {
2360      // If the widescreen breakpoint isn't active, we just take the last device returned by the config.
2361      desktopPreviousDevice = breakpointKeys[numOfDevices - 1];
2362    }
2363
2364    return desktopPreviousDevice;
2365  }
2366  /**
2367   * Get Device Minimum Breakpoint
2368   *
2369   * Returns the minimum point in the device's display range. For each device, the minimum point of its display range
2370   * is the max point of the device below it + 1px. For example, if the active devices are mobile, tablet,
2371   * and desktop, and the mobile breakpoint is 767px, the minimum display point for tablet devices is 768px.
2372   *
2373   * @since 3.4.0
2374   *
2375   * @returns {number|*}
2376   */
2377
2378
2379  getDesktopMinPoint() {
2380    const {
2381      activeBreakpoints
2382    } = this.responsiveConfig,
2383          desktopPreviousDevice = this.getDesktopPreviousDeviceKey();
2384    return activeBreakpoints[desktopPreviousDevice].value + 1;
2385  }
2386  /**
2387   * Get Device Minimum Breakpoint
2388   *
2389   * Returns the minimum point in the device's display range. For each device, the minimum point of its display range
2390   * is the max point of the device below it + 1px. For example, if the active devices are mobile, tablet,
2391   * and desktop, and the mobile breakpoint is 767px, the minimum display point for tablet devices is 768px.
2392   *
2393   * @since 3.4.0
2394   *
2395   * @param device
2396   * @returns {number|*}
2397   */
2398
2399
2400  getDeviceMinBreakpoint(device) {
2401    if ('desktop' === device) {
2402      return this.getDesktopMinPoint();
2403    }
2404
2405    const {
2406      activeBreakpoints
2407    } = this.responsiveConfig,
2408          breakpointNames = Object.keys(activeBreakpoints);
2409    let minBreakpoint;
2410
2411    if (breakpointNames[0] === device) {
2412      // For the lowest breakpoint, the min point is always 320.
2413      minBreakpoint = 320;
2414    } else if ('widescreen' === device) {

2415      // Widescreen only has a minimum point. In this case, the breakpoint
2416      // value in the Breakpoints config is itself the device min point.
2417      if (activeBreakpoints[device]) {
2418        minBreakpoint = activeBreakpoints[device].value;
2419      } else {
2420        // If the widescreen breakpoint does not exist in the active breakpoints config (for example, in the
2421        // case this method runs as the breakpoint is being added), get the value from the full config.
2422        minBreakpoint = this.responsiveConfig.breakpoints.widescreen;
2423      }
2424    } else {
2425      const deviceNameIndex = breakpointNames.indexOf(device),
2426            previousIndex = deviceNameIndex - 1;
2427      minBreakpoint = activeBreakpoints[breakpointNames[previousIndex]].value + 1;
2428    }
2429
2430    return minBreakpoint;
2431  }
2432  /**
2433   * Get Active Match Regex
2434   *
2435   * Returns a regular expression containing all active breakpoints prefixed with an underscore.
2436   *
2437   * @returns {RegExp}
2438   */
2439
2440
2441  getActiveMatchRegex() {
2442    return new RegExp(this.getActiveBreakpointsList().map(device => '_' + device).join('|') + '$');
2443  }
2444
2445}
2446
2447exports["default"] = Breakpoints;
2448
2449/***/ }),
2450

2451/***/ "../assets/dev/js/utils/events.js":
2452/*!****************************************!*\
2453  !*** ../assets/dev/js/utils/events.js ***!
2454  \****************************************/
2455/***/ ((__unused_webpack_module, exports) => {
2456
2457
2458
2459Object.defineProperty(exports, "__esModule", ({
2460  value: true
2461}));
2462exports["default"] = exports.Events = void 0;
2463
2464class Events {
2465  /**
2466   * Dispatch an Elementor event.
2467   *
2468   * Will dispatch both native event & jQuery event (as BC).
2469   * By default, `bcEvent` is `null`.
2470   *
2471   * @param {Object} context - The context that will dispatch the event.
2472   * @param {string} event - Event to dispatch.
2473   * @param {*} data - Data to pass to the event, default to `null`.
2474   * @param {string|null} bcEvent - BC event to dispatch, default to `null`.
2475   *
2476   * @return {void}
2477   */
2478  static dispatch(context, event, data = null, bcEvent = null) {
2479    // Make sure to use the native context if it's a jQuery instance.
2480    context = context instanceof jQuery ? context[0] : context; // Dispatch the BC event only if exists.
2481
2482    if (bcEvent) {
2483      context.dispatchEvent(new CustomEvent(bcEvent, {
2484        detail: data
2485      }));
2486    } // jQuery's `.on()` listens also to native custom events, so there is no need
2487    // to dispatch also a jQuery event.
2488
2489
2490    context.dispatchEvent(new CustomEvent(event, {
2491      detail: data
2492    }));
2493  }
2494
2495}
2496
2497exports.Events = Events;
2498var _default = Events;
2499exports["default"] = _default;
2500
2501/***/ }),
2502

2503/***/ "../assets/dev/js/utils/hooks.js":
2504/*!***************************************!*\
2505  !*** ../assets/dev/js/utils/hooks.js ***!
2506  \***************************************/
2507/***/ ((module) => {
2508
2509
2510/**
2511 * Handles managing all events for whatever you plug it into. Priorities for hooks are based on lowest to highest in
2512 * that, lowest priority hooks are fired first.
2513 */
2514
2515var EventManager = function () {
2516  var slice = Array.prototype.slice,
2517      MethodsAvailable;
2518  /**
2519   * Contains the hooks that get registered with this EventManager. The array for storage utilizes a "flat"
2520   * object literal such that looking up the hook utilizes the native object literal hash.
2521   */
2522
2523  var STORAGE = {
2524    actions: {},
2525    filters: {}
2526  };
2527  /**
2528   * Removes the specified hook by resetting the value of it.
2529   *
2530   * @param type Type of hook, either 'actions' or 'filters'
2531   * @param hook The hook (namespace.identifier) to remove
2532   *
2533   * @private
2534   */
2535
2536  function _removeHook(type, hook, callback, context) {
2537    var handlers, handler, i;
2538
2539    if (!STORAGE[type][hook]) {
2540      return;
2541    }
2542
2543    if (!callback) {
2544      STORAGE[type][hook] = [];
2545    } else {
2546      handlers = STORAGE[type][hook];
2547
2548      if (!context) {
2549        for (i = handlers.length; i--;) {
2550          if (handlers[i].callback === callback) {
2551            handlers.splice(i, 1);
2552          }
2553        }
2554      } else {
2555        for (i = handlers.length; i--;) {
2556          handler = handlers[i];
2557
2558          if (handler.callback === callback && handler.context === context) {
2559            handlers.splice(i, 1);
2560          }
2561        }
2562      }
2563    }
2564  }
2565  /**
2566   * Use an insert sort for keeping our hooks organized based on priority. This function is ridiculously faster
2567   * than bubble sort, etc: http://jsperf.com/javascript-sort
2568   *
2569   * @param hooks The custom array containing all of the appropriate hooks to perform an insert sort on.
2570   * @private
2571   */
2572
2573
2574  function _hookInsertSort(hooks) {
2575    var tmpHook, j, prevHook;
2576
2577    for (var i = 1, len = hooks.length; i < len; i++) {
2578      tmpHook = hooks[i];
2579      j = i;
2580
2581      while ((prevHook = hooks[j - 1]) && prevHook.priority > tmpHook.priority) {
2582        hooks[j] = hooks[j - 1];
2583        --j;
2584      }
2585
2586      hooks[j] = tmpHook;
2587    }
2588
2589    return hooks;
2590  }
2591  /**
2592   * Adds the hook to the appropriate storage container
2593   *
2594   * @param type 'actions' or 'filters'
2595   * @param hook The hook (namespace.identifier) to add to our event manager
2596   * @param callback The function that will be called when the hook is executed.
2597   * @param priority The priority of this hook. Must be an integer.
2598   * @param [context] A value to be used for this
2599   * @private
2600   */
2601
2602
2603  function _addHook(type, hook, callback, priority, context) {
2604    var hookObject = {
2605      callback: callback,
2606      priority: priority,
2607      context: context
2608    }; // Utilize 'prop itself' : http://jsperf.com/hasownproperty-vs-in-vs-undefined/19
2609
2610    var hooks = STORAGE[type][hook];
2611
2612    if (hooks) {
2613      // TEMP FIX BUG
2614      var hasSameCallback = false;
2615      jQuery.each(hooks, function () {
2616        if (this.callback === callback) {
2617          hasSameCallback = true;
2618          return false;
2619        }
2620      });
2621
2622      if (hasSameCallback) {
2623        return;
2624      } // END TEMP FIX BUG
2625
2626
2627      hooks.push(hookObject);
2628      hooks = _hookInsertSort(hooks);
2629    } else {
2630      hooks = [hookObject];
2631    }
2632
2633    STORAGE[type][hook] = hooks;
2634  }
2635  /**
2636   * Runs the specified hook. If it is an action, the value is not modified but if it is a filter, it is.
2637   *
2638   * @param type 'actions' or 'filters'
2639   * @param hook The hook ( namespace.identifier ) to be ran.
2640   * @param args Arguments to pass to the action/filter. If it's a filter, args is actually a single parameter.
2641   * @private
2642   */
2643
2644
2645  function _runHook(type, hook, args) {
2646    var handlers = STORAGE[type][hook],
2647        i,
2648        len;
2649
2650    if (!handlers) {
2651      return 'filters' === type ? args[0] : false;
2652    }
2653
2654    len = handlers.length;
2655
2656    if ('filters' === type) {
2657      for (i = 0; i < len; i++) {
2658        args[0] = handlers[i].callback.apply(handlers[i].context, args

2658);
2659      }
2660    } else {
2661      for (i = 0; i < len; i++) {
2662        handlers[i].callback.apply(handlers[i].context, args);
2663      }
2664    }
2665
2666    return 'filters' === type ? args[0] : true;
2667  }
2668  /**
2669   * Adds an action to the event manager.
2670   *
2671   * @param action Must contain namespace.identifier
2672   * @param callback Must be a valid callback function before this action is added
2673   * @param [priority=10] Used to control when the function is executed in relation to other callbacks bound to the same hook
2674   * @param [context] Supply a value to be used for this
2675   */
2676
2677
2678  function addAction(action, callback, priority, context) {
2679    if ('string' === typeof action && 'function' === typeof callback) {
2680      priority = parseInt(priority || 10, 10);
2681
2682      _addHook('actions', action, callback, priority, context);
2683    }
2684
2685    return MethodsAvailable;
2686  }
2687  /**
2688   * Performs an action if it exists. You can pass as many arguments as you want to this function; the only rule is
2689   * that the first argument must always be the action.
2690   */
2691
2692
2693  function doAction() {
2694    var args = slice.call(arguments);
2695    var action = args.shift();
2696
2697    if ('string' === typeof action) {
2698      _runHook('actions', action, args);
2699    }
2700
2701    return MethodsAvailable;
2702  }
2703  /**
2704   * Removes the specified action if it contains a namespace.identifier & exists.
2705   *
2706   * @param action The action to remove
2707   * @param [callback] Callback function to remove
2708   */
2709
2710
2711  function removeAction(action, callback) {
2712    if ('string' === typeof action) {
2713      _removeHook('actions', action, callback);
2714    }
2715
2716    return MethodsAvailable;
2717  }
2718  /**
2719   * Adds a filter to the event manager.
2720   *
2721   * @param filter Must contain namespace.identifier
2722   * @param callback Must be a valid callback function before this action is added
2723   * @param [priority=10] Used to control when the function is executed in relation to other callbacks bound to the same hook
2724   * @param [context] Supply a value to be used for this
2725   */
2726
2727
2728  function addFilter(filter, callback, priority, context) {
2729    if ('string' === typeof filter && 'function' === typeof callback) {
2730      priority = parseInt(priority || 10, 10);
2731
2732      _addHook('filters', filter, callback, priority, context);
2733    }
2734
2735    return MethodsAvailable;
2736  }
2737  /**
2738   * Performs a filter if it exists. You should only ever pass 1 argument to be filtered. The only rule is that
2739   * the first argument must always be the filter.
2740   */
2741
2742
2743  function applyFilters() {
2744    var args = slice.call(arguments);
2745    var filter = args.shift();
2746
2747    if ('string' === typeof filter) {
2748      return _runHook('filters', filter, args);
2749    }
2750
2751    return MethodsAvailable;
2752  }
2753  /**
2754   * Removes the specified filter if it contains a namespace.identifier & exists.
2755   *
2756   * @param filter The action to remove
2757   * @param [callback] Callback function to remove
2758   */
2759
2760
2761  function removeFilter(filter, callback) {
2762    if ('string' === typeof filter) {
2763      _removeHook('filters', filter, callback);
2764    }
2765
2766    return MethodsAvailable;
2767  }
2768  /**
2769   * Maintain a reference to the object scope so our public methods never get confusing.
2770   */
2771
2772
2773  MethodsAvailable = {
2774    removeFilter: removeFilter,
2775    applyFilters: applyFilters,
2776    addFilter: addFilter,
2777    removeAction: removeAction,
2778    doAction: doAction,
2779    addAction: addAction
2780  }; // return all of the publicly available methods
2781
2782  return MethodsAvailable;
2783};
2784
2785module.exports = EventManager;
2786
2787/***/ }),
2788

2789/***/ "../core/common/assets/js/utils/environment.js":
2790/*!*****************************************************!*\
2791  !*** ../core/common/assets/js/utils/environment.js ***!
2792  \*****************************************************/
2793/***/ ((__unused_webpack_module, exports) => {
2794
2795
2796
2797Object.defineProperty(exports, "__esModule", ({
2798  value: true
2799}));
2800exports["default"] = void 0;
2801
2802const matchUserAgent = UserAgentStr => {
2803  return userAgent.indexOf(UserAgentStr) >= 0;
2804},
2805      userAgent = navigator.userAgent,
2806      // Solution influenced by https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
2807// Opera 8.0+
2808isOpera = !!window.opr && !!opr.addons || !!window.opera || matchUserAgent(' OPR/'),
2809      // Firefox 1.0+
2810isFirefox = matchUserAgent('Firefox'),
2811      // Safari 3.0+ "[object HTMLElementConstructor]"
2812isSafari = /^((?!chrome|android).)*safari/i.test(userAgent) || /constructor/i.test(window.HTMLElement) || (p => {
2813  return '[object SafariRemoteNotification]' === p.toString();
2814})(!window.safari || typeof safari !== 'undefined' && safari.pushNotification),
2815      // Internet Explorer 6-11
2816isIE = /Trident|MSIE/.test(userAgent) && (
2817/*@cc_on!@*/
2818 false || !!document.documentMode),
2819      // Edge 20+
2820isEdge = !isIE && !!window.StyleMedia || matchUserAgent('Edg'),
2821      // Google Chrome (Not accurate)
2822isChrome = !!window.chrome && matchUserAgent('Chrome') && !(isEdge || isOpera),
2823      // Blink engine
2824isBlink = matchUserAgent('Chrome') && !!window.CSS,
2825      // Apple Webkit engine
2826isAppleWebkit = matchUserAgent('AppleWebKit') && !isBlink,
2827      environment = {
2828  appleWebkit: isAppleWebkit,
2829  blink: isBlink,
2830  chrome: isChrome,
2831  edge: isEdge,
2832  firefox: isFirefox,
2833  ie: isIE,
2834  mac: matchUserAgent('Macintosh'),
2835  opera: isOpera,
2836  safari: isSafari,
2837  webkit: matchUserAgent('AppleWebKit')
2838};
2839
2840var _default = environment;
2841exports["default"] = _default;
2842
2843/***/ }),
2844

2845/***/ "../core/common/assets/js/utils/storage.js":
2846/*!*************************************************!*\
2847  !*** ../core/common/assets/js/utils/storage.js ***!
2848  \*************************************************/
2849/***/ ((__unused_webpack_module, exports) => {
2850
2851
2852
2853Object.defineProperty(exports, "__esModule", ({
2854  value: true
2855}));
2856exports["default"] = void 0;
2857
2858class _default extends elementorModules.Module {
2859  get(key, options) {
2860    options = options || {};
2861    let storage;
2862
2863    try {
2864      storage = options.session ? sessionStorage : localStorage;
2865    } catch (e) {
2866      return key ? undefined : {};
2867    }
2868
2869    let elementorStorage = storage.getItem('elementor');
2870
2871    if (elementorStorage) {
2872      elementorStorage = JSON.parse(elementorStorage);
2873    } else {
2874      elementorStorage = {};
2875    }
2876
2877    if (!elementorStorage.__expiration) {
2878      elementorStorage.__expiration = {};
2879    }
2880
2881    const expiration = elementorStorage.__expiration;
2882    let expirationToCheck = [];
2883
2884    if (key) {
2885      if (expiration[key]) {
2886        expirationToCheck = [key];
2887      }
2888    } else {
2889      expirationToCheck = Object.keys(expiration);
2890    }
2891
2892    let entryExpired = false;
2893    expirationToCheck.forEach(expirationKey => {
2894      if (new Date(expiration[expirationKey]) < new Date()) {
2895        delete elementorStorage[expirationKey];
2896        delete expiration[expirationKey];
2897        entryExpired = true;
2898      }
2899    });
2900
2901    if (entryExpired) {
2902      this.save(elementorStorage, options.session);
2903    }
2904
2905    if (key) {
2906      return elementorStorage[key];
2907    }
2908
2909    return elementorStorage;
2910  }
2911
2912  set(key, value, options) {
2913    options = options || {};
2914    const elementorStorage = this.get(null, options);
2915    elementorStorage[key] = value;
2916
2917    if (options.lifetimeInSeconds) {
2918      const date = new Date();
2919      date.setTime(date.getTime() + options.lifetimeInSeconds * 1000);
2920      elementorStorage.__expiration[key] = date.getTime();
2921    }
2922
2923    this.save(elementorStorage, options.session);
2924  }
2925
2926  save(object, session) {
2927    let storage;
2928
2929    try {
2930      storage = session ? sessionStorage : localStorage;
2931    } catch (e) {
2932      return;
2933    }
2934
2935    storage.setItem('elementor', JSON.stringify(object));
2936  }
2937
2938}
2939
2940exports["default"] = _default;
2941
2942/***/ }),
2943

2944/***/ "../modules/shapes/assets/js/frontend/frontend.js":
2945/*!********************************************************!*\
2946  !*** ../modules/shapes/assets/js/frontend/frontend.js ***!
2947  \********************************************************/
2948/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
2949
2950
2951
2952Object.defineProperty(exports, "__esModule", ({
2953  value: true
2954}));
2955exports["default"] = void 0;
2956
2957class _default extends elementorModules.Module {
2958  constructor() {
2959    super();
2960    elementorFrontend.elementsHandler.attachHandler('text-path', () => __webpack_require__.e(/*! import() | text-path */ "text-path").then(__webpack_require__.bind(__webpack_require__, /*! ./handlers/text-path */ "../modules/shapes/assets/js/frontend/handlers/text-path.js")));
2961  }
2962
2963}
2964
2965exports["default"] = _default;
2966
2967/***/ })

2967
2968
2969},
2970/******/ __webpack_require__ => { // webpackRuntimeModules
2971/******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
2972/******/ __webpack_require__.O(0, ["frontend-modules"], () => (__webpack_exec__("../assets/dev/js/frontend/frontend.js")));
2973/******/ var __webpack_exports__ = __webpack_require__.O();
2974/******/ }
2975]);
2976//# 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.