frontend.js - balmet.com - Unnamed repository; edit this file 'description' to name the repository.

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