(()=> {
"use strict";
var __webpack_modules__=({});
var __webpack_module_cache__={};
function __webpack_require__(moduleId){
var cachedModule=__webpack_module_cache__[moduleId];
if(cachedModule!==undefined){
return cachedModule.exports;
}
var module=__webpack_module_cache__[moduleId]={
exports: {}
};
__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
return module.exports;
}
__webpack_require__.m=__webpack_modules__;
(()=> {
var deferred=[];
__webpack_require__.O=(result, chunkIds, fn, priority)=> {
if(chunkIds){
priority=priority||0;
for(var i=deferred.length; i > 0&&deferred[i - 1][2] > priority; i--) deferred[i]=deferred[i - 1];
deferred[i]=[chunkIds, fn, priority];
return;
}
var notFulfilled=Infinity;
for (var i=0; i < deferred.length; i++){
var [chunkIds, fn, priority]=deferred[i];
var fulfilled=true;
for (var j=0; j < chunkIds.length; j++){
if((priority & 1===0||notFulfilled >=priority)&&Object.keys(__webpack_require__.O).every((key)=> (__webpack_require__.O[key](chunkIds[j])))){
chunkIds.splice(j--, 1);
}else{
fulfilled=false;
if(priority < notFulfilled) notFulfilled=priority;
}
}
if(fulfilled){
deferred.splice(i--, 1)
var r=fn();
if(r!==undefined) result=r;
}
}
return result;
};
})();
(()=> {
__webpack_require__.f={};
__webpack_require__.e=(chunkId)=> {
return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=> {
__webpack_require__.f[key](chunkId, promises);
return promises;
}, []));
};
})();
(()=> {
__webpack_require__.u=(chunkId)=> {
if(chunkId==="code-highlight") return "" + chunkId + ".8b676d9a001f56fb77fa.bundle.js";
if(chunkId==="video-playlist") return "" + chunkId + ".964a12bbea2078517f07.bundle.js";
if(chunkId==="paypal-button") return "" + chunkId + ".3028ea98fc2e17fdfe8f.bundle.js";
if(chunkId==="vendors-node_modules_dompurify_dist_purify_js") return "98217e0c00e1f53421ef.bundle.js";
if(chunkId==="stripe-button") return "" + chunkId + ".b00915f9aec396f7b070.bundle.js";
if(chunkId==="progress-tracker") return "" + chunkId + ".3ec316715116e9087057.bundle.js";
if(chunkId==="animated-headline") return "" + chunkId + ".e4c2ed3934d0df18c40a.bundle.js";
if(chunkId==="media-carousel") return "" + chunkId + ".d8417210e0b731dd32b8.bundle.js";
if(chunkId==="carousel") return "" + chunkId + ".998a291abf70435fd698.bundle.js";
if(chunkId==="countdown") return "" + chunkId + ".60cf02eaf22d71d83f3d.bundle.js";
if(chunkId==="hotspot") return "" + chunkId + ".70886883c622dd8d5eb2.bundle.js";
if(chunkId==="form") return "form.97ef0fd396471477cc8e.bundle.js";
if(chunkId==="gallery") return "" + chunkId + ".805130d33e18cb04635f.bundle.js";
if(chunkId==="lottie") return "" + chunkId + ".a00fda0bbf10f9b99eae.bundle.js";
if(chunkId==="nav-menu") return "" + chunkId + ".3302c748e084579995fb.bundle.js";
if(chunkId==="popup") return "" + chunkId + ".1f90f6cfd0d44ef28772.bundle.js";
if(chunkId==="load-more") return "" + chunkId + ".ad89e46f2f6bfd9c27e8.bundle.js";
if(chunkId==="posts") return "" + chunkId + ".5d2d70b1d6918b6d8205.bundle.js";
if(chunkId==="portfolio") return "" + chunkId + ".9a52c1f0953359d74119.bundle.js";
if(chunkId==="share-buttons") return "" + chunkId + ".58e0fcb000aa02df3f24.bundle.js";
if(chunkId==="slides") return "" + chunkId + ".3b185c687f9167dfae0c.bundle.js";
if(chunkId==="social") return "" + chunkId + ".deeefd0e3641200f8239.bundle.js";
if(chunkId==="table-of-contents") return "" + chunkId + ".d228157a74585ba6b08c.bundle.js";
if(chunkId==="archive-posts") return "" + chunkId + ".0aae8c3bd7d196797b6c.bundle.js";
if(chunkId==="search-form") return "" + chunkId + ".4beabae7f0e0a3129ef7.bundle.js";
if(chunkId==="woocommerce-menu-cart") return "" + chunkId + ".010ec7298aee1fcdc2ea.bundle.js";
if(chunkId==="woocommerce-purchase-summary") return "" + chunkId + ".8d56a92f38ab4fc4575f.bundle.js";
if(chunkId==="woocommerce-checkout-page") return "" + chunkId + ".9b1242f2568f94bb8d5c.bundle.js";
if(chunkId==="woocommerce-cart") return "" + chunkId + ".73c6990b0b1a1ea18220.bundle.js";
if(chunkId==="woocommerce-my-account") return "" + chunkId + ".6509f179e93231fa2b6a.bundle.js";
if(chunkId==="woocommerce-notices") return "" + chunkId + ".d8c0850de1984ac89f33.bundle.js";
if(chunkId==="product-add-to-cart") return "" + chunkId + ".e099bc90899376d00959.bundle.js";
if(chunkId==="loop") return "loop.27d8ba43536f8b76ca41.bundle.js";
if(chunkId==="loop-carousel") return "" + chunkId + ".827a11bd7f1b0343de42.bundle.js";
if(chunkId==="ajax-pagination") return "" + chunkId + ".bc400e6cb24a14a2ea97.bundle.js";
if(chunkId==="mega-menu") return "" + chunkId + ".2e0078a6bbdc8abdf4af.bundle.js";
if(chunkId==="mega-menu-stretch-content") return "" + chunkId + ".4648b25d00c1f94cec4e.bundle.js";
if(chunkId==="menu-title-keyboard-handler") return "" + chunkId + ".b34510de747c3b311e45.bundle.js";
if(chunkId==="nested-carousel") return "" + chunkId + ".c8ad1035e988a2ae42b1.bundle.js";
if(chunkId==="taxonomy-filter") return "" + chunkId + ".9d41aac2f76c01cfdb42.bundle.js";
if(chunkId==="off-canvas") return "" + chunkId + ".26fe37796a9397d32c9f.bundle.js";
if(chunkId==="contact-buttons") return "" + chunkId + ".5f4d4ece4d991cd56a20.bundle.js";
if(chunkId==="contact-buttons-var-10") return "" + chunkId + ".5ceb4ecd2152a5f8b96e.bundle.js";
if(chunkId==="search") return "" + chunkId + ".5154a7b515b28ee3dfe6.bundle.js";
return undefined;
};
})();
(()=> {
__webpack_require__.g=(function(){
if(typeof globalThis==='object') return globalThis;
try {
return this||new Function('return this')();
} catch (e){
if(typeof window==='object') return window;
}
})();
})();
(()=> {
__webpack_require__.o=(obj, prop)=> (Object.prototype.hasOwnProperty.call(obj, prop))
})();
(()=> {
var inProgress={};
var dataWebpackPrefix="elementor-pro:";
__webpack_require__.l=(url, done, key, chunkId)=> {
if(inProgress[url]){ inProgress[url].push(done); return; }
var script, needAttach;
if(key!==undefined){
var scripts=document.getElementsByTagName("script");
for(var i=0; i < scripts.length; i++){
var s=scripts[i];
if(s.getAttribute("src")==url||s.getAttribute("data-webpack")==dataWebpackPrefix + key){ script=s; break; }
}
}
if(!script){
needAttach=true;
script=document.createElement('script');
script.charset='utf-8';
script.timeout=120;
if(__webpack_require__.nc){
script.setAttribute("nonce", __webpack_require__.nc);
}
script.setAttribute("data-webpack", dataWebpackPrefix + key);
script.src=url;
}
inProgress[url]=[done];
var onScriptComplete=(prev, event)=> {
script.onerror=script.onload=null;
clearTimeout(timeout);
var doneFns=inProgress[url];
delete inProgress[url];
script.parentNode&&script.parentNode.removeChild(script);
doneFns&&doneFns.forEach((fn)=> (fn(event)));
if(prev) return prev(event);
}
var timeout=setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
script.onerror=onScriptComplete.bind(null, script.onerror);
script.onload=onScriptComplete.bind(null, script.onload);
needAttach&&document.head.appendChild(script);
};
})();
(()=> {
var scriptUrl;
if(__webpack_require__.g.importScripts) scriptUrl=__webpack_require__.g.location + "";
var document=__webpack_require__.g.document;
if(!scriptUrl&&document){
if(document.currentScript)
scriptUrl=document.currentScript.src;
if(!scriptUrl){
var scripts=document.getElementsByTagName("script");
if(scripts.length){
var i=scripts.length - 1;
while (i > -1&&!scriptUrl) scriptUrl=scripts[i--].src;
}
}
}
if(!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
scriptUrl=scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
__webpack_require__.p=scriptUrl;
})();
(()=> {
var installedChunks={
"webpack-pro.runtime": 0
};
__webpack_require__.f.j=(chunkId, promises)=> {
var installedChunkData=__webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId]:undefined;
if(installedChunkData!==0){
if(installedChunkData){
promises.push(installedChunkData[2]);
}else{
if("webpack-pro.runtime"!=chunkId){
var promise=new Promise((resolve, reject)=> (installedChunkData=installedChunks[chunkId]=[resolve, reject]));
promises.push(installedChunkData[2]=promise);
var url=__webpack_require__.p + __webpack_require__.u(chunkId);
var error=new Error();
var loadingEnded=(event)=> {
if(__webpack_require__.o(installedChunks, chunkId)){
installedChunkData=installedChunks[chunkId];
if(installedChunkData!==0) installedChunks[chunkId]=undefined;
if(installedChunkData){
var errorType=event&&(event.type==='load' ? 'missing':event.type);
var realSrc=event&&event.target&&event.target.src;
error.message='Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
error.name='ChunkLoadError';
error.type=errorType;
error.request=realSrc;
installedChunkData[1](error);
}
}
};
__webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
} else installedChunks[chunkId]=0;
}
}
};
__webpack_require__.O.j=(chunkId)=> (installedChunks[chunkId]===0);
var webpackJsonpCallback=(parentChunkLoadingFunction, data)=> {
var [chunkIds, moreModules, runtime]=data;
var moduleId, chunkId, i=0;
if(chunkIds.some((id)=> (installedChunks[id]!==0))){
for(moduleId in moreModules){
if(__webpack_require__.o(moreModules, moduleId)){
__webpack_require__.m[moduleId]=moreModules[moduleId];
}
}
if(runtime) var result=runtime(__webpack_require__);
}
if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
for(;i < chunkIds.length; i++){
chunkId=chunkIds[i];
if(__webpack_require__.o(installedChunks, chunkId)&&installedChunks[chunkId]){
installedChunks[chunkId][0]();
}
installedChunks[chunkId]=0;
}
return __webpack_require__.O(result);
}
var chunkLoadingGlobal=self["webpackChunkelementor_pro"]=self["webpackChunkelementor_pro"]||[];
chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
chunkLoadingGlobal.push=webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
})();
})()
;
(self["webpackChunkelementor_pro"]=self["webpackChunkelementor_pro"]||[]).push([["frontend"],{
"../assets/dev/js/frontend/frontend.js":
((__unused_webpack_module, __unused_webpack_exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
__webpack_require__( "../assets/dev/js/public-path.js");
var _frontend=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/frontend.js"));
var _frontend2=_interopRequireDefault(__webpack_require__( "../modules/sticky/assets/js/frontend/frontend.js"));
var _frontend3=_interopRequireDefault(__webpack_require__( "../modules/code-highlight/assets/js/frontend/frontend.js"));
var _frontend4=_interopRequireDefault(__webpack_require__( "../modules/video-playlist/assets/js/frontend/frontend.js"));
var _frontend5=_interopRequireDefault(__webpack_require__( "../modules/payments/assets/js/frontend/frontend.js"));
var _frontend6=_interopRequireDefault(__webpack_require__( "../modules/progress-tracker/assets/js/frontend/frontend.js"));
var _controls=_interopRequireDefault(__webpack_require__( "../assets/dev/js/frontend/utils/controls.js"));
var _dropdownMenuHeightController=_interopRequireDefault(__webpack_require__( "../assets/dev/js/frontend/utils/dropdown-menu-height-controller.js"));
class ElementorProFrontend extends elementorModules.ViewModule {
onInit(){
super.onInit();
this.config=ElementorProFrontendConfig;
this.modules={};
this.initOnReadyComponents();
}
bindEvents(){
jQuery(window).on('elementor/frontend/init', this.onElementorFrontendInit.bind(this));
}
initModules(){
let handlers={
motionFX: _frontend.default,
sticky: _frontend2.default,
codeHighlight: _frontend3.default,
videoPlaylist: _frontend4.default,
payments: _frontend5.default,
progressTracker: _frontend6.default
};
elementorProFrontend.trigger('elementor-pro/modules/init:before');
elementorProFrontend.trigger('elementor-pro/modules/init/before');
handlers=elementorFrontend.hooks.applyFilters('elementor-pro/frontend/handlers', handlers);
jQuery.each(handlers, (moduleName, ModuleClass)=> {
this.modules[moduleName]=new ModuleClass();
});
this.modules.linkActions={
addAction: function (){
elementorFrontend.utils.urlActions.addAction(...arguments);
}};}
onElementorFrontendInit(){
this.initModules();
}
initOnReadyComponents(){
this.utils={
controls: new _controls.default(),
DropdownMenuHeightController: _dropdownMenuHeightController.default
};}}
window.elementorProFrontend=new ElementorProFrontend();
}),
"../assets/dev/js/frontend/utils/controls.js":
((__unused_webpack_module, exports)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
class Controls {
getControlValue(controlSettings, controlKey, controlSubKey){
let value;
if('object'===typeof controlSettings[controlKey]&&controlSubKey){
value=controlSettings[controlKey][controlSubKey];
}else{
value=controlSettings[controlKey];
}
return value;
}
getResponsiveControlValue(controlSettings, controlKey){
let controlSubKey=arguments.length > 2&&arguments[2]!==undefined ? arguments[2]:'';
const currentDeviceMode=elementorFrontend.getCurrentDeviceMode(),
controlValueDesktop=this.getControlValue(controlSettings, controlKey, controlSubKey);
if('widescreen'===currentDeviceMode){
const controlValueWidescreen=this.getControlValue(controlSettings, `${controlKey}_widescreen`, controlSubKey);
return !!controlValueWidescreen||0===controlValueWidescreen ? controlValueWidescreen:controlValueDesktop;
}
const activeBreakpoints=elementorFrontend.breakpoints.getActiveBreakpointsList({
withDesktop: true
});
let parentDeviceMode=currentDeviceMode,
deviceIndex=activeBreakpoints.indexOf(currentDeviceMode),
controlValue='';
while (deviceIndex <=activeBreakpoints.length){
if('desktop'===parentDeviceMode){
controlValue=controlValueDesktop;
break;
}
const responsiveControlKey=`${controlKey}_${parentDeviceMode}`,
responsiveControlValue=this.getControlValue(controlSettings, responsiveControlKey, controlSubKey);
if(!!responsiveControlValue||0===responsiveControlValue){
controlValue=responsiveControlValue;
break;
}
deviceIndex++;
parentDeviceMode=activeBreakpoints[deviceIndex];
}
return controlValue;
}}
exports["default"]=Controls;
}),
"../assets/dev/js/frontend/utils/dropdown-menu-height-controller.js":
((__unused_webpack_module, exports)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
class DropdownMenuHeightController {
constructor(widgetConfig){
this.widgetConfig=widgetConfig;
}
calculateStickyMenuNavHeight(){
this.widgetConfig.elements.$dropdownMenuContainer.css(this.widgetConfig.settings.menuHeightCssVarName, '');
const menuToggleHeight=this.widgetConfig.elements.$dropdownMenuContainer.offset().top - jQuery(window).scrollTop();
return elementorFrontend.elements.$window.height() - menuToggleHeight;
}
calculateMenuTabContentHeight($tab){
return elementorFrontend.elements.$window.height() - $tab[0].getBoundingClientRect().top;
}
isElementSticky(){
return this.widgetConfig.elements.$element.hasClass('elementor-sticky')||this.widgetConfig.elements.$element.parents('.elementor-sticky').length;
}
getMenuHeight(){
return this.isElementSticky() ? this.calculateStickyMenuNavHeight() + 'px':this.widgetConfig.settings.dropdownMenuContainerMaxHeight;
}
setMenuHeight(menuHeight){
this.widgetConfig.elements.$dropdownMenuContainer.css(this.widgetConfig.settings.menuHeightCssVarName, menuHeight);
}
reassignMobileMenuHeight(){
const menuHeight=this.isToggleActive() ? this.getMenuHeight():0;
return this.setMenuHeight(menuHeight);
}
reassignMenuHeight($activeTabContent){
if(!this.isElementSticky()||0===$activeTabContent.length){
return;
}
const offsetBottom=elementorFrontend.elements.$window.height() - $activeTabContent[0].getBoundingClientRect().top,
isContentHeightBiggerThanWindow=$activeTabContent.height() > offsetBottom;
if(!isContentHeightBiggerThanWindow){
return;
}
$activeTabContent.css('height', this.calculateMenuTabContentHeight($activeTabContent) + 'px');
$activeTabContent.css('overflow-y', 'scroll');
}
resetMenuHeight($activeTabContent){
if(!this.isElementSticky()){
return;
}
$activeTabContent.css('height', 'initial');
$activeTabContent.css('overflow-y', 'visible');
}
isToggleActive(){
const $menuToggle=this.widgetConfig.elements.$menuToggle;
if(!!this.widgetConfig.attributes?.menuToggleState){
return 'true'===$menuToggle.attr(this.widgetConfig.attributes.menuToggleState);
}
return $menuToggle.hasClass(this.widgetConfig.classes.menuToggleActiveClass);
}}
exports["default"]=DropdownMenuHeightController;
}),
"../assets/dev/js/public-path.js":
((__unused_webpack_module, __unused_webpack_exports, __webpack_require__)=> {
"use strict";
__webpack_require__.p=ElementorProFrontendConfig.urls.assets + 'js/';
}),
"../modules/code-highlight/assets/js/frontend/frontend.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
class _default extends elementorModules.Module {
constructor(){
super();
elementorFrontend.elementsHandler.attachHandler('code-highlight', ()=> __webpack_require__.e( "code-highlight").then(__webpack_require__.bind(__webpack_require__,  "../modules/code-highlight/assets/js/frontend/handler.js")));
}}
exports["default"]=_default;
}),
"../modules/motion-fx/assets/js/frontend/frontend.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _handler=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/handler.js"));
class _default extends elementorModules.Module {
constructor(){
super();
elementorFrontend.elementsHandler.attachHandler('global', _handler.default, null);
}}
exports["default"]=_default;
}),
"../modules/motion-fx/assets/js/frontend/handler.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _motionFx=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/motion-fx/motion-fx.js"));
class _default extends elementorModules.frontend.handlers.Base {
__construct(){
super.__construct(...arguments);
this.toggle=elementorFrontend.debounce(this.toggle, 200);
}
getDefaultSettings(){
return {
selectors: {
container: '.elementor-widget-container'
}};}
getDefaultElements(){
const selectors=this.getSettings('selectors');
return {
$container: this.$element.find(selectors.container)
};}
bindEvents(){
elementorFrontend.elements.$window.on('resize', this.toggle);
}
unbindEvents(){
elementorFrontend.elements.$window.off('resize', this.toggle);
}
addCSSTransformEvents(){
const motionFxScrolling=this.getElementSettings('motion_fx_motion_fx_scrolling');
if(motionFxScrolling&&!this.isTransitionEventAdded){
this.isTransitionEventAdded=true;
this.elements.$container.on('mouseenter', ()=> {
this.elements.$container.css('--e-transform-transition-duration', '');
});
}}
initEffects(){
this.effects={
translateY: {
interaction: 'scroll',
actions: ['translateY']
},
translateX: {
interaction: 'scroll',
actions: ['translateX']
},
rotateZ: {
interaction: 'scroll',
actions: ['rotateZ']
},
scale: {
interaction: 'scroll',
actions: ['scale']
},
opacity: {
interaction: 'scroll',
actions: ['opacity']
},
blur: {
interaction: 'scroll',
actions: ['blur']
},
mouseTrack: {
interaction: 'mouseMove',
actions: ['translateXY']
},
tilt: {
interaction: 'mouseMove',
actions: ['tilt']
}};}
prepareOptions(name){
const elementSettings=this.getElementSettings(),
type='motion_fx'===name ? 'element':'background',
interactions={};
jQuery.each(elementSettings, (key, value)=> {
const keyRegex=new RegExp('^' + name + '_(.+?)_effect'),
keyMatches=key.match(keyRegex);
if(!keyMatches||!value){
return;
}
const options={},
effectName=keyMatches[1];
jQuery.each(elementSettings, (subKey, subValue)=> {
const subKeyRegex=new RegExp(name + '_' + effectName + '_(.+)'),
subKeyMatches=subKey.match(subKeyRegex);
if(!subKeyMatches){
return;
}
const subFieldName=subKeyMatches[1];
if('effect'===subFieldName){
return;
}
if('object'===typeof subValue){
subValue=Object.keys(subValue.sizes).length ? subValue.sizes:subValue.size;
}
options[subKeyMatches[1]]=subValue;
});
const effect=this.effects[effectName],
interactionName=effect.interaction;
if(!interactions[interactionName]){
interactions[interactionName]={};}
effect.actions.forEach(action=> interactions[interactionName][action]=options);
});
let $element=this.$element,
$dimensionsElement;
const elementType=this.getElementType();
if('element'===type&&!['section', 'container'].includes(elementType)){
$dimensionsElement=$element;
let childElementSelector;
if('column'===elementType){
childElementSelector='.elementor-widget-wrap';
}else{
childElementSelector='.elementor-widget-container';
}
$element=$element.find('> ' + childElementSelector);
}
const options={
type,
interactions,
elementSettings,
$element,
$dimensionsElement,
refreshDimensions: this.isEdit,
range: elementSettings[name + '_range'],
classes: {
element: 'elementor-motion-effects-element',
parent: 'elementor-motion-effects-parent',
backgroundType: 'elementor-motion-effects-element-type-background',
container: 'elementor-motion-effects-container',
layer: 'elementor-motion-effects-layer',
perspective: 'elementor-motion-effects-perspective'
}};
if(!options.range&&'fixed'===this.getCurrentDeviceSetting('_position')){
options.range='page';
}
if('fixed'===this.getCurrentDeviceSetting('_position')){
options.isFixedPosition=true;
}
if('background'===type&&'column'===this.getElementType()){
options.addBackgroundLayerTo=' > .elementor-element-populated';
}
return options;
}
activate(name){
const options=this.prepareOptions(name);
if(jQuery.isEmptyObject(options.interactions)){
return;
}
this[name]=new _motionFx.default(options);
}
deactivate(name){
if(this[name]){
this[name].destroy();
delete this[name];
}}
toggle(){
const currentDeviceMode=elementorFrontend.getCurrentDeviceMode(),
elementSettings=this.getElementSettings();
['motion_fx', 'background_motion_fx'].forEach(name=> {
const devices=elementSettings[name + '_devices'],
isCurrentModeActive = !devices||-1!==devices.indexOf(currentDeviceMode);
if(isCurrentModeActive&&(elementSettings[name + '_motion_fx_scrolling']||elementSettings[name + '_motion_fx_mouse'])){
if(this[name]){
this.refreshInstance(name);
}else{
this.activate(name);
}}else{
this.deactivate(name);
}});
}
refreshInstance(instanceName){
const instance=this[instanceName];
if(!instance){
return;
}
const preparedOptions=this.prepareOptions(instanceName);
instance.setSettings(preparedOptions);
instance.refresh();
}
onInit(){
super.onInit();
this.initEffects();
this.addCSSTransformEvents();
this.toggle();
}
onElementChange(propertyName){
if(/motion_fx_((scrolling)|(mouse)|(devices))$/.test(propertyName)){
if('motion_fx_motion_fx_scrolling'===propertyName){
this.addCSSTransformEvents();
}
this.toggle();
return;
}
const propertyMatches=propertyName.match('.*?(motion_fx|_transform)');
if(propertyMatches){
const instanceName=propertyMatches[0].match('(_transform)') ? 'motion_fx':propertyMatches[0];
this.refreshInstance(instanceName);
if(!this[instanceName]){
this.activate(instanceName);
}}
if(/^_position/.test(propertyName)){
['motion_fx', 'background_motion_fx'].forEach(instanceName=> {
this.refreshInstance(instanceName);
});
}}
onDestroy(){
super.onDestroy();
['motion_fx', 'background_motion_fx'].forEach(name=> {
this.deactivate(name);
});
}}
exports["default"]=_default;
}),
"../modules/motion-fx/assets/js/frontend/motion-fx/actions.js":
((__unused_webpack_module, exports)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
class _default extends elementorModules.Module {
getMovePointFromPassedPercents(movableRange, passedPercents){
const movePoint=passedPercents / movableRange * 100;
return +movePoint.toFixed(2);
}
getEffectValueFromMovePoint(range, movePoint){
return range * movePoint / 100;
}
getStep(passedPercents, options){
if('element'===this.getSettings('type')){
return this.getElementStep(passedPercents, options);
}
return this.getBackgroundStep(passedPercents, options);
}
getElementStep(passedPercents, options){
return -(passedPercents - 50) * options.speed;
}
getBackgroundStep(passedPercents, options){
const movableRange=this.getSettings('dimensions.movable' + options.axis.toUpperCase());
return -this.getEffectValueFromMovePoint(movableRange, passedPercents);
}
getDirectionMovePoint(passedPercents, direction, range){
let movePoint;
if(passedPercents < range.start){
if('out-in'===direction){
movePoint=0;
}else if('in-out'===direction){
movePoint=100;
}else{
movePoint=this.getMovePointFromPassedPercents(range.start, passedPercents);
if('in-out-in'===direction){
movePoint=100 - movePoint;
}}
}else if(passedPercents < range.end){
if('in-out-in'===direction){
movePoint=0;
}else if('out-in-out'===direction){
movePoint=100;
}else{
movePoint=this.getMovePointFromPassedPercents(range.end - range.start, passedPercents - range.start);
if('in-out'===direction){
movePoint=100 - movePoint;
}}
}else if('in-out'===direction){
movePoint=0;
}else if('out-in'===direction){
movePoint=100;
}else{
movePoint=this.getMovePointFromPassedPercents(100 - range.end, 100 - passedPercents);
if('in-out-in'===direction){
movePoint=100 - movePoint;
}}
return movePoint;
}
translateX(actionData, passedPercents){
actionData.axis='x';
actionData.unit='px';
this.transform('translateX', passedPercents, actionData);
}
translateY(actionData, passedPercents){
actionData.axis='y';
actionData.unit='px';
this.transform('translateY', passedPercents, actionData);
}
translateXY(actionData, passedPercentsX, passedPercentsY){
this.translateX(actionData, passedPercentsX);
this.translateY(actionData, passedPercentsY);
}
tilt(actionData, passedPercentsX, passedPercentsY){
const options={
speed: actionData.speed / 10,
direction: actionData.direction
};
this.rotateX(options, passedPercentsY);
this.rotateY(options, 100 - passedPercentsX);
}
rotateX(actionData, passedPercents){
actionData.axis='x';
actionData.unit='deg';
this.transform('rotateX', passedPercents, actionData);
}
rotateY(actionData, passedPercents){
actionData.axis='y';
actionData.unit='deg';
this.transform('rotateY', passedPercents, actionData);
}
rotateZ(actionData, passedPercents){
actionData.unit='deg';
this.transform('rotateZ', passedPercents, actionData);
}
scale(actionData, passedPercents){
const movePoint=this.getDirectionMovePoint(passedPercents, actionData.direction, actionData.range);
this.updateRulePart('transform', 'scale', 1 + actionData.speed * movePoint / 1000);
}
transform(action, passedPercents, actionData){
if(actionData.direction){
passedPercents=100 - passedPercents;
}
this.updateRulePart('transform', action, this.getStep(passedPercents, actionData) + actionData.unit);
}
setCSSTransformVariables(elementSettings){
this.CSSTransformVariables=[];
jQuery.each(elementSettings, (settingKey, settingValue)=> {
const transformKeyMatches=settingKey.match(/_transform_(.+?)_effect/m);
if(transformKeyMatches&&settingValue){
if('perspective'===transformKeyMatches[1]){
this.CSSTransformVariables.unshift(transformKeyMatches[1]);
return;
}
if(this.CSSTransformVariables.includes(transformKeyMatches[1])){
return;
}
this.CSSTransformVariables.push(transformKeyMatches[1]);
}});
}
opacity(actionData, passedPercents){
const movePoint=this.getDirectionMovePoint(passedPercents, actionData.direction, actionData.range),
level=actionData.level / 10,
opacity=1 - level + this.getEffectValueFromMovePoint(level, movePoint);
this.$element.css({
opacity,
'will-change': 'opacity'
});
}
blur(actionData, passedPercents){
const movePoint=this.getDirectionMovePoint(passedPercents, actionData.direction, actionData.range),
blur=actionData.level - this.getEffectValueFromMovePoint(actionData.level, movePoint);
this.updateRulePart('filter', 'blur', blur + 'px');
}
updateRulePart(ruleName, key, value){
if(!this.rulesVariables[ruleName]){
this.rulesVariables[ruleName]={};}
if(!this.rulesVariables[ruleName][key]){
this.rulesVariables[ruleName][key]=true;
this.updateRule(ruleName);
}
const cssVarKey=`--${key}`;
this.$element[0].style.setProperty(cssVarKey, value);
}
updateRule(ruleName){
let value='';
value +=this.concatTransformCSSProperties(ruleName);
value +=this.concatTransformMotionEffectCSSProperties(ruleName);
this.$element.css(ruleName, value);
}
concatTransformCSSProperties(ruleName){
let value='';
if('transform'===ruleName){
jQuery.each(this.CSSTransformVariables, (index, variableKey)=> {
const variableName=variableKey;
if(variableKey.startsWith('flip')){
variableKey=variableKey.replace('flip', 'scale');
}
const defaultUnit=variableKey.startsWith('rotate')||variableKey.startsWith('skew') ? 'deg':'px',
defaultValue=variableKey.startsWith('scale') ? 1:0 + defaultUnit;
value +=`${variableKey}(var(--e-transform-${variableName}, ${defaultValue}))`;
});
}
return value;
}
concatTransformMotionEffectCSSProperties(ruleName){
let value='';
jQuery.each(this.rulesVariables[ruleName], variableKey=> {
value +=`${variableKey}(var(--${variableKey}))`;
});
return value;
}
runAction(actionName, actionData, passedPercents){
if(actionData.affectedRange){
if(actionData.affectedRange.start > passedPercents){
passedPercents=actionData.affectedRange.start;
}
if(actionData.affectedRange.end < passedPercents){
passedPercents=actionData.affectedRange.end;
}}
for (var _len=arguments.length, args=new Array(_len > 3 ? _len - 3:0), _key=3; _key < _len; _key++){
args[_key - 3]=arguments[_key];
}
this[actionName](actionData, passedPercents, ...args);
}
refresh(){
this.rulesVariables={};
this.CSSTransformVariables=[];
this.$element.css({
transform: '',
filter: '',
opacity: '',
'will-change': ''
});
}
onInit(){
this.$element=this.getSettings('$targetElement');
this.refresh();
}}
exports["default"]=_default;
}),
"../modules/motion-fx/assets/js/frontend/motion-fx/interactions/base.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _defineProperty2=_interopRequireDefault(__webpack_require__( "../node_modules/@babel/runtime/helpers/defineProperty.js"));
class _default extends elementorModules.ViewModule {
constructor(){
super(...arguments);
(0, _defineProperty2.default)(this, "onInsideViewport", ()=> {
this.run();
this.animationFrameRequest=requestAnimationFrame(this.onInsideViewport);
});
}
__construct(options){
this.motionFX=options.motionFX;
if(!this.intersectionObservers){
this.setElementInViewportObserver();
}}
setElementInViewportObserver(){
this.intersectionObserver=elementorModules.utils.Scroll.scrollObserver({
callback: event=> {
if(event.isInViewport){
this.onInsideViewport();
}else{
this.removeAnimationFrameRequest();
}}
});
const observedElement='page'===this.motionFX.getSettings('range') ? elementorFrontend.elements.$body[0]:this.motionFX.elements.$parent[0];
this.intersectionObserver.observe(observedElement);
}
runCallback(){
const callback=this.getSettings('callback');
callback(...arguments);
}
removeIntersectionObserver(){
if(this.intersectionObserver){
this.intersectionObserver.unobserve(this.motionFX.elements.$parent[0]);
}}
removeAnimationFrameRequest(){
if(this.animationFrameRequest){
cancelAnimationFrame(this.animationFrameRequest);
}}
destroy(){
this.removeAnimationFrameRequest();
this.removeIntersectionObserver();
}
onInit(){
super.onInit();
}}
exports["default"]=_default;
}),
"../modules/motion-fx/assets/js/frontend/motion-fx/interactions/mouse-move.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _base=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/base.js"));
class MouseMoveInteraction extends _base.default {
bindEvents(){
if(!MouseMoveInteraction.mouseTracked){
elementorFrontend.elements.$window.on('mousemove', MouseMoveInteraction.updateMousePosition);
MouseMoveInteraction.mouseTracked=true;
}}
run(){
const mousePosition=MouseMoveInteraction.mousePosition,
oldMousePosition=this.oldMousePosition;
if(oldMousePosition.x===mousePosition.x&&oldMousePosition.y===mousePosition.y){
return;
}
this.oldMousePosition={
x: mousePosition.x,
y: mousePosition.y
};
const passedPercentsX=100 / innerWidth * mousePosition.x,
passedPercentsY=100 / innerHeight * mousePosition.y;
this.runCallback(passedPercentsX, passedPercentsY);
}
onInit(){
this.oldMousePosition={};
super.onInit();
}}
exports["default"]=MouseMoveInteraction;
MouseMoveInteraction.mousePosition={};
MouseMoveInteraction.updateMousePosition=event=> {
MouseMoveInteraction.mousePosition={
x: event.clientX,
y: event.clientY
};};
}),
"../modules/motion-fx/assets/js/frontend/motion-fx/interactions/scroll.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _base=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/base.js"));
class _default extends _base.default {
run(){
if(pageYOffset===this.windowScrollTop){
return false;
}
this.onScrollMovement();
this.windowScrollTop=pageYOffset;
}
onScrollMovement(){
this.updateMotionFxDimensions();
this.updateAnimation();
this.resetTransitionVariable();
}
resetTransitionVariable(){
this.motionFX.$element.css('--e-transform-transition-duration', '100ms');
}
updateMotionFxDimensions(){
const motionFXSettings=this.motionFX.getSettings();
if(motionFXSettings.refreshDimensions){
this.motionFX.defineDimensions();
}}
updateAnimation(){
let passedRangePercents;
if('page'===this.motionFX.getSettings('range')){
passedRangePercents=elementorModules.utils.Scroll.getPageScrollPercentage();
}else if(this.motionFX.getSettings('isFixedPosition')){
passedRangePercents=elementorModules.utils.Scroll.getPageScrollPercentage({}, window.innerHeight);
}else{
passedRangePercents=elementorModules.utils.Scroll.getElementViewportPercentage(this.motionFX.elements.$parent);
}
this.runCallback(passedRangePercents);
}}
exports["default"]=_default;
}),
"../modules/motion-fx/assets/js/frontend/motion-fx/motion-fx.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _scroll=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/scroll.js"));
var _mouseMove=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/motion-fx/interactions/mouse-move.js"));
var _actions=_interopRequireDefault(__webpack_require__( "../modules/motion-fx/assets/js/frontend/motion-fx/actions.js"));
class _default extends elementorModules.ViewModule {
getDefaultSettings(){
return {
type: 'element',
$element: null,
$dimensionsElement: null,
addBackgroundLayerTo: null,
interactions: {},
refreshDimensions: false,
range: 'viewport',
classes: {
element: 'motion-fx-element',
parent: 'motion-fx-parent',
backgroundType: 'motion-fx-element-type-background',
container: 'motion-fx-container',
layer: 'motion-fx-layer',
perspective: 'motion-fx-perspective'
}};}
bindEvents(){
this.defineDimensions=this.defineDimensions.bind(this);
elementorFrontend.elements.$window.on('resize elementor-pro/motion-fx/recalc', this.defineDimensions);
}
unbindEvents(){
elementorFrontend.elements.$window.off('resize elementor-pro/motion-fx/recalc', this.defineDimensions);
}
addBackgroundLayer(){
const settings=this.getSettings();
this.elements.$motionFXContainer=jQuery('<div>', {
class: settings.classes.container
});
this.elements.$motionFXLayer=jQuery('<div>', {
class: settings.classes.layer
});
this.updateBackgroundLayerSize();
this.elements.$motionFXContainer.prepend(this.elements.$motionFXLayer);
const $addBackgroundLayerTo=settings.addBackgroundLayerTo ? this.$element.find(settings.addBackgroundLayerTo):this.$element;
$addBackgroundLayerTo.prepend(this.elements.$motionFXContainer);
}
removeBackgroundLayer(){
this.elements.$motionFXContainer.remove();
}
updateBackgroundLayerSize(){
const settings=this.getSettings(),
speed={
x: 0,
y: 0
},
mouseInteraction=settings.interactions.mouseMove,
scrollInteraction=settings.interactions.scroll;
if(mouseInteraction&&mouseInteraction.translateXY){
speed.x=mouseInteraction.translateXY.speed * 10;
speed.y=mouseInteraction.translateXY.speed * 10;
}
if(scrollInteraction){
if(scrollInteraction.translateX){
speed.x=scrollInteraction.translateX.speed * 10;
}
if(scrollInteraction.translateY){
speed.y=scrollInteraction.translateY.speed * 10;
}}
this.elements.$motionFXLayer.css({
width: 100 + speed.x + '%',
height: 100 + speed.y + '%'
});
}
defineDimensions(){
const $dimensionsElement=this.getSettings('$dimensionsElement')||this.$element,
elementOffset=$dimensionsElement.offset();
const dimensions={
elementHeight: $dimensionsElement.outerHeight(),
elementWidth: $dimensionsElement.outerWidth(),
elementTop: elementOffset.top,
elementLeft: elementOffset.left
};
dimensions.elementRange=dimensions.elementHeight + innerHeight;
this.setSettings('dimensions', dimensions);
if('background'===this.getSettings('type')){
this.defineBackgroundLayerDimensions();
}}
defineBackgroundLayerDimensions(){
const dimensions=this.getSettings('dimensions');
dimensions.layerHeight=this.elements.$motionFXLayer.height();
dimensions.layerWidth=this.elements.$motionFXLayer.width();
dimensions.movableX=dimensions.layerWidth - dimensions.elementWidth;
dimensions.movableY=dimensions.layerHeight - dimensions.elementHeight;
this.setSettings('dimensions', dimensions);
}
initInteractionsTypes(){
this.interactionsTypes={
scroll: _scroll.default,
mouseMove: _mouseMove.default
};}
prepareSpecialActions(){
const settings=this.getSettings(),
hasTiltEffect = !!(settings.interactions.mouseMove&&settings.interactions.mouseMove.tilt);
this.elements.$parent.toggleClass(settings.classes.perspective, hasTiltEffect);
}
cleanSpecialActions(){
const settings=this.getSettings();
this.elements.$parent.removeClass(settings.classes.perspective);
}
runInteractions(){
var _this=this;
const settings=this.getSettings();
this.actions.setCSSTransformVariables(settings.elementSettings);
this.prepareSpecialActions();
jQuery.each(settings.interactions, (interactionName, actions)=> {
this.interactions[interactionName]=new this.interactionsTypes[interactionName]({
motionFX: this,
callback: function (){
for (var _len=arguments.length, args=new Array(_len), _key=0; _key < _len; _key++){
args[_key]=arguments[_key];
}
jQuery.each(actions, (actionName, actionData)=> _this.actions.runAction(actionName, actionData, ...args));
}});
this.interactions[interactionName].run();
});
}
destroyInteractions(){
this.cleanSpecialActions();
jQuery.each(this.interactions, (interactionName, interaction)=> interaction.destroy());
this.interactions={};}
refresh(){
this.actions.setSettings(this.getSettings());
if('background'===this.getSettings('type')){
this.updateBackgroundLayerSize();
this.defineBackgroundLayerDimensions();
}
this.actions.refresh();
this.destroyInteractions();
this.runInteractions();
}
destroy(){
this.destroyInteractions();
this.actions.refresh();
const settings=this.getSettings();
this.$element.removeClass(settings.classes.element);
this.elements.$parent.removeClass(settings.classes.parent);
if('background'===settings.type){
this.$element.removeClass(settings.classes.backgroundType);
this.removeBackgroundLayer();
}}
onInit(){
super.onInit();
const settings=this.getSettings();
this.$element=settings.$element;
this.elements.$parent=this.$element.parent();
this.$element.addClass(settings.classes.element);
this.elements.$parent=this.$element.parent();
this.elements.$parent.addClass(settings.classes.parent);
if('background'===settings.type){
this.$element.addClass(settings.classes.backgroundType);
this.addBackgroundLayer();
}
this.defineDimensions();
settings.$targetElement='element'===settings.type ? this.$element:this.elements.$motionFXLayer;
this.interactions={};
this.actions=new _actions.default(settings);
this.initInteractionsTypes();
this.runInteractions();
}}
exports["default"]=_default;
}),
"../modules/payments/assets/js/frontend/frontend.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
class _default extends elementorModules.Module {
constructor(){
super();
elementorFrontend.elementsHandler.attachHandler('paypal-button', ()=> __webpack_require__.e( "paypal-button").then(__webpack_require__.bind(__webpack_require__,  "../modules/payments/assets/js/frontend/handlers/paypal-button.js")));
elementorFrontend.elementsHandler.attachHandler('stripe-button', ()=> Promise.all([__webpack_require__.e("vendors-node_modules_dompurify_dist_purify_js"), __webpack_require__.e("stripe-button")]).then(__webpack_require__.bind(__webpack_require__,  "../modules/payments/assets/js/frontend/handlers/stripe-button.js")));
}}
exports["default"]=_default;
}),
"../modules/progress-tracker/assets/js/frontend/frontend.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
class _default extends elementorModules.Module {
constructor(){
super();
elementorFrontend.elementsHandler.attachHandler('progress-tracker', ()=> __webpack_require__.e( "progress-tracker").then(__webpack_require__.bind(__webpack_require__,  "../modules/progress-tracker/assets/js/frontend/handlers/progress-tracker.js")));
}}
exports["default"]=_default;
}),
"../modules/sticky/assets/js/frontend/frontend.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
var _interopRequireDefault=__webpack_require__( "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _sticky=_interopRequireDefault(__webpack_require__( "../modules/sticky/assets/js/frontend/handlers/sticky.js"));
class _default extends elementorModules.Module {
constructor(){
super();
elementorFrontend.elementsHandler.attachHandler('section', _sticky.default, null);
elementorFrontend.elementsHandler.attachHandler('container', _sticky.default, null);
elementorFrontend.elementsHandler.attachHandler('widget', _sticky.default, null);
}}
exports["default"]=_default;
}),
"../modules/sticky/assets/js/frontend/handlers/sticky.js":
((__unused_webpack_module, exports)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
var _default=exports["default"]=elementorModules.frontend.handlers.Base.extend({
currentConfig: {},
debouncedReactivate: null,
bindEvents(){
elementorFrontend.addListenerOnce(this.getUniqueHandlerID() + 'sticky', 'resize', this.reactivateOnResize);
},
unbindEvents(){
elementorFrontend.removeListeners(this.getUniqueHandlerID() + 'sticky', 'resize', this.reactivateOnResize);
},
isStickyInstanceActive(){
return undefined!==this.$element.data('sticky');
},
getResponsiveSetting(setting){
const elementSettings=this.getElementSettings();
return elementorFrontend.getCurrentDeviceSetting(elementSettings, setting);
},
getResponsiveSettingList(setting){
const breakpoints=Object.keys(elementorFrontend.config.responsive.activeBreakpoints);
return ['', ...breakpoints].map(suffix=> {
return suffix ? `${setting}_${suffix}`:setting;
});
},
getConfig(){
const elementSettings=this.getElementSettings(),
stickyOptions={
to: elementSettings.sticky,
offset: this.getResponsiveSetting('sticky_offset'),
effectsOffset: this.getResponsiveSetting('sticky_effects_offset'),
classes: {
sticky: 'elementor-sticky',
stickyActive: 'elementor-sticky--active elementor-section--handles-inside',
stickyEffects: 'elementor-sticky--effects',
spacer: 'elementor-sticky__spacer'
},
isRTL: elementorFrontend.config.is_rtl,
handleScrollbarWidth: elementorFrontend.isEditMode()
},
$wpAdminBar=elementorFrontend.elements.$wpAdminBar,
isParentContainer=this.isContainerElement(this.$element[0])&&!this.isContainerElement(this.$element[0].parentElement);
if($wpAdminBar.length&&'top'===elementSettings.sticky&&'fixed'===$wpAdminBar.css('position')){
stickyOptions.offset +=$wpAdminBar.height();
}
if(elementSettings.sticky_parent&&!isParentContainer){
stickyOptions.parent='.e-container, .e-container__inner, .e-con, .e-con-inner, .elementor-widget-wrap';
}
return stickyOptions;
},
activate(){
this.currentConfig=this.getConfig();
this.$element.sticky(this.currentConfig);
},
deactivate(){
if(!this.isStickyInstanceActive()){
return;
}
this.$element.sticky('destroy');
},
run(refresh){
if(!this.getElementSettings('sticky')){
this.deactivate();
return;
}
var currentDeviceMode=elementorFrontend.getCurrentDeviceMode(),
activeDevices=this.getElementSettings('sticky_on');
if(-1!==activeDevices.indexOf(currentDeviceMode)){
if(true===refresh){
this.reactivate();
}else if(!this.isStickyInstanceActive()){
this.activate();
}}else{
this.deactivate();
}},
reactivateOnResize(){
clearTimeout(this.debouncedReactivate);
this.debouncedReactivate=setTimeout(()=> {
const config=this.getConfig(),
isDifferentConfig=JSON.stringify(config)!==JSON.stringify(this.currentConfig);
if(isDifferentConfig){
this.run(true);
}}, 300);
},
reactivate(){
this.deactivate();
this.activate();
},
onElementChange(settingKey){
if(-1!==['sticky', 'sticky_on'].indexOf(settingKey)){
this.run(true);
}
const settings=[...this.getResponsiveSettingList('sticky_offset'), ...this.getResponsiveSettingList('sticky_effects_offset'), 'sticky_parent'];
if(-1!==settings.indexOf(settingKey)){
this.reactivate();
}},
onDeviceModeChange(){
setTimeout(()=> this.run(true));
},
onInit(){
elementorModules.frontend.handlers.Base.prototype.onInit.apply(this, arguments);
if(elementorFrontend.isEditMode()){
elementor.listenTo(elementor.channels.deviceMode, 'change', ()=> this.onDeviceModeChange());
}
this.run();
},
onDestroy(){
elementorModules.frontend.handlers.Base.prototype.onDestroy.apply(this, arguments);
this.deactivate();
},
isContainerElement(element){
const containerClasses=[
'e-container', 'e-container__inner', 'e-con', 'e-con-inner'];
return containerClasses.some(containerClass=> {
return element?.classList.contains(containerClass);
});
}});
}),
"../modules/video-playlist/assets/js/frontend/frontend.js":
((__unused_webpack_module, exports, __webpack_require__)=> {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"]=void 0;
class _default extends elementorModules.Module {
constructor(){
super();
elementorFrontend.hooks.addAction('frontend/element_ready/video-playlist.default', $element=> {
__webpack_require__.e( "video-playlist").then(__webpack_require__.bind(__webpack_require__,  "../modules/video-playlist/assets/js/frontend/handler.js")).then(_ref=> {
let {
default: dynamicHandler
}=_ref;
elementorFrontend.elementsHandler.addHandler(dynamicHandler, {
$element,
toggleSelf: false
});
});
});
}}
exports["default"]=_default;
}),
"../node_modules/@babel/runtime/helpers/defineProperty.js":
((module, __unused_webpack_exports, __webpack_require__)=> {
var toPropertyKey=__webpack_require__( "../node_modules/@babel/runtime/helpers/toPropertyKey.js");
function _defineProperty(obj, key, value){
key=toPropertyKey(key);
if(key in obj){
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
}else{
obj[key]=value;
}
return obj;
}
module.exports=_defineProperty, module.exports.__esModule=true, module.exports["default"]=module.exports;
}),
"../node_modules/@babel/runtime/helpers/interopRequireDefault.js":
((module)=> {
function _interopRequireDefault(obj){
return obj&&obj.__esModule ? obj:{
"default": obj
};}
module.exports=_interopRequireDefault, module.exports.__esModule=true, module.exports["default"]=module.exports;
}),
"../node_modules/@babel/runtime/helpers/toPrimitive.js":
((module, __unused_webpack_exports, __webpack_require__)=> {
var _typeof=(__webpack_require__( "../node_modules/@babel/runtime/helpers/typeof.js")["default"]);
function toPrimitive(t, r){
if("object"!=_typeof(t)||!t) return t;
var e=t[Symbol.toPrimitive];
if(void 0!==e){
var i=e.call(t, r||"default");
if("object"!=_typeof(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string"===r ? String:Number)(t);
}
module.exports=toPrimitive, module.exports.__esModule=true, module.exports["default"]=module.exports;
}),
"../node_modules/@babel/runtime/helpers/toPropertyKey.js":
((module, __unused_webpack_exports, __webpack_require__)=> {
var _typeof=(__webpack_require__( "../node_modules/@babel/runtime/helpers/typeof.js")["default"]);
var toPrimitive=__webpack_require__( "../node_modules/@babel/runtime/helpers/toPrimitive.js");
function toPropertyKey(t){
var i=toPrimitive(t, "string");
return "symbol"==_typeof(i) ? i:i + "";
}
module.exports=toPropertyKey, module.exports.__esModule=true, module.exports["default"]=module.exports;
}),
"../node_modules/@babel/runtime/helpers/typeof.js":
((module)=> {
function _typeof(o){
"@babel/helpers - typeof";
return (module.exports=_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator ? function (o){
return typeof o;
}:function (o){
return o&&"function"==typeof Symbol&&o.constructor===Symbol&&o!==Symbol.prototype ? "symbol":typeof o;
}, module.exports.__esModule=true, module.exports["default"]=module.exports), _typeof(o);
}
module.exports=_typeof, module.exports.__esModule=true, module.exports["default"]=module.exports;
})
},
__webpack_require__=> {
var __webpack_exec__=(moduleId)=> (__webpack_require__(__webpack_require__.s=moduleId))
var __webpack_exports__=(__webpack_exec__("../assets/dev/js/frontend/frontend.js"));
}
]);