@ozdao/prometheus-framework 0.2.198 → 0.2.200

package/dist/node_modules/embla-carousel/esm/embla-carousel.esm.cjs

@@ -1 +1,1612 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});function Et(t){return typeof t=="number"}function xt(t){return typeof t=="string"}function It(t){return typeof t=="boolean"}function Vt(t){return Object.prototype.toString.call(t)==="[object Object]"}function P(t){return Math.abs(t)}function Tt(t){return Math.sign(t)}function ut(t,n){return P(t-n)}function Kt(t,n){if(t===0||n===0||P(t)<=P(n))return 0;const r=ut(P(t),P(n));return P(r/t)}function ft(t){return at(t).map(Number)}function H(t){return t[dt(t)]}function dt(t){return Math.max(0,t.length-1)}function vt(t,n){return n===dt(t)}function zt(t,n=0){return Array.from(Array(t),(r,s)=>n+s)}function at(t){return Object.keys(t)}function Bt(t,n){return[t,n].reduce((r,s)=>(at(s).forEach(c=>{const o=r[c],e=s[c],f=Vt(o)&&Vt(e);r[c]=f?Bt(o,e):e}),r),{})}function Lt(t,n){return typeof n.MouseEvent<"u"&&t instanceof n.MouseEvent}function Xt(t,n){const r={start:s,center:c,end:o};function s(){return 0}function c(i){return o(i)/2}function o(i){return n-i}function e(i,u){return xt(t)?r[t](i):t(n,i,u)}return{measure:e}}function lt(){let t=[];function n(c,o,e,f={passive:!0}){let i;if("addEventListener"in c)c.addEventListener(o,e,f),i=()=>c.removeEventListener(o,e,f);else{const u=c;u.addListener(e),i=()=>u.removeListener(e)}return t.push(i),s}function r(){t=t.filter(c=>c())}const s={add:n,clear:r};return s}function Yt(t,n,r,s){const c=lt(),o=1e3/60;let e=null,f=0,i=0;function u(){c.add(t,"visibilitychange",()=>{t.hidden&&d()})}function h(){x(),c.clear()}function l(g){if(!i)return;e||(e=g);const a=g-e;for(e=g,f+=a;f>=o;)r(o),f-=o;const S=f/o;s(S),i&&n.requestAnimationFrame(l)}function p(){i||(i=n.requestAnimationFrame(l))}function x(){n.cancelAnimationFrame(i),e=null,f=0,i=0}function d(){e=null,f=0}return{init:u,destroy:h,start:p,stop:x,update:()=>r(o),render:s}}function Jt(t,n){const r=n==="rtl",s=t==="y",c=s?"y":"x",o=s?"x":"y",e=!s&&r?-1:1,f=h(),i=l();function u(d){const{height:m,width:g}=d;return s?m:g}function h(){return s?"top":r?"right":"left"}function l(){return s?"bottom":r?"left":"right"}function p(d){return d*e}return{scroll:c,cross:o,startEdge:f,endEdge:i,measureSize:u,direction:p}}function nt(t=0,n=0){const r=P(t-n);function s(u){return u<t}function c(u){return u>n}function o(u){return s(u)||c(u)}function e(u){return o(u)?s(u)?t:n:u}function f(u){return r?u-r*Math.ceil((u-n)/r):u}return{length:r,max:n,min:t,constrain:e,reachedAny:o,reachedMax:c,reachedMin:s,removeOffset:f}}function kt(t,n,r){const{constrain:s}=nt(0,t),c=t+1;let o=e(n);function e(p){return r?P((c+p)%c):s(p)}function f(){return o}function i(p){return o=e(p),l}function u(p){return h().set(f()+p)}function h(){return kt(t,f(),r)}const l={get:f,set:i,add:u,clone:h};return l}function Zt(t,n,r,s,c,o,e,f,i,u,h,l,p,x,d,m,g,a,S){const{cross:b,direction:T}=t,A=["INPUT","SELECT","TEXTAREA"],v={passive:!1},L=lt(),E=lt(),I=nt(50,225).constrain(x.measure(20)),D={mouse:300,touch:400},F={mouse:500,touch:600},V=d?43:25;let Y=!1,B=0,q=0,W=!1,U=!1,J=!1,$=!1;function tt(y){if(!S)return;function M(w){(It(S)||S(y,w))&&z(w)}const C=n;L.add(C,"dragstart",w=>w.preventDefault(),v).add(C,"touchmove",()=>{},v).add(C,"touchend",()=>{}).add(C,"touchstart",M).add(C,"mousedown",M).add(C,"touchcancel",N).add(C,"contextmenu",N).add(C,"click",ot,!0)}function Q(){L.clear(),E.clear()}function et(){const y=$?r:n;E.add(y,"touchmove",G,v).add(y,"touchend",N).add(y,"mousemove",G,v).add(y,"mouseup",N)}function _(y){const M=y.nodeName||"";return A.includes(M)}function st(){return(d?F:D)[$?"mouse":"touch"]}function rt(y,M){const C=l.add(Tt(y)*-1),w=h.byDistance(y,!d).distance;return d||P(y)<I?w:g&&M?w*.5:h.byIndex(C.get(),0).distance}function z(y){const M=Lt(y,s);$=M,J=d&&M&&!y.buttons&&Y,Y=ut(c.get(),e.get())>=2,!(M&&y.button!==0)&&(_(y.target)||(W=!0,o.pointerDown(y),u.useFriction(0).useDuration(0),c.set(e),et(),B=o.readPoint(y),q=o.readPoint(y,b),p.emit("pointerDown")))}function G(y){if(!Lt(y,s)&&y.touches.length>=2)return N(y);const C=o.readPoint(y),w=o.readPoint(y,b),j=ut(C,B),K=ut(w,q);if(!U&&!$&&(!y.cancelable||(U=j>K,!U)))return N(y);const R=o.pointerMove(y);j>m&&(J=!0),u.useFriction(.3).useDuration(.75),f.start(),c.add(T(R)),y.preventDefault()}function N(y){const C=h.byDistance(0,!1).index!==l.get(),w=o.pointerUp(y)*st(),j=rt(T(w),C),K=Kt(w,j),R=V-10*K,X=a+K/50;U=!1,W=!1,E.clear(),u.useDuration(R).useFriction(X),i.distance(j,!d),$=!1,p.emit("pointerUp")}function ot(y){J&&(y.stopPropagation(),y.preventDefault(),J=!1)}function k(){return W}return{init:tt,destroy:Q,pointerDown:k}}function Wt(t,n){let s,c;function o(l){return l.timeStamp}function e(l,p){const d=`client${(p||t.scroll)==="x"?"X":"Y"}`;return(Lt(l,n)?l:l.touches[0])[d]}function f(l){return s=l,c=l,e(l)}function i(l){const p=e(l)-e(c),x=o(l)-o(s)>170;return c=l,x&&(s=l),p}function u(l){if(!s||!c)return 0;const p=e(c)-e(s),x=o(l)-o(s),d=o(l)-o(c)>170,m=p/x;return x&&!d&&P(m)>.1?m:0}return{pointerDown:f,pointerMove:i,pointerUp:u,readPoint:e}}function tn(){function t(r){const{offsetTop:s,offsetLeft:c,offsetWidth:o,offsetHeight:e}=r;return{top:s,right:c+o,bottom:s+e,left:c,width:o,height:e}}return{measure:t}}function nn(t){function n(s){return t*(s/100)}return{measure:n}}function en(t,n,r,s,c,o,e){const f=[t].concat(s);let i,u,h=[],l=!1;function p(g){return c.measureSize(e.measure(g))}function x(g){if(!o)return;u=p(t),h=s.map(p);function a(S){for(const b of S){if(l)return;const T=b.target===t,A=s.indexOf(b.target),v=T?u:h[A],L=p(T?t:s[A]);if(P(L-v)>=.5){g.reInit(),n.emit("resize");break}}}i=new ResizeObserver(S=>{(It(o)||o(g,S))&&a(S)}),r.requestAnimationFrame(()=>{f.forEach(S=>i.observe(S))})}function d(){l=!0,i&&i.disconnect()}return{init:x,destroy:d}}function on(t,n,r,s,c,o){let e=0,f=0,i=c,u=o,h=t.get(),l=0;function p(v){const L=v/1e3,E=i*L,I=s.get()-t.get(),D=!i;let F=0;return D?(e=0,r.set(s),t.set(s),F=I):(r.set(t),e+=I/E,e*=u,h+=e,t.add(e*L),F=h-l),f=Tt(F),l=h,A}function x(){const v=s.get()-n.get();return P(v)<.001}function d(){return i}function m(){return f}function g(){return e}function a(){return b(c)}function S(){return T(o)}function b(v){return i=v,A}function T(v){return u=v,A}const A={direction:m,duration:d,velocity:g,seek:p,settled:x,useBaseFriction:S,useBaseDuration:a,useFriction:T,useDuration:b};return A}function sn(t,n,r,s,c){const o=c.measure(10),e=c.measure(50),f=nt(.1,.99);let i=!1;function u(){return!(i||!t.reachedAny(r.get())||!t.reachedAny(n.get()))}function h(x){if(!u())return;const d=t.reachedMin(n.get())?"min":"max",m=P(t[d]-n.get()),g=r.get()-n.get(),a=f.constrain(m/e);r.subtract(g*a),!x&&P(g)<o&&(r.set(t.constrain(r.get())),s.useDuration(25).useBaseFriction())}function l(x){i=!x}return{shouldConstrain:u,constrain:h,toggleActive:l}}function rn(t,n,r,s,c){const o=nt(-n+t,0),e=l(),f=h(),i=p();function u(d,m){return ut(d,m)<1}function h(){const d=e[0],m=H(e),g=e.lastIndexOf(d),a=e.indexOf(m)+1;return nt(g,a)}function l(){return r.map((d,m)=>{const{min:g,max:a}=o,S=o.constrain(d),b=!m,T=vt(r,m);return b?a:T||u(g,S)?g:u(a,S)?a:S}).map(d=>parseFloat(d.toFixed(3)))}function p(){if(n<=t+c)return[o.max];if(s==="keepSnaps")return e;const{min:d,max:m}=f;return e.slice(d,m)}return{snapsContained:i,scrollContainLimit:f}}function cn(t,n,r){const s=n[0],c=r?s-t:H(n);return{limit:nt(c,s)}}function un(t,n,r,s){const o=n.min+.1,e=n.max+.1,{reachedMin:f,reachedMax:i}=nt(o,e);function u(p){return p===1?i(r.get()):p===-1?f(r.get()):!1}function h(p){if(!u(p))return;const x=t*(p*-1);s.forEach(d=>d.add(x))}return{loop:h}}function fn(t){const{max:n,length:r}=t;function s(o){const e=o-n;return r?e/-r:0}return{get:s}}function an(t,n,r,s,c){const{startEdge:o,endEdge:e}=t,{groupSlides:f}=c,i=l().map(n.measure),u=p(),h=x();function l(){return f(s).map(m=>H(m)[e]-m[0][o]).map(P)}function p(){return s.map(m=>r[o]-m[o]).map(m=>-P(m))}function x(){return f(u).map(m=>m[0]).map((m,g)=>m+i[g])}return{snaps:u,snapsAligned:h}}function ln(t,n,r,s,c,o){const{groupSlides:e}=c,{min:f,max:i}=s,u=h();function h(){const p=e(o),x=!t||n==="keepSnaps";return r.length===1?[o]:x?p:p.slice(f,i).map((d,m,g)=>{const a=!m,S=vt(g,m);if(a){const b=H(g[0])+1;return zt(b)}if(S){const b=dt(o)-H(g)[0]+1;return zt(b,H(g)[0])}return d})}return{slideRegistry:u}}function dn(t,n,r,s,c){const{reachedAny:o,removeOffset:e,constrain:f}=s;function i(d){return d.concat().sort((m,g)=>P(m)-P(g))[0]}function u(d){const m=t?e(d):f(d),g=n.map((S,b)=>({diff:h(S-m,0),index:b})).sort((S,b)=>P(S.diff)-P(b.diff)),{index:a}=g[0];return{index:a,distance:m}}function h(d,m){const g=[d,d+r,d-r];if(!t)return d;if(!m)return i(g);const a=g.filter(S=>Tt(S)===m);return a.length?i(a):H(g)-r}function l(d,m){const g=n[d]-c.get(),a=h(g,m);return{index:d,distance:a}}function p(d,m){const g=c.get()+d,{index:a,distance:S}=u(g),b=!t&&o(g);if(!m||b)return{index:a,distance:d};const T=n[a]-S,A=d+h(T,0);return{index:a,distance:A}}return{byDistance:p,byIndex:l,shortcut:h}}function pn(t,n,r,s,c,o,e){function f(l){const p=l.distance,x=l.index!==n.get();o.add(p),p&&(s.duration()?t.start():(t.update(),t.render(1),t.update())),x&&(r.set(n.get()),n.set(l.index),e.emit("select"))}function i(l,p){const x=c.byDistance(l,p);f(x)}function u(l,p){const x=n.clone().set(l),d=c.byIndex(x.get(),p);f(d)}return{distance:i,index:u}}function mn(t,n,r,s,c,o,e){let f=0;function i(){o.add(document,"keydown",u,!1),n.forEach(h)}function u(p){p.code==="Tab"&&(f=new Date().getTime())}function h(p){const x=()=>{if(new Date().getTime()-f>10)return;t.scrollLeft=0;const g=n.indexOf(p),a=r.findIndex(S=>S.includes(g));Et(a)&&(c.useDuration(0),s.index(a,0),e.emit("slideFocus"))};o.add(p,"focus",x,{passive:!0,capture:!0})}return{init:i}}function ct(t){let n=t;function r(){return n}function s(i){n=e(i)}function c(i){n+=e(i)}function o(i){n-=e(i)}function e(i){return Et(i)?i:i.get()}return{get:r,set:s,add:c,subtract:o}}function Ht(t,n){const r=t.scroll==="x"?o:e,s=n.style;let c=!1;function o(l){return`translate3d(${l}px,0px,0px)`}function e(l){return`translate3d(0px,${l}px,0px)`}function f(l){c||(s.transform=r(t.direction(l)))}function i(l){c=!l}function u(){c||(s.transform="",n.getAttribute("style")||n.removeAttribute("style"))}return{clear:u,to:f,toggleActive:i}}function gn(t,n,r,s,c,o,e,f,i){const h=ft(c),l=ft(c).reverse(),p=a().concat(S());function x(L,E){return L.reduce((I,D)=>I-c[D],E)}function d(L,E){return L.reduce((I,D)=>x(I,E)>0?I.concat([D]):I,[])}function m(L){return o.map((E,I)=>({start:E-s[I]+.5+L,end:E+n-.5+L}))}function g(L,E,I){const D=m(E);return L.map(F=>{const V=I?0:-r,Y=I?r:0,B=I?"end":"start",q=D[F][B];return{index:F,loopPoint:q,slideLocation:ct(-1),translate:Ht(t,i[F]),target:()=>f.get()>q?V:Y}})}function a(){const L=e[0],E=d(l,L);return g(E,r,!1)}function S(){const L=n-e[0]-1,E=d(h,L);return g(E,-r,!0)}function b(){return p.every(({index:L})=>{const E=h.filter(I=>I!==L);return x(E,n)<=.1})}function T(){p.forEach(L=>{const{target:E,translate:I,slideLocation:D}=L,F=E();F!==D.get()&&(I.to(F),D.set(F))})}function A(){p.forEach(L=>L.translate.clear())}return{canLoop:b,clear:A,loop:T,loopPoints:p}}function hn(t,n,r){let s,c=!1;function o(i){if(!r)return;function u(h){for(const l of h)if(l.type==="childList"){i.reInit(),n.emit("slidesChanged");break}}s=new MutationObserver(h=>{c||(It(r)||r(i,h))&&u(h)}),s.observe(t,{childList:!0})}function e(){s&&s.disconnect(),c=!0}return{init:o,destroy:e}}function Sn(t,n,r,s){const c={};let o=null,e=null,f,i=!1;function u(){f=new IntersectionObserver(d=>{i||(d.forEach(m=>{const g=n.indexOf(m.target);c[g]=m}),o=null,e=null,r.emit("slidesInView"))},{root:t.parentElement,threshold:s}),n.forEach(d=>f.observe(d))}function h(){f&&f.disconnect(),i=!0}function l(d){return at(c).reduce((m,g)=>{const a=parseInt(g),{isIntersecting:S}=c[a];return(d&&S||!d&&!S)&&m.push(a),m},[])}function p(d=!0){if(d&&o)return o;if(!d&&e)return e;const m=l(d);return d&&(o=m),d||(e=m),m}return{init:u,destroy:h,get:p}}function yn(t,n,r,s,c,o){const{measureSize:e,startEdge:f,endEdge:i}=t,u=r[0]&&c,h=d(),l=m(),p=r.map(e),x=g();function d(){if(!u)return 0;const S=r[0];return P(n[f]-S[f])}function m(){if(!u)return 0;const S=o.getComputedStyle(H(s));return parseFloat(S.getPropertyValue(`margin-${i}`))}function g(){return r.map((S,b,T)=>{const A=!b,v=vt(T,b);return A?p[b]+h:v?p[b]+l:T[b+1][f]-S[f]}).map(P)}return{slideSizes:p,slideSizesWithGaps:x,startGap:h,endGap:l}}function bn(t,n,r,s,c,o,e,f,i){const{startEdge:u,endEdge:h,direction:l}=t,p=Et(r);function x(a,S){return ft(a).filter(b=>b%S===0).map(b=>a.slice(b,b+S))}function d(a){return a.length?ft(a).reduce((S,b,T)=>{const A=H(S)||0,v=A===0,L=b===dt(a),E=c[u]-o[A][u],I=c[u]-o[b][h],D=!s&&v?l(e):0,F=!s&&L?l(f):0,V=P(I-F-(E+D));return T&&V>n+i&&S.push(b),L&&S.push(a.length),S},[]).map((S,b,T)=>{const A=Math.max(T[b-1]||0);return a.slice(A,S)}):[]}function m(a){return p?x(a,r):d(a)}return{groupSlides:m}}function xn(t,n,r,s,c,o,e){const{align:f,axis:i,direction:u,startIndex:h,loop:l,duration:p,dragFree:x,dragThreshold:d,inViewThreshold:m,slidesToScroll:g,skipSnaps:a,containScroll:S,watchResize:b,watchSlides:T,watchDrag:A}=o,v=2,L=tn(),E=L.measure(n),I=r.map(L.measure),D=Jt(i,u),F=D.measureSize(E),V=nn(F),Y=Xt(f,F),B=!l&&!!S,q=l||!!S,{slideSizes:W,slideSizesWithGaps:U,startGap:J,endGap:$}=yn(D,E,I,r,q,c),tt=bn(D,F,g,l,E,I,J,$,v),{snaps:Q,snapsAligned:et}=an(D,Y,E,I,tt),_=-H(Q)+H(U),{snapsContained:st,scrollContainLimit:rt}=rn(F,_,et,S,v),z=B?st:et,{limit:G}=cn(_,z,l),N=kt(dt(z),h,l),ot=N.clone(),k=ft(r),O=({dragHandler:Z,scrollBody:St,scrollBounds:yt,options:{loop:pt}},bt)=>{pt||yt.constrain(Z.pointerDown()),St.seek(bt)},y=({scrollBody:Z,translate:St,location:yt,offsetLocation:pt,scrollLooper:bt,slideLooper:Rt,dragHandler:qt,animation:Ut,eventHandler:Pt,scrollBounds:$t,options:{loop:Ot}},Ct)=>{const wt=Z.settled(),Qt=!$t.shouldConstrain(),Nt=Ot?wt:wt&&Qt;Nt&&!qt.pointerDown()&&(Ut.stop(),Pt.emit("settle")),Nt||Pt.emit("scroll");const _t=yt.get()*Ct+K.get()*(1-Ct);pt.set(_t),Ot&&(bt.loop(Z.direction()),Rt.loop()),St.to(pt.get())},M=Yt(s,c,Z=>O(ht,Z),Z=>y(ht,Z)),C=.68,w=z[N.get()],j=ct(w),K=ct(w),R=ct(w),X=ct(w),it=on(j,R,K,X,p,C),mt=dn(l,z,_,G,X),gt=pn(M,N,ot,it,mt,X,e),Mt=fn(G),At=lt(),Gt=Sn(n,r,e,m),{slideRegistry:Ft}=ln(B,S,z,rt,tt,k),jt=mn(t,r,Ft,gt,it,At,e),ht={ownerDocument:s,ownerWindow:c,eventHandler:e,containerRect:E,slideRects:I,animation:M,axis:D,dragHandler:Zt(D,t,s,c,X,Wt(D,c),j,M,gt,it,mt,N,e,V,x,d,a,C,A),eventStore:At,percentOfView:V,index:N,indexPrevious:ot,limit:G,location:j,offsetLocation:R,previousLocation:K,options:o,resizeHandler:en(n,e,c,r,D,b,L),scrollBody:it,scrollBounds:sn(G,R,X,it,V),scrollLooper:un(_,G,R,[j,R,K,X]),scrollProgress:Mt,scrollSnapList:z.map(Mt.get),scrollSnaps:z,scrollTarget:mt,scrollTo:gt,slideLooper:gn(D,F,_,W,U,Q,z,R,r),slideFocus:jt,slidesHandler:hn(n,e,T),slidesInView:Gt,slideIndexes:k,slideRegistry:Ft,slidesToScroll:tt,target:X,translate:Ht(D,n)};return ht}function Ln(){let t={},n;function r(u){n=u}function s(u){return t[u]||[]}function c(u){return s(u).forEach(h=>h(n,u)),i}function o(u,h){return t[u]=s(u).concat([h]),i}function e(u,h){return t[u]=s(u).filter(l=>l!==h),i}function f(){t={}}const i={init:r,emit:c,off:e,on:o,clear:f};return i}const En={align:"center",axis:"x",container:null,slides:null,containScroll:"trimSnaps",direction:"ltr",slidesToScroll:1,inViewThreshold:0,breakpoints:{},dragFree:!1,dragThreshold:10,loop:!1,skipSnaps:!1,duration:25,startIndex:0,active:!0,watchDrag:!0,watchResize:!0,watchSlides:!0};function In(t){function n(o,e){return Bt(o,e||{})}function r(o){const e=o.breakpoints||{},f=at(e).filter(i=>t.matchMedia(i).matches).map(i=>e[i]).reduce((i,u)=>n(i,u),{});return n(o,f)}function s(o){return o.map(e=>at(e.breakpoints||{})).reduce((e,f)=>e.concat(f),[]).map(t.matchMedia)}return{mergeOptions:n,optionsAtMedia:r,optionsMediaQueries:s}}function Tn(t){let n=[];function r(o,e){return n=e.filter(({options:f})=>t.optionsAtMedia(f).active!==!1),n.forEach(f=>f.init(o,t)),e.reduce((f,i)=>Object.assign(f,{[i.name]:i}),{})}function s(){n=n.filter(o=>o.destroy())}return{init:r,destroy:s}}function Dt(t,n,r){const s=t.ownerDocument,c=s.defaultView,o=In(c),e=Tn(o),f=lt(),i=Ln(),{mergeOptions:u,optionsAtMedia:h,optionsMediaQueries:l}=o,{on:p,off:x,emit:d}=i,m=F;let g=!1,a,S=u(En,Dt.globalOptions),b=u(S),T=[],A,v,L;function E(){const{container:O,slides:y}=b;v=(xt(O)?t.querySelector(O):O)||t.children[0];const C=xt(y)?v.querySelectorAll(y):y;L=[].slice.call(C||v.children)}function I(O){const y=xn(t,v,L,s,c,O,i);if(O.loop&&!y.slideLooper.canLoop()){const M=Object.assign({},O,{loop:!1});return I(M)}return y}function D(O,y){g||(S=u(S,O),b=h(S),T=y||T,E(),a=I(b),l([S,...T.map(({options:M})=>M)]).forEach(M=>f.add(M,"change",F)),b.active&&(a.translate.to(a.location.get()),a.animation.init(),a.slidesInView.init(),a.slideFocus.init(),a.eventHandler.init(k),a.resizeHandler.init(k),a.slidesHandler.init(k),a.options.loop&&a.slideLooper.loop(),v.offsetParent&&L.length&&a.dragHandler.init(k),A=e.init(k,T)))}function F(O,y){const M=Q();V(),D(u({startIndex:M},O),y),i.emit("reInit")}function V(){a.dragHandler.destroy(),a.eventStore.clear(),a.translate.clear(),a.slideLooper.clear(),a.resizeHandler.destroy(),a.slidesHandler.destroy(),a.slidesInView.destroy(),a.animation.destroy(),e.destroy(),f.clear()}function Y(){g||(g=!0,f.clear(),V(),i.emit("destroy"),i.clear())}function B(O,y,M){!b.active||g||(a.scrollBody.useBaseFriction().useDuration(y===!0?0:b.duration),a.scrollTo.index(O,M||0))}function q(O){const y=a.index.add(1).get();B(y,O,-1)}function W(O){const y=a.index.add(-1).get();B(y,O,1)}function U(){return a.index.add(1).get()!==Q()}function J(){return a.index.add(-1).get()!==Q()}function $(){return a.scrollSnapList}function tt(){return a.scrollProgress.get(a.location.get())}function Q(){return a.index.get()}function et(){return a.indexPrevious.get()}function _(){return a.slidesInView.get()}function st(){return a.slidesInView.get(!1)}function rt(){return A}function z(){return a}function G(){return t}function N(){return v}function ot(){return L}const k={canScrollNext:U,canScrollPrev:J,containerNode:N,internalEngine:z,destroy:Y,off:x,on:p,emit:d,plugins:rt,previousScrollSnap:et,reInit:m,rootNode:G,scrollNext:q,scrollPrev:W,scrollProgress:tt,scrollSnapList:$,scrollTo:B,selectedScrollSnap:Q,slideNodes:ot,slidesInView:_,slidesNotInView:st};return D(n,r),setTimeout(()=>i.emit("init"),0),k}Dt.globalOptions=void 0;exports.default=Dt;
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function isNumber(subject) {
+  return typeof subject === "number";
+}
+function isString(subject) {
+  return typeof subject === "string";
+}
+function isBoolean(subject) {
+  return typeof subject === "boolean";
+}
+function isObject(subject) {
+  return Object.prototype.toString.call(subject) === "[object Object]";
+}
+function mathAbs(n) {
+  return Math.abs(n);
+}
+function mathSign(n) {
+  return Math.sign(n);
+}
+function deltaAbs(valueB, valueA) {
+  return mathAbs(valueB - valueA);
+}
+function factorAbs(valueB, valueA) {
+  if (valueB === 0 || valueA === 0) return 0;
+  if (mathAbs(valueB) <= mathAbs(valueA)) return 0;
+  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA));
+  return mathAbs(diff / valueB);
+}
+function arrayKeys(array) {
+  return objectKeys(array).map(Number);
+}
+function arrayLast(array) {
+  return array[arrayLastIndex(array)];
+}
+function arrayLastIndex(array) {
+  return Math.max(0, array.length - 1);
+}
+function arrayIsLastIndex(array, index) {
+  return index === arrayLastIndex(array);
+}
+function arrayFromNumber(n, startAt = 0) {
+  return Array.from(Array(n), (_, i) => startAt + i);
+}
+function objectKeys(object) {
+  return Object.keys(object);
+}
+function objectsMergeDeep(objectA, objectB) {
+  return [objectA, objectB].reduce((mergedObjects, currentObject) => {
+    objectKeys(currentObject).forEach((key) => {
+      const valueA = mergedObjects[key];
+      const valueB = currentObject[key];
+      const areObjects = isObject(valueA) && isObject(valueB);
+      mergedObjects[key] = areObjects ? objectsMergeDeep(valueA, valueB) : valueB;
+    });
+    return mergedObjects;
+  }, {});
+}
+function isMouseEvent(evt, ownerWindow) {
+  return typeof ownerWindow.MouseEvent !== "undefined" && evt instanceof ownerWindow.MouseEvent;
+}
+function Alignment(align, viewSize) {
+  const predefined = {
+    start,
+    center,
+    end
+  };
+  function start() {
+    return 0;
+  }
+  function center(n) {
+    return end(n) / 2;
+  }
+  function end(n) {
+    return viewSize - n;
+  }
+  function measure(n, index) {
+    if (isString(align)) return predefined[align](n);
+    return align(viewSize, n, index);
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function EventStore() {
+  let listeners = [];
+  function add(node, type, handler, options = {
+    passive: true
+  }) {
+    let removeListener;
+    if ("addEventListener" in node) {
+      node.addEventListener(type, handler, options);
+      removeListener = () => node.removeEventListener(type, handler, options);
+    } else {
+      const legacyMediaQueryList = node;
+      legacyMediaQueryList.addListener(handler);
+      removeListener = () => legacyMediaQueryList.removeListener(handler);
+    }
+    listeners.push(removeListener);
+    return self;
+  }
+  function clear() {
+    listeners = listeners.filter((remove) => remove());
+  }
+  const self = {
+    add,
+    clear
+  };
+  return self;
+}
+function Animations(ownerDocument, ownerWindow, update, render) {
+  const documentVisibleHandler = EventStore();
+  const timeStep = 1e3 / 60;
+  let lastTimeStamp = null;
+  let lag = 0;
+  let animationFrame = 0;
+  function init() {
+    documentVisibleHandler.add(ownerDocument, "visibilitychange", () => {
+      if (ownerDocument.hidden) reset();
+    });
+  }
+  function destroy() {
+    stop();
+    documentVisibleHandler.clear();
+  }
+  function animate(timeStamp) {
+    if (!animationFrame) return;
+    if (!lastTimeStamp) lastTimeStamp = timeStamp;
+    const elapsed = timeStamp - lastTimeStamp;
+    lastTimeStamp = timeStamp;
+    lag += elapsed;
+    while (lag >= timeStep) {
+      update(timeStep);
+      lag -= timeStep;
+    }
+    const lagOffset = lag / timeStep;
+    render(lagOffset);
+    if (animationFrame) ownerWindow.requestAnimationFrame(animate);
+  }
+  function start() {
+    if (animationFrame) return;
+    animationFrame = ownerWindow.requestAnimationFrame(animate);
+  }
+  function stop() {
+    ownerWindow.cancelAnimationFrame(animationFrame);
+    lastTimeStamp = null;
+    lag = 0;
+    animationFrame = 0;
+  }
+  function reset() {
+    lastTimeStamp = null;
+    lag = 0;
+  }
+  const self = {
+    init,
+    destroy,
+    start,
+    stop,
+    update: () => update(timeStep),
+    render
+  };
+  return self;
+}
+function Axis(axis, contentDirection) {
+  const isRightToLeft = contentDirection === "rtl";
+  const isVertical = axis === "y";
+  const scroll = isVertical ? "y" : "x";
+  const cross = isVertical ? "x" : "y";
+  const sign = !isVertical && isRightToLeft ? -1 : 1;
+  const startEdge = getStartEdge();
+  const endEdge = getEndEdge();
+  function measureSize(nodeRect) {
+    const {
+      height,
+      width
+    } = nodeRect;
+    return isVertical ? height : width;
+  }
+  function getStartEdge() {
+    if (isVertical) return "top";
+    return isRightToLeft ? "right" : "left";
+  }
+  function getEndEdge() {
+    if (isVertical) return "bottom";
+    return isRightToLeft ? "left" : "right";
+  }
+  function direction(n) {
+    return n * sign;
+  }
+  const self = {
+    scroll,
+    cross,
+    startEdge,
+    endEdge,
+    measureSize,
+    direction
+  };
+  return self;
+}
+function Limit(min = 0, max = 0) {
+  const length = mathAbs(min - max);
+  function reachedMin(n) {
+    return n < min;
+  }
+  function reachedMax(n) {
+    return n > max;
+  }
+  function reachedAny(n) {
+    return reachedMin(n) || reachedMax(n);
+  }
+  function constrain(n) {
+    if (!reachedAny(n)) return n;
+    return reachedMin(n) ? min : max;
+  }
+  function removeOffset(n) {
+    if (!length) return n;
+    return n - length * Math.ceil((n - max) / length);
+  }
+  const self = {
+    length,
+    max,
+    min,
+    constrain,
+    reachedAny,
+    reachedMax,
+    reachedMin,
+    removeOffset
+  };
+  return self;
+}
+function Counter(max, start, loop) {
+  const {
+    constrain
+  } = Limit(0, max);
+  const loopEnd = max + 1;
+  let counter = withinLimit(start);
+  function withinLimit(n) {
+    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd);
+  }
+  function get() {
+    return counter;
+  }
+  function set(n) {
+    counter = withinLimit(n);
+    return self;
+  }
+  function add(n) {
+    return clone().set(get() + n);
+  }
+  function clone() {
+    return Counter(max, get(), loop);
+  }
+  const self = {
+    get,
+    set,
+    add,
+    clone
+  };
+  return self;
+}
+function DragHandler(axis, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction, watchDrag) {
+  const {
+    cross: crossAxis,
+    direction
+  } = axis;
+  const focusNodes = ["INPUT", "SELECT", "TEXTAREA"];
+  const nonPassiveEvent = {
+    passive: false
+  };
+  const initEvents = EventStore();
+  const dragEvents = EventStore();
+  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20));
+  const snapForceBoost = {
+    mouse: 300,
+    touch: 400
+  };
+  const freeForceBoost = {
+    mouse: 500,
+    touch: 600
+  };
+  const baseSpeed = dragFree ? 43 : 25;
+  let isMoving = false;
+  let startScroll = 0;
+  let startCross = 0;
+  let pointerIsDown = false;
+  let preventScroll = false;
+  let preventClick = false;
+  let isMouse = false;
+  function init(emblaApi) {
+    if (!watchDrag) return;
+    function downIfAllowed(evt) {
+      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt);
+    }
+    const node = rootNode;
+    initEvents.add(node, "dragstart", (evt) => evt.preventDefault(), nonPassiveEvent).add(node, "touchmove", () => void 0, nonPassiveEvent).add(node, "touchend", () => void 0).add(node, "touchstart", downIfAllowed).add(node, "mousedown", downIfAllowed).add(node, "touchcancel", up).add(node, "contextmenu", up).add(node, "click", click, true);
+  }
+  function destroy() {
+    initEvents.clear();
+    dragEvents.clear();
+  }
+  function addDragEvents() {
+    const node = isMouse ? ownerDocument : rootNode;
+    dragEvents.add(node, "touchmove", move, nonPassiveEvent).add(node, "touchend", up).add(node, "mousemove", move, nonPassiveEvent).add(node, "mouseup", up);
+  }
+  function isFocusNode(node) {
+    const nodeName = node.nodeName || "";
+    return focusNodes.includes(nodeName);
+  }
+  function forceBoost() {
+    const boost = dragFree ? freeForceBoost : snapForceBoost;
+    const type = isMouse ? "mouse" : "touch";
+    return boost[type];
+  }
+  function allowedForce(force, targetChanged) {
+    const next = index.add(mathSign(force) * -1);
+    const baseForce = scrollTarget.byDistance(force, !dragFree).distance;
+    if (dragFree || mathAbs(force) < goToNextThreshold) return baseForce;
+    if (skipSnaps && targetChanged) return baseForce * 0.5;
+    return scrollTarget.byIndex(next.get(), 0).distance;
+  }
+  function down(evt) {
+    const isMouseEvt = isMouseEvent(evt, ownerWindow);
+    isMouse = isMouseEvt;
+    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;
+    isMoving = deltaAbs(target.get(), location.get()) >= 2;
+    if (isMouseEvt && evt.button !== 0) return;
+    if (isFocusNode(evt.target)) return;
+    pointerIsDown = true;
+    dragTracker.pointerDown(evt);
+    scrollBody.useFriction(0).useDuration(0);
+    target.set(location);
+    addDragEvents();
+    startScroll = dragTracker.readPoint(evt);
+    startCross = dragTracker.readPoint(evt, crossAxis);
+    eventHandler.emit("pointerDown");
+  }
+  function move(evt) {
+    const isTouchEvt = !isMouseEvent(evt, ownerWindow);
+    if (isTouchEvt && evt.touches.length >= 2) return up(evt);
+    const lastScroll = dragTracker.readPoint(evt);
+    const lastCross = dragTracker.readPoint(evt, crossAxis);
+    const diffScroll = deltaAbs(lastScroll, startScroll);
+    const diffCross = deltaAbs(lastCross, startCross);
+    if (!preventScroll && !isMouse) {
+      if (!evt.cancelable) return up(evt);
+      preventScroll = diffScroll > diffCross;
+      if (!preventScroll) return up(evt);
+    }
+    const diff = dragTracker.pointerMove(evt);
+    if (diffScroll > dragThreshold) preventClick = true;
+    scrollBody.useFriction(0.3).useDuration(0.75);
+    animation.start();
+    target.add(direction(diff));
+    evt.preventDefault();
+  }
+  function up(evt) {
+    const currentLocation = scrollTarget.byDistance(0, false);
+    const targetChanged = currentLocation.index !== index.get();
+    const rawForce = dragTracker.pointerUp(evt) * forceBoost();
+    const force = allowedForce(direction(rawForce), targetChanged);
+    const forceFactor = factorAbs(rawForce, force);
+    const speed = baseSpeed - 10 * forceFactor;
+    const friction = baseFriction + forceFactor / 50;
+    preventScroll = false;
+    pointerIsDown = false;
+    dragEvents.clear();
+    scrollBody.useDuration(speed).useFriction(friction);
+    scrollTo.distance(force, !dragFree);
+    isMouse = false;
+    eventHandler.emit("pointerUp");
+  }
+  function click(evt) {
+    if (preventClick) {
+      evt.stopPropagation();
+      evt.preventDefault();
+      preventClick = false;
+    }
+  }
+  function pointerDown() {
+    return pointerIsDown;
+  }
+  const self = {
+    init,
+    destroy,
+    pointerDown
+  };
+  return self;
+}
+function DragTracker(axis, ownerWindow) {
+  const logInterval = 170;
+  let startEvent;
+  let lastEvent;
+  function readTime(evt) {
+    return evt.timeStamp;
+  }
+  function readPoint(evt, evtAxis) {
+    const property = evtAxis || axis.scroll;
+    const coord = `client${property === "x" ? "X" : "Y"}`;
+    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord];
+  }
+  function pointerDown(evt) {
+    startEvent = evt;
+    lastEvent = evt;
+    return readPoint(evt);
+  }
+  function pointerMove(evt) {
+    const diff = readPoint(evt) - readPoint(lastEvent);
+    const expired = readTime(evt) - readTime(startEvent) > logInterval;
+    lastEvent = evt;
+    if (expired) startEvent = evt;
+    return diff;
+  }
+  function pointerUp(evt) {
+    if (!startEvent || !lastEvent) return 0;
+    const diffDrag = readPoint(lastEvent) - readPoint(startEvent);
+    const diffTime = readTime(evt) - readTime(startEvent);
+    const expired = readTime(evt) - readTime(lastEvent) > logInterval;
+    const force = diffDrag / diffTime;
+    const isFlick = diffTime && !expired && mathAbs(force) > 0.1;
+    return isFlick ? force : 0;
+  }
+  const self = {
+    pointerDown,
+    pointerMove,
+    pointerUp,
+    readPoint
+  };
+  return self;
+}
+function NodeRects() {
+  function measure(node) {
+    const {
+      offsetTop,
+      offsetLeft,
+      offsetWidth,
+      offsetHeight
+    } = node;
+    const offset = {
+      top: offsetTop,
+      right: offsetLeft + offsetWidth,
+      bottom: offsetTop + offsetHeight,
+      left: offsetLeft,
+      width: offsetWidth,
+      height: offsetHeight
+    };
+    return offset;
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function PercentOfView(viewSize) {
+  function measure(n) {
+    return viewSize * (n / 100);
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects) {
+  const observeNodes = [container].concat(slides);
+  let resizeObserver;
+  let containerSize;
+  let slideSizes = [];
+  let destroyed = false;
+  function readSize(node) {
+    return axis.measureSize(nodeRects.measure(node));
+  }
+  function init(emblaApi) {
+    if (!watchResize) return;
+    containerSize = readSize(container);
+    slideSizes = slides.map(readSize);
+    function defaultCallback(entries) {
+      for (const entry of entries) {
+        if (destroyed) return;
+        const isContainer = entry.target === container;
+        const slideIndex = slides.indexOf(entry.target);
+        const lastSize = isContainer ? containerSize : slideSizes[slideIndex];
+        const newSize = readSize(isContainer ? container : slides[slideIndex]);
+        const diffSize = mathAbs(newSize - lastSize);
+        if (diffSize >= 0.5) {
+          emblaApi.reInit();
+          eventHandler.emit("resize");
+          break;
+        }
+      }
+    }
+    resizeObserver = new ResizeObserver((entries) => {
+      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {
+        defaultCallback(entries);
+      }
+    });
+    ownerWindow.requestAnimationFrame(() => {
+      observeNodes.forEach((node) => resizeObserver.observe(node));
+    });
+  }
+  function destroy() {
+    destroyed = true;
+    if (resizeObserver) resizeObserver.disconnect();
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function ScrollBody(location, offsetLocation, previousLocation, target, baseDuration, baseFriction) {
+  let bodyVelocity = 0;
+  let scrollDirection = 0;
+  let scrollDuration = baseDuration;
+  let scrollFriction = baseFriction;
+  let rawLocation = location.get();
+  let rawLocationPrevious = 0;
+  function seek(timeStep) {
+    const fixedDeltaTimeSeconds = timeStep / 1e3;
+    const duration2 = scrollDuration * fixedDeltaTimeSeconds;
+    const diff = target.get() - location.get();
+    const isInstant = !scrollDuration;
+    let directionDiff = 0;
+    if (isInstant) {
+      bodyVelocity = 0;
+      previousLocation.set(target);
+      location.set(target);
+      directionDiff = diff;
+    } else {
+      previousLocation.set(location);
+      bodyVelocity += diff / duration2;
+      bodyVelocity *= scrollFriction;
+      rawLocation += bodyVelocity;
+      location.add(bodyVelocity * fixedDeltaTimeSeconds);
+      directionDiff = rawLocation - rawLocationPrevious;
+    }
+    scrollDirection = mathSign(directionDiff);
+    rawLocationPrevious = rawLocation;
+    return self;
+  }
+  function settled() {
+    const diff = target.get() - offsetLocation.get();
+    return mathAbs(diff) < 1e-3;
+  }
+  function duration() {
+    return scrollDuration;
+  }
+  function direction() {
+    return scrollDirection;
+  }
+  function velocity() {
+    return bodyVelocity;
+  }
+  function useBaseDuration() {
+    return useDuration(baseDuration);
+  }
+  function useBaseFriction() {
+    return useFriction(baseFriction);
+  }
+  function useDuration(n) {
+    scrollDuration = n;
+    return self;
+  }
+  function useFriction(n) {
+    scrollFriction = n;
+    return self;
+  }
+  const self = {
+    direction,
+    duration,
+    velocity,
+    seek,
+    settled,
+    useBaseFriction,
+    useBaseDuration,
+    useFriction,
+    useDuration
+  };
+  return self;
+}
+function ScrollBounds(limit, location, target, scrollBody, percentOfView) {
+  const pullBackThreshold = percentOfView.measure(10);
+  const edgeOffsetTolerance = percentOfView.measure(50);
+  const frictionLimit = Limit(0.1, 0.99);
+  let disabled = false;
+  function shouldConstrain() {
+    if (disabled) return false;
+    if (!limit.reachedAny(target.get())) return false;
+    if (!limit.reachedAny(location.get())) return false;
+    return true;
+  }
+  function constrain(pointerDown) {
+    if (!shouldConstrain()) return;
+    const edge = limit.reachedMin(location.get()) ? "min" : "max";
+    const diffToEdge = mathAbs(limit[edge] - location.get());
+    const diffToTarget = target.get() - location.get();
+    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);
+    target.subtract(diffToTarget * friction);
+    if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {
+      target.set(limit.constrain(target.get()));
+      scrollBody.useDuration(25).useBaseFriction();
+    }
+  }
+  function toggleActive(active) {
+    disabled = !active;
+  }
+  const self = {
+    shouldConstrain,
+    constrain,
+    toggleActive
+  };
+  return self;
+}
+function ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance) {
+  const scrollBounds = Limit(-contentSize + viewSize, 0);
+  const snapsBounded = measureBounded();
+  const scrollContainLimit = findScrollContainLimit();
+  const snapsContained = measureContained();
+  function usePixelTolerance(bound, snap) {
+    return deltaAbs(bound, snap) < 1;
+  }
+  function findScrollContainLimit() {
+    const startSnap = snapsBounded[0];
+    const endSnap = arrayLast(snapsBounded);
+    const min = snapsBounded.lastIndexOf(startSnap);
+    const max = snapsBounded.indexOf(endSnap) + 1;
+    return Limit(min, max);
+  }
+  function measureBounded() {
+    return snapsAligned.map((snapAligned, index) => {
+      const {
+        min,
+        max
+      } = scrollBounds;
+      const snap = scrollBounds.constrain(snapAligned);
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(snapsAligned, index);
+      if (isFirst) return max;
+      if (isLast) return min;
+      if (usePixelTolerance(min, snap)) return min;
+      if (usePixelTolerance(max, snap)) return max;
+      return snap;
+    }).map((scrollBound) => parseFloat(scrollBound.toFixed(3)));
+  }
+  function measureContained() {
+    if (contentSize <= viewSize + pixelTolerance) return [scrollBounds.max];
+    if (containScroll === "keepSnaps") return snapsBounded;
+    const {
+      min,
+      max
+    } = scrollContainLimit;
+    return snapsBounded.slice(min, max);
+  }
+  const self = {
+    snapsContained,
+    scrollContainLimit
+  };
+  return self;
+}
+function ScrollLimit(contentSize, scrollSnaps, loop) {
+  const max = scrollSnaps[0];
+  const min = loop ? max - contentSize : arrayLast(scrollSnaps);
+  const limit = Limit(min, max);
+  const self = {
+    limit
+  };
+  return self;
+}
+function ScrollLooper(contentSize, limit, location, vectors) {
+  const jointSafety = 0.1;
+  const min = limit.min + jointSafety;
+  const max = limit.max + jointSafety;
+  const {
+    reachedMin,
+    reachedMax
+  } = Limit(min, max);
+  function shouldLoop(direction) {
+    if (direction === 1) return reachedMax(location.get());
+    if (direction === -1) return reachedMin(location.get());
+    return false;
+  }
+  function loop(direction) {
+    if (!shouldLoop(direction)) return;
+    const loopDistance = contentSize * (direction * -1);
+    vectors.forEach((v) => v.add(loopDistance));
+  }
+  const self = {
+    loop
+  };
+  return self;
+}
+function ScrollProgress(limit) {
+  const {
+    max,
+    length
+  } = limit;
+  function get(n) {
+    const currentLocation = n - max;
+    return length ? currentLocation / -length : 0;
+  }
+  const self = {
+    get
+  };
+  return self;
+}
+function ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {
+  const {
+    startEdge,
+    endEdge
+  } = axis;
+  const {
+    groupSlides
+  } = slidesToScroll;
+  const alignments = measureSizes().map(alignment.measure);
+  const snaps = measureUnaligned();
+  const snapsAligned = measureAligned();
+  function measureSizes() {
+    return groupSlides(slideRects).map((rects) => arrayLast(rects)[endEdge] - rects[0][startEdge]).map(mathAbs);
+  }
+  function measureUnaligned() {
+    return slideRects.map((rect) => containerRect[startEdge] - rect[startEdge]).map((snap) => -mathAbs(snap));
+  }
+  function measureAligned() {
+    return groupSlides(snaps).map((g) => g[0]).map((snap, index) => snap + alignments[index]);
+  }
+  const self = {
+    snaps,
+    snapsAligned
+  };
+  return self;
+}
+function SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes) {
+  const {
+    groupSlides
+  } = slidesToScroll;
+  const {
+    min,
+    max
+  } = scrollContainLimit;
+  const slideRegistry = createSlideRegistry();
+  function createSlideRegistry() {
+    const groupedSlideIndexes = groupSlides(slideIndexes);
+    const doNotContain = !containSnaps || containScroll === "keepSnaps";
+    if (scrollSnaps.length === 1) return [slideIndexes];
+    if (doNotContain) return groupedSlideIndexes;
+    return groupedSlideIndexes.slice(min, max).map((group, index, groups) => {
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(groups, index);
+      if (isFirst) {
+        const range = arrayLast(groups[0]) + 1;
+        return arrayFromNumber(range);
+      }
+      if (isLast) {
+        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1;
+        return arrayFromNumber(range, arrayLast(groups)[0]);
+      }
+      return group;
+    });
+  }
+  const self = {
+    slideRegistry
+  };
+  return self;
+}
+function ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {
+  const {
+    reachedAny,
+    removeOffset,
+    constrain
+  } = limit;
+  function minDistance(distances) {
+    return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0];
+  }
+  function findTargetSnap(target) {
+    const distance = loop ? removeOffset(target) : constrain(target);
+    const ascDiffsToSnaps = scrollSnaps.map((snap, index2) => ({
+      diff: shortcut(snap - distance, 0),
+      index: index2
+    })).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));
+    const {
+      index
+    } = ascDiffsToSnaps[0];
+    return {
+      index,
+      distance
+    };
+  }
+  function shortcut(target, direction) {
+    const targets = [target, target + contentSize, target - contentSize];
+    if (!loop) return target;
+    if (!direction) return minDistance(targets);
+    const matchingTargets = targets.filter((t) => mathSign(t) === direction);
+    if (matchingTargets.length) return minDistance(matchingTargets);
+    return arrayLast(targets) - contentSize;
+  }
+  function byIndex(index, direction) {
+    const diffToSnap = scrollSnaps[index] - targetVector.get();
+    const distance = shortcut(diffToSnap, direction);
+    return {
+      index,
+      distance
+    };
+  }
+  function byDistance(distance, snap) {
+    const target = targetVector.get() + distance;
+    const {
+      index,
+      distance: targetSnapDistance
+    } = findTargetSnap(target);
+    const reachedBound = !loop && reachedAny(target);
+    if (!snap || reachedBound) return {
+      index,
+      distance
+    };
+    const diffToSnap = scrollSnaps[index] - targetSnapDistance;
+    const snapDistance = distance + shortcut(diffToSnap, 0);
+    return {
+      index,
+      distance: snapDistance
+    };
+  }
+  const self = {
+    byDistance,
+    byIndex,
+    shortcut
+  };
+  return self;
+}
+function ScrollTo(animation, indexCurrent, indexPrevious, scrollBody, scrollTarget, targetVector, eventHandler) {
+  function scrollTo(target) {
+    const distanceDiff = target.distance;
+    const indexDiff = target.index !== indexCurrent.get();
+    targetVector.add(distanceDiff);
+    if (distanceDiff) {
+      if (scrollBody.duration()) {
+        animation.start();
+      } else {
+        animation.update();
+        animation.render(1);
+        animation.update();
+      }
+    }
+    if (indexDiff) {
+      indexPrevious.set(indexCurrent.get());
+      indexCurrent.set(target.index);
+      eventHandler.emit("select");
+    }
+  }
+  function distance(n, snap) {
+    const target = scrollTarget.byDistance(n, snap);
+    scrollTo(target);
+  }
+  function index(n, direction) {
+    const targetIndex = indexCurrent.clone().set(n);
+    const target = scrollTarget.byIndex(targetIndex.get(), direction);
+    scrollTo(target);
+  }
+  const self = {
+    distance,
+    index
+  };
+  return self;
+}
+function SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler) {
+  let lastTabPressTime = 0;
+  function init() {
+    eventStore.add(document, "keydown", registerTabPress, false);
+    slides.forEach(addSlideFocusEvent);
+  }
+  function registerTabPress(event) {
+    if (event.code === "Tab") lastTabPressTime = (/* @__PURE__ */ new Date()).getTime();
+  }
+  function addSlideFocusEvent(slide) {
+    const focus = () => {
+      const nowTime = (/* @__PURE__ */ new Date()).getTime();
+      const diffTime = nowTime - lastTabPressTime;
+      if (diffTime > 10) return;
+      root.scrollLeft = 0;
+      const index = slides.indexOf(slide);
+      const group = slideRegistry.findIndex((group2) => group2.includes(index));
+      if (!isNumber(group)) return;
+      scrollBody.useDuration(0);
+      scrollTo.index(group, 0);
+      eventHandler.emit("slideFocus");
+    };
+    eventStore.add(slide, "focus", focus, {
+      passive: true,
+      capture: true
+    });
+  }
+  const self = {
+    init
+  };
+  return self;
+}
+function Vector1D(initialValue) {
+  let value = initialValue;
+  function get() {
+    return value;
+  }
+  function set(n) {
+    value = normalizeInput(n);
+  }
+  function add(n) {
+    value += normalizeInput(n);
+  }
+  function subtract(n) {
+    value -= normalizeInput(n);
+  }
+  function normalizeInput(n) {
+    return isNumber(n) ? n : n.get();
+  }
+  const self = {
+    get,
+    set,
+    add,
+    subtract
+  };
+  return self;
+}
+function Translate(axis, container) {
+  const translate = axis.scroll === "x" ? x : y;
+  const containerStyle = container.style;
+  let disabled = false;
+  function x(n) {
+    return `translate3d(${n}px,0px,0px)`;
+  }
+  function y(n) {
+    return `translate3d(0px,${n}px,0px)`;
+  }
+  function to(target) {
+    if (disabled) return;
+    containerStyle.transform = translate(axis.direction(target));
+  }
+  function toggleActive(active) {
+    disabled = !active;
+  }
+  function clear() {
+    if (disabled) return;
+    containerStyle.transform = "";
+    if (!container.getAttribute("style")) container.removeAttribute("style");
+  }
+  const self = {
+    clear,
+    to,
+    toggleActive
+  };
+  return self;
+}
+function SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, location, slides) {
+  const roundingSafety = 0.5;
+  const ascItems = arrayKeys(slideSizesWithGaps);
+  const descItems = arrayKeys(slideSizesWithGaps).reverse();
+  const loopPoints = startPoints().concat(endPoints());
+  function removeSlideSizes(indexes, from) {
+    return indexes.reduce((a, i) => {
+      return a - slideSizesWithGaps[i];
+    }, from);
+  }
+  function slidesInGap(indexes, gap) {
+    return indexes.reduce((a, i) => {
+      const remainingGap = removeSlideSizes(a, gap);
+      return remainingGap > 0 ? a.concat([i]) : a;
+    }, []);
+  }
+  function findSlideBounds(offset) {
+    return snaps.map((snap, index) => ({
+      start: snap - slideSizes[index] + roundingSafety + offset,
+      end: snap + viewSize - roundingSafety + offset
+    }));
+  }
+  function findLoopPoints(indexes, offset, isEndEdge) {
+    const slideBounds = findSlideBounds(offset);
+    return indexes.map((index) => {
+      const initial = isEndEdge ? 0 : -contentSize;
+      const altered = isEndEdge ? contentSize : 0;
+      const boundEdge = isEndEdge ? "end" : "start";
+      const loopPoint = slideBounds[index][boundEdge];
+      return {
+        index,
+        loopPoint,
+        slideLocation: Vector1D(-1),
+        translate: Translate(axis, slides[index]),
+        target: () => location.get() > loopPoint ? initial : altered
+      };
+    });
+  }
+  function startPoints() {
+    const gap = scrollSnaps[0];
+    const indexes = slidesInGap(descItems, gap);
+    return findLoopPoints(indexes, contentSize, false);
+  }
+  function endPoints() {
+    const gap = viewSize - scrollSnaps[0] - 1;
+    const indexes = slidesInGap(ascItems, gap);
+    return findLoopPoints(indexes, -contentSize, true);
+  }
+  function canLoop() {
+    return loopPoints.every(({
+      index
+    }) => {
+      const otherIndexes = ascItems.filter((i) => i !== index);
+      return removeSlideSizes(otherIndexes, viewSize) <= 0.1;
+    });
+  }
+  function loop() {
+    loopPoints.forEach((loopPoint) => {
+      const {
+        target,
+        translate,
+        slideLocation
+      } = loopPoint;
+      const shiftLocation = target();
+      if (shiftLocation === slideLocation.get()) return;
+      translate.to(shiftLocation);
+      slideLocation.set(shiftLocation);
+    });
+  }
+  function clear() {
+    loopPoints.forEach((loopPoint) => loopPoint.translate.clear());
+  }
+  const self = {
+    canLoop,
+    clear,
+    loop,
+    loopPoints
+  };
+  return self;
+}
+function SlidesHandler(container, eventHandler, watchSlides) {
+  let mutationObserver;
+  let destroyed = false;
+  function init(emblaApi) {
+    if (!watchSlides) return;
+    function defaultCallback(mutations) {
+      for (const mutation of mutations) {
+        if (mutation.type === "childList") {
+          emblaApi.reInit();
+          eventHandler.emit("slidesChanged");
+          break;
+        }
+      }
+    }
+    mutationObserver = new MutationObserver((mutations) => {
+      if (destroyed) return;
+      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {
+        defaultCallback(mutations);
+      }
+    });
+    mutationObserver.observe(container, {
+      childList: true
+    });
+  }
+  function destroy() {
+    if (mutationObserver) mutationObserver.disconnect();
+    destroyed = true;
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function SlidesInView(container, slides, eventHandler, threshold) {
+  const intersectionEntryMap = {};
+  let inViewCache = null;
+  let notInViewCache = null;
+  let intersectionObserver;
+  let destroyed = false;
+  function init() {
+    intersectionObserver = new IntersectionObserver((entries) => {
+      if (destroyed) return;
+      entries.forEach((entry) => {
+        const index = slides.indexOf(entry.target);
+        intersectionEntryMap[index] = entry;
+      });
+      inViewCache = null;
+      notInViewCache = null;
+      eventHandler.emit("slidesInView");
+    }, {
+      root: container.parentElement,
+      threshold
+    });
+    slides.forEach((slide) => intersectionObserver.observe(slide));
+  }
+  function destroy() {
+    if (intersectionObserver) intersectionObserver.disconnect();
+    destroyed = true;
+  }
+  function createInViewList(inView) {
+    return objectKeys(intersectionEntryMap).reduce((list, slideIndex) => {
+      const index = parseInt(slideIndex);
+      const {
+        isIntersecting
+      } = intersectionEntryMap[index];
+      const inViewMatch = inView && isIntersecting;
+      const notInViewMatch = !inView && !isIntersecting;
+      if (inViewMatch || notInViewMatch) list.push(index);
+      return list;
+    }, []);
+  }
+  function get(inView = true) {
+    if (inView && inViewCache) return inViewCache;
+    if (!inView && notInViewCache) return notInViewCache;
+    const slideIndexes = createInViewList(inView);
+    if (inView) inViewCache = slideIndexes;
+    if (!inView) notInViewCache = slideIndexes;
+    return slideIndexes;
+  }
+  const self = {
+    init,
+    destroy,
+    get
+  };
+  return self;
+}
+function SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {
+  const {
+    measureSize,
+    startEdge,
+    endEdge
+  } = axis;
+  const withEdgeGap = slideRects[0] && readEdgeGap;
+  const startGap = measureStartGap();
+  const endGap = measureEndGap();
+  const slideSizes = slideRects.map(measureSize);
+  const slideSizesWithGaps = measureWithGaps();
+  function measureStartGap() {
+    if (!withEdgeGap) return 0;
+    const slideRect = slideRects[0];
+    return mathAbs(containerRect[startEdge] - slideRect[startEdge]);
+  }
+  function measureEndGap() {
+    if (!withEdgeGap) return 0;
+    const style = ownerWindow.getComputedStyle(arrayLast(slides));
+    return parseFloat(style.getPropertyValue(`margin-${endEdge}`));
+  }
+  function measureWithGaps() {
+    return slideRects.map((rect, index, rects) => {
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(rects, index);
+      if (isFirst) return slideSizes[index] + startGap;
+      if (isLast) return slideSizes[index] + endGap;
+      return rects[index + 1][startEdge] - rect[startEdge];
+    }).map(mathAbs);
+  }
+  const self = {
+    slideSizes,
+    slideSizesWithGaps,
+    startGap,
+    endGap
+  };
+  return self;
+}
+function SlidesToScroll(axis, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap, pixelTolerance) {
+  const {
+    startEdge,
+    endEdge,
+    direction
+  } = axis;
+  const groupByNumber = isNumber(slidesToScroll);
+  function byNumber(array, groupSize) {
+    return arrayKeys(array).filter((i) => i % groupSize === 0).map((i) => array.slice(i, i + groupSize));
+  }
+  function bySize(array) {
+    if (!array.length) return [];
+    return arrayKeys(array).reduce((groups, rectB, index) => {
+      const rectA = arrayLast(groups) || 0;
+      const isFirst = rectA === 0;
+      const isLast = rectB === arrayLastIndex(array);
+      const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge];
+      const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge];
+      const gapA = !loop && isFirst ? direction(startGap) : 0;
+      const gapB = !loop && isLast ? direction(endGap) : 0;
+      const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA));
+      if (index && chunkSize > viewSize + pixelTolerance) groups.push(rectB);
+      if (isLast) groups.push(array.length);
+      return groups;
+    }, []).map((currentSize, index, groups) => {
+      const previousSize = Math.max(groups[index - 1] || 0);
+      return array.slice(previousSize, currentSize);
+    });
+  }
+  function groupSlides(array) {
+    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);
+  }
+  const self = {
+    groupSlides
+  };
+  return self;
+}
+function Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler) {
+  const {
+    align,
+    axis: scrollAxis,
+    direction,
+    startIndex,
+    loop,
+    duration,
+    dragFree,
+    dragThreshold,
+    inViewThreshold,
+    slidesToScroll: groupSlides,
+    skipSnaps,
+    containScroll,
+    watchResize,
+    watchSlides,
+    watchDrag
+  } = options;
+  const pixelTolerance = 2;
+  const nodeRects = NodeRects();
+  const containerRect = nodeRects.measure(container);
+  const slideRects = slides.map(nodeRects.measure);
+  const axis = Axis(scrollAxis, direction);
+  const viewSize = axis.measureSize(containerRect);
+  const percentOfView = PercentOfView(viewSize);
+  const alignment = Alignment(align, viewSize);
+  const containSnaps = !loop && !!containScroll;
+  const readEdgeGap = loop || !!containScroll;
+  const {
+    slideSizes,
+    slideSizesWithGaps,
+    startGap,
+    endGap
+  } = SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow);
+  const slidesToScroll = SlidesToScroll(axis, viewSize, groupSlides, loop, containerRect, slideRects, startGap, endGap, pixelTolerance);
+  const {
+    snaps,
+    snapsAligned
+  } = ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll);
+  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);
+  const {
+    snapsContained,
+    scrollContainLimit
+  } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance);
+  const scrollSnaps = containSnaps ? snapsContained : snapsAligned;
+  const {
+    limit
+  } = ScrollLimit(contentSize, scrollSnaps, loop);
+  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);
+  const indexPrevious = index.clone();
+  const slideIndexes = arrayKeys(slides);
+  const update = ({
+    dragHandler,
+    scrollBody: scrollBody2,
+    scrollBounds,
+    options: {
+      loop: loop2
+    }
+  }, timeStep) => {
+    if (!loop2) scrollBounds.constrain(dragHandler.pointerDown());
+    scrollBody2.seek(timeStep);
+  };
+  const render = ({
+    scrollBody: scrollBody2,
+    translate,
+    location: location2,
+    offsetLocation: offsetLocation2,
+    scrollLooper,
+    slideLooper,
+    dragHandler,
+    animation: animation2,
+    eventHandler: eventHandler2,
+    scrollBounds,
+    options: {
+      loop: loop2
+    }
+  }, lagOffset) => {
+    const shouldSettle = scrollBody2.settled();
+    const withinBounds = !scrollBounds.shouldConstrain();
+    const hasSettled = loop2 ? shouldSettle : shouldSettle && withinBounds;
+    if (hasSettled && !dragHandler.pointerDown()) {
+      animation2.stop();
+      eventHandler2.emit("settle");
+    }
+    if (!hasSettled) eventHandler2.emit("scroll");
+    const interpolatedLocation = location2.get() * lagOffset + previousLocation.get() * (1 - lagOffset);
+    offsetLocation2.set(interpolatedLocation);
+    if (loop2) {
+      scrollLooper.loop(scrollBody2.direction());
+      slideLooper.loop();
+    }
+    translate.to(offsetLocation2.get());
+  };
+  const animation = Animations(ownerDocument, ownerWindow, (timeStep) => update(engine, timeStep), (lagOffset) => render(engine, lagOffset));
+  const friction = 0.68;
+  const startLocation = scrollSnaps[index.get()];
+  const location = Vector1D(startLocation);
+  const previousLocation = Vector1D(startLocation);
+  const offsetLocation = Vector1D(startLocation);
+  const target = Vector1D(startLocation);
+  const scrollBody = ScrollBody(location, offsetLocation, previousLocation, target, duration, friction);
+  const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);
+  const scrollTo = ScrollTo(animation, index, indexPrevious, scrollBody, scrollTarget, target, eventHandler);
+  const scrollProgress = ScrollProgress(limit);
+  const eventStore = EventStore();
+  const slidesInView = SlidesInView(container, slides, eventHandler, inViewThreshold);
+  const {
+    slideRegistry
+  } = SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes);
+  const slideFocus = SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler);
+  const engine = {
+    ownerDocument,
+    ownerWindow,
+    eventHandler,
+    containerRect,
+    slideRects,
+    animation,
+    axis,
+    dragHandler: DragHandler(axis, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction, watchDrag),
+    eventStore,
+    percentOfView,
+    index,
+    indexPrevious,
+    limit,
+    location,
+    offsetLocation,
+    previousLocation,
+    options,
+    resizeHandler: ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects),
+    scrollBody,
+    scrollBounds: ScrollBounds(limit, offsetLocation, target, scrollBody, percentOfView),
+    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [location, offsetLocation, previousLocation, target]),
+    scrollProgress,
+    scrollSnapList: scrollSnaps.map(scrollProgress.get),
+    scrollSnaps,
+    scrollTarget,
+    scrollTo,
+    slideLooper: SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides),
+    slideFocus,
+    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),
+    slidesInView,
+    slideIndexes,
+    slideRegistry,
+    slidesToScroll,
+    target,
+    translate: Translate(axis, container)
+  };
+  return engine;
+}
+function EventHandler() {
+  let listeners = {};
+  let api;
+  function init(emblaApi) {
+    api = emblaApi;
+  }
+  function getListeners(evt) {
+    return listeners[evt] || [];
+  }
+  function emit(evt) {
+    getListeners(evt).forEach((e) => e(api, evt));
+    return self;
+  }
+  function on(evt, cb) {
+    listeners[evt] = getListeners(evt).concat([cb]);
+    return self;
+  }
+  function off(evt, cb) {
+    listeners[evt] = getListeners(evt).filter((e) => e !== cb);
+    return self;
+  }
+  function clear() {
+    listeners = {};
+  }
+  const self = {
+    init,
+    emit,
+    off,
+    on,
+    clear
+  };
+  return self;
+}
+const defaultOptions = {
+  align: "center",
+  axis: "x",
+  container: null,
+  slides: null,
+  containScroll: "trimSnaps",
+  direction: "ltr",
+  slidesToScroll: 1,
+  inViewThreshold: 0,
+  breakpoints: {},
+  dragFree: false,
+  dragThreshold: 10,
+  loop: false,
+  skipSnaps: false,
+  duration: 25,
+  startIndex: 0,
+  active: true,
+  watchDrag: true,
+  watchResize: true,
+  watchSlides: true
+};
+function OptionsHandler(ownerWindow) {
+  function mergeOptions(optionsA, optionsB) {
+    return objectsMergeDeep(optionsA, optionsB || {});
+  }
+  function optionsAtMedia(options) {
+    const optionsAtMedia2 = options.breakpoints || {};
+    const matchedMediaOptions = objectKeys(optionsAtMedia2).filter((media) => ownerWindow.matchMedia(media).matches).map((media) => optionsAtMedia2[media]).reduce((a, mediaOption) => mergeOptions(a, mediaOption), {});
+    return mergeOptions(options, matchedMediaOptions);
+  }
+  function optionsMediaQueries(optionsList) {
+    return optionsList.map((options) => objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries) => acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);
+  }
+  const self = {
+    mergeOptions,
+    optionsAtMedia,
+    optionsMediaQueries
+  };
+  return self;
+}
+function PluginsHandler(optionsHandler) {
+  let activePlugins = [];
+  function init(emblaApi, plugins) {
+    activePlugins = plugins.filter(({
+      options
+    }) => optionsHandler.optionsAtMedia(options).active !== false);
+    activePlugins.forEach((plugin) => plugin.init(emblaApi, optionsHandler));
+    return plugins.reduce((map, plugin) => Object.assign(map, {
+      [plugin.name]: plugin
+    }), {});
+  }
+  function destroy() {
+    activePlugins = activePlugins.filter((plugin) => plugin.destroy());
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function EmblaCarousel(root, userOptions, userPlugins) {
+  const ownerDocument = root.ownerDocument;
+  const ownerWindow = ownerDocument.defaultView;
+  const optionsHandler = OptionsHandler(ownerWindow);
+  const pluginsHandler = PluginsHandler(optionsHandler);
+  const mediaHandlers = EventStore();
+  const eventHandler = EventHandler();
+  const {
+    mergeOptions,
+    optionsAtMedia,
+    optionsMediaQueries
+  } = optionsHandler;
+  const {
+    on,
+    off,
+    emit
+  } = eventHandler;
+  const reInit = reActivate;
+  let destroyed = false;
+  let engine;
+  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions);
+  let options = mergeOptions(optionsBase);
+  let pluginList = [];
+  let pluginApis;
+  let container;
+  let slides;
+  function storeElements() {
+    const {
+      container: userContainer,
+      slides: userSlides
+    } = options;
+    const customContainer = isString(userContainer) ? root.querySelector(userContainer) : userContainer;
+    container = customContainer || root.children[0];
+    const customSlides = isString(userSlides) ? container.querySelectorAll(userSlides) : userSlides;
+    slides = [].slice.call(customSlides || container.children);
+  }
+  function createEngine(options2) {
+    const engine2 = Engine(root, container, slides, ownerDocument, ownerWindow, options2, eventHandler);
+    if (options2.loop && !engine2.slideLooper.canLoop()) {
+      const optionsWithoutLoop = Object.assign({}, options2, {
+        loop: false
+      });
+      return createEngine(optionsWithoutLoop);
+    }
+    return engine2;
+  }
+  function activate(withOptions, withPlugins) {
+    if (destroyed) return;
+    optionsBase = mergeOptions(optionsBase, withOptions);
+    options = optionsAtMedia(optionsBase);
+    pluginList = withPlugins || pluginList;
+    storeElements();
+    engine = createEngine(options);
+    optionsMediaQueries([optionsBase, ...pluginList.map(({
+      options: options2
+    }) => options2)]).forEach((query) => mediaHandlers.add(query, "change", reActivate));
+    if (!options.active) return;
+    engine.translate.to(engine.location.get());
+    engine.animation.init();
+    engine.slidesInView.init();
+    engine.slideFocus.init();
+    engine.eventHandler.init(self);
+    engine.resizeHandler.init(self);
+    engine.slidesHandler.init(self);
+    if (engine.options.loop) engine.slideLooper.loop();
+    if (container.offsetParent && slides.length) engine.dragHandler.init(self);
+    pluginApis = pluginsHandler.init(self, pluginList);
+  }
+  function reActivate(withOptions, withPlugins) {
+    const startIndex = selectedScrollSnap();
+    deActivate();
+    activate(mergeOptions({
+      startIndex
+    }, withOptions), withPlugins);
+    eventHandler.emit("reInit");
+  }
+  function deActivate() {
+    engine.dragHandler.destroy();
+    engine.eventStore.clear();
+    engine.translate.clear();
+    engine.slideLooper.clear();
+    engine.resizeHandler.destroy();
+    engine.slidesHandler.destroy();
+    engine.slidesInView.destroy();
+    engine.animation.destroy();
+    pluginsHandler.destroy();
+    mediaHandlers.clear();
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    mediaHandlers.clear();
+    deActivate();
+    eventHandler.emit("destroy");
+    eventHandler.clear();
+  }
+  function scrollTo(index, jump, direction) {
+    if (!options.active || destroyed) return;
+    engine.scrollBody.useBaseFriction().useDuration(jump === true ? 0 : options.duration);
+    engine.scrollTo.index(index, direction || 0);
+  }
+  function scrollNext(jump) {
+    const next = engine.index.add(1).get();
+    scrollTo(next, jump, -1);
+  }
+  function scrollPrev(jump) {
+    const prev = engine.index.add(-1).get();
+    scrollTo(prev, jump, 1);
+  }
+  function canScrollNext() {
+    const next = engine.index.add(1).get();
+    return next !== selectedScrollSnap();
+  }
+  function canScrollPrev() {
+    const prev = engine.index.add(-1).get();
+    return prev !== selectedScrollSnap();
+  }
+  function scrollSnapList() {
+    return engine.scrollSnapList;
+  }
+  function scrollProgress() {
+    return engine.scrollProgress.get(engine.location.get());
+  }
+  function selectedScrollSnap() {
+    return engine.index.get();
+  }
+  function previousScrollSnap() {
+    return engine.indexPrevious.get();
+  }
+  function slidesInView() {
+    return engine.slidesInView.get();
+  }
+  function slidesNotInView() {
+    return engine.slidesInView.get(false);
+  }
+  function plugins() {
+    return pluginApis;
+  }
+  function internalEngine() {
+    return engine;
+  }
+  function rootNode() {
+    return root;
+  }
+  function containerNode() {
+    return container;
+  }
+  function slideNodes() {
+    return slides;
+  }
+  const self = {
+    canScrollNext,
+    canScrollPrev,
+    containerNode,
+    internalEngine,
+    destroy,
+    off,
+    on,
+    emit,
+    plugins,
+    previousScrollSnap,
+    reInit,
+    rootNode,
+    scrollNext,
+    scrollPrev,
+    scrollProgress,
+    scrollSnapList,
+    scrollTo,
+    selectedScrollSnap,
+    slideNodes,
+    slidesInView,
+    slidesNotInView
+  };
+  activate(userOptions, userPlugins);
+  setTimeout(() => eventHandler.emit("init"), 0);
+  return self;
+}
+EmblaCarousel.globalOptions = void 0;
+exports.default = EmblaCarousel;
+//# sourceMappingURL=embla-carousel.esm.cjs.map