!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Swiper=t()}(this,function(){"use strict";function L(e){return null!==e&&"object"==typeof e&&"constructor"in e&&e.constructor===Object}function b(e,t){void 0===e&&(e={}),void 0===t&&(t={}),Object.keys(t).forEach(n=>{void 0===e[n]?e[n]=t[n]:L(t[n])&&L(e[n])&&Object.keys(t[n]).length>0&&b(e[n],t[n])})}const F={body:{},addEventListener(){},removeEventListener(){},activeElement:{blur(){},nodeName:""},querySelector:()=>null,querySelectorAll:()=>[],getElementById:()=>null,createEvent:()=>({initEvent(){}}),createElement:()=>({children:[],childNodes:[],style:{},setAttribute(){},getElementsByTagName:()=>[]}),createElementNS:()=>({}),importNode:()=>null,location:{hash:"",host:"",hostname:"",href:"",origin:"",pathname:"",protocol:"",search:""}};function n(){const e="undefined"!=typeof document?document:{};return b(e,F),e}const ne={document:F,navigator:{userAgent:""},location:{hash:"",host:"",hostname:"",href:"",origin:"",pathname:"",protocol:"",search:""},history:{replaceState(){},pushState(){},go(){},back(){}},CustomEvent:function(){return this},addEventListener(){},removeEventListener(){},getComputedStyle:()=>({getPropertyValue:()=>""}),Image(){},Date(){},screen:{},setTimeout(){},clearTimeout(){},matchMedia:()=>({}),requestAnimationFrame:e=>"undefined"==typeof setTimeout?(e(),null):setTimeout(e,0),cancelAnimationFrame(e){"undefined"!=typeof setTimeout&&clearTimeout(e)}};function t(){const e="undefined"!=typeof window?window:{};return b(e,ne),e}class c extends Array{constructor(e){"number"==typeof e?super(e):(super(...e||[]),function(e){const t=e.__proto__;Object.defineProperty(e,"__proto__",{get:()=>t,set(e){t.__proto__=e}})}(this))}}function u(e){void 0===e&&(e=[]);const t=[];return e.forEach(e=>{Array.isArray(e)?t.push(...u(e)):t.push(e)}),t}function T(e,t){return Array.prototype.filter.call(e,t)}function e(e,s){const a=t(),i=n();let o=[];if(!s&&e instanceof c)return e;if(!e)return new c(o);if("string"==typeof e){const t=e.trim();if(t.indexOf("<")>=0&&t.indexOf(">")>=0){let e="div";0===t.indexOf("<li")&&(e="ul"),0===t.indexOf("<tr")&&(e="tbody"),0!==t.indexOf("<td")&&0!==t.indexOf("<th")||(e="tr"),0===t.indexOf("<tbody")&&(e="table"),0===t.indexOf("<option")&&(e="select");const n=i.createElement(e);n.innerHTML=t;for(let e=0;e<n.childNodes.length;e+=1)o.push(n.childNodes[e])}else o=function(e,t){if("string"!=typeof e)return[e];const n=[],s=t.querySelectorAll(e);for(let e=0;e<s.length;e+=1)n.push(s[e]);return n}(e.trim(),s||i)}else if(e.nodeType||e===a||e===i)o.push(e);else if(Array.isArray(e)){if(e instanceof c)return e;o=e}return new c(function(e){const t=[];for(let n=0;n<e.length;n+=1)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(o))}e.fn=c.prototype;const z={addClass:function(){for(var t=arguments.length,n=new Array(t),e=0;e<t;e++)n[e]=arguments[e];const s=u(n.map(e=>e.split(" ")));return this.forEach(e=>{e.classList.add(...s)}),this},removeClass:function(){for(var t=arguments.length,n=new Array(t),e=0;e<t;e++)n[e]=arguments[e];const s=u(n.map(e=>e.split(" ")));return this.forEach(e=>{e.classList.remove(...s)}),this},hasClass:function(){for(var t=arguments.length,n=new Array(t),e=0;e<t;e++)n[e]=arguments[e];const s=u(n.map(e=>e.split(" ")));return T(this,e=>s.filter(t=>e.classList.contains(t)).length>0).length>0},toggleClass:function(){for(var t=arguments.length,n=new Array(t),e=0;e<t;e++)n[e]=arguments[e];const s=u(n.map(e=>e.split(" ")));this.forEach(e=>{s.forEach(t=>{e.classList.toggle(t)})})},attr:function(e,t){if(1===arguments.length&&"string"==typeof e)return this[0]?this[0].getAttribute(e):void 0;for(let n=0;n<this.length;n+=1)if(2===arguments.length)this[n].setAttribute(e,t);else for(const t in e)this[n][t]=e[t],this[n].setAttribute(t,e[t]);return this},removeAttr:function(e){for(let t=0;t<this.length;t+=1)this[t].removeAttribute(e);return this},transform:function(e){for(let t=0;t<this.length;t+=1)this[t].style.transform=e;return this},transition:function(e){for(let t=0;t<this.length;t+=1)this[t].style.transitionDuration="string"!=typeof e?`${e}ms`:e;return this},on:function(){for(var c=arguments.length,o=new Array(c),i=0;i<c;i++)o[i]=arguments[i];let[l,a,n,s]=o;function d(t){const s=t.target;if(!s)return;const o=t.target.dom7EventData||[];if(o.indexOf(t)<0&&o.unshift(t),e(s).is(a))n.apply(s,o);else{const t=e(s).parents();for(let s=0;s<t.length;s+=1)e(t[s]).is(a)&&n.apply(t[s],o)}}function u(e){const t=e&&e.target&&e.target.dom7EventData||[];t.indexOf(e)<0&&t.unshift(e),n.apply(this,t)}"function"==typeof o[1]&&([l,n,s]=o,a=void 0),s||(s=!1);const r=l.split(" ");let t;for(let o=0;o<this.length;o+=1){const e=this[o];if(a)for(t=0;t<r.length;t+=1){const o=r[t];e.dom7LiveListeners||(e.dom7LiveListeners={}),e.dom7LiveListeners[o]||(e.dom7LiveListeners[o]=[]),e.dom7LiveListeners[o].push({listener:n,proxyListener:d}),e.addEventListener(o,d,s)}else for(t=0;t<r.length;t+=1){const o=r[t];e.dom7Listeners||(e.dom7Listeners={}),e.dom7Listeners[o]||(e.dom7Listeners[o]=[]),e.dom7Listeners[o].push({listener:n,proxyListener:u}),e.addEventListener(o,u,s)}}return this},off:function(){for(var i=arguments.length,n=new Array(i),s=0;s<i;s++)n[s]=arguments[s];let[a,o,e,t]=n;"function"==typeof n[1]&&([a,e,t]=n,o=void 0),t||(t=!1);const r=a.split(" ");for(let s=0;s<r.length;s+=1){const n=r[s];for(let a=0;a<this.length;a+=1){const i=this[a];let s;if(!o&&i.dom7Listeners?s=i.dom7Listeners[n]:o&&i.dom7LiveListeners&&(s=i.dom7LiveListeners[n]),s&&s.length)for(let a=s.length-1;a>=0;a-=1){const o=s[a];e&&o.listener===e||e&&o.listener&&o.listener.dom7proxy&&o.listener.dom7proxy===e?(i.removeEventListener(n,o.proxyListener,t),s.splice(a,1)):e||(i.removeEventListener(n,o.proxyListener,t),s.splice(a,1))}}}return this},trigger:function(){const s=t();for(var o=arguments.length,e=new Array(o),n=0;n<o;n++)e[n]=arguments[n];const i=e[0].split(" "),a=e[1];for(let t=0;t<i.length;t+=1){const n=i[t];for(let o=0;o<this.length;o+=1){const t=this[o];if(s.CustomEvent){const o=new s.CustomEvent(n,{detail:a,bubbles:!0,cancelable:!0});t.dom7EventData=e.filter((e,t)=>t>0),t.dispatchEvent(o),t.dom7EventData=[],delete t.dom7EventData}}}return this},transitionEnd:function(e){const t=this;return e&&t.on("transitionend",function n(s){s.target===this&&(e.call(this,s),t.off("transitionend",n))}),this},outerWidth:function(e){if(this.length>0){if(e){const e=this.styles();return this[0].offsetWidth+parseFloat(e.getPropertyValue("margin-right"))+parseFloat(e.getPropertyValue("margin-left"))}return this[0].offsetWidth}return null},outerHeight:function(e){if(this.length>0){if(e){const e=this.styles();return this[0].offsetHeight+parseFloat(e.getPropertyValue("margin-top"))+parseFloat(e.getPropertyValue("margin-bottom"))}return this[0].offsetHeight}return null},styles:function(){const e=t();return this[0]?e.getComputedStyle(this[0],null):{}},offset:function(){if(this.length>0){const s=t(),a=n(),e=this[0],o=e.getBoundingClientRect(),i=a.body,r=e.clientTop||i.clientTop||0,c=e.clientLeft||i.clientLeft||0,l=e===s?s.scrollY:e.scrollTop,d=e===s?s.scrollX:e.scrollLeft;return{top:o.top+l-r,left:o.left+d-c}}return null},css:function(e,n){const o=t();let s;if(1===arguments.length){if("string"!=typeof e){for(s=0;s<this.length;s+=1)for(const t in e)this[s].style[t]=e[t];return this}if(this[0])return o.getComputedStyle(this[0],null).getPropertyValue(e)}if(2===arguments.length&&"string"==typeof e){for(s=0;s<this.length;s+=1)this[s].style[e]=n;return this}return this},each:function(e){return e?(this.forEach((t,n)=>{e.apply(t,[t,n])}),this):this},html:function(e){if(void 0===e)return this[0]?this[0].innerHTML:null;for(let t=0;t<this.length;t+=1)this[t].innerHTML=e;return this},text:function(e){if(void 0===e)return this[0]?this[0].textContent.trim():null;for(let t=0;t<this.length;t+=1)this[t].textContent=e;return this},is:function(s){const r=t(),l=n(),o=this[0];let a,i;if(!o||void 0===s)return!1;if("string"==typeof s){if(o.matches)return o.matches(s);if(o.webkitMatchesSelector)return o.webkitMatchesSelector(s);if(o.msMatchesSelector)return o.msMatchesSelector(s);for(a=e(s),i=0;i<a.length;i+=1)if(a[i]===o)return!0;return!1}if(s===l)return o===l;if(s===r)return o===r;if(s.nodeType||s instanceof c){for(a=s.nodeType?[s]:s,i=0;i<a.length;i+=1)if(a[i]===o)return!0;return!1}return!1},index:function(){let t,e=this[0];if(e){for(t=0;null!==(e=e.previousSibling);)1===e.nodeType&&(t+=1);return t}},eq:function(t){if(void 0===t)return this;const n=this.length;if(t>n-1)return e([]);if(t<0){const s=n+t;return e(s<0?[]:[this[s]])}return e([this[t]])},append:function(){let e;const t=n();for(let n=0;n<arguments.length;n+=1){e=n<0||arguments.length<=n?void 0:arguments[n];for(let n=0;n<this.length;n+=1)if("string"==typeof e){const s=t.createElement("div");for(s.innerHTML=e;s.firstChild;)this[n].appendChild(s.firstChild)}else if(e instanceof c)for(let t=0;t<e.length;t+=1)this[n].appendChild(e[t]);else this[n].appendChild(e)}return this},prepend:function(e){const o=n();let t,s;for(t=0;t<this.length;t+=1)if("string"==typeof e){const n=o.createElement("div");for(n.innerHTML=e,s=n.childNodes.length-1;s>=0;s-=1)this[t].insertBefore(n.childNodes[s],this[t].childNodes[0])}else if(e instanceof c)for(s=0;s<e.length;s+=1)this[t].insertBefore(e[s],this[t].childNodes[0]);else this[t].insertBefore(e,this[t].childNodes[0]);return this},next:function(t){return this.length>0?t?e(this[0].nextElementSibling&&e(this[0].nextElementSibling).is(t)?[this[0].nextElementSibling]:[]):e(this[0].nextElementSibling?[this[0].nextElementSibling]:[]):e([])},nextAll:function(t){const s=[];let n=this[0];if(!n)return e([]);for(;n.nextElementSibling;){const o=n.nextElementSibling;t?e(o).is(t)&&s.push(o):s.push(o),n=o}return e(s)},prev:function(t){if(this.length>0){const n=this[0];return t?e(n.previousElementSibling&&e(n.previousElementSibling).is(t)?[n.previousElementSibling]:[]):e(n.previousElementSibling?[n.previousElementSibling]:[])}return e([])},prevAll:function(t){const s=[];let n=this[0];if(!n)return e([]);for(;n.previousElementSibling;){const o=n.previousElementSibling;t?e(o).is(t)&&s.push(o):s.push(o),n=o}return e(s)},parent:function(t){const n=[];for(let s=0;s<this.length;s+=1)null!==this[s].parentNode&&(t?e(this[s].parentNode).is(t)&&n.push(this[s].parentNode):n.push(this[s].parentNode));return e(n)},parents:function(t){const n=[];for(let o=0;o<this.length;o+=1){let s=this[o].parentNode;for(;s;)t?e(s).is(t)&&n.push(s):n.push(s),s=s.parentNode}return e(n)},closest:function(t){let n=this;return void 0===t?e([]):(n.is(t)||(n=n.parents(t).eq(0)),n)},find:function(t){const n=[];for(let e=0;e<this.length;e+=1){const s=this[e].querySelectorAll(t);for(let e=0;e<s.length;e+=1)n.push(s[e])}return e(n)},children:function(t){const n=[];for(let s=0;s<this.length;s+=1){const o=this[s].children;for(let s=0;s<o.length;s+=1)t&&!e(o[s]).is(t)||n.push(o[s])}return e(n)},filter:function(t){return e(T(this,t))},remove:function(){for(let e=0;e<this.length;e+=1)this[e].parentNode&&this[e].parentNode.removeChild(this[e]);return this}};function r(e,t){return void 0===t&&(t=0),setTimeout(e,t)}function s(){return Date.now()}function O(e,n){void 0===n&&(n="x");const r=t();let i,s,a;const o=function(e){const s=t();let n;return s.getComputedStyle&&(n=s.getComputedStyle(e,null)),!n&&e.currentStyle&&(n=e.currentStyle),n||(n=e.style),n}(e);return r.WebKitCSSMatrix?(s=o.transform||o.webkitTransform,s.split(",").length>6&&(s=s.split(", ").map(e=>e.replace(",",".")).join(", ")),a=new r.WebKitCSSMatrix("none"===s?"":s)):(a=o.MozTransform||o.OTransform||o.MsTransform||o.msTransform||o.transform||o.getPropertyValue("transform").replace("translate(","matrix(1, 0, 0, 1,"),i=a.toString().split(",")),"x"===n&&(s=r.WebKitCSSMatrix?a.m41:parseFloat(16===i.length?i[12]:i[4])),"y"===n&&(s=r.WebKitCSSMatrix?a.m42:parseFloat(16===i.length?i[13]:i[5])),s||0}function m(e){return"object"==typeof e&&null!==e&&e.constructor&&"Object"===Object.prototype.toString.call(e).slice(8,-1)}function G(e){return"undefined"!=typeof window&&void 0!==window.HTMLElement?e instanceof HTMLElement:e&&(1===e.nodeType||11===e.nodeType)}function o(){const e=Object(arguments.length<=0?void 0:arguments[0]),t=["__proto__","constructor","prototype"];for(let s=1;s<arguments.length;s+=1){const n=s<0||arguments.length<=s?void 0:arguments[s];if(n!=null&&!G(n)){const s=Object.keys(Object(n)).filter(e=>t.indexOf(e)<0);for(let i=0,r=s.length;i<r;i+=1){const t=s[i],a=Object.getOwnPropertyDescriptor(n,t);void 0!==a&&a.enumerable&&(m(e[t])&&m(n[t])?n[t].__swiper__?e[t]=n[t]:o(e[t],n[t]):!m(e[t])&&m(n[t])?(e[t]={},n[t].__swiper__?e[t]=n[t]:o(e[t],n[t])):e[t]=n[t])}}}return e}function f(e,t,n){e.style.setProperty(t,n)}function k(e){let{swiper:n,targetPosition:s,side:c}=e;const o=t(),i=-n.translate;let a,r=null;const h=n.params.speed;n.wrapperEl.style.scrollSnapType="none",o.cancelAnimationFrame(n.cssModeFrameID);const l=s>i?"next":"prev",d=(e,t)=>"next"===l&&e>=t||"prev"===l&&e<=t,u=()=>{a=(new Date).getTime(),null===r&&(r=a);const t=Math.max(Math.min((a-r)/h,1),0),l=.5-Math.cos(t*Math.PI)/2;let e=i+l*(s-i);if(d(e,s)&&(e=s),n.wrapperEl.scrollTo({[c]:e}),d(e,s))return n.wrapperEl.style.overflow="hidden",n.wrapperEl.style.scrollSnapType="",setTimeout(()=>{n.wrapperEl.style.overflow="",n.wrapperEl.scrollTo({[c]:e})}),void o.cancelAnimationFrame(n.cssModeFrameID);n.cssModeFrameID=o.requestAnimationFrame(u)};u()}let j,y,_;function N(){return j||(j=function(){const e=t(),s=n();return{smoothScroll:s.documentElement&&"scrollBehavior"in s.documentElement.style,touch:!!("ontouchstart"in e||e.DocumentTouch&&s instanceof e.DocumentTouch),passiveListener:function(){let t=!1;try{const n=Object.defineProperty({},"passive",{get(){t=!0}});e.addEventListener("testPassiveListener",null,n)}catch{}return t}(),gestures:"ongesturestart"in e}}()),j}function X(e){return void 0===e&&(e={}),y||(y=function(e){let{userAgent:c}=void 0===e?{}:e;const h=N(),i=t(),a=i.navigator.platform,s=c||i.navigator.userAgent,o={ios:!1,android:!1},l=i.screen.width,d=i.screen.height,u=s.match(/(Android);?[\s/]+([\d.]+)?/);let n=s.match(/(iPad).*OS\s([\d_]+)/);const m=s.match(/(iPod)(.*OS\s([\d_]+))?/),f=!n&&s.match(/(iPhone\sOS|iOS)\s([\d_]+)/),p="Win32"===a;let r="MacIntel"===a;return!n&&r&&h.touch&&["1024x1366","1366x1024","834x1194","1194x834","834x1112","1112x834","768x1024","1024x768","820x1180","1180x820","810x1080","1080x810"].indexOf(`${l}x${d}`)>=0&&(n=s.match(/(Version)\/([\d.]+)/),n||(n=[0,1,"13_0_0"]),r=!1),u&&!p&&(o.os="android",o.android=!0),(n||f||m)&&(o.os="ios",o.ios=!0),o}(e)),y}function U(){return _||(_=function(){const e=t();return{isSafari:function(){const t=e.navigator.userAgent.toLowerCase();return t.indexOf("safari")>=0&&t.indexOf("chrome")<0&&t.indexOf("android")<0}(),isWebView:/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(e.navigator.userAgent)}}()),_}Object.keys(z).forEach(t=>{Object.defineProperty(e.fn,t,{value:z[t],writable:!0})});var v,E,S,M,P,$={on(e,t,n){const s=this;if("function"!=typeof t)return s;const o=n?"unshift":"push";return e.split(" ").forEach(e=>{s.eventsListeners[e]||(s.eventsListeners[e]=[]),s.eventsListeners[e][o](t)}),s},once(e,t,n){const o=this;if("function"!=typeof t)return o;function s(){o.off(e,s),s.__emitterProxy&&delete s.__emitterProxy;for(var i=arguments.length,a=new Array(i),n=0;n<i;n++)a[n]=arguments[n];t.apply(o,a)}return s.__emitterProxy=t,o.on(e,s,n)},onAny(e,t){const n=this;if("function"!=typeof e)return n;const s=t?"unshift":"push";return n.eventsAnyListeners.indexOf(e)<0&&n.eventsAnyListeners[s](e),n},offAny(e){const t=this;if(!t.eventsAnyListeners)return t;const n=t.eventsAnyListeners.indexOf(e);return n>=0&&t.eventsAnyListeners.splice(n,1),t},off(e,t){const n=this;return n.eventsListeners?(e.split(" ").forEach(e=>{void 0===t?n.eventsListeners[e]=[]:n.eventsListeners[e]&&n.eventsListeners[e].forEach((s,o)=>{(s===t||s.__emitterProxy&&s.__emitterProxy===t)&&n.eventsListeners[e].splice(o,1)})}),n):n},emit(){const e=this;if(!e.eventsListeners)return e;let n,s,o;for(var a=arguments.length,t=new Array(a),i=0;i<a;i++)t[i]=arguments[i];return"string"==typeof t[0]||Array.isArray(t[0])?(n=t[0],s=t.slice(1,t.length),o=e):(n=t[0].events,s=t[0].data,o=t[0].context||e),s.unshift(o),(Array.isArray(n)?n:n.split(" ")).forEach(t=>{e.eventsAnyListeners&&e.eventsAnyListeners.length&&e.eventsAnyListeners.forEach(e=>{e.apply(o,[t,...s])}),e.eventsListeners&&e.eventsListeners[t]&&e.eventsListeners[t].forEach(e=>{e.apply(o,s)})}),e}},V={updateSize:function(){const e=this;let t,n;const s=e.$el;t=void 0!==e.params.width&&null!==e.params.width?e.params.width:s[0].clientWidth,n=void 0!==e.params.height&&null!==e.params.height?e.params.height:s[0].clientHeight,0===t&&e.isHorizontal()||0===n&&e.isVertical()||(t=t-parseInt(s.css("padding-left")||0,10)-parseInt(s.css("padding-right")||0,10),n=n-parseInt(s.css("padding-top")||0,10)-parseInt(s.css("padding-bottom")||0,10),Number.isNaN(t)&&(t=0),Number.isNaN(n)&&(n=0),Object.assign(e,{width:t,height:n,size:e.isHorizontal()?t:n}))},updateSlides:function(){const t=this;function c(e){return t.isHorizontal()?e:{width:"height","margin-top":"margin-left","margin-bottom ":"margin-right","margin-left":"margin-top","margin-right":"margin-bottom","padding-left":"padding-top","padding-right":"padding-bottom",marginRight:"marginBottom"}[e]}function u(e,t){return parseFloat(e.getPropertyValue(c(t))||0)}const e=t.params,{$wrapperEl:_,size:i,rtlTranslate:v,wrongRTL:C}=t,b=t.virtual&&e.virtual.enabled,x=b?t.virtual.slides.length:t.slides.length,r=_.children(`.${t.params.slideClass}`),h=b?t.virtual.slides.length:r.length;let n=[];const l=[],d=[];let g=e.slidesOffsetBefore;"function"==typeof g&&(g=e.slidesOffsetBefore.call(t));let p=e.slidesOffsetAfter;"function"==typeof p&&(p=e.slidesOffsetAfter.call(t));const w=t.snapGrid.length,O=t.slidesGrid.length;let a=e.spaceBetween,s=-g,j=0,m=0;if(void 0===i)return;"string"==typeof a&&a.indexOf("%")>=0&&(a=parseFloat(a.replace("%",""))/100*i),t.virtualSize=-a,v?r.css({marginLeft:"",marginBottom:"",marginTop:""}):r.css({marginRight:"",marginBottom:"",marginTop:""}),e.centeredSlides&&e.cssMode&&(f(t.wrapperEl,"--swiper-centered-offset-before",""),f(t.wrapperEl,"--swiper-centered-offset-after",""));const y=e.grid&&e.grid.rows>1&&t.grid;let o;y&&t.grid.initSlides(h);const E="auto"===e.slidesPerView&&e.breakpoints&&Object.keys(e.breakpoints).filter(t=>void 0!==e.breakpoints[t].slidesPerView).length>0;for(let p=0;p<h;p+=1){o=0;const f=r.eq(p);if(y&&t.grid.updateSlide(p,f,h,c),"none"!==f.css("display")){if("auto"===e.slidesPerView){E&&(r[p].style[c("width")]="");const n=getComputedStyle(f[0]),s=f[0].style.transform,i=f[0].style.webkitTransform;if(s&&(f[0].style.transform="none"),i&&(f[0].style.webkitTransform="none"),e.roundLengths)o=t.isHorizontal()?f.outerWidth(!0):f.outerHeight(!0);else{const e=u(n,"width"),a=u(n,"padding-left"),r=u(n,"padding-right"),t=u(n,"margin-left"),s=u(n,"margin-right"),i=n.getPropertyValue("box-sizing");if(i&&"border-box"===i)o=e+t+s;else{const{clientWidth:n,offsetWidth:i}=f[0];o=e+a+r+t+s+(i-n)}}s&&(f[0].style.transform=s),i&&(f[0].style.webkitTransform=i),e.roundLengths&&(o=Math.floor(o))}else o=(i-(e.slidesPerView-1)*a)/e.slidesPerView,e.roundLengths&&(o=Math.floor(o)),r[p]&&(r[p].style[c("width")]=`${o}px`);r[p]&&(r[p].swiperSlideSize=o),d.push(o),e.centeredSlides?(s=s+o/2+j/2+a,0===j&&0!==p&&(s=s-i/2-a),0===p&&(s=s-i/2-a),Math.abs(s)<.001&&(s=0),e.roundLengths&&(s=Math.floor(s)),m%e.slidesPerGroup==0&&n.push(s),l.push(s)):(e.roundLengths&&(s=Math.floor(s)),(m-Math.min(t.params.slidesPerGroupSkip,m))%t.params.slidesPerGroup==0&&n.push(s),l.push(s),s=s+o+a),t.virtualSize+=o+a,j=o,m+=1}}if(t.virtualSize=Math.max(t.virtualSize,i)+p,v&&C&&("slide"===e.effect||"coverflow"===e.effect)&&_.css({width:`${t.virtualSize+e.spaceBetween}px`}),e.setWrapperSize&&_.css({[c("width")]:`${t.virtualSize+e.spaceBetween}px`}),y&&t.grid.updateWrapperSize(o,n,c),!e.centeredSlides){const s=[];for(let o=0;o<n.length;o+=1){let a=n[o];e.roundLengths&&(a=Math.floor(a)),n[o]<=t.virtualSize-i&&s.push(a)}n=s,Math.floor(t.virtualSize-i)-Math.floor(n[n.length-1])>1&&n.push(t.virtualSize-i)}if(0===n.length&&(n=[0]),0!==e.spaceBetween){const n=t.isHorizontal()&&v?"marginLeft":c("marginRight");r.filter((t,n)=>!e.cssMode||n!==r.length-1).css({[n]:`${a}px`})}if(e.centeredSlides&&e.centeredSlidesBounds){let t=0;d.forEach(n=>{t+=n+(e.spaceBetween?e.spaceBetween:0)}),t-=e.spaceBetween;const s=t-i;n=n.map(e=>e<0?-g:e>s?s+p:e)}if(e.centerInsufficientSlides){let t=0;if(d.forEach(n=>{t+=n+(e.spaceBetween?e.spaceBetween:0)}),t-=e.spaceBetween,t<i){const e=(i-t)/2;n.forEach((t,s)=>{n[s]=t-e}),l.forEach((t,n)=>{l[n]=t+e})}}if(Object.assign(t,{slides:r,snapGrid:n,slidesGrid:l,slidesSizesGrid:d}),e.centeredSlides&&e.cssMode&&!e.centeredSlidesBounds){f(t.wrapperEl,"--swiper-centered-offset-before",-n[0]+"px"),f(t.wrapperEl,"--swiper-centered-offset-after",t.size/2-d[d.length-1]/2+"px");const e=-t.snapGrid[0],s=-t.slidesGrid[0];t.snapGrid=t.snapGrid.map(t=>t+e),t.slidesGrid=t.slidesGrid.map(e=>e+s)}if(h!==x&&t.emit("slidesLengthChange"),n.length!==w&&(t.params.watchOverflow&&t.checkOverflow(),t.emit("snapGridLengthChange")),l.length!==O&&t.emit("slidesGridLengthChange"),e.watchSlidesProgress&&t.updateSlidesOffset(),!(b||e.cssMode||"slide"!==e.effect&&"fade"!==e.effect)){const n=`${e.containerModifierClass}backface-hidden`,s=t.$el.hasClass(n);h<=e.maxBackfaceHiddenSlides?s||t.$el.addClass(n):s&&t.$el.removeClass(n)}},updateAutoHeight:function(e){const t=this,s=[],i=t.virtual&&t.params.virtual.enabled;let n,o=0;"number"==typeof e?t.setTransition(e):!0===e&&t.setTransition(t.params.speed);const a=e=>i?t.slides.filter(t=>parseInt(t.getAttribute("data-swiper-slide-index"),10)===e)[0]:t.slides.eq(e)[0];if("auto"!==t.params.slidesPerView&&t.params.slidesPerView>1)if(t.params.centeredSlides)t.visibleSlides.each(e=>{s.push(e)});else for(n=0;n<Math.ceil(t.params.slidesPerView);n+=1){const e=t.activeIndex+n;if(e>t.slides.length&&!i)break;s.push(a(e))}else s.push(a(t.activeIndex));for(n=0;n<s.length;n+=1)if(void 0!==s[n]){const e=s[n].offsetHeight;o=e>o?e:o}(o||0===o)&&t.$wrapperEl.css("height",`${o}px`)},updateSlidesOffset:function(){const t=this,e=t.slides;for(let n=0;n<e.length;n+=1)e[n].swiperSlideOffset=t.isHorizontal()?e[n].offsetLeft:e[n].offsetTop},updateSlidesProgress:function(t){void 0===t&&(t=this&&this.translate||0);const n=this,s=n.params,{slides:o,rtlTranslate:a,snapGrid:r}=n;if(0===o.length)return;void 0===o[0].swiperSlideOffset&&n.updateSlidesOffset();let i=-t;a&&(i=t),o.removeClass(s.slideVisibleClass),n.visibleSlidesIndexes=[],n.visibleSlides=[];for(let e=0;e<o.length;e+=1){const t=o[e];let c=t.swiperSlideOffset;s.cssMode&&s.centeredSlides&&(c-=o[0].swiperSlideOffset);const u=(i+(s.centeredSlides?n.minTranslate():0)-c)/(t.swiperSlideSize+s.spaceBetween),h=(i-r[0]+(s.centeredSlides?n.minTranslate():0)-c)/(t.swiperSlideSize+s.spaceBetween),l=-(i-c),d=l+n.slidesSizesGrid[e];(l>=0&&l<n.size-1||d>1&&d<=n.size||l<=0&&d>=n.size)&&(n.visibleSlides.push(t),n.visibleSlidesIndexes.push(e),o.eq(e).addClass(s.slideVisibleClass)),t.progress=a?-u:u,t.originalProgress=a?-h:h}n.visibleSlides=e(n.visibleSlides)},updateProgress:function(e){const t=this;if(void 0===e){const n=t.rtlTranslate?-1:1;e=t&&t.translate&&t.translate*n||0}const i=t.params,a=t.maxTranslate()-t.minTranslate();let{progress:n,isBeginning:s,isEnd:o}=t;const r=s,c=o;0===a?(n=0,s=!0,o=!0):(n=(e-t.minTranslate())/a,s=n<=0,o=n>=1),Object.assign(t,{progress:n,isBeginning:s,isEnd:o}),(i.watchSlidesProgress||i.centeredSlides&&i.autoHeight)&&t.updateSlidesProgress(e),s&&!r&&t.emit("reachBeginning toEdge"),o&&!c&&t.emit("reachEnd toEdge"),(r&&!s||c&&!o)&&t.emit("fromEdge"),t.emit("progress",n)},updateSlidesClasses:function(){const i=this,{slides:a,params:e,$wrapperEl:t,activeIndex:r,realIndex:c}=i,l=i.virtual&&e.virtual.enabled;let o;a.removeClass(`${e.slideActiveClass} ${e.slideNextClass} ${e.slidePrevClass} ${e.slideDuplicateActiveClass} ${e.slideDuplicateNextClass} ${e.slideDuplicatePrevClass}`),o=l?i.$wrapperEl.find(`.${e.slideClass}[data-swiper-slide-index="${r}"]`):a.eq(r),o.addClass(e.slideActiveClass),e.loop&&(o.hasClass(e.slideDuplicateClass)?t.children(`.${e.slideClass}:not(.${e.slideDuplicateClass})[data-swiper-slide-index="${c}"]`).addClass(e.slideDuplicateActiveClass):t.children(`.${e.slideClass}.${e.slideDuplicateClass}[data-swiper-slide-index="${c}"]`).addClass(e.slideDuplicateActiveClass));let n=o.nextAll(`.${e.slideClass}`).eq(0).addClass(e.slideNextClass);e.loop&&0===n.length&&(n=a.eq(0),n.addClass(e.slideNextClass));let s=o.prevAll(`.${e.slideClass}`).eq(0).addClass(e.slidePrevClass);e.loop&&0===s.length&&(s=a.eq(-1),s.addClass(e.slidePrevClass)),e.loop&&(n.hasClass(e.slideDuplicateClass)?t.children(`.${e.slideClass}:not(.${e.slideDuplicateClass})[data-swiper-slide-index="${n.attr("data-swiper-slide-index")}"]`).addClass(e.slideDuplicateNextClass):t.children(`.${e.slideClass}.${e.slideDuplicateClass}[data-swiper-slide-index="${n.attr("data-swiper-slide-index")}"]`).addClass(e.slideDuplicateNextClass),s.hasClass(e.slideDuplicateClass)?t.children(`.${e.slideClass}:not(.${e.slideDuplicateClass})[data-swiper-slide-index="${s.attr("data-swiper-slide-index")}"]`).addClass(e.slideDuplicatePrevClass):t.children(`.${e.slideClass}.${e.slideDuplicateClass}[data-swiper-slide-index="${s.attr("data-swiper-slide-index")}"]`).addClass(e.slideDuplicatePrevClass)),i.emitSlidesClasses()},updateActiveIndex:function(e){const t=this,o=t.rtlTranslate?t.translate:-t.translate,{slidesGrid:s,snapGrid:a,params:r,activeIndex:c,realIndex:d,snapIndex:u}=t;let i,n=e;if(void 0===n){for(let e=0;e<s.length;e+=1)void 0!==s[e+1]?o>=s[e]&&o<s[e+1]-(s[e+1]-s[e])/2?n=e:o>=s[e]&&o<s[e+1]&&(n=e+1):o>=s[e]&&(n=e);r.normalizeSlideIndex&&(n<0||void 0===n)&&(n=0)}if(a.indexOf(o)>=0)i=a.indexOf(o);else{const e=Math.min(r.slidesPerGroupSkip,n);i=e+Math.floor((n-e)/r.slidesPerGroup)}if(i>=a.length&&(i=a.length-1),n===c)return void(i!==u&&(t.snapIndex=i,t.emit("snapIndexChange")));const l=parseInt(t.slides.eq(n).attr("data-swiper-slide-index")||n,10);Object.assign(t,{snapIndex:i,realIndex:l,previousIndex:c,activeIndex:n}),t.emit("activeIndexChange"),t.emit("snapIndexChange"),d!==l&&t.emit("realIndexChange"),(t.initialized||t.params.runCallbacksOnInit)&&t.emit("slideChange")},updateClickedSlide:function(t){const n=this,o=n.params,s=e(t).closest(`.${o.slideClass}`)[0];let i,a=!1;if(s)for(let e=0;e<n.slides.length;e+=1)if(n.slides[e]===s){a=!0,i=e;break}if(!s||!a)return n.clickedSlide=void 0,void(n.clickedIndex=void 0);n.clickedSlide=s,n.virtual&&n.params.virtual.enabled?n.clickedIndex=parseInt(e(s).attr("data-swiper-slide-index"),10):n.clickedIndex=i,o.slideToClickedSlide&&void 0!==n.clickedIndex&&n.clickedIndex!==n.activeIndex&&n.slideToClickedSlide()}},oe={getTranslate:function(e){void 0===e&&(e=this.isHorizontal()?"x":"y");const{params:s,rtlTranslate:o,translate:t,$wrapperEl:i}=this;if(s.virtualTranslate)return o?-t:t;if(s.cssMode)return t;let n=O(i[0],e);return o&&(n=-n),n||0},setTranslate:function(e,t){const n=this,{rtlTranslate:c,params:i,$wrapperEl:l,wrapperEl:d,progress:u}=n;let a,s=0,o=0;n.isHorizontal()?s=c?-e:e:o=e,i.roundLengths&&(s=Math.floor(s),o=Math.floor(o)),i.cssMode?d[n.isHorizontal()?"scrollLeft":"scrollTop"]=n.isHorizontal()?-s:-o:i.virtualTranslate||l.transform(`translate3d(${s}px, ${o}px, 0px)`),n.previousTranslate=n.translate,n.translate=n.isHorizontal()?s:o;const r=n.maxTranslate()-n.minTranslate();a=0===r?0:(e-n.minTranslate())/r,a!==u&&n.updateProgress(e),n.emit("setTranslate",n.translate,t)},minTranslate:function(){return-this.snapGrid[0]},maxTranslate:function(){return-this.snapGrid[this.snapGrid.length-1]},translateTo:function(e,t,n,s,o){void 0===e&&(e=0),void 0===t&&(t=this.params.speed),void 0===n&&(n=!0),void 0===s&&(s=!0);const i=this,{params:r,wrapperEl:c}=i;if(i.animating&&r.preventInteractionOnTransition)return!1;const l=i.minTranslate(),d=i.maxTranslate();let a;if(a=s&&e>l?l:s&&e<d?d:e,i.updateProgress(a),r.cssMode){const e=i.isHorizontal();if(0===t)c[e?"scrollLeft":"scrollTop"]=-a;else{if(!i.support.smoothScroll)return k({swiper:i,targetPosition:-a,side:e?"left":"top"}),!0;c.scrollTo({[e?"left":"top"]:-a,behavior:"smooth"})}return!0}return 0===t?(i.setTransition(0),i.setTranslate(a),n&&(i.emit("beforeTransitionStart",t,o),i.emit("transitionEnd"))):(i.setTransition(t),i.setTranslate(a),n&&(i.emit("beforeTransitionStart",t,o),i.emit("transitionStart")),i.animating||(i.animating=!0,i.onTranslateToWrapperTransitionEnd||(i.onTranslateToWrapperTransitionEnd=function(e){i&&!i.destroyed&&e.target===this&&(i.$wrapperEl[0].removeEventListener("transitionend",i.onTranslateToWrapperTransitionEnd),i.$wrapperEl[0].removeEventListener("webkitTransitionEnd",i.onTranslateToWrapperTransitionEnd),i.onTranslateToWrapperTransitionEnd=null,delete i.onTranslateToWrapperTransitionEnd,n&&i.emit("transitionEnd"))}),i.$wrapperEl[0].addEventListener("transitionend",i.onTranslateToWrapperTransitionEnd),i.$wrapperEl[0].addEventListener("webkitTransitionEnd",i.onTranslateToWrapperTransitionEnd))),!0}};function A(e){let{swiper:t,runCallbacks:a,direction:r,step:n}=e;const{activeIndex:o,previousIndex:i}=t;let s=r;if(s||(s=o>i?"next":o<i?"prev":"reset"),t.emit(`transition${n}`),a&&o!==i){if("reset"===s)return void t.emit(`slideResetTransition${n}`);t.emit(`slideChangeTransition${n}`),"next"===s?t.emit(`slideNextTransition${n}`):t.emit(`slidePrevTransition${n}`)}}S={slideTo:function(e,t,n,s,o){if(void 0===e&&(e=0),void 0===t&&(t=this.params.speed),void 0===n&&(n=!0),"number"!=typeof e&&"string"!=typeof e)throw new Error(`The 'index' argument cannot have type other than 'number' or 'string'. [${typeof e}] given.`);if("string"==typeof e){const t=parseInt(e,10);if(!isFinite(t))throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${e}] given.`);e=t}const i=this;let a=e;a<0&&(a=0);const{params:l,snapGrid:h,slidesGrid:u,previousIndex:b,activeIndex:d,rtlTranslate:f,wrapperEl:p,enabled:v}=i;if(i.animating&&l.preventInteractionOnTransition||!v&&!s&&!o)return!1;const g=Math.min(i.params.slidesPerGroupSkip,a);let m=g+Math.floor((a-g)/i.params.slidesPerGroup);m>=h.length&&(m=h.length-1),(d||l.initialSlide||0)===(b||0)&&n&&i.emit("beforeSlideChangeStart");const r=-h[m];if(i.updateProgress(r),l.normalizeSlideIndex)for(let e=0;e<u.length;e+=1){const t=-Math.floor(100*r),n=Math.floor(100*u[e]),s=Math.floor(100*u[e+1]);void 0!==u[e+1]?t>=n&&t<s-(s-n)/2?a=e:t>=n&&t<s&&(a=e+1):t>=n&&(a=e)}if(i.initialized&&a!==d){if(!i.allowSlideNext&&r<i.translate&&r<i.minTranslate())return!1;if(!i.allowSlidePrev&&r>i.translate&&r>i.maxTranslate()&&(d||0)!==a)return!1}let c;if(c=a>d?"next":a<d?"prev":"reset",f&&-r===i.translate||!f&&r===i.translate)return i.updateActiveIndex(a),l.autoHeight&&i.updateAutoHeight(),i.updateSlidesClasses(),"slide"!==l.effect&&i.setTranslate(r),"reset"!==c&&(i.transitionStart(n,c),i.transitionEnd(n,c)),!1;if(l.cssMode){const e=i.isHorizontal(),n=f?r:-r;if(0===t){const t=i.virtual&&i.params.virtual.enabled;t&&(i.wrapperEl.style.scrollSnapType="none",i._immediateVirtual=!0),p[e?"scrollLeft":"scrollTop"]=n,t&&requestAnimationFrame(()=>{i.wrapperEl.style.scrollSnapType="",i._swiperImmediateVirtual=!1})}else{if(!i.support.smoothScroll)return k({swiper:i,targetPosition:n,side:e?"left":"top"}),!0;p.scrollTo({[e?"left":"top"]:n,behavior:"smooth"})}return!0}return i.setTransition(t),i.setTranslate(r),i.updateActiveIndex(a),i.updateSlidesClasses(),i.emit("beforeTransitionStart",t,s),i.transitionStart(n,c),0===t?i.transitionEnd(n,c):i.animating||(i.animating=!0,i.onSlideToWrapperTransitionEnd||(i.onSlideToWrapperTransitionEnd=function(e){i&&!i.destroyed&&e.target===this&&(i.$wrapperEl[0].removeEventListener("transitionend",i.onSlideToWrapperTransitionEnd),i.$wrapperEl[0].removeEventListener("webkitTransitionEnd",i.onSlideToWrapperTransitionEnd),i.onSlideToWrapperTransitionEnd=null,delete i.onSlideToWrapperTransitionEnd,i.transitionEnd(n,c))}),i.$wrapperEl[0].addEventListener("transitionend",i.onSlideToWrapperTransitionEnd),i.$wrapperEl[0].addEventListener("webkitTransitionEnd",i.onSlideToWrapperTransitionEnd)),!0},slideToLoop:function(e,t,n,s){void 0===e&&(e=0),void 0===t&&(t=this.params.speed),void 0===n&&(n=!0);const o=this;let i=e;return o.params.loop&&(i+=o.loopedSlides),o.slideTo(i,t,n,s)},slideNext:function(e,t,n){void 0===e&&(e=this.params.speed),void 0===t&&(t=!0);const s=this,{animating:a,enabled:r,params:o}=s;if(!r)return s;let i=o.slidesPerGroup;"auto"===o.slidesPerView&&1===o.slidesPerGroup&&o.slidesPerGroupAuto&&(i=Math.max(s.slidesPerViewDynamic("current",!0),1));const c=s.activeIndex<o.slidesPerGroupSkip?1:i;if(o.loop){if(a&&o.loopPreventsSlide)return!1;s.loopFix(),s._clientLeft=s.$wrapperEl[0].clientLeft}return o.rewind&&s.isEnd?s.slideTo(0,e,t,n):s.slideTo(s.activeIndex+c,e,t,n)},slidePrev:function(e,t,n){void 0===e&&(e=this.params.speed),void 0===t&&(t=!0);const s=this,{params:i,animating:d,snapGrid:a,slidesGrid:u,rtlTranslate:h,enabled:m}=s;if(!m)return s;if(i.loop){if(d&&i.loopPreventsSlide)return!1;s.loopFix(),s._clientLeft=s.$wrapperEl[0].clientLeft}function c(e){return e<0?-Math.floor(Math.abs(e)):Math.floor(e)}const l=c(h?s.translate:-s.translate),f=a.map(e=>c(e));let r=a[f.indexOf(l)-1];if(void 0===r&&i.cssMode){let e;a.forEach((t,n)=>{l>=t&&(e=n)}),void 0!==e&&(r=a[e>0?e-1:e])}let o=0;if(void 0!==r&&(o=u.indexOf(r),o<0&&(o=s.activeIndex-1),"auto"===i.slidesPerView&&1===i.slidesPerGroup&&i.slidesPerGroupAuto&&(o=o-s.slidesPerViewDynamic("previous",!0)+1,o=Math.max(o,0))),i.rewind&&s.isBeginning){const o=s.params.virtual&&s.params.virtual.enabled&&s.virtual?s.virtual.slides.length-1:s.slides.length-1;return s.slideTo(o,e,t,n)}return s.slideTo(o,e,t,n)},slideReset:function(e,t,n){return void 0===e&&(e=this.params.speed),void 0===t&&(t=!0),this.slideTo(this.activeIndex,e,t,n)},slideToClosest:function(e,t,n,s){void 0===e&&(e=this.params.speed),void 0===t&&(t=!0),void 0===s&&(s=.5);const o=this;let i=o.activeIndex;const c=Math.min(o.params.slidesPerGroupSkip,i),a=c+Math.floor((i-c)/o.params.slidesPerGroup),r=o.rtlTranslate?o.translate:-o.translate;if(r>=o.snapGrid[a]){const e=o.snapGrid[a];r-e>(o.snapGrid[a+1]-e)*s&&(i+=o.params.slidesPerGroup)}else{const e=o.snapGrid[a-1];r-e<=(o.snapGrid[a]-e)*s&&(i-=o.params.slidesPerGroup)}return i=Math.max(i,0),i=Math.min(i,o.slidesGrid.length-1),o.slideTo(i,e,t,n)},slideToClickedSlide:function(){const t=this,{params:s,$wrapperEl:a}=t,o="auto"===s.slidesPerView?t.slidesPerViewDynamic():s.slidesPerView;let i,n=t.clickedIndex;if(s.loop){if(t.animating)return;i=parseInt(e(t.clickedSlide).attr("data-swiper-slide-index"),10),s.centeredSlides?n<t.loopedSlides-o/2||n>t.slides.length-t.loopedSlides+o/2?(t.loopFix(),n=a.children(`.${s.slideClass}[data-swiper-slide-index="${i}"]:not(.${s.slideDuplicateClass})`).eq(0).index(),r(()=>{t.slideTo(n)})):t.slideTo(n):n>t.slides.length-o?(t.loopFix(),n=a.children(`.${s.slideClass}[data-swiper-slide-index="${i}"]:not(.${s.slideDuplicateClass})`).eq(0).index(),r(()=>{t.slideTo(n)})):t.slideTo(n)}else t.slideTo(n)}},M={loopCreate:function(){const o=this,l=n(),{params:t,$wrapperEl:a}=o,i=a.children().length>0?e(a.children()[0].parentNode):a;i.children(`.${t.slideClass}.${t.slideDuplicateClass}`).remove();let s=i.children(`.${t.slideClass}`);if(t.loopFillGroupWithBlank){const n=t.slidesPerGroup-s.length%t.slidesPerGroup;if(n!==t.slidesPerGroup){for(let s=0;s<n;s+=1){const o=e(l.createElement("div")).addClass(`${t.slideClass} ${t.slideBlankClass}`);i.append(o)}s=i.children(`.${t.slideClass}`)}}"auto"!==t.slidesPerView||t.loopedSlides||(t.loopedSlides=s.length),o.loopedSlides=Math.ceil(parseFloat(t.loopedSlides||t.slidesPerView,10)),o.loopedSlides+=t.loopAdditionalSlides,o.loopedSlides>s.length&&(o.loopedSlides=s.length);const r=[],c=[];s.each((t,n)=>{const i=e(t);n<o.loopedSlides&&c.push(t),n<s.length&&n>=s.length-o.loopedSlides&&r.push(t),i.attr("data-swiper-slide-index",n)});for(let n=0;n<c.length;n+=1)i.append(e(c[n].cloneNode(!0)).addClass(t.slideDuplicateClass));for(let n=r.length-1;n>=0;n-=1)i.prepend(e(r[n].cloneNode(!0)).addClass(t.slideDuplicateClass))},loopFix:function(){const e=this;e.emit("beforeLoopFix");const{activeIndex:s,slides:i,loopedSlides:t,allowSlidePrev:r,allowSlideNext:c,snapGrid:l,rtlTranslate:a}=e;let n;e.allowSlidePrev=!0,e.allowSlideNext=!0;const o=-l[s]-e.getTranslate();s<t?(n=i.length-3*t+s,n+=t,e.slideTo(n,0,!1,!0)&&0!==o&&e.setTranslate((a?-e.translate:e.translate)-o)):s>=i.length-t&&(n=-i.length+s+t,n+=t,e.slideTo(n,0,!1,!0)&&0!==o&&e.setTranslate((a?-e.translate:e.translate)-o)),e.allowSlidePrev=r,e.allowSlideNext=c,e.emit("loopFix")},loopDestroy:function(){const{$wrapperEl:t,params:e,slides:n}=this;t.children(`.${e.slideClass}.${e.slideDuplicateClass},.${e.slideClass}.${e.slideBlankClass}`).remove(),n.removeAttr("data-swiper-slide-index")}};function B(o){const r=this,u=n(),b=t(),c=r.touchEventsData,{params:a,touches:d,enabled:g}=r;if(!g)return;if(r.animating&&a.preventInteractionOnTransition)return;!r.animating&&a.cssMode&&a.loop&&r.loopFix();let i=o;i.originalEvent&&(i=i.originalEvent);let l=e(i.target);if("wrapper"===a.touchEventsTarget&&!l.closest(r.wrapperEl).length)return;if(c.isTouchEvent="touchstart"===i.type,!c.isTouchEvent&&"which"in i&&3===i.which)return;if(!c.isTouchEvent&&"button"in i&&i.button>0)return;if(c.isTouched&&c.isMoved)return;!!a.noSwipingClass&&""!==a.noSwipingClass&&i.target&&i.target.shadowRoot&&o.path&&o.path[0]&&(l=e(o.path[0]));const m=a.noSwipingSelector?a.noSwipingSelector:`.${a.noSwipingClass}`,v=!!i.target&&!!i.target.shadowRoot;if(a.noSwiping&&(v?function(e,s){return void 0===s&&(s=this),function s(o){return o&&o!==n()&&o!==t()?(o.assignedSlot&&(o=o.assignedSlot),o.closest(e)||s(o.getRootNode().host)):null}(s)}(m,i.target):l.closest(m)[0]))return void(r.allowClick=!0);if(a.swipeHandler&&!l.closest(a.swipeHandler)[0])return;d.currentX="touchstart"===i.type?i.targetTouches[0].pageX:i.pageX,d.currentY="touchstart"===i.type?i.targetTouches[0].pageY:i.pageY;const h=d.currentX,j=d.currentY,f=a.edgeSwipeDetection||a.iOSEdgeSwipeDetection,p=a.edgeSwipeThreshold||a.iOSEdgeSwipeThreshold;if(f&&(h<=p||h>=b.innerWidth-p)){if("prevent"!==f)return;o.preventDefault()}if(Object.assign(c,{isTouched:!0,isMoved:!1,allowTouchCallbacks:!0,isScrolling:void 0,startMoving:void 0}),d.startX=h,d.startY=j,c.touchStartTime=s(),r.allowClick=!0,r.updateSize(),r.swipeDirection=void 0,a.threshold>0&&(c.allowThresholdMove=!1),"touchstart"!==i.type){let t=!0;l.is(c.focusableElements)&&(t=!1,"SELECT"===l[0].nodeName&&(c.isTouched=!1)),u.activeElement&&e(u.activeElement).is(c.focusableElements)&&u.activeElement!==l[0]&&u.activeElement.blur();const n=t&&r.allowTouchMove&&a.touchStartPreventDefault;!a.touchStartForcePreventDefault&&!n||l[0].isContentEditable||i.preventDefault()}r.params.freeMode&&r.params.freeMode.enabled&&r.freeMode&&r.animating&&!a.cssMode&&r.freeMode.onTouchStart(),r.emit("touchStart",i)}function te(t){const v=n(),o=this,i=o.touchEventsData,{params:c,touches:a,rtlTranslate:j,enabled:b}=o;if(!b)return;let r=t;if(r.originalEvent&&(r=r.originalEvent),!i.isTouched)return void(i.startMoving&&i.isScrolling&&o.emit("touchMoveOpposite",r));if(i.isTouchEvent&&"touchmove"!==r.type)return;const g="touchmove"===r.type&&r.targetTouches&&(r.targetTouches[0]||r.changedTouches[0]),d="touchmove"===r.type?g.pageX:r.pageX,u="touchmove"===r.type?g.pageY:r.pageY;if(r.preventedByNestedSwiper)return a.startX=d,void(a.startY=u);if(!o.allowTouchMove)return e(r.target).is(i.focusableElements)||(o.allowClick=!1),void(i.isTouched&&(Object.assign(a,{startX:d,startY:u,currentX:d,currentY:u}),i.touchStartTime=s()));if(i.isTouchEvent&&c.touchReleaseOnEdges&&!c.loop)if(o.isVertical()){if(u<a.startY&&o.translate<=o.maxTranslate()||u>a.startY&&o.translate>=o.minTranslate())return i.isTouched=!1,void(i.isMoved=!1)}else if(d<a.startX&&o.translate<=o.maxTranslate()||d>a.startX&&o.translate>=o.minTranslate())return;if(i.isTouchEvent&&v.activeElement&&r.target===v.activeElement&&e(r.target).is(i.focusableElements))return i.isMoved=!0,void(o.allowClick=!1);if(i.allowTouchCallbacks&&o.emit("touchMove",r),r.targetTouches&&r.targetTouches.length>1)return;a.currentX=d,a.currentY=u;const m=a.currentX-a.startX,h=a.currentY-a.startY;if(o.params.threshold&&Math.sqrt(m**2+h**2)<o.params.threshold)return;if(void 0===i.isScrolling){let e;o.isHorizontal()&&a.currentY===a.startY||o.isVertical()&&a.currentX===a.startX?i.isScrolling=!1:m*m+h*h>=25&&(e=180*Math.atan2(Math.abs(h),Math.abs(m))/Math.PI,i.isScrolling=o.isHorizontal()?e>c.touchAngle:90-e>c.touchAngle)}if(i.isScrolling&&o.emit("touchMoveOpposite",r),void 0===i.startMoving&&(a.currentX===a.startX&&a.currentY===a.startY||(i.startMoving=!0)),i.isScrolling)return void(i.isTouched=!1);if(!i.startMoving)return;o.allowClick=!1,!c.cssMode&&r.cancelable&&r.preventDefault(),c.touchMoveStopPropagation&&!c.nested&&r.stopPropagation(),i.isMoved||(c.loop&&!c.cssMode&&o.loopFix(),i.startTranslate=o.getTranslate(),o.setTransition(0),o.animating&&o.$wrapperEl.trigger("webkitTransitionEnd transitionend"),i.allowMomentumBounce=!1,!c.grabCursor||!0!==o.allowSlideNext&&!0!==o.allowSlidePrev||o.setGrabCursor(!0),o.emit("sliderFirstMove",r)),o.emit("sliderMove",r),i.isMoved=!0;let l=o.isHorizontal()?m:h;a.diff=l,l*=c.touchRatio,j&&(l=-l),o.swipeDirection=l>0?"prev":"next",i.currentTranslate=l+i.startTranslate;let f=!0,p=c.resistanceRatio;if(c.touchReleaseOnEdges&&(p=0),l>0&&i.currentTranslate>o.minTranslate()?(f=!1,c.resistance&&(i.currentTranslate=o.minTranslate()-1+(-o.minTranslate()+i.startTranslate+l)**p)):l<0&&i.currentTranslate<o.maxTranslate()&&(f=!1,c.resistance&&(i.currentTranslate=o.maxTranslate()+1-(o.maxTranslate()-i.startTranslate-l)**p)),f&&(r.preventedByNestedSwiper=!0),!o.allowSlideNext&&"next"===o.swipeDirection&&i.currentTranslate<i.startTranslate&&(i.currentTranslate=i.startTranslate),!o.allowSlidePrev&&"prev"===o.swipeDirection&&i.currentTranslate>i.startTranslate&&(i.currentTranslate=i.startTranslate),o.allowSlidePrev||o.allowSlideNext||(i.currentTranslate=i.startTranslate),c.threshold>0){if(!(Math.abs(l)>c.threshold||i.allowThresholdMove))return void(i.currentTranslate=i.startTranslate);if(!i.allowThresholdMove)return i.allowThresholdMove=!0,a.startX=a.currentX,a.startY=a.currentY,i.currentTranslate=i.startTranslate,void(a.diff=o.isHorizontal()?a.currentX-a.startX:a.currentY-a.startY)}c.followFinger&&!c.cssMode&&((c.freeMode&&c.freeMode.enabled&&o.freeMode||c.watchSlidesProgress)&&(o.updateActiveIndex(),o.updateSlidesClasses()),o.params.freeMode&&c.freeMode.enabled&&o.freeMode&&o.freeMode.onTouchMove(),o.updateProgress(i.currentTranslate),o.setTranslate(i.currentTranslate))}function se(e){const t=this,n=t.touchEventsData,{params:o,touches:j,rtlTranslate:b,slidesGrid:a,enabled:v}=t;if(!v)return;let i=e;if(i.originalEvent&&(i=i.originalEvent),n.allowTouchCallbacks&&t.emit("touchEnd",i),n.allowTouchCallbacks=!1,!n.isTouched)return n.isMoved&&o.grabCursor&&t.setGrabCursor(!1),n.isMoved=!1,void(n.startMoving=!1);o.grabCursor&&n.isMoved&&n.isTouched&&(!0===t.allowSlideNext||!0===t.allowSlidePrev)&&t.setGrabCursor(!1);const p=s(),g=p-n.touchStartTime;if(t.allowClick){const e=i.path||i.composedPath&&i.composedPath();t.updateClickedSlide(e&&e[0]||i.target),t.emit("tap click",i),g<300&&p-n.lastClickTime<300&&t.emit("doubleTap doubleClick",i)}if(n.lastClickTime=s(),r(()=>{t.destroyed||(t.allowClick=!0)}),!n.isTouched||!n.isMoved||!t.swipeDirection||0===j.diff||n.currentTranslate===n.startTranslate)return n.isTouched=!1,n.isMoved=!1,void(n.startMoving=!1);let l;if(n.isTouched=!1,n.isMoved=!1,n.startMoving=!1,l=o.followFinger?b?t.translate:-t.translate:-n.currentTranslate,o.cssMode)return;if(t.params.freeMode&&o.freeMode.enabled)return void t.freeMode.onTouchEnd({currentPos:l});let c=0,f=t.slidesSizesGrid[0];for(let e=0;e<a.length;e+=e<o.slidesPerGroupSkip?1:o.slidesPerGroup){const t=e<o.slidesPerGroupSkip-1?1:o.slidesPerGroup;void 0!==a[e+t]?l>=a[e]&&l<a[e+t]&&(c=e,f=a[e+t]-a[e]):l>=a[e]&&(c=e,f=a[a.length-1]-a[a.length-2])}let m=null,d=null;o.rewind&&(t.isBeginning?d=t.params.virtual&&t.params.virtual.enabled&&t.virtual?t.virtual.slides.length-1:t.slides.length-1:t.isEnd&&(m=0));const h=(l-a[c])/f,u=c<o.slidesPerGroupSkip-1?1:o.slidesPerGroup;if(g>o.longSwipesMs){if(!o.longSwipes)return void t.slideTo(t.activeIndex);"next"===t.swipeDirection&&(h>=o.longSwipesRatio?t.slideTo(o.rewind&&t.isEnd?m:c+u):t.slideTo(c)),"prev"===t.swipeDirection&&(h>1-o.longSwipesRatio?t.slideTo(c+u):null!==d&&h<0&&Math.abs(h)>o.longSwipesRatio?t.slideTo(d):t.slideTo(c))}else{if(!o.shortSwipes)return void t.slideTo(t.activeIndex);t.navigation&&(i.target===t.navigation.nextEl||i.target===t.navigation.prevEl)?i.target===t.navigation.nextEl?t.slideTo(c+u):t.slideTo(c):("next"===t.swipeDirection&&t.slideTo(null!==m?m:c+u),"prev"===t.swipeDirection&&t.slideTo(null!==d?d:c))}}function D(){const e=this,{params:t,el:n}=e;if(n&&0===n.offsetWidth)return;t.breakpoints&&e.setBreakpoint();const{allowSlideNext:s,allowSlidePrev:o,snapGrid:i}=e;e.allowSlideNext=!0,e.allowSlidePrev=!0,e.updateSize(),e.updateSlides(),e.updateSlidesClasses(),("auto"===t.slidesPerView||t.slidesPerView>1)&&e.isEnd&&!e.isBeginning&&!e.params.centeredSlides?e.slideTo(e.slides.length-1,0,!1,!0):e.slideTo(e.activeIndex,0,!1,!0),e.autoplay&&e.autoplay.running&&e.autoplay.paused&&e.autoplay.run(),e.allowSlidePrev=o,e.allowSlideNext=s,e.params.watchOverflow&&i!==e.snapGrid&&e.checkOverflow()}function ie(e){const t=this;t.enabled&&(t.allowClick||(t.params.preventClicks&&e.preventDefault(),t.params.preventClicksPropagation&&t.animating&&(e.stopPropagation(),e.stopImmediatePropagation())))}function K(){const e=this,{wrapperEl:t,rtlTranslate:o,enabled:i}=e;if(!i)return;let n;e.previousTranslate=e.translate,e.isHorizontal()?e.translate=-t.scrollLeft:e.translate=-t.scrollTop,0===e.translate&&(e.translate=0),e.updateActiveIndex(),e.updateSlidesClasses();const s=e.maxTranslate()-e.minTranslate();n=0===s?0:(e.translate-e.minTranslate())/s,n!==e.progress&&e.updateProgress(o?-e.translate:e.translate),e.emit("setTranslate",e.translate,!1)}let C=!1;function q(){}const H=(e,t)=>{const l=n(),{params:i,touchEvents:s,el:a,wrapperEl:h,device:d,support:r}=e,c=!!i.nested,o="on"===t?"addEventListener":"removeEventListener",u=t;if(r.touch){const t=!("touchstart"!==s.start||!r.passiveListener||!i.passiveListeners)&&{passive:!0,capture:!1};a[o](s.start,e.onTouchStart,t),a[o](s.move,e.onTouchMove,r.passiveListener?{passive:!1,capture:c}:c),a[o](s.end,e.onTouchEnd,t),s.cancel&&a[o](s.cancel,e.onTouchEnd,t)}else a[o](s.start,e.onTouchStart,!1),l[o](s.move,e.onTouchMove,c),l[o](s.end,e.onTouchEnd,!1);(i.preventClicks||i.preventClicksPropagation)&&a[o]("click",e.onClick,!0),i.cssMode&&h[o]("scroll",e.onScroll),i.updateOnWindowResize?e[u](d.ios||d.android?"resize orientationchange observerUpdate":"resize observerUpdate",D,!0):e[u]("observerUpdate",D,!0)};P={attachEvents:function(){const e=this,t=n(),{params:s,support:o}=e;e.onTouchStart=B.bind(e),e.onTouchMove=te.bind(e),e.onTouchEnd=se.bind(e),s.cssMode&&(e.onScroll=K.bind(e)),e.onClick=ie.bind(e),o.touch&&!C&&(t.addEventListener("touchstart",q),C=!0),H(e,"on")},detachEvents:function(){H(this,"off")}};const R=(e,t)=>e.grid&&t.grid&&t.grid.rows>1;E={addClasses:function(){const t=this,{classNames:n,params:e,rtl:o,$el:i,device:s,support:a}=t,r=function(e,t){const n=[];return e.forEach(e=>{"object"==typeof e?Object.keys(e).forEach(s=>{e[s]&&n.push(t+s)}):"string"==typeof e&&n.push(t+e)}),n}(["initialized",e.direction,{"pointer-events":!a.touch},{"free-mode":t.params.freeMode&&e.freeMode.enabled},{autoheight:e.autoHeight},{rtl:o},{grid:e.grid&&e.grid.rows>1},{"grid-column":e.grid&&e.grid.rows>1&&"column"===e.grid.fill},{android:s.android},{ios:s.ios},{"css-mode":e.cssMode},{centered:e.cssMode&&e.centeredSlides}],e.containerModifierClass);n.push(...r),i.addClass([...n].join(" ")),t.emitContainerClasses()},removeClasses:function(){const{$el:e,classNames:t}=this;e.removeClass(t.join(" ")),this.emitContainerClasses()}},v={init:!0,direction:"horizontal",touchEventsTarget:"wrapper",initialSlide:0,speed:300,cssMode:!1,updateOnWindowResize:!0,resizeObserver:!0,nested:!1,createElements:!1,enabled:!0,focusableElements:"input, select, option, textarea, button, video, label",width:null,height:null,preventInteractionOnTransition:!1,userAgent:null,url:null,edgeSwipeDetection:!1,edgeSwipeThreshold:20,autoHeight:!1,setWrapperSize:!1,virtualTranslate:!1,effect:"slide",breakpoints:void 0,breakpointsBase:"window",spaceBetween:0,slidesPerView:1,slidesPerGroup:1,slidesPerGroupSkip:0,slidesPerGroupAuto:!1,centeredSlides:!1,centeredSlidesBounds:!1,slidesOffsetBefore:0,slidesOffsetAfter:0,normalizeSlideIndex:!0,centerInsufficientSlides:!1,watchOverflow:!0,roundLengths:!1,touchRatio:1,touchAngle:45,simulateTouch:!0,shortSwipes:!0,longSwipes:!0,longSwipesRatio:.5,longSwipesMs:300,followFinger:!0,allowTouchMove:!0,threshold:0,touchMoveStopPropagation:!1,touchStartPreventDefault:!0,touchStartForcePreventDefault:!1,touchReleaseOnEdges:!1,uniqueNavElements:!0,resistance:!0,resistanceRatio:.85,watchSlidesProgress:!1,grabCursor:!1,preventClicks:!0,preventClicksPropagation:!0,slideToClickedSlide:!1,preloadImages:!0,updateOnImagesReady:!0,loop:!1,loopAdditionalSlides:0,loopedSlides:null,loopFillGroupWithBlank:!1,loopPreventsSlide:!0,rewind:!1,allowSlidePrev:!0,allowSlideNext:!0,swipeHandler:null,noSwiping:!0,noSwipingClass:"swiper-no-swiping",noSwipingSelector:null,passiveListeners:!0,maxBackfaceHiddenSlides:10,containerModifierClass:"swiper-",slideClass:"swiper-slide",slideBlankClass:"swiper-slide-invisible-blank",slideActiveClass:"swiper-slide-active",slideDuplicateActiveClass:"swiper-slide-duplicate-active",slideVisibleClass:"swiper-slide-visible",slideDuplicateClass:"swiper-slide-duplicate",slideNextClass:"swiper-slide-next",slideDuplicateNextClass:"swiper-slide-duplicate-next",slidePrevClass:"swiper-slide-prev",slideDuplicatePrevClass:"swiper-slide-duplicate-prev",wrapperClass:"swiper-wrapper",runCallbacksOnInit:!0,_emitClasses:!1};function W(e,t){return function(n){void 0===n&&(n={});const s=Object.keys(n)[0],i=n[s];"object"==typeof i&&null!==i?(["navigation","pagination","scrollbar"].indexOf(s)>=0&&!0===e[s]&&(e[s]={auto:!0}),s in e&&"enabled"in i?(!0===e[s]&&(e[s]={enabled:!0}),"object"!=typeof e[s]||"enabled"in e[s]||(e[s].enabled=!0),e[s]||(e[s]={enabled:!1}),o(t,n)):o(t,n)):o(t,n)}}const x={eventsEmitter:$,update:V,translate:oe,transition:{setTransition:function(e,t){const n=this;n.params.cssMode||n.$wrapperEl.transition(e),n.emit("setTransition",e,t)},transitionStart:function(e,t){void 0===e&&(e=!0);const n=this,{params:s}=n;s.cssMode||(s.autoHeight&&n.updateAutoHeight(),A({swiper:n,runCallbacks:e,direction:t,step:"Start"}))},transitionEnd:function(e,t){void 0===e&&(e=!0);const n=this,{params:s}=n;n.animating=!1,s.cssMode||(n.setTransition(0),A({swiper:n,runCallbacks:e,direction:t,step:"End"}))}},slide:S,loop:M,grabCursor:{setGrabCursor:function(e){const t=this;if(t.support.touch||!t.params.simulateTouch||t.params.watchOverflow&&t.isLocked||t.params.cssMode)return;const n="container"===t.params.touchEventsTarget?t.el:t.wrapperEl;n.style.cursor="move",n.style.cursor=e?"grabbing":"grab"},unsetGrabCursor:function(){const e=this;e.support.touch||e.params.watchOverflow&&e.isLocked||e.params.cssMode||(e["container"===e.params.touchEventsTarget?"el":"wrapperEl"].style.cursor="")}},events:P,breakpoints:{setBreakpoint:function(){const e=this,{activeIndex:f,initialized:c,loopedSlides:m=0,params:t,$el:a}=e,s=t.breakpoints;if(!s||s&&0===Object.keys(s).length)return;const i=e.getBreakpoint(s,e.params.breakpointsBase,e.el);if(!i||e.currentBreakpoint===i)return;const n=(i in s?s[i]:void 0)||e.originalParams,r=R(e,t),l=R(e,n),d=t.enabled;r&&!l?(a.removeClass(`${t.containerModifierClass}grid ${t.containerModifierClass}grid-column`),e.emitContainerClasses()):!r&&l&&(a.addClass(`${t.containerModifierClass}grid`),(n.grid.fill&&"column"===n.grid.fill||!n.grid.fill&&"column"===t.grid.fill)&&a.addClass(`${t.containerModifierClass}grid-column`),e.emitContainerClasses());const u=n.direction&&n.direction!==t.direction,p=t.loop&&(n.slidesPerView!==t.slidesPerView||u);u&&c&&e.changeDirection(),o(e.params,n);const h=e.params.enabled;Object.assign(e,{allowTouchMove:e.params.allowTouchMove,allowSlideNext:e.params.allowSlideNext,allowSlidePrev:e.params.allowSlidePrev}),d&&!h?e.disable():!d&&h&&e.enable(),e.currentBreakpoint=i,e.emit("_beforeBreakpoint",n),p&&c&&(e.loopDestroy(),e.loopCreate(),e.updateSlides(),e.slideTo(f-m+e.loopedSlides,0,!1)),e.emit("breakpoint",n)},getBreakpoint:function(e,n,s){if(void 0===n&&(n="window"),!e||"container"===n&&!s)return;let o=!1;const a=t(),r="window"===n?a.innerHeight:s.clientHeight,i=Object.keys(e).map(e=>{if("string"==typeof e&&0===e.indexOf("@")){const t=parseFloat(e.substr(1));return{value:r*t,point:e}}return{value:e,point:e}});i.sort((e,t)=>parseInt(e.value,10)-parseInt(t.value,10));for(let e=0;e<i.length;e+=1){const{point:t,value:r}=i[e];"window"===n?a.matchMedia(`(min-width: ${r}px)`).matches&&(o=t):r<=s.clientWidth&&(o=t)}return o||"max"}},checkOverflow:{checkOverflow:function(){const e=this,{isLocked:t,params:n}=e,{slidesOffsetBefore:s}=n;if(s){const t=e.slides.length-1,n=e.slidesGrid[t]+e.slidesSizesGrid[t]+2*s;e.isLocked=e.size>n}else e.isLocked=1===e.snapGrid.length;!0===n.allowSlideNext&&(e.allowSlideNext=!e.isLocked),!0===n.allowSlidePrev&&(e.allowSlidePrev=!e.isLocked),t&&t!==e.isLocked&&(e.isEnd=!1),t!==e.isLocked&&e.emit(e.isLocked?"lock":"unlock")}},classes:E,images:{loadImage:function(n,s,o,i,a,r){const d=t();let c;function l(){r&&r()}e(n).parent("picture")[0]||n.complete&&a?l():s?(c=new d.Image,c.onload=l,c.onerror=l,i&&(c.sizes=i),o&&(c.srcset=o),s&&(c.src=s)):l()},preloadImages:function(){const e=this;function t(){e!=null&&e&&!e.destroyed&&(void 0!==e.imagesLoaded&&(e.imagesLoaded+=1),e.imagesLoaded===e.imagesToLoad.length&&(e.params.updateOnImagesReady&&e.update(),e.emit("imagesReady")))}e.imagesToLoad=e.$el.find("img");for(let s=0;s<e.imagesToLoad.length;s+=1){const n=e.imagesToLoad[s];e.loadImage(n,n.currentSrc||n.getAttribute("src"),n.srcset||n.getAttribute("srcset"),n.sizes||n.getAttribute("sizes"),!0,t)}}}},g={};class i{constructor(){let r,n;for(var l=arguments.length,a=new Array(l),c=0;c<l;c++)a[c]=arguments[c];if(1===a.length&&a[0].constructor&&"Object"===Object.prototype.toString.call(a[0]).slice(8,-1)?n=a[0]:[r,n]=a,n||(n={}),n=o({},n),r&&!n.el&&(n.el=r),n.el&&e(n.el).length>1){const t=[];return e(n.el).each(e=>{const s=o({},n,{el:e});t.push(new i(s))}),t}const t=this;t.__swiper__=!0,t.support=N(),t.device=X({userAgent:n.userAgent}),t.browser=U(),t.eventsListeners={},t.eventsAnyListeners=[],t.modules=[...t.__modules__],n.modules&&Array.isArray(n.modules)&&t.modules.push(...n.modules);const d={};t.modules.forEach(e=>{e({swiper:t,extendParams:W(n,d),on:t.on.bind(t),once:t.once.bind(t),off:t.off.bind(t),emit:t.emit.bind(t)})});const u=o({},v,d);return t.params=o({},u,g,n),t.originalParams=o({},t.params),t.passedParams=o({},n),t.params&&t.params.on&&Object.keys(t.params.on).forEach(e=>{t.on(e,t.params.on[e])}),t.params&&t.params.onAny&&t.onAny(t.params.onAny),t.$=e,Object.assign(t,{enabled:t.params.enabled,el:r,classNames:[],slides:e(),slidesGrid:[],snapGrid:[],slidesSizesGrid:[],isHorizontal:()=>"horizontal"===t.params.direction,isVertical:()=>"vertical"===t.params.direction,activeIndex:0,realIndex:0,isBeginning:!0,isEnd:!1,translate:0,previousTranslate:0,progress:0,velocity:0,animating:!1,allowSlideNext:t.params.allowSlideNext,allowSlidePrev:t.params.allowSlidePrev,touchEvents:function(){const e=["touchstart","touchmove","touchend","touchcancel"],n=["pointerdown","pointermove","pointerup"];return t.touchEventsTouch={start:e[0],move:e[1],end:e[2],cancel:e[3]},t.touchEventsDesktop={start:n[0],move:n[1],end:n[2]},t.support.touch||!t.params.simulateTouch?t.touchEventsTouch:t.touchEventsDesktop}(),touchEventsData:{isTouched:void 0,isMoved:void 0,allowTouchCallbacks:void 0,touchStartTime:void 0,isScrolling:void 0,currentTranslate:void 0,startTranslate:void 0,allowThresholdMove:void 0,focusableElements:t.params.focusableElements,lastClickTime:s(),clickTimeout:void 0,velocities:[],allowMomentumBounce:void 0,isTouchEvent:void 0,startMoving:void 0},allowClick:!0,allowTouchMove:t.params.allowTouchMove,touches:{startX:0,startY:0,currentX:0,currentY:0,diff:0},imagesToLoad:[],imagesLoaded:0}),t.emit("_swiper"),t.params.init&&t.init(),t}enable(){const e=this;e.enabled||(e.enabled=!0,e.params.grabCursor&&e.setGrabCursor(),e.emit("enable"))}disable(){const e=this;e.enabled&&(e.enabled=!1,e.params.grabCursor&&e.unsetGrabCursor(),e.emit("disable"))}setProgress(e,t){const n=this;e=Math.min(Math.max(e,0),1);const s=n.minTranslate(),o=(n.maxTranslate()-s)*e+s;n.translateTo(o,void 0===t?0:t),n.updateActiveIndex(),n.updateSlidesClasses()}emitContainerClasses(){const e=this;if(!e.params._emitClasses||!e.el)return;const t=e.el.className.split(" ").filter(t=>0===t.indexOf("swiper")||0===t.indexOf(e.params.containerModifierClass));e.emit("_containerClasses",t.join(" "))}getSlideClasses(e){const t=this;return e.className.split(" ").filter(e=>0===e.indexOf("swiper-slide")||0===e.indexOf(t.params.slideClass)).join(" ")}emitSlidesClasses(){const e=this;if(!e.params._emitClasses||!e.el)return;const t=[];e.slides.each(n=>{const s=e.getSlideClasses(n);t.push({slideEl:n,classNames:s}),e.emit("_slideClass",n,s)}),e.emit("_slideClasses",t)}slidesPerViewDynamic(e,t){void 0===e&&(e="current"),void 0===t&&(t=!1);const{params:r,slides:s,slidesGrid:o,slidesSizesGrid:c,size:i,activeIndex:n}=this;let a=1;if(r.centeredSlides){let e,t=s[n].swiperSlideSize;for(let o=n+1;o<s.length;o+=1)s[o]&&!e&&(t+=s[o].swiperSlideSize,a+=1,t>i&&(e=!0));for(let o=n-1;o>=0;o-=1)s[o]&&!e&&(t+=s[o].swiperSlideSize,a+=1,t>i&&(e=!0))}else if("current"===e)for(let e=n+1;e<s.length;e+=1)(t?o[e]+c[e]-o[n]<i:o[e]-o[n]<i)&&(a+=1);else for(let e=n-1;e>=0;e-=1)o[n]-o[e]<i&&(a+=1);return a}update(){const e=this;if(!e||e.destroyed)return;const{snapGrid:o,params:t}=e;function n(){const t=e.rtlTranslate?-1*e.translate:e.translate,n=Math.min(Math.max(t,e.maxTranslate()),e.minTranslate());e.setTranslate(n),e.updateActiveIndex(),e.updateSlidesClasses()}let s;t.breakpoints&&e.setBreakpoint(),e.updateSize(),e.updateSlides(),e.updateProgress(),e.updateSlidesClasses(),e.params.freeMode&&e.params.freeMode.enabled?(n(),e.params.autoHeight&&e.updateAutoHeight()):(s=("auto"===e.params.slidesPerView||e.params.slidesPerView>1)&&e.isEnd&&!e.params.centeredSlides?e.slideTo(e.slides.length-1,0,!1,!0):e.slideTo(e.activeIndex,0,!1,!0),s||n()),t.watchOverflow&&o!==e.snapGrid&&e.checkOverflow(),e.emit("update")}changeDirection(e,t){void 0===t&&(t=!0);const n=this,s=n.params.direction;return e||(e="horizontal"===s?"vertical":"horizontal"),e===s||"horizontal"!==e&&"vertical"!==e||(n.$el.removeClass(`${n.params.containerModifierClass}${s}`).addClass(`${n.params.containerModifierClass}${e}`),n.emitContainerClasses(),n.params.direction=e,n.slides.each(t=>{"vertical"===e?t.style.width="":t.style.height=""}),n.emit("changeDirection"),t&&n.update()),n}mount(t){const s=this;if(s.mounted)return!0;const o=e(t||s.params.el);if(!(t=o[0]))return!1;t.swiper=s;const a=()=>`.${(s.params.wrapperClass||"").trim().split(" ").join(".")}`;let i=(()=>{if(t&&t.shadowRoot&&t.shadowRoot.querySelector){const n=e(t.shadowRoot.querySelector(a()));return n.children=e=>o.children(e),n}return o.children(a())})();if(0===i.length&&s.params.createElements){const t=n().createElement("div");i=e(t),t.className=s.params.wrapperClass,o.append(t),o.children(`.${s.params.slideClass}`).each(e=>{i.append(e)})}return Object.assign(s,{$el:o,el:t,$wrapperEl:i,wrapperEl:i[0],mounted:!0,rtl:"rtl"===t.dir.toLowerCase()||"rtl"===o.css("direction"),rtlTranslate:"horizontal"===s.params.direction&&("rtl"===t.dir.toLowerCase()||"rtl"===o.css("direction")),wrongRTL:"-webkit-box"===i.css("display")}),!0}init(e){const t=this;return t.initialized?t:(!1===t.mount(e)||(t.emit("beforeInit"),t.params.breakpoints&&t.setBreakpoint(),t.addClasses(),t.params.loop&&t.loopCreate(),t.updateSize(),t.updateSlides(),t.params.watchOverflow&&t.checkOverflow(),t.params.grabCursor&&t.enabled&&t.setGrabCursor(),t.params.preloadImages&&t.preloadImages(),t.params.loop?t.slideTo(t.params.initialSlide+t.loopedSlides,0,t.params.runCallbacksOnInit,!1,!0):t.slideTo(t.params.initialSlide,0,t.params.runCallbacksOnInit,!1,!0),t.attachEvents(),t.initialized=!0,t.emit("init"),t.emit("afterInit")),t)}destroy(e,t){void 0===e&&(e=!0),void 0===t&&(t=!0);const n=this,{params:s,$el:i,$wrapperEl:a,slides:o}=n;return void 0===n.params||n.destroyed||(n.emit("beforeDestroy"),n.initialized=!1,n.detachEvents(),s.loop&&n.loopDestroy(),t&&(n.removeClasses(),i.removeAttr("style"),a.removeAttr("style"),o&&o.length&&o.removeClass([s.slideVisibleClass,s.slideActiveClass,s.slideNextClass,s.slidePrevClass].join(" ")).removeAttr("style").removeAttr("data-swiper-slide-index")),n.emit("destroy"),Object.keys(n.eventsListeners).forEach(e=>{n.off(e)}),!1!==e&&(n.$el[0].swiper=null,function(e){const t=e;Object.keys(t).forEach(e=>{try{t[e]=null}catch{}try{delete t[e]}catch{}})}(n)),n.destroyed=!0),null}static extendDefaults(e){o(g,e)}static get extendedDefaults(){return g}static get defaults(){return v}static installModule(e){i.prototype.__modules__||(i.prototype.__modules__=[]);const t=i.prototype.__modules__;"function"==typeof e&&t.indexOf(e)<0&&t.push(e)}static use(e){return Array.isArray(e)?(e.forEach(e=>i.installModule(e)),i):(i.installModule(e),i)}}function w(e,t,s,o){const i=n();return e.params.createElements&&Object.keys(o).forEach(n=>{if(!s[n]&&!0===s.auto){let a=e.$el.children(`.${o[n]}`)[0];a||(a=i.createElement("div"),a.className=o[n],e.$el.append(a)),s[n]=a,t[n]=a}}),s}function a(e){return void 0===e&&(e=""),`.${e.trim().replace(/([.:!/])/g,"\\$1").replace(/ /g,".")}`}function I(e){const t=this,{$wrapperEl:s,params:n}=t;if(n.loop&&t.loopDestroy(),"object"==typeof e&&"length"in e)for(let t=0;t<e.length;t+=1)e[t]&&s.append(e[t]);else s.append(e);n.loop&&t.loopCreate(),n.observer||t.update()}function Q(e){const t=this,{params:n,$wrapperEl:s,activeIndex:o}=t;n.loop&&t.loopDestroy();let i=o+1;if("object"==typeof e&&"length"in e){for(let t=0;t<e.length;t+=1)e[t]&&s.prepend(e[t]);i=o+e.length}else s.prepend(e);n.loop&&t.loopCreate(),n.observer||t.update(),t.slideTo(i,0,!1)}function Z(e,t){const n=this,{$wrapperEl:i,params:o,activeIndex:l}=n;let s=l;o.loop&&(s-=n.loopedSlides,n.loopDestroy(),n.slides=i.children(`.${o.slideClass}`));const c=n.slides.length;if(e<=0)return void n.prependSlide(t);if(e>=c)return void n.appendSlide(t);let a=s>e?s+1:s;const r=[];for(let t=c-1;t>=e;t-=1){const s=n.slides.eq(t);s.remove(),r.unshift(s)}if("object"==typeof t&&"length"in t){for(let e=0;e<t.length;e+=1)t[e]&&i.append(t[e]);a=s>e?s+t.length:s}else i.append(t);for(let e=0;e<r.length;e+=1)i.append(r[e]);o.loop&&n.loopCreate(),o.observer||n.update(),o.loop?n.slideTo(a+n.loopedSlides,0,!1):n.slideTo(a,0,!1)}function J(e){const t=this,{params:o,$wrapperEl:a,activeIndex:r}=t;let i=r;o.loop&&(i-=t.loopedSlides,t.loopDestroy(),t.slides=a.children(`.${o.slideClass}`));let s,n=i;if("object"==typeof e&&"length"in e){for(let o=0;o<e.length;o+=1)s=e[o],t.slides[s]&&t.slides.eq(s).remove(),s<n&&(n-=1);n=Math.max(n,0)}else s=e,t.slides[s]&&t.slides.eq(s).remove(),s<n&&(n-=1),n=Math.max(n,0);o.loop&&t.loopCreate(),o.observer||t.update(),o.loop?t.slideTo(n+t.loopedSlides,0,!1):t.slideTo(n,0,!1)}function ee(){const e=this,t=[];for(let n=0;n<e.slides.length;n+=1)t.push(n);e.removeSlide(t)}function l(e){const{effect:n,swiper:t,on:s,setTranslate:i,setTransition:c,overwriteParams:a,perspective:r}=e;let o;s("beforeInit",()=>{if(t.params.effect!==n)return;t.classNames.push(`${t.params.containerModifierClass}${n}`),r&&r()&&t.classNames.push(`${t.params.containerModifierClass}3d`);const e=a?a():{};Object.assign(t.params,e),Object.assign(t.originalParams,e)}),s("setTranslate",()=>{t.params.effect===n&&i()}),s("setTransition",(e,s)=>{t.params.effect===n&&c(s)}),s("virtualUpdate",()=>{t.slides.length||(o=!0),requestAnimationFrame(()=>{o&&t.slides&&t.slides.length&&(i(),o=!1)})})}function h(e,t){return e.transformEl?t.find(e.transformEl).css({"backface-visibility":"hidden","-webkit-backface-visibility":"hidden"}):t}function p(e){let{swiper:t,duration:i,transformEl:n,allSlides:a}=e;const{slides:s,activeIndex:o,$wrapperEl:r}=t;if(t.params.virtualTranslate&&0!==i){let e,i=!1;e=a?n?s.find(n):s:n?s.eq(o).find(n):s.eq(o),e.transitionEnd(()=>{if(i)return;if(!t||t.destroyed)return;i=!0,t.animating=!1;const e=["webkitTransitionEnd","transitionend"];for(let t=0;t<e.length;t+=1)r.trigger(e[t])})}}function d(t,n,s){const a="swiper-slide-shadow"+(s?`-${s}`:""),i=t.transformEl?n.find(t.transformEl):n;let o=i.children(`.${a}`);return o.length||(o=e(`<div class="swiper-slide-shadow${s?`-${s}`:""}"></div>`),i.append(o)),o}Object.keys(x).forEach(e=>{Object.keys(x[e]).forEach(t=>{i.prototype[t]=x[e][t]})}),i.use([function(e){let{swiper:n,on:c,emit:i}=e;const s=t();let o=null,a=null;const r=()=>{n&&!n.destroyed&&n.initialized&&(i("beforeResize"),i("resize"))},l=()=>{n&&!n.destroyed&&n.initialized&&i("orientationchange")};c("init",()=>{n.params.resizeObserver&&void 0!==s.ResizeObserver?n&&!n.destroyed&&n.initialized&&(o=new ResizeObserver(e=>{a=s.requestAnimationFrame(()=>{const{width:t,height:s}=n;let o=t,i=s;e.forEach(e=>{let{contentBoxSize:t,contentRect:s,target:a}=e;a&&a!==n.el||(o=s?s.width:(t[0]||t).inlineSize,i=s?s.height:(t[0]||t).blockSize)}),o===t&&i===s||r()})}),o.observe(n.el)):(s.addEventListener("resize",r),s.addEventListener("orientationchange",l))}),c("destroy",()=>{a&&s.cancelAnimationFrame(a),o&&o.unobserve&&n.el&&(o.unobserve(n.el),o=null),s.removeEventListener("resize",r),s.removeEventListener("orientationchange",l)})},function(e){let{swiper:n,extendParams:c,on:a,emit:r}=e;const o=[],s=t(),i=function(e,t){void 0===t&&(t={});const n=new(s.MutationObserver||s.WebkitMutationObserver)(e=>{if(1===e.length)return void r("observerUpdate",e[0]);const t=function(){r("observerUpdate",e[0])};s.requestAnimationFrame?s.requestAnimationFrame(t):s.setTimeout(t,0)});n.observe(e,{attributes:void 0===t.attributes||t.attributes,childList:void 0===t.childList||t.childList,characterData:void 0===t.characterData||t.characterData}),o.push(n)};c({observer:!1,observeParents:!1,observeSlideChildren:!1}),a("init",()=>{if(n.params.observer){if(n.params.observeParents){const e=n.$el.parents();for(let t=0;t<e.length;t+=1)i(e[t])}i(n.$el[0],{childList:n.params.observeSlideChildren}),i(n.$wrapperEl[0],{attributes:!1})}}),a("destroy",()=>{o.forEach(e=>{e.disconnect()}),o.splice(0,o.length)})}]);const Y=[function(t){let a,{swiper:n,extendParams:c,on:o,emit:i}=t;function r(t,s){const o=n.params.virtual;if(o.cache&&n.virtual.cache[s])return n.virtual.cache[s];const i=e(o.renderSlide?o.renderSlide.call(n,t,s):`<div class="${n.params.slideClass}" data-swiper-slide-index="${s}">${t}</div>`);return i.attr("data-swiper-slide-index")||i.attr("data-swiper-slide-index",s),o.cache&&(n.virtual.cache[s]=i),i}function s(e){const{slidesPerView:f,slidesPerGroup:l,centeredSlides:w}=n.params,{addSlidesBefore:b,addSlidesAfter:v}=n.params.virtual,{from:d,to:c,slides:a,slidesGrid:O,offset:_}=n.virtual;n.params.cssMode||n.updateActiveIndex();const g=n.activeIndex||0;let p,u,m;p=n.rtlTranslate?"right":n.isHorizontal()?"left":"top",w?(u=Math.floor(f/2)+l+v,m=Math.floor(f/2)+l+b):(u=f+(l-1)+v,m=l+b);const t=Math.max((g||0)-m,0),s=Math.min((g||0)+u,a.length-1),o=(n.slidesGrid[t]||0)-(n.slidesGrid[0]||0);function j(){n.updateSlides(),n.updateProgress(),n.updateSlidesClasses(),n.lazy&&n.params.lazy.enabled&&n.lazy.load(),i("virtualUpdate")}if(Object.assign(n.virtual,{from:t,to:s,offset:o,slidesGrid:n.slidesGrid}),d===t&&c===s&&!e)return n.slidesGrid!==O&&o!==_&&n.slides.css(p,`${o}px`),n.updateProgress(),void i("virtualUpdate");if(n.params.virtual.renderExternal)return n.params.virtual.renderExternal.call(n,{offset:o,from:t,to:s,slides:function(){const e=[];for(let n=t;n<=s;n+=1)e.push(a[n]);return e}()}),void(n.params.virtual.renderExternalUpdate?j():i("virtualUpdate"));const y=[],h=[];if(e)n.$wrapperEl.find(`.${n.params.slideClass}`).remove();else for(let e=d;e<=c;e+=1)(e<t||e>s)&&n.$wrapperEl.find(`.${n.params.slideClass}[data-swiper-slide-index="${e}"]`).remove();for(let n=0;n<a.length;n+=1)n>=t&&n<=s&&(void 0===c||e?h.push(n):(n>c&&h.push(n),n<d&&y.push(n)));h.forEach(e=>{n.$wrapperEl.append(r(a[e],e))}),y.sort((e,t)=>t-e).forEach(e=>{n.$wrapperEl.prepend(r(a[e],e))}),n.$wrapperEl.children(".swiper-slide").css(p,`${o}px`),j()}c({virtual:{enabled:!1,slides:[],cache:!0,renderSlide:null,renderExternal:null,renderExternalUpdate:!0,addSlidesBefore:0,addSlidesAfter:0}}),n.virtual={cache:{},from:void 0,to:void 0,slides:[],offset:0,slidesGrid:[]},o("beforeInit",()=>{n.params.virtual.enabled&&(n.virtual.slides=n.params.virtual.slides,n.classNames.push(`${n.params.containerModifierClass}virtual`),n.params.watchSlidesProgress=!0,n.originalParams.watchSlidesProgress=!0,n.params.initialSlide||s())}),o("setTranslate",()=>{n.params.virtual.enabled&&(n.params.cssMode&&!n._immediateVirtual?(clearTimeout(a),a=setTimeout(()=>{s()},100)):s())}),o("init update resize",()=>{n.params.virtual.enabled&&n.params.cssMode&&f(n.wrapperEl,"--swiper-virtual-size",`${n.virtualSize}px`)}),Object.assign(n.virtual,{appendSlide:function(e){if("object"==typeof e&&"length"in e)for(let t=0;t<e.length;t+=1)e[t]&&n.virtual.slides.push(e[t]);else n.virtual.slides.push(e);s(!0)},prependSlide:function(e){const o=n.activeIndex;let i=o+1,t=1;if(Array.isArray(e)){for(let t=0;t<e.length;t+=1)e[t]&&n.virtual.slides.unshift(e[t]);i=o+e.length,t=e.length}else n.virtual.slides.unshift(e);if(n.params.virtual.cache){const e=n.virtual.cache,s={};Object.keys(e).forEach(n=>{const o=e[n],i=o.attr("data-swiper-slide-index");i&&o.attr("data-swiper-slide-index",parseInt(i,10)+t),s[parseInt(n,10)+t]=o}),n.virtual.cache=s}s(!0),n.slideTo(i,0)},removeSlide:function(e){if(e==null)return;let t=n.activeIndex;if(Array.isArray(e))for(let s=e.length-1;s>=0;s-=1)n.virtual.slides.splice(e[s],1),n.params.virtual.cache&&delete n.virtual.cache[e[s]],e[s]<t&&(t-=1),t=Math.max(t,0);else n.virtual.slides.splice(e,1),n.params.virtual.cache&&delete n.virtual.cache[e],e<t&&(t-=1),t=Math.max(t,0);s(!0),n.slideTo(t,0)},removeAllSlides:function(){n.virtual.slides=[],n.params.virtual.cache&&(n.virtual.cache={}),s(!0),n.slideTo(0,0)},update:s})},function(s){let{swiper:o,extendParams:u,on:a,emit:h}=s;const i=n(),r=t();function c(e){if(!o.enabled)return;const{rtlTranslate:c}=o;let t=e;t.originalEvent&&(t=t.originalEvent);const n=t.keyCode||t.charCode,f=o.params.keyboard.pageUpDown,s=f&&33===n,a=f&&34===n,l=37===n,d=39===n,u=38===n,m=40===n;if(!o.allowSlideNext&&(o.isHorizontal()&&d||o.isVertical()&&m||a))return!1;if(!o.allowSlidePrev&&(o.isHorizontal()&&l||o.isVertical()&&u||s))return!1;if(!(t.shiftKey||t.altKey||t.ctrlKey||t.metaKey||i.activeElement&&i.activeElement.nodeName&&("input"===i.activeElement.nodeName.toLowerCase()||"textarea"===i.activeElement.nodeName.toLowerCase()))){if(o.params.keyboard.onlyInViewport&&(s||a||l||d||u||m)){let t=!1;if(o.$el.parents(`.${o.params.slideClass}`).length>0&&0===o.$el.parents(`.${o.params.slideActiveClass}`).length)return;const n=o.$el,s=n[0].clientWidth,i=n[0].clientHeight,l=r.innerWidth,d=r.innerHeight,e=o.$el.offset();c&&(e.left-=o.$el[0].scrollLeft);const a=[[e.left,e.top],[e.left+s,e.top],[e.left,e.top+i],[e.left+s,e.top+i]];for(let n=0;n<a.length;n+=1){const e=a[n];if(e[0]>=0&&e[0]<=l&&e[1]>=0&&e[1]<=d){if(0===e[0]&&0===e[1])continue;t=!0}}if(!t)return}o.isHorizontal()?((s||a||l||d)&&(t.preventDefault?t.preventDefault():t.returnValue=!1),((a||d)&&!c||(s||l)&&c)&&o.slideNext(),((s||l)&&!c||(a||d)&&c)&&o.slidePrev()):((s||a||u||m)&&(t.preventDefault?t.preventDefault():t.returnValue=!1),(a||m)&&o.slideNext(),(s||u)&&o.slidePrev()),h("keyPress",n)}}function l(){o.keyboard.enabled||(e(i).on("keydown",c),o.keyboard.enabled=!0)}function d(){o.keyboard.enabled&&(e(i).off("keydown",c),o.keyboard.enabled=!1)}o.keyboard={enabled:!1},u({keyboard:{enabled:!1,onlyInViewport:!0,pageUpDown:!0}}),a("init",()=>{o.params.keyboard.enabled&&l()}),a("destroy",()=>{o.keyboard.enabled&&d()}),Object.assign(o.keyboard,{enable:l,disable:d})},function(n){let{swiper:o,extendParams:y,on:f,emit:d}=n;const v=t();let c;y({mousewheel:{enabled:!1,releaseOnEdges:!1,invert:!1,forceToAxis:!1,sensitivity:1,eventsTarget:"container",thresholdDelta:null,thresholdTime:null}}),o.mousewheel={enabled:!1};let a,u=s();const i=[];function b(){o.enabled&&(o.mouseEntered=!0)}function j(){o.enabled&&(o.mouseEntered=!1)}function p(e){return!(o.params.mousewheel.thresholdDelta&&e.delta<o.params.mousewheel.thresholdDelta)&&!(o.params.mousewheel.thresholdTime&&s()-u<o.params.mousewheel.thresholdTime)&&(e.delta>=6&&s()-u<60||(e.direction<0?o.isEnd&&!o.params.loop||o.animating||(o.slideNext(),d("scroll",e.raw)):o.isBeginning&&!o.params.loop||o.animating||(o.slidePrev(),d("scroll",e.raw)),u=(new v.Date).getTime(),!1))}function l(t){let l=t,f=!0;if(!o.enabled)return;const m=o.params.mousewheel;o.params.cssMode&&l.preventDefault();let g=o.$el;if("container"!==o.params.mousewheel.eventsTarget&&(g=e(o.params.mousewheel.eventsTarget)),!o.mouseEntered&&!g[0].contains(l.target)&&!m.releaseOnEdges)return!0;l.originalEvent&&(l=l.originalEvent);let n=0;const v=o.rtlTranslate?-1:1,u=function(e){let o=0,s=0,t=0,n=0;return"detail"in e&&(s=e.detail),"wheelDelta"in e&&(s=-e.wheelDelta/120),"wheelDeltaY"in e&&(s=-e.wheelDeltaY/120),"wheelDeltaX"in e&&(o=-e.wheelDeltaX/120),"axis"in e&&e.axis===e.HORIZONTAL_AXIS&&(o=s,s=0),t=10*o,n=10*s,"deltaY"in e&&(n=e.deltaY),"deltaX"in e&&(t=e.deltaX),e.shiftKey&&!t&&(t=n,n=0),(t||n)&&e.deltaMode&&(1===e.deltaMode?(t*=40,n*=40):(t*=800,n*=800)),t&&!o&&(o=t<1?-1:1),n&&!s&&(s=n<1?-1:1),{spinX:o,spinY:s,pixelX:t,pixelY:n}}(l);if(m.forceToAxis)if(o.isHorizontal()){if(!(Math.abs(u.pixelX)>Math.abs(u.pixelY)))return!0;n=-u.pixelX*v}else{if(!(Math.abs(u.pixelY)>Math.abs(u.pixelX)))return!0;n=-u.pixelY}else n=Math.abs(u.pixelX)>Math.abs(u.pixelY)?-u.pixelX*v:-u.pixelY;if(0===n)return!0;m.invert&&(n=-n);let h=o.getTranslate()+n*m.sensitivity;if(h>=o.minTranslate()&&(h=o.minTranslate()),h<=o.maxTranslate()&&(h=o.maxTranslate()),f=!!o.params.loop||h!==o.minTranslate()&&h!==o.maxTranslate(),f&&o.params.nested&&l.stopPropagation(),o.params.freeMode&&o.params.freeMode.enabled){{const e={time:s(),delta:Math.abs(n),direction:Math.sign(n)},t=a&&e.time<a.time+500&&e.delta<=a.delta&&e.direction===a.direction;if(!t){a=void 0,o.params.loop&&o.loopFix();let s=o.getTranslate()+n*m.sensitivity;const u=o.isBeginning,h=o.isEnd;if(s>=o.minTranslate()&&(s=o.minTranslate()),s<=o.maxTranslate()&&(s=o.maxTranslate()),o.setTransition(0),o.setTranslate(s),o.updateProgress(),o.updateActiveIndex(),o.updateSlidesClasses(),(!u&&o.isBeginning||!h&&o.isEnd)&&o.updateSlidesClasses(),o.params.freeMode.sticky){clearTimeout(c),c=void 0,i.length>=15&&i.shift();const t=i.length?i[i.length-1]:void 0,s=i[0];if(i.push(e),t&&(e.delta>t.delta||e.direction!==t.direction))i.splice(0);else if(i.length>=15&&e.time-s.time<500&&s.delta-e.delta>=1&&e.delta<=6){const t=n>0?.8:.2;a=e,i.splice(0),c=r(()=>{o.slideToClosest(o.params.speed,!0,void 0,t)},0)}c||(c=r(()=>{a=e,i.splice(0),o.slideToClosest(o.params.speed,!0,void 0,.5)},500))}if(t||d("scroll",l),o.params.autoplay&&o.params.autoplayDisableOnInteraction&&o.autoplay.stop(),s===o.minTranslate()||s===o.maxTranslate())return!0}}}else{const e={time:s(),delta:Math.abs(n),direction:Math.sign(n),raw:t};i.length>=2&&i.shift();const a=i.length?i[i.length-1]:void 0;if(i.push(e),a?(e.direction!==a.direction||e.delta>a.delta||e.time>a.time+150)&&p(e):p(e),function(e){const t=o.params.mousewheel;if(e.direction<0){if(o.isEnd&&!o.params.loop&&t.releaseOnEdges)return!0}else if(o.isBeginning&&!o.params.loop&&t.releaseOnEdges)return!0;return!1}(e))return!0}return l.preventDefault?l.preventDefault():l.returnValue=!1,!1}function g(t){let n=o.$el;"container"!==o.params.mousewheel.eventsTarget&&(n=e(o.params.mousewheel.eventsTarget)),n[t]("mouseenter",b),n[t]("mouseleave",j),n[t]("wheel",l)}function h(){return o.params.cssMode?(o.wrapperEl.removeEventListener("wheel",l),!0):!o.mousewheel.enabled&&(g("on"),o.mousewheel.enabled=!0,!0)}function m(){return o.params.cssMode?(o.wrapperEl.addEventListener(event,l),!0):!!o.mousewheel.enabled&&(g("off"),o.mousewheel.enabled=!1,!0)}f("init",()=>{!o.params.mousewheel.enabled&&o.params.cssMode&&m(),o.params.mousewheel.enabled&&h()}),f("destroy",()=>{o.params.cssMode&&h(),o.mousewheel.enabled&&m()}),Object.assign(o.mousewheel,{enable:h,disable:m})},function(t){let{swiper:n,extendParams:u,on:s,emit:h}=t;function i(t){let s;return t&&(s=e(t),n.params.uniqueNavElements&&"string"==typeof t&&s.length>1&&1===n.$el.find(t).length&&(s=n.$el.find(t))),s}function a(e,t){const s=n.params.navigation;e&&e.length>0&&(e[t?"addClass":"removeClass"](s.disabledClass),e[0]&&"BUTTON"===e[0].tagName&&(e[0].disabled=t),n.params.watchOverflow&&n.enabled&&e[n.isLocked?"addClass":"removeClass"](s.lockClass))}function o(){if(n.params.loop)return;const{$nextEl:e,$prevEl:t}=n.navigation;a(t,n.isBeginning&&!n.params.rewind),a(e,n.isEnd&&!n.params.rewind)}function r(e){e.preventDefault(),(!n.isBeginning||n.params.loop||n.params.rewind)&&n.slidePrev()}function c(e){e.preventDefault(),(!n.isEnd||n.params.loop||n.params.rewind)&&n.slideNext()}function l(){const s=n.params.navigation;if(n.params.navigation=w(n,n.originalParams.navigation,n.params.navigation,{nextEl:"swiper-button-next",prevEl:"swiper-button-prev"}),!s.nextEl&&!s.prevEl)return;const e=i(s.nextEl),t=i(s.prevEl);e&&e.length>0&&e.on("click",c),t&&t.length>0&&t.on("click",r),Object.assign(n.navigation,{$nextEl:e,nextEl:e&&e[0],$prevEl:t,prevEl:t&&t[0]}),n.enabled||(e&&e.addClass(s.lockClass),t&&t.addClass(s.lockClass))}function d(){const{$nextEl:e,$prevEl:t}=n.navigation;e&&e.length&&(e.off("click",c),e.removeClass(n.params.navigation.disabledClass)),t&&t.length&&(t.off("click",r),t.removeClass(n.params.navigation.disabledClass))}u({navigation:{nextEl:null,prevEl:null,hideOnClick:!1,disabledClass:"swiper-button-disabled",hiddenClass:"swiper-button-hidden",lockClass:"swiper-button-lock"}}),n.navigation={nextEl:null,$nextEl:null,prevEl:null,$prevEl:null},s("init",()=>{l(),o()}),s("toEdge fromEdge lock unlock",()=>{o()}),s("destroy",()=>{d()}),s("enable disable",()=>{const{$nextEl:e,$prevEl:t}=n.navigation;e&&e[n.enabled?"removeClass":"addClass"](n.params.navigation.lockClass),t&&t[n.enabled?"removeClass":"addClass"](n.params.navigation.lockClass)}),s("click",(t,s)=>{const{$nextEl:o,$prevEl:i}=n.navigation,a=s.target;if(n.params.navigation.hideOnClick&&!e(a).is(i)&&!e(a).is(o)){if(n.pagination&&n.params.pagination&&n.params.pagination.clickable&&(n.pagination.el===a||n.pagination.el.contains(a)))return;let e;o?e=o.hasClass(n.params.navigation.hiddenClass):i&&(e=i.hasClass(n.params.navigation.hiddenClass)),h(!0===e?"navigationShow":"navigationHide"),o&&o.toggleClass(n.params.navigation.hiddenClass),i&&i.toggleClass(n.params.navigation.hiddenClass)}}),Object.assign(n.navigation,{update:o,init:l,destroy:d})},function(t){let{swiper:n,extendParams:p,on:o,emit:d}=t;const s="swiper-pagination";let l;p({pagination:{el:null,bulletElement:"span",clickable:!1,hideOnClick:!1,renderBullet:null,renderProgressbar:null,renderFraction:null,renderCustom:null,progressbarOpposite:!1,type:"bullets",dynamicBullets:!1,dynamicMainBullets:1,formatFractionCurrent:e=>e,formatFractionTotal:e=>e,bulletClass:`${s}-bullet`,bulletActiveClass:`${s}-bullet-active`,modifierClass:`${s}-`,currentClass:`${s}-current`,totalClass:`${s}-total`,hiddenClass:`${s}-hidden`,progressbarFillClass:`${s}-progressbar-fill`,progressbarOppositeClass:`${s}-progressbar-opposite`,clickableClass:`${s}-clickable`,lockClass:`${s}-lock`,horizontalClass:`${s}-horizontal`,verticalClass:`${s}-vertical`}}),n.pagination={el:null,$el:null,bullets:[]};let r=0;function h(){return!n.params.pagination.el||!n.pagination.el||!n.pagination.$el||0===n.pagination.$el.length}function c(e,t){const{bulletActiveClass:s}=n.params.pagination;e[t]().addClass(`${s}-${t}`)[t]().addClass(`${s}-${t}-${t}`)}function i(){const m=n.rtl,t=n.params.pagination;if(h())return;const u=n.virtual&&n.params.virtual.enabled?n.virtual.slides.length:n.slides.length,o=n.pagination.$el;let s;const i=n.params.loop?Math.ceil((u-2*n.loopedSlides)/n.params.slidesPerGroup):n.snapGrid.length;if(n.params.loop?(s=Math.ceil((n.activeIndex-n.loopedSlides)/n.params.slidesPerGroup),s>u-1-2*n.loopedSlides&&(s-=u-2*n.loopedSlides),s>i-1&&(s-=i),s<0&&"bullets"!==n.params.paginationType&&(s=i+s)):s=void 0!==n.snapIndex?n.snapIndex:n.activeIndex||0,"bullets"===t.type&&n.pagination.bullets&&n.pagination.bullets.length>0){const i=n.pagination.bullets;let a,d,u;if(t.dynamicBullets&&(l=i.eq(0)[n.isHorizontal()?"outerWidth":"outerHeight"](!0),o.css(n.isHorizontal()?"width":"height",l*(t.dynamicMainBullets+4)+"px"),t.dynamicMainBullets>1&&void 0!==n.previousIndex&&(r+=s-(n.previousIndex-n.loopedSlides||0),r>t.dynamicMainBullets-1?r=t.dynamicMainBullets-1:r<0&&(r=0)),a=Math.max(s-r,0),d=a+(Math.min(i.length,t.dynamicMainBullets)-1),u=(d+a)/2),i.removeClass(["","-next","-next-next","-prev","-prev-prev","-main"].map(e=>`${t.bulletActiveClass}${e}`).join(" ")),o.length>1)i.each(n=>{const o=e(n),i=o.index();i===s&&o.addClass(t.bulletActiveClass),t.dynamicBullets&&(i>=a&&i<=d&&o.addClass(`${t.bulletActiveClass}-main`),i===a&&c(o,"prev"),i===d&&c(o,"next"))});else{const e=i.eq(s),o=e.index();if(e.addClass(t.bulletActiveClass),t.dynamicBullets){const e=i.eq(a),s=i.eq(d);for(let e=a;e<=d;e+=1)i.eq(e).addClass(`${t.bulletActiveClass}-main`);if(n.params.loop)if(o>=i.length){for(let e=t.dynamicMainBullets;e>=0;e-=1)i.eq(i.length-e).addClass(`${t.bulletActiveClass}-main`);i.eq(i.length-t.dynamicMainBullets-1).addClass(`${t.bulletActiveClass}-prev`)}else c(e,"prev"),c(s,"next");else c(e,"prev"),c(s,"next")}}if(t.dynamicBullets){const e=Math.min(i.length,t.dynamicMainBullets+4),s=(l*e-l)/2-u*l,o=m?"right":"left";i.css(n.isHorizontal()?o:"top",`${s}px`)}}if("fraction"===t.type&&(o.find(a(t.currentClass)).text(t.formatFractionCurrent(s+1)),o.find(a(t.totalClass)).text(t.formatFractionTotal(i))),"progressbar"===t.type){let e;e=t.progressbarOpposite?n.isHorizontal()?"vertical":"horizontal":n.isHorizontal()?"horizontal":"vertical";const r=(s+1)/i;let c=1,l=1;"horizontal"===e?c=r:l=r,o.find(a(t.progressbarFillClass)).transform(`translate3d(0,0,0) scaleX(${c}) scaleY(${l})`).transition(n.params.speed)}"custom"===t.type&&t.renderCustom?(o.html(t.renderCustom(n,s+1,i)),d("paginationRender",o[0])):d("paginationUpdate",o[0]),n.params.watchOverflow&&n.enabled&&o[n.isLocked?"addClass":"removeClass"](t.lockClass)}function u(){const e=n.params.pagination;if(h())return;const o=n.virtual&&n.params.virtual.enabled?n.virtual.slides.length:n.slides.length,s=n.pagination.$el;let t="";if("bullets"===e.type){let i=n.params.loop?Math.ceil((o-2*n.loopedSlides)/n.params.slidesPerGroup):n.snapGrid.length;n.params.freeMode&&n.params.freeMode.enabled&&!n.params.loop&&i>o&&(i=o);for(let s=0;s<i;s+=1)e.renderBullet?t+=e.renderBullet.call(n,s,e.bulletClass):t+=`<${e.bulletElement} class="${e.bulletClass}"></${e.bulletElement}>`;s.html(t),n.pagination.bullets=s.find(a(e.bulletClass))}"fraction"===e.type&&(t=e.renderFraction?e.renderFraction.call(n,e.currentClass,e.totalClass):`<span class="${e.currentClass}"></span> / <span class="${e.totalClass}"></span>`,s.html(t)),"progressbar"===e.type&&(t=e.renderProgressbar?e.renderProgressbar.call(n,e.progressbarFillClass):`<span class="${e.progressbarFillClass}"></span>`,s.html(t)),"custom"!==e.type&&d("paginationRender",n.pagination.$el[0])}function m(){n.params.pagination=w(n,n.originalParams.pagination,n.params.pagination,{el:"swiper-pagination"});const t=n.params.pagination;if(!t.el)return;let s=e(t.el);0!==s.length&&(n.params.uniqueNavElements&&"string"==typeof t.el&&s.length>1&&(s=n.$el.find(t.el),s.length>1&&(s=s.filter(t=>e(t).parents(".swiper")[0]===n.el))),"bullets"===t.type&&t.clickable&&s.addClass(t.clickableClass),s.addClass(t.modifierClass+t.type),s.addClass(n.isHorizontal()?t.horizontalClass:t.verticalClass),"bullets"===t.type&&t.dynamicBullets&&(s.addClass(`${t.modifierClass}${t.type}-dynamic`),r=0,t.dynamicMainBullets<1&&(t.dynamicMainBullets=1)),"progressbar"===t.type&&t.progressbarOpposite&&s.addClass(t.progressbarOppositeClass),t.clickable&&s.on("click",a(t.bulletClass),function(t){t.preventDefault();let s=e(this).index()*n.params.slidesPerGroup;n.params.loop&&(s+=n.loopedSlides),n.slideTo(s)}),Object.assign(n.pagination,{$el:s,el:s[0]}),n.enabled||s.addClass(t.lockClass))}function f(){const e=n.params.pagination;if(h())return;const t=n.pagination.$el;t.removeClass(e.hiddenClass),t.removeClass(e.modifierClass+e.type),t.removeClass(n.isHorizontal()?e.horizontalClass:e.verticalClass),n.pagination.bullets&&n.pagination.bullets.removeClass&&n.pagination.bullets.removeClass(e.bulletActiveClass),e.clickable&&t.off("click",a(e.bulletClass))}o("init",()=>{m(),u(),i()}),o("activeIndexChange",()=>{(n.params.loop||void 0===n.snapIndex)&&i()}),o("snapIndexChange",()=>{n.params.loop||i()}),o("slidesLengthChange",()=>{n.params.loop&&(u(),i())}),o("snapGridLengthChange",()=>{n.params.loop||(u(),i())}),o("destroy",()=>{f()}),o("enable disable",()=>{const{$el:e}=n.pagination;e&&e[n.enabled?"removeClass":"addClass"](n.params.pagination.lockClass)}),o("lock unlock",()=>{i()}),o("click",(t,s)=>{const o=s.target,{$el:i}=n.pagination;if(n.params.pagination.el&&n.params.pagination.hideOnClick&&i.length>0&&!e(o).hasClass(n.params.pagination.bulletClass)){if(n.navigation&&(n.navigation.nextEl&&o===n.navigation.nextEl||n.navigation.prevEl&&o===n.navigation.prevEl))return;const e=i.hasClass(n.params.pagination.hiddenClass);d(!0===e?"paginationShow":"paginationHide"),i.toggleClass(n.params.pagination.hiddenClass)}}),Object.assign(n.pagination,{render:u,update:i,init:m,destroy:f})},function(t){let{swiper:s,extendParams:E,on:a,emit:u}=t;const g=n();let m,o,i,f,c=!1,p=null,l=null;function h(){if(!s.params.scrollbar.el||!s.scrollbar.el)return;const{scrollbar:r,rtlTranslate:c,progress:l}=s,{$dragEl:n,$el:a}=r,d=s.params.scrollbar;let t=o,e=(i-o)*l;c?(e=-e,e>0?(t=o-e,e=0):-e+o>i&&(t=i+e)):e<0?(t=o+e,e=0):e+o>i&&(t=i-e),s.isHorizontal()?(n.transform(`translate3d(${e}px, 0, 0)`),n[0].style.width=`${t}px`):(n.transform(`translate3d(0px, ${e}px, 0)`),n[0].style.height=`${t}px`),d.hide&&(clearTimeout(p),a[0].style.opacity=1,p=setTimeout(()=>{a[0].style.opacity=0,a.transition(400)},1e3))}function d(){if(!s.params.scrollbar.el||!s.scrollbar.el)return;const{scrollbar:n}=s,{$dragEl:e,$el:t}=n;e[0].style.width="",e[0].style.height="",i=s.isHorizontal()?t[0].offsetWidth:t[0].offsetHeight,f=s.size/(s.virtualSize+s.params.slidesOffsetBefore-(s.params.centeredSlides?s.snapGrid[0]:0)),o="auto"===s.params.scrollbar.dragSize?i*f:parseInt(s.params.scrollbar.dragSize,10),s.isHorizontal()?e[0].style.width=`${o}px`:e[0].style.height=`${o}px`,t[0].style.display=f>=1?"none":"",s.params.scrollbar.hide&&(t[0].style.opacity=0),s.params.watchOverflow&&s.enabled&&n.$el[s.isLocked?"addClass":"removeClass"](s.params.scrollbar.lockClass)}function v(e){return s.isHorizontal()?"touchstart"===e.type||"touchmove"===e.type?e.targetTouches[0].clientX:e.clientX:"touchstart"===e.type||"touchmove"===e.type?e.targetTouches[0].clientY:e.clientY}function b(e){const{scrollbar:a,rtlTranslate:r}=s,{$el:c}=a;let t;t=(v(e)-c.offset()[s.isHorizontal()?"left":"top"]-(null!==m?m:o/2))/(i-o),t=Math.max(Math.min(t,1),0),r&&(t=1-t);const n=s.minTranslate()+(s.maxTranslate()-s.minTranslate())*t;s.updateProgress(n),s.setTranslate(n),s.updateActiveIndex(),s.updateSlidesClasses()}function j(e){const o=s.params.scrollbar,{scrollbar:i,$wrapperEl:a}=s,{$el:n,$dragEl:t}=i;c=!0,m=e.target===t[0]||e.target===t?v(e)-e.target.getBoundingClientRect()[s.isHorizontal()?"left":"top"]:null,e.preventDefault(),e.stopPropagation(),a.transition(100),t.transition(100),b(e),clearTimeout(l),n.transition(0),o.hide&&n.css("opacity",1),s.params.cssMode&&s.$wrapperEl.css("scroll-snap-type","none"),u("scrollbarDragStart",e)}function y(e){const{scrollbar:t,$wrapperEl:n}=s,{$el:o,$dragEl:i}=t;c&&(e.preventDefault?e.preventDefault():e.returnValue=!1,b(e),n.transition(0),o.transition(0),i.transition(0),u("scrollbarDragMove",e))}function _(e){const t=s.params.scrollbar,{scrollbar:o,$wrapperEl:i}=s,{$el:n}=o;c&&(c=!1,s.params.cssMode&&(s.$wrapperEl.css("scroll-snap-type",""),i.transition("")),t.hide&&(clearTimeout(l),l=r(()=>{n.css("opacity",0),n.transition(400)},1e3)),u("scrollbarDragEnd",e),t.snapOnRelease&&s.slideToClosest())}function O(e){const{scrollbar:d,touchEventsTouch:i,touchEventsDesktop:a,params:c,support:r}=s,n=d.$el[0],o=!!r.passiveListener&&!!c.passiveListeners&&{passive:!1,capture:!1},l=!!r.passiveListener&&!!c.passiveListeners&&{passive:!0,capture:!1};if(!n)return;const t="on"===e?"addEventListener":"removeEventListener";r.touch?(n[t](i.start,j,o),n[t](i.move,y,o),n[t](i.end,_,l)):(n[t](a.start,j,o),g[t](a.move,y,o),g[t](a.end,_,l))}function x(){const{scrollbar:a,$el:i}=s;s.params.scrollbar=w(s,s.originalParams.scrollbar,s.params.scrollbar,{el:"swiper-scrollbar"});const n=s.params.scrollbar;if(!n.el)return;let t=e(n.el);s.params.uniqueNavElements&&"string"==typeof n.el&&t.length>1&&1===i.find(n.el).length&&(t=i.find(n.el));let o=t.find(`.${s.params.scrollbar.dragClass}`);0===o.length&&(o=e(`<div class="${s.params.scrollbar.dragClass}"></div>`),t.append(o)),Object.assign(a,{$el:t,el:t[0],$dragEl:o,dragEl:o[0]}),n.draggable&&s.params.scrollbar.el&&O("on"),t&&t[s.enabled?"removeClass":"addClass"](s.params.scrollbar.lockClass)}function C(){s.params.scrollbar.el&&O("off")}E({scrollbar:{el:null,dragSize:"auto",hide:!1,draggable:!1,snapOnRelease:!0,lockClass:"swiper-scrollbar-lock",dragClass:"swiper-scrollbar-drag"}}),s.scrollbar={el:null,dragEl:null,$el:null,$dragEl:null},a("init",()=>{x(),d(),h()}),a("update resize observerUpdate lock unlock",()=>{d()}),a("setTranslate",()=>{h()}),a("setTransition",(e,t)=>{!function(e){s.params.scrollbar.el&&s.scrollbar.el&&s.scrollbar.$dragEl.transition(e)}(t)}),a("enable disable",()=>{const{$el:e}=s.scrollbar;e&&e[s.enabled?"removeClass":"addClass"](s.params.scrollbar.lockClass)}),a("destroy",()=>{C()}),Object.assign(s.scrollbar,{updateSize:d,setTranslate:h,init:x,destroy:C})},function(t){let{swiper:n,extendParams:a,on:s}=t;a({parallax:{enabled:!1}});const o=(t,s)=>{const{rtl:u}=n,a=e(t),l=u?-1:1,d=a.attr("data-swiper-parallax")||"0";let o=a.attr("data-swiper-parallax-x"),i=a.attr("data-swiper-parallax-y");const r=a.attr("data-swiper-parallax-scale"),c=a.attr("data-swiper-parallax-opacity");if(o||i?(o=o||"0",i=i||"0"):n.isHorizontal()?(o=d,i="0"):(i=d,o="0"),o=o.indexOf("%")>=0?parseInt(o,10)*s*l+"%":o*s*l+"px",i=i.indexOf("%")>=0?parseInt(i,10)*s+"%":i*s+"px",c!=null){const e=c-(c-1)*(1-Math.abs(s));a[0].style.opacity=e}if(r==null)a.transform(`translate3d(${o}, ${i}, 0px)`);else{const e=r-(r-1)*(1-Math.abs(s));a.transform(`translate3d(${o}, ${i}, 0px) scale(${e})`)}},i=()=>{const{$el:s,slides:i,progress:t,snapGrid:a}=n;s.children("[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]").each(e=>{o(e,t)}),i.each((s,i)=>{let r=s.progress;n.params.slidesPerGroup>1&&"auto"!==n.params.slidesPerView&&(r+=Math.ceil(i/2)-t*(a.length-1)),r=Math.min(Math.max(r,-1),1),e(s).find("[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]").each(e=>{o(e,r)})})};s("beforeInit",()=>{n.params.parallax.enabled&&(n.params.watchSlidesProgress=!0,n.originalParams.watchSlidesProgress=!0)}),s("init",()=>{n.params.parallax.enabled&&i()}),s("setTranslate",()=>{n.params.parallax.enabled&&i()}),s("setTransition",(t,s)=>{n.params.parallax.enabled&&function(t){void 0===t&&(t=n.params.speed);const{$el:s}=n;s.find("[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]").each(n=>{const s=e(n);let o=parseInt(s.attr("data-swiper-parallax-duration"),10)||t;0===t&&(o=0),s.transition(o)})}(s)})},function(n){let{swiper:o,extendParams:T,on:r,emit:z}=n;const M=t();T({zoom:{enabled:!1,maxRatio:3,minRatio:1,toggle:!0,containerClass:"swiper-zoom-container",zoomedSlideClass:"swiper-slide-zoomed"}}),o.zoom={enabled:!1};let h,d,u,c=1,p=!1;const i={$slideEl:void 0,slideWidth:void 0,slideHeight:void 0,$imageEl:void 0,$imageWrapEl:void 0,maxRatio:3},s={isTouched:void 0,isMoved:void 0,currentX:void 0,currentY:void 0,minX:void 0,minY:void 0,maxX:void 0,maxY:void 0,width:void 0,height:void 0,startX:void 0,startY:void 0,touchesStart:{},touchesCurrent:{}},a={x:void 0,y:void 0,prevPositionX:void 0,prevPositionY:void 0,prevTime:void 0};let v=1;function j(e){if(e.targetTouches.length<2)return 1;const t=e.targetTouches[0].pageX,n=e.targetTouches[0].pageY,s=e.targetTouches[1].pageX,o=e.targetTouches[1].pageY;return Math.sqrt((s-t)**2+(o-n)**2)}function m(t){const s=o.support,n=o.params.zoom;if(d=!1,u=!1,!s.gestures){if("touchstart"!==t.type||"touchstart"===t.type&&t.targetTouches.length<2)return;d=!0,i.scaleStart=j(t)}i.$slideEl&&i.$slideEl.length||(i.$slideEl=e(t.target).closest(`.${o.params.slideClass}`),0===i.$slideEl.length&&(i.$slideEl=o.slides.eq(o.activeIndex)),i.$imageEl=i.$slideEl.find(`.${n.containerClass}`).eq(0).find("picture, img, svg, canvas, .swiper-zoom-target").eq(0),i.$imageWrapEl=i.$imageEl.parent(`.${n.containerClass}`),i.maxRatio=i.$imageWrapEl.attr("data-swiper-zoom")||n.maxRatio,0!==i.$imageWrapEl.length)?(i.$imageEl&&i.$imageEl.transition(0),p=!0):i.$imageEl=void 0}function f(e){const s=o.support,n=o.params.zoom,t=o.zoom;if(!s.gestures){if("touchmove"!==e.type||"touchmove"===e.type&&e.targetTouches.length<2)return;u=!0,i.scaleMove=j(e)}i.$imageEl&&0!==i.$imageEl.length?(s.gestures?t.scale=e.scale*c:t.scale=i.scaleMove/i.scaleStart*c,t.scale>i.maxRatio&&(t.scale=i.maxRatio-1+(t.scale-i.maxRatio+1)**.5),t.scale<n.minRatio&&(t.scale=n.minRatio+1-(n.minRatio-t.scale+1)**.5),i.$imageEl.transform(`translate3d(0,0,0) scale(${t.scale})`)):"gesturechange"===e.type&&m(e)}function l(e){const n=o.device,s=o.support,a=o.params.zoom,t=o.zoom;if(!s.gestures){if(!d||!u)return;if("touchend"!==e.type||"touchend"===e.type&&e.changedTouches.length<2&&!n.android)return;d=!1,u=!1}i.$imageEl&&0!==i.$imageEl.length&&(t.scale=Math.max(Math.min(t.scale,i.maxRatio),a.minRatio),i.$imageEl.transition(o.params.speed).transform(`translate3d(0,0,0) scale(${t.scale})`),c=t.scale,p=!1,1===t.scale&&(i.$slideEl=void 0))}function _(e){const t=o.zoom;if(!i.$imageEl||0===i.$imageEl.length)return;if(o.allowClick=!1,!s.isTouched||!i.$slideEl)return;s.isMoved||(s.width=i.$imageEl[0].offsetWidth,s.height=i.$imageEl[0].offsetHeight,s.startX=O(i.$imageWrapEl[0],"x")||0,s.startY=O(i.$imageWrapEl[0],"y")||0,i.slideWidth=i.$slideEl[0].offsetWidth,i.slideHeight=i.$slideEl[0].offsetHeight,i.$imageWrapEl.transition(0));const n=s.width*t.scale,r=s.height*t.scale;if(!(n<i.slideWidth&&r<i.slideHeight)){if(s.minX=Math.min(i.slideWidth/2-n/2,0),s.maxX=-s.minX,s.minY=Math.min(i.slideHeight/2-r/2,0),s.maxY=-s.minY,s.touchesCurrent.x="touchmove"===e.type?e.targetTouches[0].pageX:e.pageX,s.touchesCurrent.y="touchmove"===e.type?e.targetTouches[0].pageY:e.pageY,!s.isMoved&&!p){if(o.isHorizontal()&&(Math.floor(s.minX)===Math.floor(s.startX)&&s.touchesCurrent.x<s.touchesStart.x||Math.floor(s.maxX)===Math.floor(s.startX)&&s.touchesCurrent.x>s.touchesStart.x))return void(s.isTouched=!1);if(!o.isHorizontal()&&(Math.floor(s.minY)===Math.floor(s.startY)&&s.touchesCurrent.y<s.touchesStart.y||Math.floor(s.maxY)===Math.floor(s.startY)&&s.touchesCurrent.y>s.touchesStart.y))return void(s.isTouched=!1)}e.cancelable&&e.preventDefault(),e.stopPropagation(),s.isMoved=!0,s.currentX=s.touchesCurrent.x-s.touchesStart.x+s.startX,s.currentY=s.touchesCurrent.y-s.touchesStart.y+s.startY,s.currentX<s.minX&&(s.currentX=s.minX+1-(s.minX-s.currentX+1)**.8),s.currentX>s.maxX&&(s.currentX=s.maxX-1+(s.currentX-s.maxX+1)**.8),s.currentY<s.minY&&(s.currentY=s.minY+1-(s.minY-s.currentY+1)**.8),s.currentY>s.maxY&&(s.currentY=s.maxY-1+(s.currentY-s.maxY+1)**.8),a.prevPositionX||(a.prevPositionX=s.touchesCurrent.x),a.prevPositionY||(a.prevPositionY=s.touchesCurrent.y),a.prevTime||(a.prevTime=Date.now()),a.x=(s.touchesCurrent.x-a.prevPositionX)/(Date.now()-a.prevTime)/2,a.y=(s.touchesCurrent.y-a.prevPositionY)/(Date.now()-a.prevTime)/2,Math.abs(s.touchesCurrent.x-a.prevPositionX)<2&&(a.x=0),Math.abs(s.touchesCurrent.y-a.prevPositionY)<2&&(a.y=0),a.prevPositionX=s.touchesCurrent.x,a.prevPositionY=s.touchesCurrent.y,a.prevTime=Date.now(),i.$imageWrapEl.transform(`translate3d(${s.currentX}px, ${s.currentY}px,0)`)}}function w(){const e=o.zoom;i.$slideEl&&o.previousIndex!==o.activeIndex&&(i.$imageEl&&i.$imageEl.transform("translate3d(0,0,0) scale(1)"),i.$imageWrapEl&&i.$imageWrapEl.transform("translate3d(0,0,0)"),e.scale=1,c=1,i.$slideEl=void 0,i.$imageEl=void 0,i.$imageWrapEl=void 0)}function x(t){const r=o.zoom,l=o.params.zoom;if(i.$slideEl||(t&&t.target&&(i.$slideEl=e(t.target).closest(`.${o.params.slideClass}`)),i.$slideEl||(o.params.virtual&&o.params.virtual.enabled&&o.virtual?i.$slideEl=o.$wrapperEl.children(`.${o.params.slideActiveClass}`):i.$slideEl=o.slides.eq(o.activeIndex)),i.$imageEl=i.$slideEl.find(`.${l.containerClass}`).eq(0).find("picture, img, svg, canvas, .swiper-zoom-target").eq(0),i.$imageWrapEl=i.$imageEl.parent(`.${l.containerClass}`)),!i.$imageEl||0===i.$imageEl.length||!i.$imageWrapEl||0===i.$imageWrapEl.length)return;let h,m,C,b,x,O,n,a,w,_,y,j,d,u,v,g,p,f;o.params.cssMode&&(o.wrapperEl.style.overflow="hidden",o.wrapperEl.style.touchAction="none"),i.$slideEl.addClass(`${l.zoomedSlideClass}`),void 0===s.touchesStart.x&&t?(h="touchend"===t.type?t.changedTouches[0].pageX:t.pageX,m="touchend"===t.type?t.changedTouches[0].pageY:t.pageY):(h=s.touchesStart.x,m=s.touchesStart.y),r.scale=i.$imageWrapEl.attr("data-swiper-zoom")||l.maxRatio,c=i.$imageWrapEl.attr("data-swiper-zoom")||l.maxRatio,t?(p=i.$slideEl[0].offsetWidth,f=i.$slideEl[0].offsetHeight,C=i.$slideEl.offset().left+M.scrollX,b=i.$slideEl.offset().top+M.scrollY,x=C+p/2-h,O=b+f/2-m,w=i.$imageEl[0].offsetWidth,_=i.$imageEl[0].offsetHeight,y=w*r.scale,j=_*r.scale,d=Math.min(p/2-y/2,0),u=Math.min(f/2-j/2,0),v=-d,g=-u,n=x*r.scale,a=O*r.scale,n<d&&(n=d),n>v&&(n=v),a<u&&(a=u),a>g&&(a=g)):(n=0,a=0),i.$imageWrapEl.transition(300).transform(`translate3d(${n}px, ${a}px,0)`),i.$imageEl.transition(300).transform(`translate3d(0,0,0) scale(${r.scale})`)}function C(){const t=o.zoom,e=o.params.zoom;i.$slideEl||(o.params.virtual&&o.params.virtual.enabled&&o.virtual?i.$slideEl=o.$wrapperEl.children(`.${o.params.slideActiveClass}`):i.$slideEl=o.slides.eq(o.activeIndex),i.$imageEl=i.$slideEl.find(`.${e.containerClass}`).eq(0).find("picture, img, svg, canvas, .swiper-zoom-target").eq(0),i.$imageWrapEl=i.$imageEl.parent(`.${e.containerClass}`)),i.$imageEl&&0!==i.$imageEl.length&&i.$imageWrapEl&&0!==i.$imageWrapEl.length&&(o.params.cssMode&&(o.wrapperEl.style.overflow="",o.wrapperEl.style.touchAction=""),t.scale=1,c=1,i.$imageWrapEl.transition(300).transform("translate3d(0,0,0)"),i.$imageEl.transition(300).transform("translate3d(0,0,0) scale(1)"),i.$slideEl.removeClass(`${e.zoomedSlideClass}`),i.$slideEl=void 0)}function E(e){const t=o.zoom;t.scale&&1!==t.scale?C():x(e)}function g(){const e=o.support;return{passiveListener:!("touchstart"!==o.touchEvents.start||!e.passiveListener||!o.params.passiveListeners)&&{passive:!0,capture:!1},activeListenerWithCapture:!e.passiveListener||{passive:!1,capture:!0}}}function b(){return`.${o.params.slideClass}`}function S(e){const{passiveListener:t}=g(),n=b();o.$wrapperEl[e]("gesturestart",n,m,t),o.$wrapperEl[e]("gesturechange",n,f,t),o.$wrapperEl[e]("gestureend",n,l,t)}function y(){h||(h=!0,S("on"))}function F(){h&&(h=!1,S("off"))}function A(){const n=o.zoom;if(n.enabled)return;n.enabled=!0;const i=o.support,{passiveListener:e,activeListenerWithCapture:s}=g(),t=b();i.gestures?(o.$wrapperEl.on(o.touchEvents.start,y,e),o.$wrapperEl.on(o.touchEvents.end,F,e)):"touchstart"===o.touchEvents.start&&(o.$wrapperEl.on(o.touchEvents.start,t,m,e),o.$wrapperEl.on(o.touchEvents.move,t,f,s),o.$wrapperEl.on(o.touchEvents.end,t,l,e),o.touchEvents.cancel&&o.$wrapperEl.on(o.touchEvents.cancel,t,l,e)),o.$wrapperEl.on(o.touchEvents.move,`.${o.params.zoom.containerClass}`,_,s)}function k(){const n=o.zoom;if(!n.enabled)return;const i=o.support;n.enabled=!1;const{passiveListener:e,activeListenerWithCapture:s}=g(),t=b();i.gestures?(o.$wrapperEl.off(o.touchEvents.start,y,e),o.$wrapperEl.off(o.touchEvents.end,F,e)):"touchstart"===o.touchEvents.start&&(o.$wrapperEl.off(o.touchEvents.start,t,m,e),o.$wrapperEl.off(o.touchEvents.move,t,f,s),o.$wrapperEl.off(o.touchEvents.end,t,l,e),o.touchEvents.cancel&&o.$wrapperEl.off(o.touchEvents.cancel,t,l,e)),o.$wrapperEl.off(o.touchEvents.move,`.${o.params.zoom.containerClass}`,_,s)}Object.defineProperty(o.zoom,"scale",{get:()=>v,set(e){if(v!==e){const t=i.$imageEl?i.$imageEl[0]:void 0,n=i.$slideEl?i.$slideEl[0]:void 0;z("zoomChange",e,t,n)}v=e}}),r("init",()=>{o.params.zoom.enabled&&A()}),r("destroy",()=>{k()}),r("touchStart",(e,t)=>{o.zoom.enabled&&function(e){const t=o.device;i.$imageEl&&0!==i.$imageEl.length&&(s.isTouched||(t.android&&e.cancelable&&e.preventDefault(),s.isTouched=!0,s.touchesStart.x="touchstart"===e.type?e.targetTouches[0].pageX:e.pageX,s.touchesStart.y="touchstart"===e.type?e.targetTouches[0].pageY:e.pageY))}(t)}),r("touchEnd",()=>{o.zoom.enabled&&function(){const n=o.zoom;if(!i.$imageEl||0===i.$imageEl.length)return;if(!s.isTouched||!s.isMoved)return s.isTouched=!1,void(s.isMoved=!1);s.isTouched=!1,s.isMoved=!1;let e=300,t=300;const l=a.x*e,r=s.currentX+l,d=a.y*t,c=s.currentY+d;0!==a.x&&(e=Math.abs((r-s.currentX)/a.x)),0!==a.y&&(t=Math.abs((c-s.currentY)/a.y));const u=Math.max(e,t);s.currentX=r,s.currentY=c;const h=s.width*n.scale,m=s.height*n.scale;s.minX=Math.min(i.slideWidth/2-h/2,0),s.maxX=-s.minX,s.minY=Math.min(i.slideHeight/2-m/2,0),s.maxY=-s.minY,s.currentX=Math.max(Math.min(s.currentX,s.maxX),s.minX),s.currentY=Math.max(Math.min(s.currentY,s.maxY),s.minY),i.$imageWrapEl.transition(u).transform(`translate3d(${s.currentX}px, ${s.currentY}px,0)`)}()}),r("doubleTap",(e,t)=>{!o.animating&&o.params.zoom.enabled&&o.zoom.enabled&&o.params.zoom.toggle&&E(t)}),r("transitionEnd",()=>{o.zoom.enabled&&o.params.zoom.enabled&&w()}),r("slideChange",()=>{o.zoom.enabled&&o.params.zoom.enabled&&o.params.cssMode&&w()}),Object.assign(o.zoom,{enable:A,disable:k,in:x,out:C,toggle:E})},function(n){let{swiper:s,extendParams:u,on:a,emit:l}=n;u({lazy:{checkInView:!1,enabled:!1,loadPrevNext:!1,loadPrevNextAmount:1,loadOnTransitionStart:!1,scrollingElement:"",elementClass:"swiper-lazy",loadingClass:"swiper-lazy-loading",loadedClass:"swiper-lazy-loaded",preloaderClass:"swiper-lazy-preloader"}}),s.lazy={};let d=!1,c=!1;function o(t,n){void 0===n&&(n=!0);const i=s.params.lazy;if(void 0===t)return;if(0===s.slides.length)return;const a=s.virtual&&s.params.virtual.enabled?s.$wrapperEl.children(`.${s.params.slideClass}[data-swiper-slide-index="${t}"]`):s.slides.eq(t),r=a.find(`.${i.elementClass}:not(.${i.loadedClass}):not(.${i.loadingClass})`);!a.hasClass(i.elementClass)||a.hasClass(i.loadedClass)||a.hasClass(i.loadingClass)||r.push(a[0]),0!==r.length&&r.each(t=>{const r=e(t);r.addClass(i.loadingClass);const c=r.attr("data-background"),d=r.attr("data-src"),u=r.attr("data-srcset"),h=r.attr("data-sizes"),m=r.parent("picture");s.loadImage(r[0],d||c,u,h,!1,()=>{if(s!=null&&s&&(!s||s.params)&&!s.destroyed){if(c?(r.css("background-image",`url("${c}")`),r.removeAttr("data-background")):(u&&(r.attr("srcset",u),r.removeAttr("data-srcset")),h&&(r.attr("sizes",h),r.removeAttr("data-sizes")),m.length&&m.children("source").each(t=>{const n=e(t);n.attr("data-srcset")&&(n.attr("srcset",n.attr("data-srcset")),n.removeAttr("data-srcset"))}),d&&(r.attr("src",d),r.removeAttr("data-src"))),r.addClass(i.loadedClass).removeClass(i.loadingClass),a.find(`.${i.preloaderClass}`).remove(),s.params.loop&&n){const e=a.attr("data-swiper-slide-index");a.hasClass(s.params.slideDuplicateClass)?o(s.$wrapperEl.children(`[data-swiper-slide-index="${e}"]:not(.${s.params.slideDuplicateClass})`).index(),!1):o(s.$wrapperEl.children(`.${s.params.slideDuplicateClass}[data-swiper-slide-index="${e}"]`).index(),!1)}l("lazyImageReady",a[0],r[0]),s.params.autoHeight&&s.updateAutoHeight()}}),l("lazyImageLoad",a[0],r[0])})}function i(){const{$wrapperEl:a,params:t,slides:u,activeIndex:n}=s,l=s.virtual&&t.virtual.enabled,r=t.lazy;let i=t.slidesPerView;function d(e){if(l){if(a.children(`.${t.slideClass}[data-swiper-slide-index="${e}"]`).length)return!0}else if(u[e])return!0;return!1}function h(t){return l?e(t).attr("data-swiper-slide-index"):e(t).index()}if("auto"===i&&(i=0),c||(c=!0),s.params.watchSlidesProgress)a.children(`.${t.slideVisibleClass}`).each(t=>{o(l?e(t).attr("data-swiper-slide-index"):e(t).index())});else if(i>1)for(let e=n;e<n+i;e+=1)d(e)&&o(e);else o(n);if(r.loadPrevNext)if(i>1||r.loadPrevNextAmount&&r.loadPrevNextAmount>1){const t=r.loadPrevNextAmount,e=i,s=Math.min(n+e+Math.max(t,e),u.length),a=Math.max(n-Math.max(e,t),0);for(let e=n+i;e<s;e+=1)d(e)&&o(e);for(let e=a;e<n;e+=1)d(e)&&o(e)}else{const e=a.children(`.${t.slideNextClass}`);e.length>0&&o(h(e));const n=a.children(`.${t.slidePrevClass}`);n.length>0&&o(h(n))}}function r(){const a=t();if(!s||s.destroyed)return;const o=e(s.params.lazy.scrollingElement?s.params.lazy.scrollingElement:a),c=o[0]===a,m=c?a.innerWidth:o[0].offsetWidth,f=c?a.innerHeight:o[0].offsetHeight,n=s.$el.offset(),{rtlTranslate:p}=s;let l=!1;p&&(n.left-=s.$el[0].scrollLeft);const u=[[n.left,n.top],[n.left+s.width,n.top],[n.left,n.top+s.height],[n.left+s.width,n.top+s.height]];for(let t=0;t<u.length;t+=1){const e=u[t];if(e[0]>=0&&e[0]<=m&&e[1]>=0&&e[1]<=f){if(0===e[0]&&0===e[1])continue;l=!0}}const h=!("touchstart"!==s.touchEvents.start||!s.support.passiveListener||!s.params.passiveListeners)&&{passive:!0,capture:!1};l?(i(),o.off("scroll",r,h)):d||(d=!0,o.on("scroll",r,h))}a("beforeInit",()=>{s.params.lazy.enabled&&s.params.preloadImages&&(s.params.preloadImages=!1)}),a("init",()=>{s.params.lazy.enabled&&(s.params.lazy.checkInView?r():i())}),a("scroll",()=>{s.params.freeMode&&s.params.freeMode.enabled&&!s.params.freeMode.sticky&&i()}),a("scrollbarDragMove resize _freeModeNoMomentumRelease",()=>{s.params.lazy.enabled&&(s.params.lazy.checkInView?r():i())}),a("transitionStart",()=>{s.params.lazy.enabled&&(s.params.lazy.loadOnTransitionStart||!s.params.lazy.loadOnTransitionStart&&!c)&&(s.params.lazy.checkInView?r():i())}),a("transitionEnd",()=>{s.params.lazy.enabled&&!s.params.lazy.loadOnTransitionStart&&(s.params.lazy.checkInView?r():i())}),a("slideChange",()=>{const{lazy:e,cssMode:t,watchSlidesProgress:n,touchReleaseOnEdges:o,resistanceRatio:a}=s.params;e.enabled&&(t||n&&(o||0===a))&&i()}),Object.assign(s.lazy,{load:i,loadInSlide:o})},function(e){let{swiper:t,extendParams:i,on:n}=e;function o(e,t){const o=function(){let e,t,n;return(s,o)=>{for(t=-1,e=s.length;e-t>1;)n=e+t>>1,s[n]<=o?t=n:e=n;return e}}();let n,s;return this.x=e,this.y=t,this.lastIndex=e.length-1,this.interpolate=function(e){return e?(s=o(this.x,e),n=s-1,(e-this.x[n])*(this.y[s]-this.y[n])/(this.x[s]-this.x[n])+this.y[n]):0},this}function s(){t.controller.control&&t.controller.spline&&(t.controller.spline=void 0,delete t.controller.spline)}i({controller:{control:void 0,inverse:!1,by:"slide"}}),t.controller={control:void 0},n("beforeInit",()=>{t.controller.control=t.params.controller.control}),n("update",()=>{s()}),n("resize",()=>{s()}),n("observerUpdate",()=>{s()}),n("setTranslate",(e,n,s)=>{t.controller.control&&t.controller.setTranslate(n,s)}),n("setTransition",(e,n,s)=>{t.controller.control&&t.controller.setTransition(n,s)}),Object.assign(t.controller,{setTranslate:function(e,n){const s=t.controller.control;let a,i;const r=t.constructor;function c(e){const n=t.rtlTranslate?-t.translate:t.translate;"slide"===t.params.controller.by&&(!function(e){t.controller.spline||(t.controller.spline=t.params.loop?new o(t.slidesGrid,e.slidesGrid):new o(t.snapGrid,e.snapGrid))}(e),i=-t.controller.spline.interpolate(-n)),i&&"container"!==t.params.controller.by||(a=(e.maxTranslate()-e.minTranslate())/(t.maxTranslate()-t.minTranslate()),i=(n-t.minTranslate())*a+e.minTranslate()),t.params.controller.inverse&&(i=e.maxTranslate()-i),e.updateProgress(i),e.setTranslate(i,t),e.updateActiveIndex(),e.updateSlidesClasses()}if(Array.isArray(s))for(let e=0;e<s.length;e+=1)s[e]!==n&&s[e]instanceof r&&c(s[e]);else s instanceof r&&n!==s&&c(s)},setTransition:function(e,n){const i=t.constructor,s=t.controller.control;let o;function a(n){n.setTransition(e,t),0!==e&&(n.transitionStart(),n.params.autoHeight&&r(()=>{n.updateAutoHeight()}),n.$wrapperEl.transitionEnd(()=>{s&&(n.params.loop&&"slide"===t.params.controller.by&&n.loopFix(),n.transitionEnd())}))}if(Array.isArray(s))for(o=0;o<s.length;o+=1)s[o]!==n&&s[o]instanceof i&&a(s[o]);else s instanceof i&&n!==s&&a(s)}})},function(t){let{swiper:n,extendParams:j,on:i}=t;j({a11y:{enabled:!0,notificationClass:"swiper-notification",prevSlideMessage:"Previous slide",nextSlideMessage:"Next slide",firstSlideMessage:"This is the first slide",lastSlideMessage:"This is the last slide",paginationBulletMessage:"Go to slide {{index}}",slideLabelMessage:"{{index}} / {{slidesLength}}",containerMessage:null,containerRoleDescriptionMessage:null,itemRoleDescriptionMessage:null,slideRole:"group",id:null}});let s=null;function r(e){const t=s;0!==t.length&&(t.html(""),t.html(e))}function l(e){e.attr("tabIndex","0")}function f(e){e.attr("tabIndex","-1")}function d(e,t){e.attr("role",t)}function h(e,t){e.attr("aria-roledescription",t)}function c(e,t){e.attr("aria-label",t)}function m(e){e.attr("aria-disabled",!0)}function u(e){e.attr("aria-disabled",!1)}function o(t){if(13!==t.keyCode&&32!==t.keyCode)return;const s=n.params.a11y,o=e(t.target);n.navigation&&n.navigation.$nextEl&&o.is(n.navigation.$nextEl)&&(n.isEnd&&!n.params.loop||n.slideNext(),r(n.isEnd?s.lastSlideMessage:s.nextSlideMessage)),n.navigation&&n.navigation.$prevEl&&o.is(n.navigation.$prevEl)&&(n.isBeginning&&!n.params.loop||n.slidePrev(),r(n.isBeginning?s.firstSlideMessage:s.prevSlideMessage)),n.pagination&&o.is(a(n.params.pagination.bulletClass))&&o[0].click()}function p(){return n.pagination&&n.pagination.bullets&&n.pagination.bullets.length}function g(){return p()&&n.params.pagination.clickable}const v=(e,t,n)=>{l(e),"BUTTON"!==e[0].tagName&&(d(e,"button"),e.on("keydown",o)),c(e,n),function(e,t){e.attr("aria-controls",t)}(e,t)},b=e=>{const t=e.target.closest(`.${n.params.slideClass}`);if(!t||!n.slides.includes(t))return;const s=n.slides.indexOf(t)===n.activeIndex,o=n.params.watchSlidesProgress&&n.visibleSlides&&n.visibleSlides.includes(t);s||o||n.slideTo(n.slides.indexOf(t),0)};function y(){const t=n.params.a11y;n.$el.append(s);const f=n.$el;t.containerRoleDescriptionMessage&&h(f,t.containerRoleDescriptionMessage),t.containerMessage&&c(f,t.containerMessage);const u=n.$wrapperEl,m=t.id||u.attr("id")||`swiper-wrapper-${i=16,void 0===i&&(i=16),"x".repeat(i).replace(/x/g,()=>Math.round(16*Math.random()).toString(16))}`;var i,p;const j=n.params.autoplay&&n.params.autoplay.enabled?"off":"polite";p=m,u.attr("id",p),function(e,t){e.attr("aria-live",t)}(u,j),t.itemRoleDescriptionMessage&&h(e(n.slides),t.itemRoleDescriptionMessage),d(e(n.slides),t.slideRole);const y=n.params.loop?n.slides.filter(e=>!e.classList.contains(n.params.slideDuplicateClass)).length:n.slides.length;let r,l;n.slides.each((s,o)=>{const i=e(s),a=n.params.loop?parseInt(i.attr("data-swiper-slide-index"),10):o;c(i,t.slideLabelMessage.replace(/\{\{index\}\}/,a+1).replace(/\{\{slidesLength\}\}/,y))}),n.navigation&&n.navigation.$nextEl&&(r=n.navigation.$nextEl),n.navigation&&n.navigation.$prevEl&&(l=n.navigation.$prevEl),r&&r.length&&v(r,m,t.nextSlideMessage),l&&l.length&&v(l,m,t.prevSlideMessage),g()&&n.pagination.$el.on("keydown",a(n.params.pagination.bulletClass),o),n.$el.on("focus",b,!0)}i("beforeInit",()=>{s=e(`<span class="${n.params.a11y.notificationClass}" aria-live="assertive" aria-atomic="true"></span>`)}),i("afterInit",()=>{n.params.a11y.enabled&&y()}),i("fromEdge toEdge afterInit lock unlock",()=>{n.params.a11y.enabled&&function(){if(n.params.loop||n.params.rewind||!n.navigation)return;const{$nextEl:e,$prevEl:t}=n.navigation;t&&t.length>0&&(n.isBeginning?(m(t),f(t)):(u(t),l(t))),e&&e.length>0&&(n.isEnd?(m(e),f(e)):(u(e),l(e)))}()}),i("paginationUpdate",()=>{n.params.a11y.enabled&&function(){const t=n.params.a11y;p()&&n.pagination.bullets.each(s=>{const o=e(s);n.params.pagination.clickable&&(l(o),n.params.pagination.renderBullet||(d(o,"button"),c(o,t.paginationBulletMessage.replace(/\{\{index\}\}/,o.index()+1)))),o.is(`.${n.params.pagination.bulletActiveClass}`)?o.attr("aria-current","true"):o.removeAttr("aria-current")})}()}),i("destroy",()=>{n.params.a11y.enabled&&function(){let e,t;s&&s.length>0&&s.remove(),n.navigation&&n.navigation.$nextEl&&(e=n.navigation.$nextEl),n.navigation&&n.navigation.$prevEl&&(t=n.navigation.$prevEl),e&&e.off("keydown",o),t&&t.off("keydown",o),g()&&n.pagination.$el.off("keydown",a(n.params.pagination.bulletClass),o),n.$el.off("focus",b,!0)}()})},function(e){let{swiper:n,extendParams:u,on:o}=e;u({history:{enabled:!1,root:"",replaceState:!1,key:"slides"}});let i=!1,s={};const a=e=>e.toString().replace(/\s+/g,"-").replace(/[^\w-]+/g,"").replace(/--+/g,"-").replace(/^-+/,"").replace(/-+$/,""),r=e=>{const i=t();let s;s=e?new URL(e):i.location;const n=s.pathname.slice(1).split("/").filter(e=>""!==e),o=n.length;return{key:n[o-2],value:n[o-1]}},c=(e,s)=>{const r=t();if(!i||!n.params.history.enabled)return;let c;c=n.params.url?new URL(n.params.url):r.location;const d=n.slides.eq(s);let o=a(d.attr("data-history"));if(n.params.history.root.length>0){let t=n.params.history.root;"/"===t[t.length-1]&&(t=t.slice(0,t.length-1)),o=`${t}/${e}/${o}`}else c.pathname.includes(e)||(o=`${e}/${o}`);const l=r.history.state;l&&l.value===o||(n.params.history.replaceState?r.history.replaceState({value:o},null,o):r.history.pushState({value:o},null,o))},l=(e,t,s)=>{if(t){for(let o=0,r=n.slides.length;o<r;o+=1){const i=n.slides.eq(o);if(a(i.attr("data-history"))===t&&!i.hasClass(n.params.slideDuplicateClass)){const t=i.index();n.slideTo(t,e,s)}}}else n.slideTo(0,e,s)},d=()=>{s=r(n.params.url),l(n.params.speed,n.paths.value,!1)};o("init",()=>{n.params.history.enabled&&(()=>{const e=t();if(n.params.history){if(!e.history||!e.history.pushState)return n.params.history.enabled=!1,void(n.params.hashNavigation.enabled=!0);i=!0,s=r(n.params.url),(s.key||s.value)&&(l(0,s.value,n.params.runCallbacksOnInit),n.params.history.replaceState||e.addEventListener("popstate",d))}})()}),o("destroy",()=>{n.params.history.enabled&&(()=>{const e=t();n.params.history.replaceState||e.removeEventListener("popstate",d)})()}),o("transitionEnd _freeModeNoMomentumRelease",()=>{i&&c(n.params.history.key,n.activeIndex)}),o("slideChange",()=>{i&&n.params.cssMode&&c(n.params.history.key,n.activeIndex)})},function(s){let{swiper:o,extendParams:h,emit:c,on:a}=s,r=!1;const l=n(),i=t();h({hashNavigation:{enabled:!1,replaceState:!1,watchState:!1}});const d=()=>{c("hashChange");const e=l.location.hash.replace("#","");if(e!==o.slides.eq(o.activeIndex).attr("data-hash")){const t=o.$wrapperEl.children(`.${o.params.slideClass}[data-hash="${e}"]`).index();if(void 0===t)return;o.slideTo(t)}},u=()=>{if(r&&o.params.hashNavigation.enabled)if(o.params.hashNavigation.replaceState&&i.history&&i.history.replaceState)i.history.replaceState(null,null,`#${o.slides.eq(o.activeIndex).attr("data-hash")}`||""),c("hashSet");else{const e=o.slides.eq(o.activeIndex),t=e.attr("data-hash")||e.attr("data-history");l.location.hash=t||"",c("hashSet")}};a("init",()=>{o.params.hashNavigation.enabled&&(()=>{if(!o.params.hashNavigation.enabled||o.params.history&&o.params.history.enabled)return;r=!0;const t=l.location.hash.replace("#","");if(t){const e=0;for(let s=0,i=o.slides.length;s<i;s+=1){const n=o.slides.eq(s);if((n.attr("data-hash")||n.attr("data-history"))===t&&!n.hasClass(o.params.slideDuplicateClass)){const t=n.index();o.slideTo(t,e,o.params.runCallbacksOnInit,!0)}}}o.params.hashNavigation.watchState&&e(i).on("hashchange",d)})()}),a("destroy",()=>{o.params.hashNavigation.enabled&&o.params.hashNavigation.watchState&&e(i).off("hashchange",d)}),a("transitionEnd _freeModeNoMomentumRelease",()=>{r&&u()}),a("slideChange",()=>{r&&o.params.cssMode&&u()})},function(e){let o,{swiper:t,extendParams:p,on:c,emit:s}=e;function i(){const e=t.slides.eq(t.activeIndex);let n=t.params.autoplay.delay;e.attr("data-swiper-autoplay")&&(n=e.attr("data-swiper-autoplay")||t.params.autoplay.delay),clearTimeout(o),o=r(()=>{let e;t.params.autoplay.reverseDirection?t.params.loop?(t.loopFix(),e=t.slidePrev(t.params.speed,!0,!0),s("autoplay")):t.isBeginning?t.params.autoplay.stopOnLastSlide?a():(e=t.slideTo(t.slides.length-1,t.params.speed,!0,!0),s("autoplay")):(e=t.slidePrev(t.params.speed,!0,!0),s("autoplay")):t.params.loop?(t.loopFix(),e=t.slideNext(t.params.speed,!0,!0),s("autoplay")):t.isEnd?t.params.autoplay.stopOnLastSlide?a():(e=t.slideTo(0,t.params.speed,!0,!0),s("autoplay")):(e=t.slideNext(t.params.speed,!0,!0),s("autoplay")),(t.params.cssMode&&t.autoplay.running||!1===e)&&i()},n)}function u(){return void 0===o&&!t.autoplay.running&&(t.autoplay.running=!0,s("autoplayStart"),i(),!0)}function a(){return!!t.autoplay.running&&void 0!==o&&(o&&(clearTimeout(o),o=void 0),t.autoplay.running=!1,s("autoplayStop"),!0)}function l(e){t.autoplay.running&&(t.autoplay.paused||(o&&clearTimeout(o),t.autoplay.paused=!0,0!==e&&t.params.autoplay.waitForTransition?["transitionend","webkitTransitionEnd"].forEach(e=>{t.$wrapperEl[0].addEventListener(e,d)}):(t.autoplay.paused=!1,i())))}function h(){const e=n();"hidden"===e.visibilityState&&t.autoplay.running&&l(),"visible"===e.visibilityState&&t.autoplay.paused&&(i(),t.autoplay.paused=!1)}function d(e){t&&!t.destroyed&&t.$wrapperEl&&e.target===t.$wrapperEl[0]&&(["transitionend","webkitTransitionEnd"].forEach(e=>{t.$wrapperEl[0].removeEventListener(e,d)}),t.autoplay.paused=!1,t.autoplay.running?i():a())}function m(){t.params.autoplay.disableOnInteraction?a():(s("autoplayPause"),l()),["transitionend","webkitTransitionEnd"].forEach(e=>{t.$wrapperEl[0].removeEventListener(e,d)})}function f(){t.params.autoplay.disableOnInteraction||(t.autoplay.paused=!1,s("autoplayResume"),i())}t.autoplay={running:!1,paused:!1},p({autoplay:{enabled:!1,delay:3e3,waitForTransition:!0,disableOnInteraction:!0,stopOnLastSlide:!1,reverseDirection:!1,pauseOnMouseEnter:!1}}),c("init",()=>{t.params.autoplay.enabled&&(u(),n().addEventListener("visibilitychange",h),t.params.autoplay.pauseOnMouseEnter&&(t.$el.on("mouseenter",m),t.$el.on("mouseleave",f)))}),c("beforeTransitionStart",(e,n,s)=>{t.autoplay.running&&(s||!t.params.autoplay.disableOnInteraction?t.autoplay.pause(n):a())}),c("sliderFirstMove",()=>{t.autoplay.running&&(t.params.autoplay.disableOnInteraction?a():l())}),c("touchEnd",()=>{t.params.cssMode&&t.autoplay.paused&&!t.params.autoplay.disableOnInteraction&&i()}),c("destroy",()=>{t.$el.off("mouseenter",m),t.$el.off("mouseleave",f),t.autoplay.running&&a(),n().removeEventListener("visibilitychange",h)}),Object.assign(t.autoplay,{pause:l,run:i,start:u,stop:a})},function(t){let{swiper:n,extendParams:c,on:s}=t;c({thumbs:{swiper:null,multipleActiveThumbs:!0,autoScrollOffset:0,slideThumbActiveClass:"swiper-slide-thumb-active",thumbsContainerClass:"swiper-thumbs"}});let i=!1,a=!1;function l(){const t=n.thumbs.swiper;if(!t||t.destroyed)return;const o=t.clickedIndex,i=t.clickedSlide;if(i&&e(i).hasClass(n.params.thumbs.slideThumbActiveClass))return;if(o==null)return;let s;if(s=t.params.loop?parseInt(e(t.clickedSlide).attr("data-swiper-slide-index"),10):o,n.params.loop){let e=n.activeIndex;n.slides.eq(e).hasClass(n.params.slideDuplicateClass)&&(n.loopFix(),n._clientLeft=n.$wrapperEl[0].clientLeft,e=n.activeIndex);const t=n.slides.eq(e).prevAll(`[data-swiper-slide-index="${s}"]`).eq(0).index(),o=n.slides.eq(e).nextAll(`[data-swiper-slide-index="${s}"]`).eq(0).index();s=void 0===t?o:void 0===o?t:o-e<e-t?o:t}n.slideTo(s)}function r(){const{thumbs:e}=n.params;if(i)return!1;i=!0;const t=n.constructor;if(e.swiper instanceof t)n.thumbs.swiper=e.swiper,Object.assign(n.thumbs.swiper.originalParams,{watchSlidesProgress:!0,slideToClickedSlide:!1}),Object.assign(n.thumbs.swiper.params,{watchSlidesProgress:!0,slideToClickedSlide:!1});else if(m(e.swiper)){const s=Object.assign({},e.swiper);Object.assign(s,{watchSlidesProgress:!0,slideToClickedSlide:!1}),n.thumbs.swiper=new t(s),a=!0}return n.thumbs.swiper.$el.addClass(n.params.thumbs.thumbsContainerClass),n.thumbs.swiper.on("tap",l),!0}function o(e){const t=n.thumbs.swiper;if(!t||t.destroyed)return;const a="auto"===t.params.slidesPerView?t.slidesPerViewDynamic():t.params.slidesPerView,o=n.params.thumbs.autoScrollOffset,r=o&&!t.params.loop;if(n.realIndex!==t.realIndex||r){let s,c,i=t.activeIndex;if(t.params.loop){t.slides.eq(i).hasClass(t.params.slideDuplicateClass)&&(t.loopFix(),t._clientLeft=t.$wrapperEl[0].clientLeft,i=t.activeIndex);const o=t.slides.eq(i).prevAll(`[data-swiper-slide-index="${n.realIndex}"]`).eq(0).index(),e=t.slides.eq(i).nextAll(`[data-swiper-slide-index="${n.realIndex}"]`).eq(0).index();s=void 0===o?e:void 0===e?o:e-i==i-o?t.params.slidesPerGroup>1?e:i:e-i<i-o?e:o,c=n.activeIndex>n.previousIndex?"next":"prev"}else s=n.realIndex,c=s>n.previousIndex?"next":"prev";r&&(s+="next"===c?o:-1*o),t.visibleSlidesIndexes&&t.visibleSlidesIndexes.indexOf(s)<0&&(t.params.centeredSlides?s=s>i?s-Math.floor(a/2)+1:s+Math.floor(a/2)-1:s>i&&t.params.slidesPerGroup,t.slideTo(s,e?0:void 0))}let s=1;const i=n.params.thumbs.slideThumbActiveClass;if(n.params.slidesPerView>1&&!n.params.centeredSlides&&(s=n.params.slidesPerView),n.params.thumbs.multipleActiveThumbs||(s=1),s=Math.floor(s),t.slides.removeClass(i),t.params.loop||t.params.virtual&&t.params.virtual.enabled)for(let e=0;e<s;e+=1)t.$wrapperEl.children(`[data-swiper-slide-index="${n.realIndex+e}"]`).addClass(i);else for(let e=0;e<s;e+=1)t.slides.eq(n.realIndex+e).addClass(i)}n.thumbs={swiper:null},s("beforeInit",()=>{const{thumbs:e}=n.params;e&&e.swiper&&(r(),o(!0))}),s("slideChange update resize observerUpdate",()=>{o()}),s("setTransition",(e,t)=>{const s=n.thumbs.swiper;s&&!s.destroyed&&s.setTransition(t)}),s("beforeDestroy",()=>{const e=n.thumbs.swiper;e&&!e.destroyed&&a&&e.destroy()}),Object.assign(n.thumbs,{init:r,update:o})},function(e){let{swiper:t,extendParams:o,emit:n,once:i}=e;o({freeMode:{enabled:!1,momentum:!0,momentumRatio:1,momentumBounce:!0,momentumBounceRatio:1,momentumVelocityRatio:1,sticky:!1,minimumVelocity:.02}}),Object.assign(t,{freeMode:{onTouchStart:function(){const e=t.getTranslate();t.setTranslate(e),t.setTransition(0),t.touchEventsData.velocities.length=0,t.freeMode.onTouchEnd({currentPos:t.rtl?t.translate:-t.translate})},onTouchMove:function(){const{touchEventsData:e,touches:n}=t;0===e.velocities.length&&e.velocities.push({position:n[t.isHorizontal()?"startX":"startY"],time:e.touchStartTime}),e.velocities.push({position:n[t.isHorizontal()?"currentX":"currentY"],time:s()})},onTouchEnd:function(e){let{currentPos:d}=e;const{params:o,$wrapperEl:c,rtlTranslate:l,snapGrid:a,touchEventsData:r}=t,u=s()-r.touchStartTime;if(d<-t.minTranslate())t.slideTo(t.activeIndex);else if(d>-t.maxTranslate())t.slides.length<a.length?t.slideTo(a.length-1):t.slideTo(t.slides.length-1);else{if(o.freeMode.momentum){if(r.velocities.length>1){const e=r.velocities.pop(),n=r.velocities.pop(),a=e.position-n.position,i=e.time-n.time;t.velocity=a/i,t.velocity/=2,Math.abs(t.velocity)<o.freeMode.minimumVelocity&&(t.velocity=0),(i>150||s()-e.time>300)&&(t.velocity=0)}else t.velocity=0;t.velocity*=o.freeMode.momentumVelocityRatio,r.velocities.length=0;let d=1e3*o.freeMode.momentumRatio;const p=t.velocity*d;let e=t.translate+p;l&&(e=-e);let u,m=!1;const h=20*Math.abs(t.velocity)*o.freeMode.momentumBounceRatio;let f;if(e<t.maxTranslate())o.freeMode.momentumBounce?(e+t.maxTranslate()<-h&&(e=t.maxTranslate()-h),u=t.maxTranslate(),m=!0,r.allowMomentumBounce=!0):e=t.maxTranslate(),o.loop&&o.centeredSlides&&(f=!0);else if(e>t.minTranslate())o.freeMode.momentumBounce?(e-t.minTranslate()>h&&(e=t.minTranslate()+h),u=t.minTranslate(),m=!0,r.allowMomentumBounce=!0):e=t.minTranslate(),o.loop&&o.centeredSlides&&(f=!0);else if(o.freeMode.sticky){let n;for(let t=0;t<a.length;t+=1)if(a[t]>-e){n=t;break}e=Math.abs(a[n]-e)<Math.abs(a[n-1]-e)||"next"===t.swipeDirection?a[n]:a[n-1],e=-e}if(f&&i("transitionEnd",()=>{t.loopFix()}),0!==t.velocity){if(d=l?Math.abs((-e-t.translate)/t.velocity):Math.abs((e-t.translate)/t.velocity),o.freeMode.sticky){const n=Math.abs((l?-e:e)-t.translate),s=t.slidesSizesGrid[t.activeIndex];d=n<s?o.speed:n<2*s?1.5*o.speed:2.5*o.speed}}else if(o.freeMode.sticky)return void t.slideToClosest();o.freeMode.momentumBounce&&m?(t.updateProgress(u),t.setTransition(d),t.setTranslate(e),t.transitionStart(!0,t.swipeDirection),t.animating=!0,c.transitionEnd(()=>{t&&!t.destroyed&&r.allowMomentumBounce&&(n("momentumBounce"),t.setTransition(o.speed),setTimeout(()=>{t.setTranslate(u),c.transitionEnd(()=>{t&&!t.destroyed&&t.transitionEnd()})},0))})):t.velocity?(n("_freeModeNoMomentumRelease"),t.updateProgress(e),t.setTransition(d),t.setTranslate(e),t.transitionStart(!0,t.swipeDirection),t.animating||(t.animating=!0,c.transitionEnd(()=>{t&&!t.destroyed&&t.transitionEnd()}))):t.updateProgress(e),t.updateActiveIndex(),t.updateSlidesClasses()}else{if(o.freeMode.sticky)return void t.slideToClosest();o.freeMode&&n("_freeModeNoMomentumRelease")}(!o.freeMode.momentum||u>=o.longSwipesMs)&&(t.updateProgress(),t.updateActiveIndex(),t.updateSlidesClasses())}}}})},function(e){let n,s,o,{swiper:t,extendParams:i}=e;i({grid:{rows:1,fill:"column"}}),t.grid={initSlides:e=>{const{slidesPerView:a}=t.params,{rows:i,fill:r}=t.params.grid;s=n/i,o=Math.floor(e/i),n=Math.floor(e/i)===e/i?e:Math.ceil(e/i)*i,"auto"!==a&&"row"===r&&(n=Math.max(n,a*i))},updateSlide:(e,i,a,r)=>{const{slidesPerGroup:u,spaceBetween:m}=t.params,{rows:l,fill:f}=t.params.grid;let h,d,c;if("row"===f&&u>1){const t=Math.floor(e/(u*l)),s=e-l*u*t,o=0===t?u:Math.min(Math.ceil((a-t*l*u)/l),u);c=Math.floor(s/o),d=s-c*o+t*u,h=d+c*n/l,i.css({"-webkit-order":h,order:h})}else"column"===f?(d=Math.floor(e/l),c=e-d*l,(d>o||d===o&&c===l-1)&&(c+=1,c>=l&&(c=0,d+=1))):(c=Math.floor(e/s),d=e-c*s);i.css(r("margin-top"),0!==c?m&&`${m}px`:"")},updateWrapperSize:(e,s,o)=>{const{spaceBetween:i,centeredSlides:a,roundLengths:r}=t.params,{rows:c}=t.params.grid;if(t.virtualSize=(e+i)*n,t.virtualSize=Math.ceil(t.virtualSize/c)-i,t.$wrapperEl.css({[o("width")]:`${t.virtualSize+i}px`}),a){s.splice(0,s.length);const e=[];for(let n=0;n<s.length;n+=1){let o=s[n];r&&(o=Math.floor(o)),s[n]<t.virtualSize+s[0]&&e.push(o)}s.push(...e)}}}},function(e){let{swiper:t}=e;Object.assign(t,{appendSlide:I.bind(t),prependSlide:Q.bind(t),addSlide:Z.bind(t),removeSlide:J.bind(t),removeAllSlides:ee.bind(t)})},function(e){let{swiper:t,extendParams:n,on:s}=e;n({fadeEffect:{crossFade:!1,transformEl:null}}),l({effect:"fade",swiper:t,on:s,setTranslate:()=>{const{slides:e}=t,n=t.params.fadeEffect;for(let i=0;i<e.length;i+=1){const s=t.slides.eq(i);let o=-s[0].swiperSlideOffset;t.params.virtualTranslate||(o-=t.translate);let a=0;t.isHorizontal()||(a=o,o=0);const r=t.params.fadeEffect.crossFade?Math.max(1-Math.abs(s[0].progress),0):1+Math.min(Math.max(s[0].progress,-1),0);h(n,s).css({opacity:r}).transform(`translate3d(${o}px, ${a}px, 0px)`)}},setTransition:e=>{const{transformEl:n}=t.params.fadeEffect;(n?t.slides.find(n):t.slides).transition(e),p({swiper:t,duration:e,transformEl:n,allSlides:!0})},overwriteParams:()=>({slidesPerView:1,slidesPerGroup:1,watchSlidesProgress:!0,spaceBetween:0,virtualTranslate:!t.params.cssMode})})},function(t){let{swiper:n,extendParams:s,on:o}=t;s({cubeEffect:{slideShadows:!0,shadow:!0,shadowOffset:20,shadowScale:.94}}),l({effect:"cube",swiper:n,on:o,setTranslate:()=>{const{$el:m,$wrapperEl:r,slides:u,width:c,height:d,rtlTranslate:l,size:t,browser:h}=n,i=n.params.cubeEffect,o=n.isHorizontal(),f=n.virtual&&n.params.virtual.enabled;let s,a=0;i.shadow&&(o?(s=r.find(".swiper-cube-shadow"),0===s.length&&(s=e('<div class="swiper-cube-shadow"></div>'),r.append(s)),s.css({height:`${c}px`})):(s=m.find(".swiper-cube-shadow"),0===s.length&&(s=e('<div class="swiper-cube-shadow"></div>'),m.append(s))));for(let p=0;p<u.length;p+=1){const n=u.eq(p);let r=p;f&&(r=parseInt(n.attr("data-swiper-slide-index"),10));let c=90*r,h=Math.floor(c/360);l&&(c=-c,h=Math.floor(-c/360));const d=Math.max(Math.min(n[0].progress,1),-1);let s=0,g=0,m=0;r%4==0?(s=4*-h*t,m=0):(r-1)%4==0?(s=0,m=4*-h*t):(r-2)%4==0?(s=t+4*h*t,m=t):(r-3)%4==0&&(s=-t,m=3*t+4*t*h),l&&(s=-s),o||(g=s,s=0);const v=`rotateX(${o?0:-c}deg) rotateY(${o?c:0}deg) translate3d(${s}px, ${g}px, ${m}px)`;if(d<=1&&d>-1&&(a=90*r+90*d,l&&(a=90*-r-90*d)),n.transform(v),i.slideShadows){let t=o?n.find(".swiper-slide-shadow-left"):n.find(".swiper-slide-shadow-top"),s=o?n.find(".swiper-slide-shadow-right"):n.find(".swiper-slide-shadow-bottom");0===t.length&&(t=e(`<div class="swiper-slide-shadow-${o?"left":"top"}"></div>`),n.append(t)),0===s.length&&(s=e(`<div class="swiper-slide-shadow-${o?"right":"bottom"}"></div>`),n.append(s)),t.length&&(t[0].style.opacity=Math.max(-d,0)),s.length&&(s[0].style.opacity=Math.max(d,0))}}if(r.css({"-webkit-transform-origin":`50% 50% -${t/2}px`,"transform-origin":`50% 50% -${t/2}px`}),i.shadow)if(o)s.transform(`translate3d(0px, ${c/2+i.shadowOffset}px, ${-c/2}px) rotateX(90deg) rotateZ(0deg) scale(${i.shadowScale})`);else{const e=Math.abs(a)-90*Math.floor(Math.abs(a)/90),n=1.5-(Math.sin(2*e*Math.PI/360)/2+Math.cos(2*e*Math.PI/360)/2),o=i.shadowScale,t=i.shadowScale/n,r=i.shadowOffset;s.transform(`scale3d(${o}, 1, ${t}) translate3d(0px, ${d/2+r}px, ${-d/2/t}px) rotateX(-90deg)`)}const p=h.isSafari||h.isWebView?-t/2:0;r.transform(`translate3d(0px,0,${p}px) rotateX(${n.isHorizontal()?0:a}deg) rotateY(${n.isHorizontal()?-a:0}deg)`)},setTransition:e=>{const{$el:t,slides:s}=n;s.transition(e).find(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").transition(e),n.params.cubeEffect.shadow&&!n.isHorizontal()&&t.find(".swiper-cube-shadow").transition(e)},perspective:()=>!0,overwriteParams:()=>({slidesPerView:1,slidesPerGroup:1,watchSlidesProgress:!0,resistanceRatio:0,spaceBetween:0,centeredSlides:!1,virtualTranslate:!0})})},function(e){let{swiper:t,extendParams:n,on:s}=e;n({flipEffect:{slideShadows:!0,limitRotation:!0,transformEl:null}}),l({effect:"flip",swiper:t,on:s,setTranslate:()=>{const{slides:n,rtlTranslate:s}=t,e=t.params.flipEffect;for(let r=0;r<n.length;r+=1){const o=n.eq(r);let i=o[0].progress;t.params.flipEffect.limitRotation&&(i=Math.max(Math.min(o[0].progress,1),-1));const l=o[0].swiperSlideOffset;let a=-180*i,u=0,c=t.params.cssMode?-l-t.translate:-l,m=0;if(t.isHorizontal()?s&&(a=-a):(m=c,c=0,u=-a,a=0),o[0].style.zIndex=-Math.abs(Math.round(i))+n.length,e.slideShadows){let n=t.isHorizontal()?o.find(".swiper-slide-shadow-left"):o.find(".swiper-slide-shadow-top"),s=t.isHorizontal()?o.find(".swiper-slide-shadow-right"):o.find(".swiper-slide-shadow-bottom");0===n.length&&(n=d(e,o,t.isHorizontal()?"left":"top")),0===s.length&&(s=d(e,o,t.isHorizontal()?"right":"bottom")),n.length&&(n[0].style.opacity=Math.max(-i,0)),s.length&&(s[0].style.opacity=Math.max(i,0))}const f=`translate3d(${c}px, ${m}px, 0px) rotateX(${u}deg) rotateY(${a}deg)`;h(e,o).transform(f)}},setTransition:e=>{const{transformEl:n}=t.params.flipEffect;(n?t.slides.find(n):t.slides).transition(e).find(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").transition(e),p({swiper:t,duration:e,transformEl:n})},perspective:()=>!0,overwriteParams:()=>({slidesPerView:1,slidesPerGroup:1,watchSlidesProgress:!0,spaceBetween:0,virtualTranslate:!t.params.cssMode})})},function(e){let{swiper:t,extendParams:n,on:s}=e;n({coverflowEffect:{rotate:50,stretch:0,depth:100,scale:1,modifier:1,slideShadows:!0,transformEl:null}}),l({effect:"coverflow",swiper:t,on:s,setTranslate:()=>{const{width:a,height:r,slides:s,slidesSizesGrid:c}=t,e=t.params.coverflowEffect,n=t.isHorizontal(),o=t.translate,l=n?a/2-o:r/2-o,i=n?e.rotate:-e.rotate,u=e.depth;for(let r=0,_=s.length;r<_;r+=1){const o=s.eq(r),m=c[r],y=(l-o[0].swiperSlideOffset-m/2)/m,t="function"==typeof e.modifier?e.modifier(y):y*e.modifier;let f=n?i*t:0,p=n?0:i*t,g=-u*Math.abs(t),a=e.stretch;"string"==typeof a&&-1!==a.indexOf("%")&&(a=parseFloat(e.stretch)/100*m);let v=n?0:a*t,b=n?a*t:0,j=1-(1-e.scale)*Math.abs(t);Math.abs(b)<.001&&(b=0),Math.abs(v)<.001&&(v=0),Math.abs(g)<.001&&(g=0),Math.abs(f)<.001&&(f=0),Math.abs(p)<.001&&(p=0),Math.abs(j)<.001&&(j=0);const w=`translate3d(${b}px,${v}px,${g}px)  rotateX(${p}deg) rotateY(${f}deg) scale(${j})`;if(h(e,o).transform(w),o[0].style.zIndex=1-Math.abs(Math.round(t)),e.slideShadows){let s=n?o.find(".swiper-slide-shadow-left"):o.find(".swiper-slide-shadow-top"),i=n?o.find(".swiper-slide-shadow-right"):o.find(".swiper-slide-shadow-bottom");0===s.length&&(s=d(e,o,n?"left":"top")),0===i.length&&(i=d(e,o,n?"right":"bottom")),s.length&&(s[0].style.opacity=t>0?t:0),i.length&&(i[0].style.opacity=-t>0?-t:0)}}},setTransition:e=>{const{transformEl:n}=t.params.coverflowEffect;(n?t.slides.find(n):t.slides).transition(e).find(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").transition(e)},perspective:()=>!0,overwriteParams:()=>({watchSlidesProgress:!0})})},function(e){let{swiper:t,extendParams:n,on:s}=e;n({creativeEffect:{transformEl:null,limitProgress:1,shadowPerProgress:!1,progressMultiplier:1,perspective:!0,prev:{translate:[0,0,0],rotate:[0,0,0],opacity:1,scale:1},next:{translate:[0,0,0],rotate:[0,0,0],opacity:1,scale:1}}});const o=e=>"string"==typeof e?e:`${e}px`;l({effect:"creative",swiper:t,on:s,setTranslate:()=>{const{slides:s,$wrapperEl:a,slidesSizesGrid:r}=t,e=t.params.creativeEffect,{progressMultiplier:n}=e,i=t.params.centeredSlides;if(i){const e=r[0]/2-t.params.slidesOffsetBefore||0;a.transform(`translateX(calc(50% - ${e}px))`)}for(let p=0;p<s.length;p+=1){const r=s.eq(p),b=r[0].progress,c=Math.min(Math.max(r[0].progress,-e.limitProgress),e.limitProgress);let l=c;i||(l=Math.min(Math.max(r[0].originalProgress,-e.limitProgress),e.limitProgress));const g=r[0].swiperSlideOffset,u=[t.params.cssMode?-g-t.translate:-g,0,0],m=[0,0,0];let f=!1;t.isHorizontal()||(u[1]=u[0],u[0]=0);let a={translate:[0,0,0],rotate:[0,0,0],scale:1,opacity:1};c<0?(a=e.next,f=!0):c>0&&(a=e.prev,f=!0),u.forEach((e,t)=>{u[t]=`calc(${e}px + (${o(a.translate[t])} * ${Math.abs(c*n)}))`}),m.forEach((e,t)=>{m[t]=a.rotate[t]*Math.abs(c*n)}),r[0].style.zIndex=-Math.abs(Math.round(b))+s.length;const j=u.join(", "),y=`rotateX(${m[0]}deg) rotateY(${m[1]}deg) rotateZ(${m[2]}deg)`,_=l<0?`scale(${1+(1-a.scale)*l*n})`:`scale(${1-(1-a.scale)*l*n})`,w=l<0?1+(1-a.opacity)*l*n:1-(1-a.opacity)*l*n,O=`translate3d(${j}) ${y} ${_}`;if(f&&a.shadow||!f){let t=r.children(".swiper-slide-shadow");if(0===t.length&&a.shadow&&(t=d(e,r)),t.length){const n=e.shadowPerProgress?c*(1/e.limitProgress):c;t[0].style.opacity=Math.min(Math.max(Math.abs(n),0),1)}}const v=h(e,r);v.transform(O).css({opacity:w}),a.origin&&v.css("transform-origin",a.origin)}},setTransition:e=>{const{transformEl:n}=t.params.creativeEffect;(n?t.slides.find(n):t.slides).transition(e).find(".swiper-slide-shadow").transition(e),p({swiper:t,duration:e,transformEl:n,allSlides:!0})},perspective:()=>t.params.creativeEffect.perspective,overwriteParams:()=>({watchSlidesProgress:!0,virtualTranslate:!t.params.cssMode})})},function(e){let{swiper:t,extendParams:n,on:s}=e;n({cardsEffect:{slideShadows:!0,transformEl:null,rotate:!0}}),l({effect:"cards",swiper:t,on:s,setTranslate:()=>{const{slides:e,activeIndex:n}=t,s=t.params.cardsEffect,{startTranslate:o,isTouched:i}=t.touchEventsData,a=t.translate;for(let u=0;u<e.length;u+=1){const l=e.eq(u),j=l[0].progress,r=Math.min(Math.max(j,-4),4);let g=l[0].swiperSlideOffset;t.params.centeredSlides&&!t.params.cssMode&&t.$wrapperEl.transform(`translateX(${t.minTranslate()}px)`),t.params.centeredSlides&&t.params.cssMode&&(g-=e[0].swiperSlideOffset);let c=t.params.cssMode?-g-t.translate:-g,m=0;const y=-100*Math.abs(r);let p=1,b=-2*r,v=8-.75*Math.abs(r);const f=t.virtual&&t.params.virtual.enabled?t.virtual.from+u:u,_=(f===n||f===n-1)&&r>0&&r<1&&(i||t.params.cssMode)&&a<o,w=(f===n||f===n+1)&&r<0&&r>-1&&(i||t.params.cssMode)&&a>o;if(_||w){const e=(1-Math.abs((Math.abs(r)-.5)/.5))**.5;b+=-28*r*e,p+=-.5*e,v+=96*e,m=-25*e*Math.abs(r)+"%"}if(c=r<0?`calc(${c}px + (${v*Math.abs(r)}%))`:r>0?`calc(${c}px + (-${v*Math.abs(r)}%))`:`${c}px`,!t.isHorizontal()){const e=m;m=c,c=e}const O=r<0?""+(1+(1-p)*r):""+(1-(1-p)*r),x=`
        translate3d(${c}, ${m}, ${y}px)
        rotateZ(${s.rotate?b:0}deg)
        scale(${O})
      `;if(s.slideShadows){let e=l.find(".swiper-slide-shadow");0===e.length&&(e=d(s,l)),e.length&&(e[0].style.opacity=Math.min(Math.max((Math.abs(r)-.5)/.5,0),1))}l[0].style.zIndex=-Math.abs(Math.round(j))+e.length,h(s,l).transform(x)}},setTransition:e=>{const{transformEl:n}=t.params.cardsEffect;(n?t.slides.find(n):t.slides).transition(e).find(".swiper-slide-shadow").transition(e),p({swiper:t,duration:e,transformEl:n})},perspective:()=>!0,overwriteParams:()=>({watchSlidesProgress:!0,virtualTranslate:!t.params.cssMode})})}];return i.use(Y),i})