{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/deploy/multi-sports/shared/node_modules/@babel/runtime/regenerator/index.js","webpack:///(webpack)/buildin/module.js","webpack:///./app/javascript/images/about.jpg","webpack:///./app/javascript/images/ballet.svg","webpack:///./app/javascript/images/banner.jpg","webpack:///./app/javascript/images/bizx-award.png","webpack:///./app/javascript/images/cd-badge.png","webpack:///./app/javascript/images/equipment.svg","webpack:///./app/javascript/images/external-link.svg","webpack:///./app/javascript/images/facebook-cover.png","webpack:///./app/javascript/images/favicon.png","webpack:///./app/javascript/images/football.svg","webpack:///./app/javascript/images/karate.svg","webpack:///./app/javascript/images/logo.svg","webpack:///./app/javascript/images/logo-alt.png","webpack:///./app/javascript/images/logo-white.svg","webpack:///./app/javascript/images/medal.svg","webpack:///./app/javascript/images/netball.svg","webpack:///./app/javascript/images/sports.jpg","webpack:///./app/javascript/images/tactic.svg","webpack:///./app/javascript/images/tennis.svg","webpack:////home/deploy/multi-sports/shared/node_modules/rails-ujs/lib/assets/compiled/rails-ujs.js","webpack:////home/deploy/multi-sports/shared/node_modules/turbolinks/dist/turbolinks.js","webpack:////home/deploy/multi-sports/shared/node_modules/sweet-scroll/sweet-scroll.js","webpack:////home/deploy/multi-sports/shared/node_modules/alpinejs/dist/alpine.js","webpack:///(webpack)/buildin/harmony-module.js","webpack:////home/deploy/multi-sports/shared/node_modules/regenerator-runtime/runtime.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./app/javascript/images sync ^\\.\\/.*$","webpack:////home/deploy/multi-sports/shared/node_modules/@glidejs/glide/dist/glide.esm.js","webpack:///./app/javascript/packs/application.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","webpackPolyfill","deprecate","paths","children","_typeof","iterator","obj","constructor","this","Rails","linkClickSelector","buttonClickSelector","selector","exclude","inputChangeSelector","formSubmitSelector","formInputClickSelector","formDisableSelector","formEnableSelector","fileInputSelector","linkDisableSelector","buttonDisableSelector","nonce","loadCSPNonce","ref","document","querySelector","content","cspNonce","Element","matches","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","element","getData","setData","$","Array","slice","querySelectorAll","csrfParam","csrfToken","meta","CSRFProtection","xhr","token","setRequestHeader","refreshCSRFTokens","param","forEach","input","CustomEvent","fire","preventDefault","window","event","params","evt","createEvent","initCustomEvent","bubbles","cancelable","detail","Event","result","defaultPrevented","data","dispatchEvent","stopEverything","e","target","stopPropagation","stopImmediatePropagation","delegate","eventType","handler","addEventListener","parentNode","AcceptHeaders","createXHR","prepareOptions","processResponse","text","html","xml","json","script","ajax","options","response","responseText","getResponseHeader","Math","floor","status","success","statusText","error","complete","beforeSend","readyState","XMLHttpRequest","OPENED","send","url","location","href","type","toUpperCase","indexOf","dataType","accept","done","open","crossDomain","withCredentials","onreadystatechange","DONE","parser","match","JSON","parse","createElement","setAttribute","head","appendChild","removeChild","DOMParser","replace","parseFromString","isCrossDomain","originAnchor","urlAnchor","protocol","host","toArray","serializeElement","additionalParam","inputs","elements","disabled","option","selected","push","checked","map","encodeURIComponent","join","formElements","form","filter","el","allowAction","handleConfirm","answer","callback","message","getAttribute","confirm","disableFormElement","disableFormElements","disableLinkElement","enableFormElement","enableFormElements","enableLinkElement","handleDisabledElement","enableElement","disableElement","replacement","innerHTML","originalText","removeEventListener","handleMethod","formContent","method","action","style","display","body","click","isRemote","handleRemote","button","enctype","FormData","append","args","arguments","length","formSubmitButtonClick","formNoValidate","preventInsignificantClick","insignificantMetaClick","metaKey","ctrlKey","jQuery","rails","Error","ajaxPrefilter","originalOptions","start","_rails_loaded","setTimeout","Turbolinks","supported","history","pushState","requestAnimationFrame","visit","controller","clearCache","setProgressBarDelay","copyObject","closest","documentElement","nodeType","Node","ELEMENT_NODE","defer","throttle","apply","dispatch","a","u","initEvent","uuid","random","toString","Location","absoluteURL","hash","requestURL","anchor","wrap","getOrigin","split","getPath","getPathComponents","getLastPathComponent","getExtension","isHTML","isPrefixedBy","isEqualTo","toCacheKey","toJSON","valueOf","_t","HttpRequest","requestCanceled","requestTimedOut","requestFailed","requestLoaded","requestProgressed","referrer","NETWORK_FAILURE","TIMEOUT_FAILURE","timeout","sent","notifyApplicationBeforeRequestStart","setProgress","requestStarted","cancel","abort","lengthComputable","loaded","total","endRequest","requestCompletedWithResponse","failed","requestFailedWithStatusCode","notifyApplicationAfterRequestEnd","onprogress","onload","onerror","ontimeout","onabort","destroy","progress","requestFinished","ProgressBar","trickle","_t2","stylesheetElement","createStylesheetElement","progressElement","createProgressElement","defaultCSS","show","visible","installStylesheetElement","installProgressElement","startTrickling","hide","hiding","fadeProgressElement","uninstallProgressElement","stopTrickling","setValue","refresh","insertBefore","firstChild","width","opacity","trickleInterval","setInterval","clearInterval","textContent","className","BrowserAdapter","showProgressBar","_t3","progressBar","visitProposedToLocationWithAction","startVisitToLocationWithAction","visitStarted","issueRequest","changeHistory","loadCachedSnapshot","visitRequestStarted","hasCachedSnapshot","showProgressBarAfterDelay","visitRequestProgressed","visitRequestCompleted","loadResponse","visitRequestFailedWithStatusCode","reload","visitRequestFinished","hideProgressBar","visitCompleted","followRedirect","pageInvalidated","progressBarTimeout","progressBarDelay","clearTimeout","_t4","History","onPageLoad","onPopState","started","stop","update","shouldHandlePopState","state","turbolinks","restorationIdentifier","historyPoppedToLocationWithRestorationIdentifier","pageLoaded","pageIsLoaded","HeadDetails","outerHTML","tracked","fromHeadElement","childNodes","hasElementWithKey","getTrackedElementSignature","getScriptElementsNotInDetails","getElementsMatchingTypeNotInDetails","getStylesheetElementsNotInDetails","getProvisionalElements","getMetaValue","findMetaElementByName","tagName","toLowerCase","_e","Snapshot","headDetails","bodyElement","fromHTMLString","fromHTMLElement","clone","cloneNode","getRootLocation","getSetting","getCacheControlValue","getElementForAnchor","getPermanentElements","getPermanentElementById","getPermanentElementsPresentInSnapshot","id","findFirstAutofocusableElement","hasAnchor","isPreviewable","isCacheable","isVisitable","Renderer","render","renderView","viewWillRender","newBody","viewRendered","invalidateView","viewInvalidated","createScriptElement","async","attributes","__super__","SnapshotRenderer","currentSnapshot","newSnapshot","isPreview","currentHeadDetails","newHeadDetails","currentBody","shouldRender","mergeHead","replaceBody","focusFirstAutofocusableElement","copyNewHeadStylesheetElements","copyNewHeadScriptElements","removeCurrentHeadProvisionalElements","copyNewHeadProvisionalElements","relocateCurrentBodyPermanentElements","activateNewBodyScriptElements","assignNewBody","replacePlaceholderElementsWithClonedPermanentElements","trackedElementsAreIdentical","getNewHeadStylesheetElements","getNewHeadScriptElements","getCurrentHeadProvisionalElements","getNewHeadProvisionalElements","getCurrentBodyPermanentElements","permanentElement","getNewBodyScriptElements","focus","_t5","replaceChild","_t6","ErrorRenderer","newHead","replaceHeadAndBody","activateBodyScriptElements","getScriptElements","View","htmlElement","getSnapshot","snapshot","markAsPreview","renderSnapshot","renderError","removeAttribute","ScrollManager","onScroll","_t7","scrollToElement","scrollIntoView","scrollToPosition","x","y","scrollTo","updatePosition","pageXOffset","pageYOffset","position","scrollPositionChanged","SnapshotCache","size","keys","snapshots","has","read","touch","put","write","splice","unshift","trim","Visit","performScroll","_t8","identifier","adapter","timingMetrics","recordTimingMetric","request","cancelRender","fail","visitFailed","historyChanged","shouldIssueRequest","getCachedSnapshot","getCachedSnapshotForLocation","cacheSnapshot","visitRendered","redirectedToLocation","followedRedirect","replaceHistoryWithLocationAndRestorationIdentifier","scrolled","scrollToRestoredPosition","scrollToTop","scrollToAnchor","restorationData","scrollPosition","Date","getTime","getTimingMetrics","snapshotCached","frame","cancelAnimationFrame","_t9","Controller","clickBubbled","clickCaptured","view","scrollManager","startHistory","enabled","disable","stopHistory","cache","applicationAllowsVisitingLocation","locationIsVisitable","getRestorationDataForIdentifier","startVisit","pushHistoryWithLocationAndRestorationIdentifier","shouldCacheSnapshot","notifyApplicationBeforeCachingSnapshot","lastRenderedLocation","getCurrentRestorationData","notifyApplicationBeforeRender","currentVisit","notifyApplicationAfterRender","notifyApplicationAfterPageLoad","clickEventIsSignificant","getVisitableLinkForNode","getVisitableLocationForLink","applicationAllowsFollowingLinkToLocation","getActionForLink","notifyApplicationAfterClickingLinkToLocation","notifyApplicationBeforeVisitingLocation","notifyApplicationAfterVisitingLocation","timing","createVisit","isContentEditable","which","altKey","shiftKey","nodeIsVisitable","currentScript","hasAttribute","console","warn","factory","_assign","assign","canUseDOM","canUseHistory","canUsePassiveOption","support","win","opts","isString","isFunction","isArray","hasProp","raf","caf","cos","sin","pow","sqrt","PI","easings","linear","easeInQuad","_","b","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInSine","easeOutSine","easeInOutSine","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","$$","shift","isElement","isWindow","$el","isRootContainer","results","getHeight","max","scrollHeight","clientHeight","offsetHeight","getWidth","scrollWidth","clientWidth","offsetWidth","getSize","height","directionMethodMap","directionPropMap","getScroll","direction","setScroll","offset","top_1","getOffset","$context","rect","getBoundingClientRect","scroll_1","top","left","$ctx","cRect","clientTop","clientLeft","wheelEventName","listener","passive","eventName","addEvent","removeEvent","reRelativeToken","parseCoordinate","coordinate","enableVertical","res","relative","parseFloat","op","val","parseInt","defaultOptions","trigger","header","duration","easing","vertical","horizontal","cancellable","updateURL","before","after","step","SweetScroll","container","_this","ctx","$trigger","pos","startPos","loop","time","_a","startOffset","directionMap","timeElapsed","min","initial","delta","round","hook","handleClick","dataOptions","to","toTop","toLeft","handleStop","$container","distance","currentOptions","optOffset","$header","test","scroll","current","$target","_b","isRoot","viewport","innerWidth","innerHeight","getViewportAndElementSizes","toElement","$element","gotoEnd","unbind","onBefore","__","onStep","onAfter","onCancel","onComplete","_i","callbackResult","methodResult","concat","undefined","global","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","Promise","then","_classCallCheck","instance","Constructor","TypeError","_defineProperties","props","descriptor","configurable","writable","_createClass","protoProps","staticProps","_slicedToArray","arr","_arrayWithHoles","_arr","_n","_d","_s","next","err","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","_toConsumableArray","_arrayLikeToArray","_arrayWithoutHoles","iter","from","_iterableToArray","_nonIterableSpread","minLen","len","arr2","_defineProperty","ownKeys","enumerableOnly","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread2","source","getOwnPropertyDescriptors","defineProperties","arrayUnique","array","Set","isTesting","navigator","userAgent","includes","warnIfMalformedTemplate","directive","childElementCount","walk","node","firstElementChild","nextElementSibling","debounce","func","wait","context","later","saferEval","expression","dataContext","additionalHelperVariables","Function","values","saferEvalNoReturn","methodReference","xAttrRE","isXAttr","attr","replaceAtAndColonWithStandardSyntax","getXAttrs","component","directives","parseHtmlAttribute","spreadDirective","spreadObject","$data","entries","_ref","_ref2","_ref3","normalizedName","typeMatch","valueMatch","modifiers","startsWith","convertClassStringToArray","classList","filterFn","Boolean","transitionIn","forceSkip","attrs","showAttr","settingBothSidesOfTransition","transitionHelperIn","index","transitionClassesIn","transitionOut","transitionHelperOut","transitionClassesOut","showCallback","transitionHelper","modifierValue","origin","first","scale","second","hideCallback","fallback","rawValue","isNumeric","hook1","hook2","styleValues","opacityCache","transformCache","transform","transformOriginCache","transformOrigin","noModifiers","transitionOpacity","transitionScale","stages","during","transitionProperty","transitionDuration","transitionTimingFunction","end","cleanup","transition","ensureStringExpression","evaluateReturnExpression","enter","find","enterStart","enterEnd","transitionClasses","classesDuring","classesStart","classesEnd","originalClasses","__x_original_classes","_el$classList","add","_el$classList2","_el$classList3","_el$classList4","remove","_el$classList5","_el$classList6","Number","getComputedStyle","animationDuration","isConnected","subject","isNaN","handleForDirective","templateEl","initialUpdate","extraVars","iteratorNames","parseForExpression","items","ifAttribute","evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement","currentEl","item","iterationScopeVariables","scopeVariables","collection","getIterationScopeVariables","currentKey","bindKeyAttribute","generateKeyForIteration","nextEl","__x_for_key","tmpNextEl","parentElement","lookAheadForMatchingKeyedElementAndMoveItIfFound","__x_for","updateElements","importNode","addElementInLoopAfterCurrentEl","initializeElements","nextElementFromOldLoop","_loop","nextElementFromOldLoopImmutable","nextSibling","removeAnyLeftOverElementsFromPreviousUpdate","forIteratorRE","inMatch","iteratorMatch","handleAttributeBindingDirective","attrName","attrType","some","arrayWrappedValue","updateSelect","sort","classNames","_originalClasses","newClasses","isBooleanAttr","setIfChanged","handleTextDirective","output","innerText","handleHtmlDirective","handleShowDirective","removeProperty","handle","finish","showDirectiveLastElement","contains","executeAndClearRemainingShowDirectiveStack","showDirectiveStack","handleIfDirective","expressionResult","elementHasAlreadyBeenAdded","__x_inserted_me","registerListener","runListenerHandler","listenerTarget","_handler2","isKeyEvent","isListeningForASpecificKeyThatHasntBeenPressed","nextModifier","evaluateCommandExpression","keyModifiers","debounceIndex","keyToModifier","selectedSystemKeyModifiers","modifier","generateModelAssignmentFunction","currentValue","newValue","safeParseNumber","multiple","selectedOptions","number","_getPrototypeOf","getPrototypeOf","ObjectDefineProperty","_isExtensible","isExtensible","_getOwnPropertyDescriptor","getOwnPropertyNames","_preventExtensions","preventExtensions","_Array$prototype","ArrayConcat","isUndefined","proxyToValueMap","WeakMap","registerProxy","proxy","set","unwrap","replicaOrAny","wrapValue","membrane","valueIsObservable","getProxy","lockShadowTarget","shadowTarget","originalTarget","wrapDescriptor","ReactiveProxyHandler","valueObserved","valueMutated","thisArg","argArray","newTarget","shadowIsExtensible","targetIsExtensible","desc","shadowDescriptor","originalDescriptor","unwrapDescriptor","wrapReadOnlyValue","getReadOnlyProxy","ReadOnlyHandler","createShadowTarget","ObjectDotPrototype","defaultValueIsObservable","proto","defaultValueObserved","defaultValueMutated","defaultValueDistortion","getValue","unwrapProxy","fn","_start","ReactiveMembrane","valueDistortion","objectGraph","unwrappedValue","distorted","getReactiveState","readOnly","reactive","distortedValue","reactiveState","reactiveHandler","Proxy","readOnlyHandler","Component","seedDataForCloning","dataAttr","dataExpression","initExpression","unobservedData","initReturnedCallback","_this$wrapDataInObser","wrapDataInObservable","$refs","getRefsProxy","nextTickStack","$nextTick","watchers","$watch","pauseReactivity","listenForNewElementsToInitialize","observable","unwrappedData","copy","self","updateDom","mutationCallback","fullDotNotationKey","dotNotationParts","reduce","comparisonData","part","is","getUnobservedData","_this2","initializeComponentCallback","isSameNode","__x","rootEl","_this3","walkAndSkipNestedComponents","initializeElement","executeAndClearNextTickStack","registerListeners","resolveBoundAttributes","_this4","updateElement","_this5","reverse","thing","nestedPromise","promise","_this6","_ref4","listenerExpression","rightSideOfExpression","registerModelListener","_this7","modelIdx","findIndex","_ref5","$dispatch","getDispatchFunction","_this8","targetNode","MutationObserver","mutations","closestParentComponent","attributeName","rawData","addedNodes","observe","childList","subtree","Alpine","version","pauseMutationObserver","mark","_callee","_this9","_context","prev","discoverComponents","initializeComponent","discoverUninitializedComponents","listenForNewUninitializedComponentsAtRunTime","rootEls","_this10","newEl","deferLoadingAlpine","define","originalModule","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","Context","_invoke","doneResult","delegateResult","maybeInvokeDelegate","ContinueSentinel","_sent","dispatchException","abrupt","record","tryCatch","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","__await","unwrapped","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","displayName","isGeneratorFunction","genFun","ctor","setPrototypeOf","__proto__","awrap","pop","skipTempReset","charAt","rootRecord","rval","exception","loc","caught","hasCatch","hasFinally","finallyEntry","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","__webpack_amd_options__","webpackContext","req","webpackContextResolve","code","_typeof2","defaults","startAt","perView","focusAt","gap","autoplay","hoverpause","keyboard","bound","swipeThreshold","dragThreshold","perTouch","touchRatio","touchAngle","rewind","rewindDuration","animationTimingFunc","peek","breakpoints","classes","ltr","rtl","slider","carousel","swipeable","dragging","cloneSlide","activeNav","activeSlide","disabledArrow","msg","classCallCheck","createClass","_extends","receiver","parent","possibleConstructorReturn","ReferenceError","toInt","isObject","mount","glide","extensions","events","components","_name","prop","definition","mergeOptions","settings","EventsBus","hop","on","emit","Glide","_c","transformers","pattern","Run","make","Transition","Move","interval","_o","now","previous","leading","throttled","at","remaining","trailing","MARGIN_TYPE","siblings","matched","exist","HTMLElement","EventsBinder","listeners","closure","capture","VALID_DIRECTIONS","FLIPED_MOVEMENTS","Rtl","Components","modify","translate","Direction","Gap","Gaps","Grow","Clones","grow","Peeking","Peek","Focusing","Sizes","slideWidth","supportsPassive","supportsPassive$1","START_EVENTS","MOVE_EVENTS","END_EVENTS","MOUSE_EVENTS","sortBreakpoints","points","k","COMPONENTS","Html","root","track","slides","wrapper","slide","_r","Translate","Events","TRANSFORMERS","mutate","transformer","mutator","isType","isOffset","movement","compose","enable","addClass","removeClass","_v","setupSlides","setupWrapper","dimention","wrapperSize","reductor","marginLeft","marginRight","collect","_Glide$settings","peekIncrementer","_clone","_Components$Html","half","prepend","_i2","_i3","Resize","Binder","off","Build","typeClass","activeClass","sibling","removeClasses","move","calculate","isStart","isEnd","steps","countableSteps","_m","substr","Swipe","swipeSin","swipeStartX","swipeStartY","bindSwipeStart","swipe","touches","pageX","pageY","bindSwipeMove","bindSwipeEnd","subExSx","subEySy","powEX","abs","powEY","swipeHypotenuse","swipeCathetus","asin","threshold","swipeDistance","swipeDeg","unbindSwipeMove","unbindSwipeEnd","unbindSwipeStart","changedTouches","Images","dragstart","Anchors","detached","prevented","detach","draggable","attach","Controls","addBindings","setActive","removeActive","controls","removeBindings","currentTarget","Keyboard","press","keyCode","Autoplay","Breakpoints","matchMedia","point","_Core","Glide$$1","subClass","superClass","inherits","require","glideSlide","1024","600","currentSlide","slideTitle","activityTitle","640","fixedHeader","scrollTop","navigationEl"],"mappings":"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","file":"js/application-2be0ca5d40ac5105713b.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 30);\n","module.exports = require(\"regenerator-runtime\");\n","module.exports = function (module) {\n  if (!module.webpackPolyfill) {\n    module.deprecate = function () {};\n\n    module.paths = []; // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","module.exports = __webpack_public_path__ + \"media/images/about-72c5eff22da6c17818dda30d7f258872.jpg\";","module.exports = __webpack_public_path__ + \"media/images/ballet-0f92c6b55a98b081db7548a616982d3b.svg\";","module.exports = __webpack_public_path__ + \"media/images/banner-e5a2da1567057c679cc60153cbeb2836.jpg\";","module.exports = __webpack_public_path__ + \"media/images/bizx-award-5ba8b594a882fa170cd5d4377576551f.png\";","module.exports = __webpack_public_path__ + \"media/images/cd-badge-359afdf71a5d9de56ec9cdd04f5bc2bb.png\";","module.exports = __webpack_public_path__ + \"media/images/equipment-9d2ca063b6adf05c5498add598fcfc5d.svg\";","module.exports = __webpack_public_path__ + \"media/images/external-link-10ddaa5e7c2e1bfce2899da183dcf1ce.svg\";","module.exports = __webpack_public_path__ + \"media/images/facebook-cover-3611f09f0b8d4087bd65bda7537803e0.png\";","module.exports = __webpack_public_path__ + \"media/images/favicon-7adda10ca49259aed65e42df10bfcd61.png\";","module.exports = __webpack_public_path__ + \"media/images/football-faf2243ba452ece395b9bec0e01132e8.svg\";","module.exports = __webpack_public_path__ + \"media/images/karate-1aa6bb7883aa0593d0b4e96fe8299e12.svg\";","module.exports = __webpack_public_path__ + \"media/images/logo-38d44ab45132c95a890f8d45b5f32d4c.svg\";","module.exports = __webpack_public_path__ + \"media/images/logo-alt-f90c3f3297e60fd63bd564b88a7e640f.png\";","module.exports = __webpack_public_path__ + \"media/images/logo-white-5e639d1c853dc7398af3bf12a79482f8.svg\";","module.exports = __webpack_public_path__ + \"media/images/medal-7f98ce8a0fe44d15b6cb278548b6254d.svg\";","module.exports = __webpack_public_path__ + \"media/images/netball-152a6df0aa8d42f29517cea636c04155.svg\";","module.exports = __webpack_public_path__ + \"media/images/sports-f7bb29dead262d2a2fa65f0d9cf73fbe.jpg\";","module.exports = __webpack_public_path__ + \"media/images/tactic-d1287e11e42038b0c9fca0a2c0b4b78b.svg\";","module.exports = __webpack_public_path__ + \"media/images/tennis-54dfed2bf2e434e3b34429a006fc3473.svg\";","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*\nUnobtrusive JavaScript\nhttps://github.com/rails/rails/blob/master/actionview/app/assets/javascripts\nReleased under the MIT license\n */\n;\n(function () {\n  var context = this;\n  (function () {\n    (function () {\n      this.Rails = {\n        linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',\n        buttonClickSelector: {\n          selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])',\n          exclude: 'form button'\n        },\n        inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',\n        formSubmitSelector: 'form',\n        formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',\n        formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',\n        formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',\n        fileInputSelector: 'input[name][type=file]:not([disabled])',\n        linkDisableSelector: 'a[data-disable-with], a[data-disable]',\n        buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'\n      };\n    }).call(this);\n  }).call(context);\n  var Rails = context.Rails;\n  (function () {\n    (function () {\n      var nonce;\n      nonce = null;\n\n      Rails.loadCSPNonce = function () {\n        var ref;\n        return nonce = (ref = document.querySelector(\"meta[name=csp-nonce]\")) != null ? ref.content : void 0;\n      };\n\n      Rails.cspNonce = function () {\n        return nonce != null ? nonce : Rails.loadCSPNonce();\n      };\n    }).call(this);\n    (function () {\n      var expando, m;\n      m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;\n\n      Rails.matches = function (element, selector) {\n        if (selector.exclude != null) {\n          return m.call(element, selector.selector) && !m.call(element, selector.exclude);\n        } else {\n          return m.call(element, selector);\n        }\n      };\n\n      expando = '_ujsData';\n\n      Rails.getData = function (element, key) {\n        var ref;\n        return (ref = element[expando]) != null ? ref[key] : void 0;\n      };\n\n      Rails.setData = function (element, key, value) {\n        if (element[expando] == null) {\n          element[expando] = {};\n        }\n\n        return element[expando][key] = value;\n      };\n\n      Rails.$ = function (selector) {\n        return Array.prototype.slice.call(document.querySelectorAll(selector));\n      };\n    }).call(this);\n    (function () {\n      var $, csrfParam, csrfToken;\n      $ = Rails.$;\n\n      csrfToken = Rails.csrfToken = function () {\n        var meta;\n        meta = document.querySelector('meta[name=csrf-token]');\n        return meta && meta.content;\n      };\n\n      csrfParam = Rails.csrfParam = function () {\n        var meta;\n        meta = document.querySelector('meta[name=csrf-param]');\n        return meta && meta.content;\n      };\n\n      Rails.CSRFProtection = function (xhr) {\n        var token;\n        token = csrfToken();\n\n        if (token != null) {\n          return xhr.setRequestHeader('X-CSRF-Token', token);\n        }\n      };\n\n      Rails.refreshCSRFTokens = function () {\n        var param, token;\n        token = csrfToken();\n        param = csrfParam();\n\n        if (token != null && param != null) {\n          return $('form input[name=\"' + param + '\"]').forEach(function (input) {\n            return input.value = token;\n          });\n        }\n      };\n    }).call(this);\n    (function () {\n      var CustomEvent, fire, matches, preventDefault;\n      matches = Rails.matches;\n      CustomEvent = window.CustomEvent;\n\n      if (typeof CustomEvent !== 'function') {\n        CustomEvent = function CustomEvent(event, params) {\n          var evt;\n          evt = document.createEvent('CustomEvent');\n          evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);\n          return evt;\n        };\n\n        CustomEvent.prototype = window.Event.prototype;\n        preventDefault = CustomEvent.prototype.preventDefault;\n\n        CustomEvent.prototype.preventDefault = function () {\n          var result;\n          result = preventDefault.call(this);\n\n          if (this.cancelable && !this.defaultPrevented) {\n            Object.defineProperty(this, 'defaultPrevented', {\n              get: function get() {\n                return true;\n              }\n            });\n          }\n\n          return result;\n        };\n      }\n\n      fire = Rails.fire = function (obj, name, data) {\n        var event;\n        event = new CustomEvent(name, {\n          bubbles: true,\n          cancelable: true,\n          detail: data\n        });\n        obj.dispatchEvent(event);\n        return !event.defaultPrevented;\n      };\n\n      Rails.stopEverything = function (e) {\n        fire(e.target, 'ujs:everythingStopped');\n        e.preventDefault();\n        e.stopPropagation();\n        return e.stopImmediatePropagation();\n      };\n\n      Rails.delegate = function (element, selector, eventType, handler) {\n        return element.addEventListener(eventType, function (e) {\n          var target;\n          target = e.target;\n\n          while (!(!(target instanceof Element) || matches(target, selector))) {\n            target = target.parentNode;\n          }\n\n          if (target instanceof Element && handler.call(target, e) === false) {\n            e.preventDefault();\n            return e.stopPropagation();\n          }\n        });\n      };\n    }).call(this);\n    (function () {\n      var AcceptHeaders, CSRFProtection, createXHR, cspNonce, fire, prepareOptions, processResponse;\n      cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection, fire = Rails.fire;\n      AcceptHeaders = {\n        '*': '*/*',\n        text: 'text/plain',\n        html: 'text/html',\n        xml: 'application/xml, text/xml',\n        json: 'application/json, text/javascript',\n        script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'\n      };\n\n      Rails.ajax = function (options) {\n        var xhr;\n        options = prepareOptions(options);\n        xhr = createXHR(options, function () {\n          var ref, response;\n          response = processResponse((ref = xhr.response) != null ? ref : xhr.responseText, xhr.getResponseHeader('Content-Type'));\n\n          if (Math.floor(xhr.status / 100) === 2) {\n            if (typeof options.success === \"function\") {\n              options.success(response, xhr.statusText, xhr);\n            }\n          } else {\n            if (typeof options.error === \"function\") {\n              options.error(response, xhr.statusText, xhr);\n            }\n          }\n\n          return typeof options.complete === \"function\" ? options.complete(xhr, xhr.statusText) : void 0;\n        });\n\n        if (options.beforeSend != null && !options.beforeSend(xhr, options)) {\n          return false;\n        }\n\n        if (xhr.readyState === XMLHttpRequest.OPENED) {\n          return xhr.send(options.data);\n        }\n      };\n\n      prepareOptions = function prepareOptions(options) {\n        options.url = options.url || location.href;\n        options.type = options.type.toUpperCase();\n\n        if (options.type === 'GET' && options.data) {\n          if (options.url.indexOf('?') < 0) {\n            options.url += '?' + options.data;\n          } else {\n            options.url += '&' + options.data;\n          }\n        }\n\n        if (AcceptHeaders[options.dataType] == null) {\n          options.dataType = '*';\n        }\n\n        options.accept = AcceptHeaders[options.dataType];\n\n        if (options.dataType !== '*') {\n          options.accept += ', */*; q=0.01';\n        }\n\n        return options;\n      };\n\n      createXHR = function createXHR(options, done) {\n        var xhr;\n        xhr = new XMLHttpRequest();\n        xhr.open(options.type, options.url, true);\n        xhr.setRequestHeader('Accept', options.accept);\n\n        if (typeof options.data === 'string') {\n          xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');\n        }\n\n        if (!options.crossDomain) {\n          xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');\n        }\n\n        CSRFProtection(xhr);\n        xhr.withCredentials = !!options.withCredentials;\n\n        xhr.onreadystatechange = function () {\n          if (xhr.readyState === XMLHttpRequest.DONE) {\n            return done(xhr);\n          }\n        };\n\n        return xhr;\n      };\n\n      processResponse = function processResponse(response, type) {\n        var parser, script;\n\n        if (typeof response === 'string' && typeof type === 'string') {\n          if (type.match(/\\bjson\\b/)) {\n            try {\n              response = JSON.parse(response);\n            } catch (error) {}\n          } else if (type.match(/\\b(?:java|ecma)script\\b/)) {\n            script = document.createElement('script');\n            script.setAttribute('nonce', cspNonce());\n            script.text = response;\n            document.head.appendChild(script).parentNode.removeChild(script);\n          } else if (type.match(/\\b(xml|html|svg)\\b/)) {\n            parser = new DOMParser();\n            type = type.replace(/;.+/, '');\n\n            try {\n              response = parser.parseFromString(response, type);\n            } catch (error) {}\n          }\n        }\n\n        return response;\n      };\n\n      Rails.href = function (element) {\n        return element.href;\n      };\n\n      Rails.isCrossDomain = function (url) {\n        var e, originAnchor, urlAnchor;\n        originAnchor = document.createElement('a');\n        originAnchor.href = location.href;\n        urlAnchor = document.createElement('a');\n\n        try {\n          urlAnchor.href = url;\n          return !((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host || originAnchor.protocol + '//' + originAnchor.host === urlAnchor.protocol + '//' + urlAnchor.host);\n        } catch (error) {\n          e = error;\n          return true;\n        }\n      };\n    }).call(this);\n    (function () {\n      var matches, toArray;\n      matches = Rails.matches;\n\n      toArray = function toArray(e) {\n        return Array.prototype.slice.call(e);\n      };\n\n      Rails.serializeElement = function (element, additionalParam) {\n        var inputs, params;\n        inputs = [element];\n\n        if (matches(element, 'form')) {\n          inputs = toArray(element.elements);\n        }\n\n        params = [];\n        inputs.forEach(function (input) {\n          if (!input.name || input.disabled) {\n            return;\n          }\n\n          if (matches(input, 'select')) {\n            return toArray(input.options).forEach(function (option) {\n              if (option.selected) {\n                return params.push({\n                  name: input.name,\n                  value: option.value\n                });\n              }\n            });\n          } else if (input.checked || ['radio', 'checkbox', 'submit'].indexOf(input.type) === -1) {\n            return params.push({\n              name: input.name,\n              value: input.value\n            });\n          }\n        });\n\n        if (additionalParam) {\n          params.push(additionalParam);\n        }\n\n        return params.map(function (param) {\n          if (param.name != null) {\n            return encodeURIComponent(param.name) + \"=\" + encodeURIComponent(param.value);\n          } else {\n            return param;\n          }\n        }).join('&');\n      };\n\n      Rails.formElements = function (form, selector) {\n        if (matches(form, 'form')) {\n          return toArray(form.elements).filter(function (el) {\n            return matches(el, selector);\n          });\n        } else {\n          return toArray(form.querySelectorAll(selector));\n        }\n      };\n    }).call(this);\n    (function () {\n      var allowAction, fire, stopEverything;\n      fire = Rails.fire, stopEverything = Rails.stopEverything;\n\n      Rails.handleConfirm = function (e) {\n        if (!allowAction(this)) {\n          return stopEverything(e);\n        }\n      };\n\n      allowAction = function allowAction(element) {\n        var answer, callback, message;\n        message = element.getAttribute('data-confirm');\n\n        if (!message) {\n          return true;\n        }\n\n        answer = false;\n\n        if (fire(element, 'confirm')) {\n          try {\n            answer = confirm(message);\n          } catch (error) {}\n\n          callback = fire(element, 'confirm:complete', [answer]);\n        }\n\n        return answer && callback;\n      };\n    }).call(this);\n    (function () {\n      var disableFormElement, disableFormElements, disableLinkElement, enableFormElement, enableFormElements, enableLinkElement, formElements, getData, matches, setData, stopEverything;\n      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, stopEverything = Rails.stopEverything, formElements = Rails.formElements;\n\n      Rails.handleDisabledElement = function (e) {\n        var element;\n        element = this;\n\n        if (element.disabled) {\n          return stopEverything(e);\n        }\n      };\n\n      Rails.enableElement = function (e) {\n        var element;\n        element = e instanceof Event ? e.target : e;\n\n        if (matches(element, Rails.linkDisableSelector)) {\n          return enableLinkElement(element);\n        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formEnableSelector)) {\n          return enableFormElement(element);\n        } else if (matches(element, Rails.formSubmitSelector)) {\n          return enableFormElements(element);\n        }\n      };\n\n      Rails.disableElement = function (e) {\n        var element;\n        element = e instanceof Event ? e.target : e;\n\n        if (matches(element, Rails.linkDisableSelector)) {\n          return disableLinkElement(element);\n        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formDisableSelector)) {\n          return disableFormElement(element);\n        } else if (matches(element, Rails.formSubmitSelector)) {\n          return disableFormElements(element);\n        }\n      };\n\n      disableLinkElement = function disableLinkElement(element) {\n        var replacement;\n        replacement = element.getAttribute('data-disable-with');\n\n        if (replacement != null) {\n          setData(element, 'ujs:enable-with', element.innerHTML);\n          element.innerHTML = replacement;\n        }\n\n        element.addEventListener('click', stopEverything);\n        return setData(element, 'ujs:disabled', true);\n      };\n\n      enableLinkElement = function enableLinkElement(element) {\n        var originalText;\n        originalText = getData(element, 'ujs:enable-with');\n\n        if (originalText != null) {\n          element.innerHTML = originalText;\n          setData(element, 'ujs:enable-with', null);\n        }\n\n        element.removeEventListener('click', stopEverything);\n        return setData(element, 'ujs:disabled', null);\n      };\n\n      disableFormElements = function disableFormElements(form) {\n        return formElements(form, Rails.formDisableSelector).forEach(disableFormElement);\n      };\n\n      disableFormElement = function disableFormElement(element) {\n        var replacement;\n        replacement = element.getAttribute('data-disable-with');\n\n        if (replacement != null) {\n          if (matches(element, 'button')) {\n            setData(element, 'ujs:enable-with', element.innerHTML);\n            element.innerHTML = replacement;\n          } else {\n            setData(element, 'ujs:enable-with', element.value);\n            element.value = replacement;\n          }\n        }\n\n        element.disabled = true;\n        return setData(element, 'ujs:disabled', true);\n      };\n\n      enableFormElements = function enableFormElements(form) {\n        return formElements(form, Rails.formEnableSelector).forEach(enableFormElement);\n      };\n\n      enableFormElement = function enableFormElement(element) {\n        var originalText;\n        originalText = getData(element, 'ujs:enable-with');\n\n        if (originalText != null) {\n          if (matches(element, 'button')) {\n            element.innerHTML = originalText;\n          } else {\n            element.value = originalText;\n          }\n\n          setData(element, 'ujs:enable-with', null);\n        }\n\n        element.disabled = false;\n        return setData(element, 'ujs:disabled', null);\n      };\n    }).call(this);\n    (function () {\n      var stopEverything;\n      stopEverything = Rails.stopEverything;\n\n      Rails.handleMethod = function (e) {\n        var csrfParam, csrfToken, form, formContent, href, link, method;\n        link = this;\n        method = link.getAttribute('data-method');\n\n        if (!method) {\n          return;\n        }\n\n        href = Rails.href(link);\n        csrfToken = Rails.csrfToken();\n        csrfParam = Rails.csrfParam();\n        form = document.createElement('form');\n        formContent = \"<input name='_method' value='\" + method + \"' type='hidden' />\";\n\n        if (csrfParam != null && csrfToken != null && !Rails.isCrossDomain(href)) {\n          formContent += \"<input name='\" + csrfParam + \"' value='\" + csrfToken + \"' type='hidden' />\";\n        }\n\n        formContent += '<input type=\"submit\" />';\n        form.method = 'post';\n        form.action = href;\n        form.target = link.target;\n        form.innerHTML = formContent;\n        form.style.display = 'none';\n        document.body.appendChild(form);\n        form.querySelector('[type=\"submit\"]').click();\n        return stopEverything(e);\n      };\n    }).call(this);\n    (function () {\n      var ajax,\n          fire,\n          getData,\n          isCrossDomain,\n          isRemote,\n          matches,\n          serializeElement,\n          setData,\n          stopEverything,\n          slice = [].slice;\n      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, fire = Rails.fire, stopEverything = Rails.stopEverything, ajax = Rails.ajax, isCrossDomain = Rails.isCrossDomain, serializeElement = Rails.serializeElement;\n\n      isRemote = function isRemote(element) {\n        var value;\n        value = element.getAttribute('data-remote');\n        return value != null && value !== 'false';\n      };\n\n      Rails.handleRemote = function (e) {\n        var button, data, dataType, element, method, url, withCredentials;\n        element = this;\n\n        if (!isRemote(element)) {\n          return true;\n        }\n\n        if (!fire(element, 'ajax:before')) {\n          fire(element, 'ajax:stopped');\n          return false;\n        }\n\n        withCredentials = element.getAttribute('data-with-credentials');\n        dataType = element.getAttribute('data-type') || 'script';\n\n        if (matches(element, Rails.formSubmitSelector)) {\n          button = getData(element, 'ujs:submit-button');\n          method = getData(element, 'ujs:submit-button-formmethod') || element.method;\n          url = getData(element, 'ujs:submit-button-formaction') || element.getAttribute('action') || location.href;\n\n          if (method.toUpperCase() === 'GET') {\n            url = url.replace(/\\?.*$/, '');\n          }\n\n          if (element.enctype === 'multipart/form-data') {\n            data = new FormData(element);\n\n            if (button != null) {\n              data.append(button.name, button.value);\n            }\n          } else {\n            data = serializeElement(element, button);\n          }\n\n          setData(element, 'ujs:submit-button', null);\n          setData(element, 'ujs:submit-button-formmethod', null);\n          setData(element, 'ujs:submit-button-formaction', null);\n        } else if (matches(element, Rails.buttonClickSelector) || matches(element, Rails.inputChangeSelector)) {\n          method = element.getAttribute('data-method');\n          url = element.getAttribute('data-url');\n          data = serializeElement(element, element.getAttribute('data-params'));\n        } else {\n          method = element.getAttribute('data-method');\n          url = Rails.href(element);\n          data = element.getAttribute('data-params');\n        }\n\n        ajax({\n          type: method || 'GET',\n          url: url,\n          data: data,\n          dataType: dataType,\n          beforeSend: function beforeSend(xhr, options) {\n            if (fire(element, 'ajax:beforeSend', [xhr, options])) {\n              return fire(element, 'ajax:send', [xhr]);\n            } else {\n              fire(element, 'ajax:stopped');\n              return false;\n            }\n          },\n          success: function success() {\n            var args;\n            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n            return fire(element, 'ajax:success', args);\n          },\n          error: function error() {\n            var args;\n            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n            return fire(element, 'ajax:error', args);\n          },\n          complete: function complete() {\n            var args;\n            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n            return fire(element, 'ajax:complete', args);\n          },\n          crossDomain: isCrossDomain(url),\n          withCredentials: withCredentials != null && withCredentials !== 'false'\n        });\n        return stopEverything(e);\n      };\n\n      Rails.formSubmitButtonClick = function (e) {\n        var button, form;\n        button = this;\n        form = button.form;\n\n        if (!form) {\n          return;\n        }\n\n        if (button.name) {\n          setData(form, 'ujs:submit-button', {\n            name: button.name,\n            value: button.value\n          });\n        }\n\n        setData(form, 'ujs:formnovalidate-button', button.formNoValidate);\n        setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'));\n        return setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'));\n      };\n\n      Rails.preventInsignificantClick = function (e) {\n        var data, insignificantMetaClick, link, metaClick, method, nonPrimaryMouseClick;\n        link = this;\n        method = (link.getAttribute('data-method') || 'GET').toUpperCase();\n        data = link.getAttribute('data-params');\n        metaClick = e.metaKey || e.ctrlKey;\n        insignificantMetaClick = metaClick && method === 'GET' && !data;\n        nonPrimaryMouseClick = e.button != null && e.button !== 0;\n\n        if (nonPrimaryMouseClick || insignificantMetaClick) {\n          return e.stopImmediatePropagation();\n        }\n      };\n    }).call(this);\n    (function () {\n      var $, CSRFProtection, delegate, disableElement, enableElement, fire, formSubmitButtonClick, getData, handleConfirm, handleDisabledElement, handleMethod, handleRemote, loadCSPNonce, preventInsignificantClick, refreshCSRFTokens;\n      fire = Rails.fire, delegate = Rails.delegate, getData = Rails.getData, $ = Rails.$, refreshCSRFTokens = Rails.refreshCSRFTokens, CSRFProtection = Rails.CSRFProtection, loadCSPNonce = Rails.loadCSPNonce, enableElement = Rails.enableElement, disableElement = Rails.disableElement, handleDisabledElement = Rails.handleDisabledElement, handleConfirm = Rails.handleConfirm, preventInsignificantClick = Rails.preventInsignificantClick, handleRemote = Rails.handleRemote, formSubmitButtonClick = Rails.formSubmitButtonClick, handleMethod = Rails.handleMethod;\n\n      if (typeof jQuery !== \"undefined\" && jQuery !== null && jQuery.ajax != null) {\n        if (jQuery.rails) {\n          throw new Error('If you load both jquery_ujs and rails-ujs, use rails-ujs only.');\n        }\n\n        jQuery.rails = Rails;\n        jQuery.ajaxPrefilter(function (options, originalOptions, xhr) {\n          if (!options.crossDomain) {\n            return CSRFProtection(xhr);\n          }\n        });\n      }\n\n      Rails.start = function () {\n        if (window._rails_loaded) {\n          throw new Error('rails-ujs has already been loaded!');\n        }\n\n        window.addEventListener('pageshow', function () {\n          $(Rails.formEnableSelector).forEach(function (el) {\n            if (getData(el, 'ujs:disabled')) {\n              return enableElement(el);\n            }\n          });\n          return $(Rails.linkDisableSelector).forEach(function (el) {\n            if (getData(el, 'ujs:disabled')) {\n              return enableElement(el);\n            }\n          });\n        });\n        delegate(document, Rails.linkDisableSelector, 'ajax:complete', enableElement);\n        delegate(document, Rails.linkDisableSelector, 'ajax:stopped', enableElement);\n        delegate(document, Rails.buttonDisableSelector, 'ajax:complete', enableElement);\n        delegate(document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement);\n        delegate(document, Rails.linkClickSelector, 'click', preventInsignificantClick);\n        delegate(document, Rails.linkClickSelector, 'click', handleDisabledElement);\n        delegate(document, Rails.linkClickSelector, 'click', handleConfirm);\n        delegate(document, Rails.linkClickSelector, 'click', disableElement);\n        delegate(document, Rails.linkClickSelector, 'click', handleRemote);\n        delegate(document, Rails.linkClickSelector, 'click', handleMethod);\n        delegate(document, Rails.buttonClickSelector, 'click', preventInsignificantClick);\n        delegate(document, Rails.buttonClickSelector, 'click', handleDisabledElement);\n        delegate(document, Rails.buttonClickSelector, 'click', handleConfirm);\n        delegate(document, Rails.buttonClickSelector, 'click', disableElement);\n        delegate(document, Rails.buttonClickSelector, 'click', handleRemote);\n        delegate(document, Rails.inputChangeSelector, 'change', handleDisabledElement);\n        delegate(document, Rails.inputChangeSelector, 'change', handleConfirm);\n        delegate(document, Rails.inputChangeSelector, 'change', handleRemote);\n        delegate(document, Rails.formSubmitSelector, 'submit', handleDisabledElement);\n        delegate(document, Rails.formSubmitSelector, 'submit', handleConfirm);\n        delegate(document, Rails.formSubmitSelector, 'submit', handleRemote);\n        delegate(document, Rails.formSubmitSelector, 'submit', function (e) {\n          return setTimeout(function () {\n            return disableElement(e);\n          }, 13);\n        });\n        delegate(document, Rails.formSubmitSelector, 'ajax:send', disableElement);\n        delegate(document, Rails.formSubmitSelector, 'ajax:complete', enableElement);\n        delegate(document, Rails.formInputClickSelector, 'click', preventInsignificantClick);\n        delegate(document, Rails.formInputClickSelector, 'click', handleDisabledElement);\n        delegate(document, Rails.formInputClickSelector, 'click', handleConfirm);\n        delegate(document, Rails.formInputClickSelector, 'click', formSubmitButtonClick);\n        document.addEventListener('DOMContentLoaded', refreshCSRFTokens);\n        document.addEventListener('DOMContentLoaded', loadCSPNonce);\n        return window._rails_loaded = true;\n      };\n\n      if (window.Rails === Rails && fire(document, 'rails:attachBindings')) {\n        Rails.start();\n      }\n    }).call(this);\n  }).call(this);\n\n  if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === \"object\" && module.exports) {\n    module.exports = Rails;\n  } else if (typeof define === \"function\" && define.amd) {\n    define(Rails);\n  }\n}).call(this);","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*\nTurbolinks 5.2.0\nCopyright © 2018 Basecamp, LLC\n */\n(function () {\n  var t = this;\n  (function () {\n    (function () {\n      this.Turbolinks = {\n        supported: function () {\n          return null != window.history.pushState && null != window.requestAnimationFrame && null != window.addEventListener;\n        }(),\n        visit: function visit(t, r) {\n          return e.controller.visit(t, r);\n        },\n        clearCache: function clearCache() {\n          return e.controller.clearCache();\n        },\n        setProgressBarDelay: function setProgressBarDelay(t) {\n          return e.controller.setProgressBarDelay(t);\n        }\n      };\n    }).call(this);\n  }).call(t);\n  var e = t.Turbolinks;\n  (function () {\n    (function () {\n      var t,\n          r,\n          n,\n          o = [].slice;\n      e.copyObject = function (t) {\n        var e, r, n;\n        r = {};\n\n        for (e in t) {\n          n = t[e], r[e] = n;\n        }\n\n        return r;\n      }, e.closest = function (e, r) {\n        return t.call(e, r);\n      }, t = function () {\n        var t, e;\n        return t = document.documentElement, null != (e = t.closest) ? e : function (t) {\n          var e;\n\n          for (e = this; e;) {\n            if (e.nodeType === Node.ELEMENT_NODE && r.call(e, t)) return e;\n            e = e.parentNode;\n          }\n        };\n      }(), e.defer = function (t) {\n        return setTimeout(t, 1);\n      }, e.throttle = function (t) {\n        var e;\n        return e = null, function () {\n          var r;\n          return r = 1 <= arguments.length ? o.call(arguments, 0) : [], null != e ? e : e = requestAnimationFrame(function (n) {\n            return function () {\n              return e = null, t.apply(n, r);\n            };\n          }(this));\n        };\n      }, e.dispatch = function (t, e) {\n        var r, o, i, s, a, u;\n        return a = null != e ? e : {}, u = a.target, r = a.cancelable, o = a.data, i = document.createEvent(\"Events\"), i.initEvent(t, !0, r === !0), i.data = null != o ? o : {}, i.cancelable && !n && (s = i.preventDefault, i.preventDefault = function () {\n          return this.defaultPrevented || Object.defineProperty(this, \"defaultPrevented\", {\n            get: function get() {\n              return !0;\n            }\n          }), s.call(this);\n        }), (null != u ? u : document).dispatchEvent(i), i;\n      }, n = function () {\n        var t;\n        return t = document.createEvent(\"Events\"), t.initEvent(\"test\", !0, !0), t.preventDefault(), t.defaultPrevented;\n      }(), e.match = function (t, e) {\n        return r.call(t, e);\n      }, r = function () {\n        var t, e, r, n;\n        return t = document.documentElement, null != (e = null != (r = null != (n = t.matchesSelector) ? n : t.webkitMatchesSelector) ? r : t.msMatchesSelector) ? e : t.mozMatchesSelector;\n      }(), e.uuid = function () {\n        var t, e, r;\n\n        for (r = \"\", t = e = 1; 36 >= e; t = ++e) {\n          r += 9 === t || 14 === t || 19 === t || 24 === t ? \"-\" : 15 === t ? \"4\" : 20 === t ? (Math.floor(4 * Math.random()) + 8).toString(16) : Math.floor(15 * Math.random()).toString(16);\n        }\n\n        return r;\n      };\n    }).call(this), function () {\n      e.Location = function () {\n        function t(t) {\n          var e, r;\n          null == t && (t = \"\"), r = document.createElement(\"a\"), r.href = t.toString(), this.absoluteURL = r.href, e = r.hash.length, 2 > e ? this.requestURL = this.absoluteURL : (this.requestURL = this.absoluteURL.slice(0, -e), this.anchor = r.hash.slice(1));\n        }\n\n        var e, r, n, o;\n        return t.wrap = function (t) {\n          return t instanceof this ? t : new this(t);\n        }, t.prototype.getOrigin = function () {\n          return this.absoluteURL.split(\"/\", 3).join(\"/\");\n        }, t.prototype.getPath = function () {\n          var t, e;\n          return null != (t = null != (e = this.requestURL.match(/\\/\\/[^\\/]*(\\/[^?;]*)/)) ? e[1] : void 0) ? t : \"/\";\n        }, t.prototype.getPathComponents = function () {\n          return this.getPath().split(\"/\").slice(1);\n        }, t.prototype.getLastPathComponent = function () {\n          return this.getPathComponents().slice(-1)[0];\n        }, t.prototype.getExtension = function () {\n          var t, e;\n          return null != (t = null != (e = this.getLastPathComponent().match(/\\.[^.]*$/)) ? e[0] : void 0) ? t : \"\";\n        }, t.prototype.isHTML = function () {\n          return this.getExtension().match(/^(?:|\\.(?:htm|html|xhtml))$/);\n        }, t.prototype.isPrefixedBy = function (t) {\n          var e;\n          return e = r(t), this.isEqualTo(t) || o(this.absoluteURL, e);\n        }, t.prototype.isEqualTo = function (t) {\n          return this.absoluteURL === (null != t ? t.absoluteURL : void 0);\n        }, t.prototype.toCacheKey = function () {\n          return this.requestURL;\n        }, t.prototype.toJSON = function () {\n          return this.absoluteURL;\n        }, t.prototype.toString = function () {\n          return this.absoluteURL;\n        }, t.prototype.valueOf = function () {\n          return this.absoluteURL;\n        }, r = function r(t) {\n          return e(t.getOrigin() + t.getPath());\n        }, e = function e(t) {\n          return n(t, \"/\") ? t : t + \"/\";\n        }, o = function o(t, e) {\n          return t.slice(0, e.length) === e;\n        }, n = function n(t, e) {\n          return t.slice(-e.length) === e;\n        }, t;\n      }();\n    }.call(this), function () {\n      var t = function t(_t, e) {\n        return function () {\n          return _t.apply(e, arguments);\n        };\n      };\n\n      e.HttpRequest = function () {\n        function r(r, n, o) {\n          this.delegate = r, this.requestCanceled = t(this.requestCanceled, this), this.requestTimedOut = t(this.requestTimedOut, this), this.requestFailed = t(this.requestFailed, this), this.requestLoaded = t(this.requestLoaded, this), this.requestProgressed = t(this.requestProgressed, this), this.url = e.Location.wrap(n).requestURL, this.referrer = e.Location.wrap(o).absoluteURL, this.createXHR();\n        }\n\n        return r.NETWORK_FAILURE = 0, r.TIMEOUT_FAILURE = -1, r.timeout = 60, r.prototype.send = function () {\n          var t;\n          return this.xhr && !this.sent ? (this.notifyApplicationBeforeRequestStart(), this.setProgress(0), this.xhr.send(), this.sent = !0, \"function\" == typeof (t = this.delegate).requestStarted ? t.requestStarted() : void 0) : void 0;\n        }, r.prototype.cancel = function () {\n          return this.xhr && this.sent ? this.xhr.abort() : void 0;\n        }, r.prototype.requestProgressed = function (t) {\n          return t.lengthComputable ? this.setProgress(t.loaded / t.total) : void 0;\n        }, r.prototype.requestLoaded = function () {\n          return this.endRequest(function (t) {\n            return function () {\n              var e;\n              return 200 <= (e = t.xhr.status) && 300 > e ? t.delegate.requestCompletedWithResponse(t.xhr.responseText, t.xhr.getResponseHeader(\"Turbolinks-Location\")) : (t.failed = !0, t.delegate.requestFailedWithStatusCode(t.xhr.status, t.xhr.responseText));\n            };\n          }(this));\n        }, r.prototype.requestFailed = function () {\n          return this.endRequest(function (t) {\n            return function () {\n              return t.failed = !0, t.delegate.requestFailedWithStatusCode(t.constructor.NETWORK_FAILURE);\n            };\n          }(this));\n        }, r.prototype.requestTimedOut = function () {\n          return this.endRequest(function (t) {\n            return function () {\n              return t.failed = !0, t.delegate.requestFailedWithStatusCode(t.constructor.TIMEOUT_FAILURE);\n            };\n          }(this));\n        }, r.prototype.requestCanceled = function () {\n          return this.endRequest();\n        }, r.prototype.notifyApplicationBeforeRequestStart = function () {\n          return e.dispatch(\"turbolinks:request-start\", {\n            data: {\n              url: this.url,\n              xhr: this.xhr\n            }\n          });\n        }, r.prototype.notifyApplicationAfterRequestEnd = function () {\n          return e.dispatch(\"turbolinks:request-end\", {\n            data: {\n              url: this.url,\n              xhr: this.xhr\n            }\n          });\n        }, r.prototype.createXHR = function () {\n          return this.xhr = new XMLHttpRequest(), this.xhr.open(\"GET\", this.url, !0), this.xhr.timeout = 1e3 * this.constructor.timeout, this.xhr.setRequestHeader(\"Accept\", \"text/html, application/xhtml+xml\"), this.xhr.setRequestHeader(\"Turbolinks-Referrer\", this.referrer), this.xhr.onprogress = this.requestProgressed, this.xhr.onload = this.requestLoaded, this.xhr.onerror = this.requestFailed, this.xhr.ontimeout = this.requestTimedOut, this.xhr.onabort = this.requestCanceled;\n        }, r.prototype.endRequest = function (t) {\n          return this.xhr ? (this.notifyApplicationAfterRequestEnd(), null != t && t.call(this), this.destroy()) : void 0;\n        }, r.prototype.setProgress = function (t) {\n          var e;\n          return this.progress = t, \"function\" == typeof (e = this.delegate).requestProgressed ? e.requestProgressed(this.progress) : void 0;\n        }, r.prototype.destroy = function () {\n          var t;\n          return this.setProgress(1), \"function\" == typeof (t = this.delegate).requestFinished && t.requestFinished(), this.delegate = null, this.xhr = null;\n        }, r;\n      }();\n    }.call(this), function () {\n      var t = function t(_t2, e) {\n        return function () {\n          return _t2.apply(e, arguments);\n        };\n      };\n\n      e.ProgressBar = function () {\n        function e() {\n          this.trickle = t(this.trickle, this), this.stylesheetElement = this.createStylesheetElement(), this.progressElement = this.createProgressElement();\n        }\n\n        var r;\n        return r = 300, e.defaultCSS = \".turbolinks-progress-bar {\\n  position: fixed;\\n  display: block;\\n  top: 0;\\n  left: 0;\\n  height: 3px;\\n  background: #0076ff;\\n  z-index: 9999;\\n  transition: width \" + r + \"ms ease-out, opacity \" + r / 2 + \"ms \" + r / 2 + \"ms ease-in;\\n  transform: translate3d(0, 0, 0);\\n}\", e.prototype.show = function () {\n          return this.visible ? void 0 : (this.visible = !0, this.installStylesheetElement(), this.installProgressElement(), this.startTrickling());\n        }, e.prototype.hide = function () {\n          return this.visible && !this.hiding ? (this.hiding = !0, this.fadeProgressElement(function (t) {\n            return function () {\n              return t.uninstallProgressElement(), t.stopTrickling(), t.visible = !1, t.hiding = !1;\n            };\n          }(this))) : void 0;\n        }, e.prototype.setValue = function (t) {\n          return this.value = t, this.refresh();\n        }, e.prototype.installStylesheetElement = function () {\n          return document.head.insertBefore(this.stylesheetElement, document.head.firstChild);\n        }, e.prototype.installProgressElement = function () {\n          return this.progressElement.style.width = 0, this.progressElement.style.opacity = 1, document.documentElement.insertBefore(this.progressElement, document.body), this.refresh();\n        }, e.prototype.fadeProgressElement = function (t) {\n          return this.progressElement.style.opacity = 0, setTimeout(t, 1.5 * r);\n        }, e.prototype.uninstallProgressElement = function () {\n          return this.progressElement.parentNode ? document.documentElement.removeChild(this.progressElement) : void 0;\n        }, e.prototype.startTrickling = function () {\n          return null != this.trickleInterval ? this.trickleInterval : this.trickleInterval = setInterval(this.trickle, r);\n        }, e.prototype.stopTrickling = function () {\n          return clearInterval(this.trickleInterval), this.trickleInterval = null;\n        }, e.prototype.trickle = function () {\n          return this.setValue(this.value + Math.random() / 100);\n        }, e.prototype.refresh = function () {\n          return requestAnimationFrame(function (t) {\n            return function () {\n              return t.progressElement.style.width = 10 + 90 * t.value + \"%\";\n            };\n          }(this));\n        }, e.prototype.createStylesheetElement = function () {\n          var t;\n          return t = document.createElement(\"style\"), t.type = \"text/css\", t.textContent = this.constructor.defaultCSS, t;\n        }, e.prototype.createProgressElement = function () {\n          var t;\n          return t = document.createElement(\"div\"), t.className = \"turbolinks-progress-bar\", t;\n        }, e;\n      }();\n    }.call(this), function () {\n      var t = function t(_t3, e) {\n        return function () {\n          return _t3.apply(e, arguments);\n        };\n      };\n\n      e.BrowserAdapter = function () {\n        function r(r) {\n          this.controller = r, this.showProgressBar = t(this.showProgressBar, this), this.progressBar = new e.ProgressBar();\n        }\n\n        var n, o, i;\n        return i = e.HttpRequest, n = i.NETWORK_FAILURE, o = i.TIMEOUT_FAILURE, r.prototype.visitProposedToLocationWithAction = function (t, e) {\n          return this.controller.startVisitToLocationWithAction(t, e);\n        }, r.prototype.visitStarted = function (t) {\n          return t.issueRequest(), t.changeHistory(), t.loadCachedSnapshot();\n        }, r.prototype.visitRequestStarted = function (t) {\n          return this.progressBar.setValue(0), t.hasCachedSnapshot() || \"restore\" !== t.action ? this.showProgressBarAfterDelay() : this.showProgressBar();\n        }, r.prototype.visitRequestProgressed = function (t) {\n          return this.progressBar.setValue(t.progress);\n        }, r.prototype.visitRequestCompleted = function (t) {\n          return t.loadResponse();\n        }, r.prototype.visitRequestFailedWithStatusCode = function (t, e) {\n          switch (e) {\n            case n:\n            case o:\n              return this.reload();\n\n            default:\n              return t.loadResponse();\n          }\n        }, r.prototype.visitRequestFinished = function (t) {\n          return this.hideProgressBar();\n        }, r.prototype.visitCompleted = function (t) {\n          return t.followRedirect();\n        }, r.prototype.pageInvalidated = function () {\n          return this.reload();\n        }, r.prototype.showProgressBarAfterDelay = function () {\n          return this.progressBarTimeout = setTimeout(this.showProgressBar, this.controller.progressBarDelay);\n        }, r.prototype.showProgressBar = function () {\n          return this.progressBar.show();\n        }, r.prototype.hideProgressBar = function () {\n          return this.progressBar.hide(), clearTimeout(this.progressBarTimeout);\n        }, r.prototype.reload = function () {\n          return window.location.reload();\n        }, r;\n      }();\n    }.call(this), function () {\n      var t = function t(_t4, e) {\n        return function () {\n          return _t4.apply(e, arguments);\n        };\n      };\n\n      e.History = function () {\n        function r(e) {\n          this.delegate = e, this.onPageLoad = t(this.onPageLoad, this), this.onPopState = t(this.onPopState, this);\n        }\n\n        return r.prototype.start = function () {\n          return this.started ? void 0 : (addEventListener(\"popstate\", this.onPopState, !1), addEventListener(\"load\", this.onPageLoad, !1), this.started = !0);\n        }, r.prototype.stop = function () {\n          return this.started ? (removeEventListener(\"popstate\", this.onPopState, !1), removeEventListener(\"load\", this.onPageLoad, !1), this.started = !1) : void 0;\n        }, r.prototype.push = function (t, r) {\n          return t = e.Location.wrap(t), this.update(\"push\", t, r);\n        }, r.prototype.replace = function (t, r) {\n          return t = e.Location.wrap(t), this.update(\"replace\", t, r);\n        }, r.prototype.onPopState = function (t) {\n          var r, n, o, i;\n          return this.shouldHandlePopState() && (i = null != (n = t.state) ? n.turbolinks : void 0) ? (r = e.Location.wrap(window.location), o = i.restorationIdentifier, this.delegate.historyPoppedToLocationWithRestorationIdentifier(r, o)) : void 0;\n        }, r.prototype.onPageLoad = function (t) {\n          return e.defer(function (t) {\n            return function () {\n              return t.pageLoaded = !0;\n            };\n          }(this));\n        }, r.prototype.shouldHandlePopState = function () {\n          return this.pageIsLoaded();\n        }, r.prototype.pageIsLoaded = function () {\n          return this.pageLoaded || \"complete\" === document.readyState;\n        }, r.prototype.update = function (t, e, r) {\n          var n;\n          return n = {\n            turbolinks: {\n              restorationIdentifier: r\n            }\n          }, history[t + \"State\"](n, null, e);\n        }, r;\n      }();\n    }.call(this), function () {\n      e.HeadDetails = function () {\n        function t(t) {\n          var e, r, n, s, a, u;\n\n          for (this.elements = {}, n = 0, a = t.length; a > n; n++) {\n            u = t[n], u.nodeType === Node.ELEMENT_NODE && (s = u.outerHTML, r = null != (e = this.elements)[s] ? e[s] : e[s] = {\n              type: i(u),\n              tracked: o(u),\n              elements: []\n            }, r.elements.push(u));\n          }\n        }\n\n        var e, r, n, o, i;\n        return t.fromHeadElement = function (t) {\n          var e;\n          return new this(null != (e = null != t ? t.childNodes : void 0) ? e : []);\n        }, t.prototype.hasElementWithKey = function (t) {\n          return t in this.elements;\n        }, t.prototype.getTrackedElementSignature = function () {\n          var t, e;\n          return function () {\n            var r, n;\n            r = this.elements, n = [];\n\n            for (t in r) {\n              e = r[t].tracked, e && n.push(t);\n            }\n\n            return n;\n          }.call(this).join(\"\");\n        }, t.prototype.getScriptElementsNotInDetails = function (t) {\n          return this.getElementsMatchingTypeNotInDetails(\"script\", t);\n        }, t.prototype.getStylesheetElementsNotInDetails = function (t) {\n          return this.getElementsMatchingTypeNotInDetails(\"stylesheet\", t);\n        }, t.prototype.getElementsMatchingTypeNotInDetails = function (t, e) {\n          var r, n, o, i, s, a;\n          o = this.elements, s = [];\n\n          for (n in o) {\n            i = o[n], a = i.type, r = i.elements, a !== t || e.hasElementWithKey(n) || s.push(r[0]);\n          }\n\n          return s;\n        }, t.prototype.getProvisionalElements = function () {\n          var t, e, r, n, o, i, s;\n          r = [], n = this.elements;\n\n          for (e in n) {\n            o = n[e], s = o.type, i = o.tracked, t = o.elements, null != s || i ? t.length > 1 && r.push.apply(r, t.slice(1)) : r.push.apply(r, t);\n          }\n\n          return r;\n        }, t.prototype.getMetaValue = function (t) {\n          var e;\n          return null != (e = this.findMetaElementByName(t)) ? e.getAttribute(\"content\") : void 0;\n        }, t.prototype.findMetaElementByName = function (t) {\n          var r, n, o, i;\n          r = void 0, i = this.elements;\n\n          for (o in i) {\n            n = i[o].elements, e(n[0], t) && (r = n[0]);\n          }\n\n          return r;\n        }, i = function i(t) {\n          return r(t) ? \"script\" : n(t) ? \"stylesheet\" : void 0;\n        }, o = function o(t) {\n          return \"reload\" === t.getAttribute(\"data-turbolinks-track\");\n        }, r = function r(t) {\n          var e;\n          return e = t.tagName.toLowerCase(), \"script\" === e;\n        }, n = function n(t) {\n          var e;\n          return e = t.tagName.toLowerCase(), \"style\" === e || \"link\" === e && \"stylesheet\" === t.getAttribute(\"rel\");\n        }, e = function e(t, _e) {\n          var r;\n          return r = t.tagName.toLowerCase(), \"meta\" === r && t.getAttribute(\"name\") === _e;\n        }, t;\n      }();\n    }.call(this), function () {\n      e.Snapshot = function () {\n        function t(t, e) {\n          this.headDetails = t, this.bodyElement = e;\n        }\n\n        return t.wrap = function (t) {\n          return t instanceof this ? t : \"string\" == typeof t ? this.fromHTMLString(t) : this.fromHTMLElement(t);\n        }, t.fromHTMLString = function (t) {\n          var e;\n          return e = document.createElement(\"html\"), e.innerHTML = t, this.fromHTMLElement(e);\n        }, t.fromHTMLElement = function (t) {\n          var r, n, o, i;\n          return o = t.querySelector(\"head\"), r = null != (i = t.querySelector(\"body\")) ? i : document.createElement(\"body\"), n = e.HeadDetails.fromHeadElement(o), new this(n, r);\n        }, t.prototype.clone = function () {\n          return new this.constructor(this.headDetails, this.bodyElement.cloneNode(!0));\n        }, t.prototype.getRootLocation = function () {\n          var t, r;\n          return r = null != (t = this.getSetting(\"root\")) ? t : \"/\", new e.Location(r);\n        }, t.prototype.getCacheControlValue = function () {\n          return this.getSetting(\"cache-control\");\n        }, t.prototype.getElementForAnchor = function (t) {\n          try {\n            return this.bodyElement.querySelector(\"[id='\" + t + \"'], a[name='\" + t + \"']\");\n          } catch (e) {}\n        }, t.prototype.getPermanentElements = function () {\n          return this.bodyElement.querySelectorAll(\"[id][data-turbolinks-permanent]\");\n        }, t.prototype.getPermanentElementById = function (t) {\n          return this.bodyElement.querySelector(\"#\" + t + \"[data-turbolinks-permanent]\");\n        }, t.prototype.getPermanentElementsPresentInSnapshot = function (t) {\n          var e, r, n, o, i;\n\n          for (o = this.getPermanentElements(), i = [], r = 0, n = o.length; n > r; r++) {\n            e = o[r], t.getPermanentElementById(e.id) && i.push(e);\n          }\n\n          return i;\n        }, t.prototype.findFirstAutofocusableElement = function () {\n          return this.bodyElement.querySelector(\"[autofocus]\");\n        }, t.prototype.hasAnchor = function (t) {\n          return null != this.getElementForAnchor(t);\n        }, t.prototype.isPreviewable = function () {\n          return \"no-preview\" !== this.getCacheControlValue();\n        }, t.prototype.isCacheable = function () {\n          return \"no-cache\" !== this.getCacheControlValue();\n        }, t.prototype.isVisitable = function () {\n          return \"reload\" !== this.getSetting(\"visit-control\");\n        }, t.prototype.getSetting = function (t) {\n          return this.headDetails.getMetaValue(\"turbolinks-\" + t);\n        }, t;\n      }();\n    }.call(this), function () {\n      var t = [].slice;\n\n      e.Renderer = function () {\n        function e() {}\n\n        var r;\n        return e.render = function () {\n          var e, r, n, o;\n          return n = arguments[0], r = arguments[1], e = 3 <= arguments.length ? t.call(arguments, 2) : [], o = function (t, e, r) {\n            r.prototype = t.prototype;\n            var n = new r(),\n                o = t.apply(n, e);\n            return Object(o) === o ? o : n;\n          }(this, e, function () {}), o.delegate = n, o.render(r), o;\n        }, e.prototype.renderView = function (t) {\n          return this.delegate.viewWillRender(this.newBody), t(), this.delegate.viewRendered(this.newBody);\n        }, e.prototype.invalidateView = function () {\n          return this.delegate.viewInvalidated();\n        }, e.prototype.createScriptElement = function (t) {\n          var e;\n          return \"false\" === t.getAttribute(\"data-turbolinks-eval\") ? t : (e = document.createElement(\"script\"), e.textContent = t.textContent, e.async = !1, r(e, t), e);\n        }, r = function r(t, e) {\n          var r, n, o, i, s, a, u;\n\n          for (i = e.attributes, a = [], r = 0, n = i.length; n > r; r++) {\n            s = i[r], o = s.name, u = s.value, a.push(t.setAttribute(o, u));\n          }\n\n          return a;\n        }, e;\n      }();\n    }.call(this), function () {\n      var t,\n          r,\n          n = function n(t, e) {\n        function r() {\n          this.constructor = t;\n        }\n\n        for (var n in e) {\n          o.call(e, n) && (t[n] = e[n]);\n        }\n\n        return r.prototype = e.prototype, t.prototype = new r(), t.__super__ = e.prototype, t;\n      },\n          o = {}.hasOwnProperty;\n\n      e.SnapshotRenderer = function (e) {\n        function o(t, e, r) {\n          this.currentSnapshot = t, this.newSnapshot = e, this.isPreview = r, this.currentHeadDetails = this.currentSnapshot.headDetails, this.newHeadDetails = this.newSnapshot.headDetails, this.currentBody = this.currentSnapshot.bodyElement, this.newBody = this.newSnapshot.bodyElement;\n        }\n\n        return n(o, e), o.prototype.render = function (t) {\n          return this.shouldRender() ? (this.mergeHead(), this.renderView(function (e) {\n            return function () {\n              return e.replaceBody(), e.isPreview || e.focusFirstAutofocusableElement(), t();\n            };\n          }(this))) : this.invalidateView();\n        }, o.prototype.mergeHead = function () {\n          return this.copyNewHeadStylesheetElements(), this.copyNewHeadScriptElements(), this.removeCurrentHeadProvisionalElements(), this.copyNewHeadProvisionalElements();\n        }, o.prototype.replaceBody = function () {\n          var t;\n          return t = this.relocateCurrentBodyPermanentElements(), this.activateNewBodyScriptElements(), this.assignNewBody(), this.replacePlaceholderElementsWithClonedPermanentElements(t);\n        }, o.prototype.shouldRender = function () {\n          return this.newSnapshot.isVisitable() && this.trackedElementsAreIdentical();\n        }, o.prototype.trackedElementsAreIdentical = function () {\n          return this.currentHeadDetails.getTrackedElementSignature() === this.newHeadDetails.getTrackedElementSignature();\n        }, o.prototype.copyNewHeadStylesheetElements = function () {\n          var t, e, r, n, o;\n\n          for (n = this.getNewHeadStylesheetElements(), o = [], e = 0, r = n.length; r > e; e++) {\n            t = n[e], o.push(document.head.appendChild(t));\n          }\n\n          return o;\n        }, o.prototype.copyNewHeadScriptElements = function () {\n          var t, e, r, n, o;\n\n          for (n = this.getNewHeadScriptElements(), o = [], e = 0, r = n.length; r > e; e++) {\n            t = n[e], o.push(document.head.appendChild(this.createScriptElement(t)));\n          }\n\n          return o;\n        }, o.prototype.removeCurrentHeadProvisionalElements = function () {\n          var t, e, r, n, o;\n\n          for (n = this.getCurrentHeadProvisionalElements(), o = [], e = 0, r = n.length; r > e; e++) {\n            t = n[e], o.push(document.head.removeChild(t));\n          }\n\n          return o;\n        }, o.prototype.copyNewHeadProvisionalElements = function () {\n          var t, e, r, n, o;\n\n          for (n = this.getNewHeadProvisionalElements(), o = [], e = 0, r = n.length; r > e; e++) {\n            t = n[e], o.push(document.head.appendChild(t));\n          }\n\n          return o;\n        }, o.prototype.relocateCurrentBodyPermanentElements = function () {\n          var e, n, o, i, s, a, u;\n\n          for (a = this.getCurrentBodyPermanentElements(), u = [], e = 0, n = a.length; n > e; e++) {\n            i = a[e], s = t(i), o = this.newSnapshot.getPermanentElementById(i.id), r(i, s.element), r(o, i), u.push(s);\n          }\n\n          return u;\n        }, o.prototype.replacePlaceholderElementsWithClonedPermanentElements = function (t) {\n          var e, n, o, i, s, a, u;\n\n          for (u = [], o = 0, i = t.length; i > o; o++) {\n            a = t[o], n = a.element, s = a.permanentElement, e = s.cloneNode(!0), u.push(r(n, e));\n          }\n\n          return u;\n        }, o.prototype.activateNewBodyScriptElements = function () {\n          var t, e, n, o, i, s;\n\n          for (i = this.getNewBodyScriptElements(), s = [], e = 0, o = i.length; o > e; e++) {\n            n = i[e], t = this.createScriptElement(n), s.push(r(n, t));\n          }\n\n          return s;\n        }, o.prototype.assignNewBody = function () {\n          return document.body = this.newBody;\n        }, o.prototype.focusFirstAutofocusableElement = function () {\n          var t;\n          return null != (t = this.newSnapshot.findFirstAutofocusableElement()) ? t.focus() : void 0;\n        }, o.prototype.getNewHeadStylesheetElements = function () {\n          return this.newHeadDetails.getStylesheetElementsNotInDetails(this.currentHeadDetails);\n        }, o.prototype.getNewHeadScriptElements = function () {\n          return this.newHeadDetails.getScriptElementsNotInDetails(this.currentHeadDetails);\n        }, o.prototype.getCurrentHeadProvisionalElements = function () {\n          return this.currentHeadDetails.getProvisionalElements();\n        }, o.prototype.getNewHeadProvisionalElements = function () {\n          return this.newHeadDetails.getProvisionalElements();\n        }, o.prototype.getCurrentBodyPermanentElements = function () {\n          return this.currentSnapshot.getPermanentElementsPresentInSnapshot(this.newSnapshot);\n        }, o.prototype.getNewBodyScriptElements = function () {\n          return this.newBody.querySelectorAll(\"script\");\n        }, o;\n      }(e.Renderer), t = function t(_t5) {\n        var e;\n        return e = document.createElement(\"meta\"), e.setAttribute(\"name\", \"turbolinks-permanent-placeholder\"), e.setAttribute(\"content\", _t5.id), {\n          element: e,\n          permanentElement: _t5\n        };\n      }, r = function r(t, e) {\n        var r;\n        return (r = t.parentNode) ? r.replaceChild(e, t) : void 0;\n      };\n    }.call(this), function () {\n      var t = function t(_t6, e) {\n        function n() {\n          this.constructor = _t6;\n        }\n\n        for (var o in e) {\n          r.call(e, o) && (_t6[o] = e[o]);\n        }\n\n        return n.prototype = e.prototype, _t6.prototype = new n(), _t6.__super__ = e.prototype, _t6;\n      },\n          r = {}.hasOwnProperty;\n\n      e.ErrorRenderer = function (e) {\n        function r(t) {\n          var e;\n          e = document.createElement(\"html\"), e.innerHTML = t, this.newHead = e.querySelector(\"head\"), this.newBody = e.querySelector(\"body\");\n        }\n\n        return t(r, e), r.prototype.render = function (t) {\n          return this.renderView(function (e) {\n            return function () {\n              return e.replaceHeadAndBody(), e.activateBodyScriptElements(), t();\n            };\n          }(this));\n        }, r.prototype.replaceHeadAndBody = function () {\n          var t, e;\n          return e = document.head, t = document.body, e.parentNode.replaceChild(this.newHead, e), t.parentNode.replaceChild(this.newBody, t);\n        }, r.prototype.activateBodyScriptElements = function () {\n          var t, e, r, n, o, i;\n\n          for (n = this.getScriptElements(), i = [], e = 0, r = n.length; r > e; e++) {\n            o = n[e], t = this.createScriptElement(o), i.push(o.parentNode.replaceChild(t, o));\n          }\n\n          return i;\n        }, r.prototype.getScriptElements = function () {\n          return document.documentElement.querySelectorAll(\"script\");\n        }, r;\n      }(e.Renderer);\n    }.call(this), function () {\n      e.View = function () {\n        function t(t) {\n          this.delegate = t, this.htmlElement = document.documentElement;\n        }\n\n        return t.prototype.getRootLocation = function () {\n          return this.getSnapshot().getRootLocation();\n        }, t.prototype.getElementForAnchor = function (t) {\n          return this.getSnapshot().getElementForAnchor(t);\n        }, t.prototype.getSnapshot = function () {\n          return e.Snapshot.fromHTMLElement(this.htmlElement);\n        }, t.prototype.render = function (t, e) {\n          var r, n, o;\n          return o = t.snapshot, r = t.error, n = t.isPreview, this.markAsPreview(n), null != o ? this.renderSnapshot(o, n, e) : this.renderError(r, e);\n        }, t.prototype.markAsPreview = function (t) {\n          return t ? this.htmlElement.setAttribute(\"data-turbolinks-preview\", \"\") : this.htmlElement.removeAttribute(\"data-turbolinks-preview\");\n        }, t.prototype.renderSnapshot = function (t, r, n) {\n          return e.SnapshotRenderer.render(this.delegate, n, this.getSnapshot(), e.Snapshot.wrap(t), r);\n        }, t.prototype.renderError = function (t, r) {\n          return e.ErrorRenderer.render(this.delegate, r, t);\n        }, t;\n      }();\n    }.call(this), function () {\n      var t = function t(_t7, e) {\n        return function () {\n          return _t7.apply(e, arguments);\n        };\n      };\n\n      e.ScrollManager = function () {\n        function r(r) {\n          this.delegate = r, this.onScroll = t(this.onScroll, this), this.onScroll = e.throttle(this.onScroll);\n        }\n\n        return r.prototype.start = function () {\n          return this.started ? void 0 : (addEventListener(\"scroll\", this.onScroll, !1), this.onScroll(), this.started = !0);\n        }, r.prototype.stop = function () {\n          return this.started ? (removeEventListener(\"scroll\", this.onScroll, !1), this.started = !1) : void 0;\n        }, r.prototype.scrollToElement = function (t) {\n          return t.scrollIntoView();\n        }, r.prototype.scrollToPosition = function (t) {\n          var e, r;\n          return e = t.x, r = t.y, window.scrollTo(e, r);\n        }, r.prototype.onScroll = function (t) {\n          return this.updatePosition({\n            x: window.pageXOffset,\n            y: window.pageYOffset\n          });\n        }, r.prototype.updatePosition = function (t) {\n          var e;\n          return this.position = t, null != (e = this.delegate) ? e.scrollPositionChanged(this.position) : void 0;\n        }, r;\n      }();\n    }.call(this), function () {\n      e.SnapshotCache = function () {\n        function t(t) {\n          this.size = t, this.keys = [], this.snapshots = {};\n        }\n\n        var r;\n        return t.prototype.has = function (t) {\n          var e;\n          return e = r(t), e in this.snapshots;\n        }, t.prototype.get = function (t) {\n          var e;\n          if (this.has(t)) return e = this.read(t), this.touch(t), e;\n        }, t.prototype.put = function (t, e) {\n          return this.write(t, e), this.touch(t), e;\n        }, t.prototype.read = function (t) {\n          var e;\n          return e = r(t), this.snapshots[e];\n        }, t.prototype.write = function (t, e) {\n          var n;\n          return n = r(t), this.snapshots[n] = e;\n        }, t.prototype.touch = function (t) {\n          var e, n;\n          return n = r(t), e = this.keys.indexOf(n), e > -1 && this.keys.splice(e, 1), this.keys.unshift(n), this.trim();\n        }, t.prototype.trim = function () {\n          var t, e, r, n, o;\n\n          for (n = this.keys.splice(this.size), o = [], t = 0, r = n.length; r > t; t++) {\n            e = n[t], o.push(delete this.snapshots[e]);\n          }\n\n          return o;\n        }, r = function r(t) {\n          return e.Location.wrap(t).toCacheKey();\n        }, t;\n      }();\n    }.call(this), function () {\n      var t = function t(_t8, e) {\n        return function () {\n          return _t8.apply(e, arguments);\n        };\n      };\n\n      e.Visit = function () {\n        function r(r, n, o) {\n          this.controller = r, this.action = o, this.performScroll = t(this.performScroll, this), this.identifier = e.uuid(), this.location = e.Location.wrap(n), this.adapter = this.controller.adapter, this.state = \"initialized\", this.timingMetrics = {};\n        }\n\n        var n;\n        return r.prototype.start = function () {\n          return \"initialized\" === this.state ? (this.recordTimingMetric(\"visitStart\"), this.state = \"started\", this.adapter.visitStarted(this)) : void 0;\n        }, r.prototype.cancel = function () {\n          var t;\n          return \"started\" === this.state ? (null != (t = this.request) && t.cancel(), this.cancelRender(), this.state = \"canceled\") : void 0;\n        }, r.prototype.complete = function () {\n          var t;\n          return \"started\" === this.state ? (this.recordTimingMetric(\"visitEnd\"), this.state = \"completed\", \"function\" == typeof (t = this.adapter).visitCompleted && t.visitCompleted(this), this.controller.visitCompleted(this)) : void 0;\n        }, r.prototype.fail = function () {\n          var t;\n          return \"started\" === this.state ? (this.state = \"failed\", \"function\" == typeof (t = this.adapter).visitFailed ? t.visitFailed(this) : void 0) : void 0;\n        }, r.prototype.changeHistory = function () {\n          var t, e;\n          return this.historyChanged ? void 0 : (t = this.location.isEqualTo(this.referrer) ? \"replace\" : this.action, e = n(t), this.controller[e](this.location, this.restorationIdentifier), this.historyChanged = !0);\n        }, r.prototype.issueRequest = function () {\n          return this.shouldIssueRequest() && null == this.request ? (this.progress = 0, this.request = new e.HttpRequest(this, this.location, this.referrer), this.request.send()) : void 0;\n        }, r.prototype.getCachedSnapshot = function () {\n          var t;\n          return !(t = this.controller.getCachedSnapshotForLocation(this.location)) || null != this.location.anchor && !t.hasAnchor(this.location.anchor) || \"restore\" !== this.action && !t.isPreviewable() ? void 0 : t;\n        }, r.prototype.hasCachedSnapshot = function () {\n          return null != this.getCachedSnapshot();\n        }, r.prototype.loadCachedSnapshot = function () {\n          var t, e;\n          return (e = this.getCachedSnapshot()) ? (t = this.shouldIssueRequest(), this.render(function () {\n            var r;\n            return this.cacheSnapshot(), this.controller.render({\n              snapshot: e,\n              isPreview: t\n            }, this.performScroll), \"function\" == typeof (r = this.adapter).visitRendered && r.visitRendered(this), t ? void 0 : this.complete();\n          })) : void 0;\n        }, r.prototype.loadResponse = function () {\n          return null != this.response ? this.render(function () {\n            var t, e;\n            return this.cacheSnapshot(), this.request.failed ? (this.controller.render({\n              error: this.response\n            }, this.performScroll), \"function\" == typeof (t = this.adapter).visitRendered && t.visitRendered(this), this.fail()) : (this.controller.render({\n              snapshot: this.response\n            }, this.performScroll), \"function\" == typeof (e = this.adapter).visitRendered && e.visitRendered(this), this.complete());\n          }) : void 0;\n        }, r.prototype.followRedirect = function () {\n          return this.redirectedToLocation && !this.followedRedirect ? (this.location = this.redirectedToLocation, this.controller.replaceHistoryWithLocationAndRestorationIdentifier(this.redirectedToLocation, this.restorationIdentifier), this.followedRedirect = !0) : void 0;\n        }, r.prototype.requestStarted = function () {\n          var t;\n          return this.recordTimingMetric(\"requestStart\"), \"function\" == typeof (t = this.adapter).visitRequestStarted ? t.visitRequestStarted(this) : void 0;\n        }, r.prototype.requestProgressed = function (t) {\n          var e;\n          return this.progress = t, \"function\" == typeof (e = this.adapter).visitRequestProgressed ? e.visitRequestProgressed(this) : void 0;\n        }, r.prototype.requestCompletedWithResponse = function (t, r) {\n          return this.response = t, null != r && (this.redirectedToLocation = e.Location.wrap(r)), this.adapter.visitRequestCompleted(this);\n        }, r.prototype.requestFailedWithStatusCode = function (t, e) {\n          return this.response = e, this.adapter.visitRequestFailedWithStatusCode(this, t);\n        }, r.prototype.requestFinished = function () {\n          var t;\n          return this.recordTimingMetric(\"requestEnd\"), \"function\" == typeof (t = this.adapter).visitRequestFinished ? t.visitRequestFinished(this) : void 0;\n        }, r.prototype.performScroll = function () {\n          return this.scrolled ? void 0 : (\"restore\" === this.action ? this.scrollToRestoredPosition() || this.scrollToTop() : this.scrollToAnchor() || this.scrollToTop(), this.scrolled = !0);\n        }, r.prototype.scrollToRestoredPosition = function () {\n          var t, e;\n          return t = null != (e = this.restorationData) ? e.scrollPosition : void 0, null != t ? (this.controller.scrollToPosition(t), !0) : void 0;\n        }, r.prototype.scrollToAnchor = function () {\n          return null != this.location.anchor ? (this.controller.scrollToAnchor(this.location.anchor), !0) : void 0;\n        }, r.prototype.scrollToTop = function () {\n          return this.controller.scrollToPosition({\n            x: 0,\n            y: 0\n          });\n        }, r.prototype.recordTimingMetric = function (t) {\n          var e;\n          return null != (e = this.timingMetrics)[t] ? e[t] : e[t] = new Date().getTime();\n        }, r.prototype.getTimingMetrics = function () {\n          return e.copyObject(this.timingMetrics);\n        }, n = function n(t) {\n          switch (t) {\n            case \"replace\":\n              return \"replaceHistoryWithLocationAndRestorationIdentifier\";\n\n            case \"advance\":\n            case \"restore\":\n              return \"pushHistoryWithLocationAndRestorationIdentifier\";\n          }\n        }, r.prototype.shouldIssueRequest = function () {\n          return \"restore\" === this.action ? !this.hasCachedSnapshot() : !0;\n        }, r.prototype.cacheSnapshot = function () {\n          return this.snapshotCached ? void 0 : (this.controller.cacheSnapshot(), this.snapshotCached = !0);\n        }, r.prototype.render = function (t) {\n          return this.cancelRender(), this.frame = requestAnimationFrame(function (e) {\n            return function () {\n              return e.frame = null, t.call(e);\n            };\n          }(this));\n        }, r.prototype.cancelRender = function () {\n          return this.frame ? cancelAnimationFrame(this.frame) : void 0;\n        }, r;\n      }();\n    }.call(this), function () {\n      var t = function t(_t9, e) {\n        return function () {\n          return _t9.apply(e, arguments);\n        };\n      };\n\n      e.Controller = function () {\n        function r() {\n          this.clickBubbled = t(this.clickBubbled, this), this.clickCaptured = t(this.clickCaptured, this), this.pageLoaded = t(this.pageLoaded, this), this.history = new e.History(this), this.view = new e.View(this), this.scrollManager = new e.ScrollManager(this), this.restorationData = {}, this.clearCache(), this.setProgressBarDelay(500);\n        }\n\n        return r.prototype.start = function () {\n          return e.supported && !this.started ? (addEventListener(\"click\", this.clickCaptured, !0), addEventListener(\"DOMContentLoaded\", this.pageLoaded, !1), this.scrollManager.start(), this.startHistory(), this.started = !0, this.enabled = !0) : void 0;\n        }, r.prototype.disable = function () {\n          return this.enabled = !1;\n        }, r.prototype.stop = function () {\n          return this.started ? (removeEventListener(\"click\", this.clickCaptured, !0), removeEventListener(\"DOMContentLoaded\", this.pageLoaded, !1), this.scrollManager.stop(), this.stopHistory(), this.started = !1) : void 0;\n        }, r.prototype.clearCache = function () {\n          return this.cache = new e.SnapshotCache(10);\n        }, r.prototype.visit = function (t, r) {\n          var n, o;\n          return null == r && (r = {}), t = e.Location.wrap(t), this.applicationAllowsVisitingLocation(t) ? this.locationIsVisitable(t) ? (n = null != (o = r.action) ? o : \"advance\", this.adapter.visitProposedToLocationWithAction(t, n)) : window.location = t : void 0;\n        }, r.prototype.startVisitToLocationWithAction = function (t, r, n) {\n          var o;\n          return e.supported ? (o = this.getRestorationDataForIdentifier(n), this.startVisit(t, r, {\n            restorationData: o\n          })) : window.location = t;\n        }, r.prototype.setProgressBarDelay = function (t) {\n          return this.progressBarDelay = t;\n        }, r.prototype.startHistory = function () {\n          return this.location = e.Location.wrap(window.location), this.restorationIdentifier = e.uuid(), this.history.start(), this.history.replace(this.location, this.restorationIdentifier);\n        }, r.prototype.stopHistory = function () {\n          return this.history.stop();\n        }, r.prototype.pushHistoryWithLocationAndRestorationIdentifier = function (t, r) {\n          return this.restorationIdentifier = r, this.location = e.Location.wrap(t), this.history.push(this.location, this.restorationIdentifier);\n        }, r.prototype.replaceHistoryWithLocationAndRestorationIdentifier = function (t, r) {\n          return this.restorationIdentifier = r, this.location = e.Location.wrap(t), this.history.replace(this.location, this.restorationIdentifier);\n        }, r.prototype.historyPoppedToLocationWithRestorationIdentifier = function (t, r) {\n          var n;\n          return this.restorationIdentifier = r, this.enabled ? (n = this.getRestorationDataForIdentifier(this.restorationIdentifier), this.startVisit(t, \"restore\", {\n            restorationIdentifier: this.restorationIdentifier,\n            restorationData: n,\n            historyChanged: !0\n          }), this.location = e.Location.wrap(t)) : this.adapter.pageInvalidated();\n        }, r.prototype.getCachedSnapshotForLocation = function (t) {\n          var e;\n          return null != (e = this.cache.get(t)) ? e.clone() : void 0;\n        }, r.prototype.shouldCacheSnapshot = function () {\n          return this.view.getSnapshot().isCacheable();\n        }, r.prototype.cacheSnapshot = function () {\n          var t, r;\n          return this.shouldCacheSnapshot() ? (this.notifyApplicationBeforeCachingSnapshot(), r = this.view.getSnapshot(), t = this.lastRenderedLocation, e.defer(function (e) {\n            return function () {\n              return e.cache.put(t, r.clone());\n            };\n          }(this))) : void 0;\n        }, r.prototype.scrollToAnchor = function (t) {\n          var e;\n          return (e = this.view.getElementForAnchor(t)) ? this.scrollToElement(e) : this.scrollToPosition({\n            x: 0,\n            y: 0\n          });\n        }, r.prototype.scrollToElement = function (t) {\n          return this.scrollManager.scrollToElement(t);\n        }, r.prototype.scrollToPosition = function (t) {\n          return this.scrollManager.scrollToPosition(t);\n        }, r.prototype.scrollPositionChanged = function (t) {\n          var e;\n          return e = this.getCurrentRestorationData(), e.scrollPosition = t;\n        }, r.prototype.render = function (t, e) {\n          return this.view.render(t, e);\n        }, r.prototype.viewInvalidated = function () {\n          return this.adapter.pageInvalidated();\n        }, r.prototype.viewWillRender = function (t) {\n          return this.notifyApplicationBeforeRender(t);\n        }, r.prototype.viewRendered = function () {\n          return this.lastRenderedLocation = this.currentVisit.location, this.notifyApplicationAfterRender();\n        }, r.prototype.pageLoaded = function () {\n          return this.lastRenderedLocation = this.location, this.notifyApplicationAfterPageLoad();\n        }, r.prototype.clickCaptured = function () {\n          return removeEventListener(\"click\", this.clickBubbled, !1), addEventListener(\"click\", this.clickBubbled, !1);\n        }, r.prototype.clickBubbled = function (t) {\n          var e, r, n;\n          return this.enabled && this.clickEventIsSignificant(t) && (r = this.getVisitableLinkForNode(t.target)) && (n = this.getVisitableLocationForLink(r)) && this.applicationAllowsFollowingLinkToLocation(r, n) ? (t.preventDefault(), e = this.getActionForLink(r), this.visit(n, {\n            action: e\n          })) : void 0;\n        }, r.prototype.applicationAllowsFollowingLinkToLocation = function (t, e) {\n          var r;\n          return r = this.notifyApplicationAfterClickingLinkToLocation(t, e), !r.defaultPrevented;\n        }, r.prototype.applicationAllowsVisitingLocation = function (t) {\n          var e;\n          return e = this.notifyApplicationBeforeVisitingLocation(t), !e.defaultPrevented;\n        }, r.prototype.notifyApplicationAfterClickingLinkToLocation = function (t, r) {\n          return e.dispatch(\"turbolinks:click\", {\n            target: t,\n            data: {\n              url: r.absoluteURL\n            },\n            cancelable: !0\n          });\n        }, r.prototype.notifyApplicationBeforeVisitingLocation = function (t) {\n          return e.dispatch(\"turbolinks:before-visit\", {\n            data: {\n              url: t.absoluteURL\n            },\n            cancelable: !0\n          });\n        }, r.prototype.notifyApplicationAfterVisitingLocation = function (t) {\n          return e.dispatch(\"turbolinks:visit\", {\n            data: {\n              url: t.absoluteURL\n            }\n          });\n        }, r.prototype.notifyApplicationBeforeCachingSnapshot = function () {\n          return e.dispatch(\"turbolinks:before-cache\");\n        }, r.prototype.notifyApplicationBeforeRender = function (t) {\n          return e.dispatch(\"turbolinks:before-render\", {\n            data: {\n              newBody: t\n            }\n          });\n        }, r.prototype.notifyApplicationAfterRender = function () {\n          return e.dispatch(\"turbolinks:render\");\n        }, r.prototype.notifyApplicationAfterPageLoad = function (t) {\n          return null == t && (t = {}), e.dispatch(\"turbolinks:load\", {\n            data: {\n              url: this.location.absoluteURL,\n              timing: t\n            }\n          });\n        }, r.prototype.startVisit = function (t, e, r) {\n          var n;\n          return null != (n = this.currentVisit) && n.cancel(), this.currentVisit = this.createVisit(t, e, r), this.currentVisit.start(), this.notifyApplicationAfterVisitingLocation(t);\n        }, r.prototype.createVisit = function (t, r, n) {\n          var o, i, s, a, u;\n          return i = null != n ? n : {}, a = i.restorationIdentifier, s = i.restorationData, o = i.historyChanged, u = new e.Visit(this, t, r), u.restorationIdentifier = null != a ? a : e.uuid(), u.restorationData = e.copyObject(s), u.historyChanged = o, u.referrer = this.location, u;\n        }, r.prototype.visitCompleted = function (t) {\n          return this.notifyApplicationAfterPageLoad(t.getTimingMetrics());\n        }, r.prototype.clickEventIsSignificant = function (t) {\n          return !(t.defaultPrevented || t.target.isContentEditable || t.which > 1 || t.altKey || t.ctrlKey || t.metaKey || t.shiftKey);\n        }, r.prototype.getVisitableLinkForNode = function (t) {\n          return this.nodeIsVisitable(t) ? e.closest(t, \"a[href]:not([target]):not([download])\") : void 0;\n        }, r.prototype.getVisitableLocationForLink = function (t) {\n          var r;\n          return r = new e.Location(t.getAttribute(\"href\")), this.locationIsVisitable(r) ? r : void 0;\n        }, r.prototype.getActionForLink = function (t) {\n          var e;\n          return null != (e = t.getAttribute(\"data-turbolinks-action\")) ? e : \"advance\";\n        }, r.prototype.nodeIsVisitable = function (t) {\n          var r;\n          return (r = e.closest(t, \"[data-turbolinks]\")) ? \"false\" !== r.getAttribute(\"data-turbolinks\") : !0;\n        }, r.prototype.locationIsVisitable = function (t) {\n          return t.isPrefixedBy(this.view.getRootLocation()) && t.isHTML();\n        }, r.prototype.getCurrentRestorationData = function () {\n          return this.getRestorationDataForIdentifier(this.restorationIdentifier);\n        }, r.prototype.getRestorationDataForIdentifier = function (t) {\n          var e;\n          return null != (e = this.restorationData)[t] ? e[t] : e[t] = {};\n        }, r;\n      }();\n    }.call(this), function () {\n      !function () {\n        var t, e;\n        if ((t = e = document.currentScript) && !e.hasAttribute(\"data-turbolinks-suppress-warning\")) for (; t = t.parentNode;) {\n          if (t === document.body) return console.warn(\"You are loading Turbolinks from a <script> element inside the <body> element. This is probably not what you meant to do!\\n\\nLoad your application\\u2019s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.\\n\\nFor more information, see: https://github.com/turbolinks/turbolinks#working-with-script-elements\\n\\n\\u2014\\u2014\\nSuppress this warning by adding a `data-turbolinks-suppress-warning` attribute to: %s\", e.outerHTML);\n        }\n      }();\n    }.call(this), function () {\n      var t, r, n;\n      e.start = function () {\n        return r() ? (null == e.controller && (e.controller = t()), e.controller.start()) : void 0;\n      }, r = function r() {\n        return null == window.Turbolinks && (window.Turbolinks = e), n();\n      }, t = function t() {\n        var t;\n        return t = new e.Controller(), t.adapter = new e.BrowserAdapter(t), t;\n      }, n = function n() {\n        return window.Turbolinks === e;\n      }, n() && e.start();\n    }.call(this);\n  }).call(this), \"object\" == (typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) && module.exports ? module.exports = e : \"function\" == typeof define && define.amd && define(e);\n}).call(this);","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*! @preserve sweet-scroll v4.0.0 - tsuyoshiwada | MIT License */\n(function (global, factory) {\n  (typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = global || self, global.SweetScroll = factory());\n})(this, function () {\n  'use strict';\n  /*! *****************************************************************************\r\n  Copyright (c) Microsoft Corporation. All rights reserved.\r\n  Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\n  this file except in compliance with the License. You may obtain a copy of the\r\n  License at http://www.apache.org/licenses/LICENSE-2.0\r\n    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\n  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\n  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\n  MERCHANTABLITY OR NON-INFRINGEMENT.\r\n    See the Apache Version 2.0 License for specific language governing permissions\r\n  and limitations under the License.\r\n  ***************************************************************************** */\n\n  var _assign = function __assign() {\n    _assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n        s = arguments[i];\n\n        for (var p in s) {\n          if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n        }\n      }\n\n      return t;\n    };\n\n    return _assign.apply(this, arguments);\n  }; // @link https://github.com/JedWatson/exenv/blob/master/index.js\n\n\n  var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n  var canUseHistory = !canUseDOM ? false : window.history && 'pushState' in window.history && window.location.protocol !== 'file:';\n\n  var canUsePassiveOption = function () {\n    var support = false;\n\n    if (!canUseDOM) {\n      return support;\n    }\n    /* tslint:disable:no-empty */\n\n\n    try {\n      var win = window;\n      var opts = Object.defineProperty({}, 'passive', {\n        get: function get() {\n          support = true;\n        }\n      });\n      win.addEventListener('test', null, opts);\n      win.removeEventListener('test', null, opts);\n    } catch (e) {}\n    /* tslint:enable */\n\n\n    return support;\n  }();\n\n  var isString = function isString(obj) {\n    return typeof obj === 'string';\n  };\n\n  var isFunction = function isFunction(obj) {\n    return typeof obj === 'function';\n  };\n\n  var isArray = function isArray(obj) {\n    return Array.isArray(obj);\n  };\n\n  var isNumeric = function isNumeric(obj) {\n    return !isArray(obj) && obj - parseFloat(obj) + 1 >= 0;\n  };\n\n  var hasProp = function hasProp(obj, key) {\n    return obj && obj.hasOwnProperty(key);\n  };\n\n  var raf = canUseDOM ? window.requestAnimationFrame.bind(window) : null;\n  var caf = canUseDOM ? window.cancelAnimationFrame.bind(window) : null;\n  /* tslint:disable:curly */\n\n  /* tslint:disable:no-conditional-assignment */\n\n  var cos = Math.cos,\n      sin = Math.sin,\n      pow = Math.pow,\n      sqrt = Math.sqrt,\n      PI = Math.PI;\n  var easings = {\n    linear: function linear(p) {\n      return p;\n    },\n    easeInQuad: function easeInQuad(_, t, b, c, d) {\n      return c * (t /= d) * t + b;\n    },\n    easeOutQuad: function easeOutQuad(_, t, b, c, d) {\n      return -c * (t /= d) * (t - 2) + b;\n    },\n    easeInOutQuad: function easeInOutQuad(_, t, b, c, d) {\n      return (t /= d / 2) < 1 ? c / 2 * t * t + b : -c / 2 * (--t * (t - 2) - 1) + b;\n    },\n    easeInCubic: function easeInCubic(_, t, b, c, d) {\n      return c * (t /= d) * t * t + b;\n    },\n    easeOutCubic: function easeOutCubic(_, t, b, c, d) {\n      return c * ((t = t / d - 1) * t * t + 1) + b;\n    },\n    easeInOutCubic: function easeInOutCubic(_, t, b, c, d) {\n      return (t /= d / 2) < 1 ? c / 2 * t * t * t + b : c / 2 * ((t -= 2) * t * t + 2) + b;\n    },\n    easeInQuart: function easeInQuart(_, t, b, c, d) {\n      return c * (t /= d) * t * t * t + b;\n    },\n    easeOutQuart: function easeOutQuart(_, t, b, c, d) {\n      return -c * ((t = t / d - 1) * t * t * t - 1) + b;\n    },\n    easeInOutQuart: function easeInOutQuart(_, t, b, c, d) {\n      return (t /= d / 2) < 1 ? c / 2 * t * t * t * t + b : -c / 2 * ((t -= 2) * t * t * t - 2) + b;\n    },\n    easeInQuint: function easeInQuint(_, t, b, c, d) {\n      return c * (t /= d) * t * t * t * t + b;\n    },\n    easeOutQuint: function easeOutQuint(_, t, b, c, d) {\n      return c * ((t = t / d - 1) * t * t * t * t + 1) + b;\n    },\n    easeInOutQuint: function easeInOutQuint(_, t, b, c, d) {\n      return (t /= d / 2) < 1 ? c / 2 * t * t * t * t * t + b : c / 2 * ((t -= 2) * t * t * t * t + 2) + b;\n    },\n    easeInSine: function easeInSine(_, t, b, c, d) {\n      return -c * cos(t / d * (PI / 2)) + c + b;\n    },\n    easeOutSine: function easeOutSine(_, t, b, c, d) {\n      return c * sin(t / d * (PI / 2)) + b;\n    },\n    easeInOutSine: function easeInOutSine(_, t, b, c, d) {\n      return -c / 2 * (cos(PI * t / d) - 1) + b;\n    },\n    easeInExpo: function easeInExpo(_, t, b, c, d) {\n      return t === 0 ? b : c * pow(2, 10 * (t / d - 1)) + b;\n    },\n    easeOutExpo: function easeOutExpo(_, t, b, c, d) {\n      return t === d ? b + c : c * (-pow(2, -10 * t / d) + 1) + b;\n    },\n    easeInOutExpo: function easeInOutExpo(_, t, b, c, d) {\n      if (t === 0) return b;\n      if (t === d) return b + c;\n      if ((t /= d / 2) < 1) return c / 2 * pow(2, 10 * (t - 1)) + b;\n      return c / 2 * (-pow(2, -10 * --t) + 2) + b;\n    },\n    easeInCirc: function easeInCirc(_, t, b, c, d) {\n      return -c * (sqrt(1 - (t /= d) * t) - 1) + b;\n    },\n    easeOutCirc: function easeOutCirc(_, t, b, c, d) {\n      return c * sqrt(1 - (t = t / d - 1) * t) + b;\n    },\n    easeInOutCirc: function easeInOutCirc(_, t, b, c, d) {\n      return (t /= d / 2) < 1 ? -c / 2 * (sqrt(1 - t * t) - 1) + b : c / 2 * (sqrt(1 - (t -= 2) * t) + 1) + b;\n    }\n  };\n\n  var $$ = function $$(selector) {\n    return Array.prototype.slice.call(!selector ? [] : document.querySelectorAll(selector));\n  };\n\n  var $ = function $(selector) {\n    return $$(selector).shift() || null;\n  };\n\n  var isElement = function isElement(obj) {\n    return obj instanceof Element;\n  };\n\n  var isWindow = function isWindow($el) {\n    return $el === window;\n  };\n\n  var isRootContainer = function isRootContainer($el) {\n    return $el === document.documentElement || $el === document.body;\n  };\n\n  var matches = function matches($el, selector) {\n    if (isElement(selector)) {\n      return $el === selector;\n    }\n\n    var results = $$(selector);\n    var i = results.length; // tslint:disable-next-line no-empty\n\n    while (--i >= 0 && results[i] !== $el) {}\n\n    return i > -1;\n  };\n\n  var getHeight = function getHeight($el) {\n    return Math.max($el.scrollHeight, $el.clientHeight, $el.offsetHeight);\n  };\n\n  var getWidth = function getWidth($el) {\n    return Math.max($el.scrollWidth, $el.clientWidth, $el.offsetWidth);\n  };\n\n  var getSize = function getSize($el) {\n    return {\n      width: getWidth($el),\n      height: getHeight($el)\n    };\n  };\n\n  var getViewportAndElementSizes = function getViewportAndElementSizes($el) {\n    var isRoot = isWindow($el) || isRootContainer($el);\n    return {\n      viewport: {\n        width: isRoot ? Math.min(window.innerWidth, document.documentElement.clientWidth) : $el.clientWidth,\n        height: isRoot ? window.innerHeight : $el.clientHeight\n      },\n      size: isRoot ? {\n        width: Math.max(getWidth(document.body), getWidth(document.documentElement)),\n        height: Math.max(getHeight(document.body), getHeight(document.documentElement))\n      } : getSize($el)\n    };\n  };\n\n  var directionMethodMap = {\n    y: 'scrollTop',\n    x: 'scrollLeft'\n  };\n  var directionPropMap = {\n    y: 'pageYOffset',\n    x: 'pageXOffset'\n  };\n\n  var getScroll = function getScroll($el, direction) {\n    return isWindow($el) ? $el[directionPropMap[direction]] : $el[directionMethodMap[direction]];\n  };\n\n  var setScroll = function setScroll($el, offset, direction) {\n    if (isWindow($el)) {\n      var top_1 = direction === 'y';\n      $el.scrollTo(!top_1 ? offset : $el.pageXOffset, top_1 ? offset : $el.pageYOffset);\n    } else {\n      $el[directionMethodMap[direction]] = offset;\n    }\n  };\n\n  var getOffset = function getOffset($el, $context) {\n    var rect = $el.getBoundingClientRect();\n\n    if (rect.width || rect.height) {\n      var scroll_1 = {\n        top: 0,\n        left: 0\n      };\n      var $ctx = void 0;\n\n      if (isWindow($context) || isRootContainer($context)) {\n        $ctx = document.documentElement;\n        scroll_1.top = window[directionPropMap.y];\n        scroll_1.left = window[directionPropMap.x];\n      } else {\n        $ctx = $context;\n        var cRect = $ctx.getBoundingClientRect();\n        scroll_1.top = cRect.top * -1 + $ctx[directionMethodMap.y];\n        scroll_1.left = cRect.left * -1 + $ctx[directionMethodMap.x];\n      }\n\n      return {\n        top: rect.top + scroll_1.top - $ctx.clientTop,\n        left: rect.left + scroll_1.left - $ctx.clientLeft\n      };\n    }\n\n    return rect;\n  };\n\n  var wheelEventName = function () {\n    if (!canUseDOM) {\n      return 'wheel';\n    }\n\n    return 'onwheel' in document ? 'wheel' : 'mousewheel';\n  }();\n\n  var eventName = function eventName(name) {\n    return name === 'wheel' ? wheelEventName : name;\n  };\n\n  var apply = function apply($el, method, event, listener, passive) {\n    event.split(' ').forEach(function (name) {\n      $el[method](eventName(name), listener, canUsePassiveOption ? {\n        passive: passive\n      } : false);\n    });\n  };\n\n  var addEvent = function addEvent($el, event, listener, passive) {\n    return apply($el, 'addEventListener', event, listener, passive);\n  };\n\n  var removeEvent = function removeEvent($el, event, listener, passive) {\n    return apply($el, 'removeEventListener', event, listener, passive);\n  };\n\n  var reRelativeToken = /^(\\+|-)=(\\d+(?:\\.\\d+)?)$/;\n\n  var parseCoordinate = function parseCoordinate(coordinate, enableVertical) {\n    var res = {\n      top: 0,\n      left: 0,\n      relative: false\n    }; // Object ({ top: {n}, left: {n} })\n\n    if (hasProp(coordinate, 'top') || hasProp(coordinate, 'left')) {\n      res = _assign({}, res, coordinate); // Array ([{n}, [{n}])\n    } else if (isArray(coordinate)) {\n      if (coordinate.length > 1) {\n        res.top = coordinate[0];\n        res.left = coordinate[1];\n      } else if (coordinate.length === 1) {\n        res.top = enableVertical ? coordinate[0] : 0;\n        res.left = !enableVertical ? coordinate[0] : 0;\n      } else {\n        return null;\n      } // Number\n\n    } else if (isNumeric(coordinate)) {\n      if (enableVertical) {\n        res.top = coordinate;\n      } else {\n        res.left = coordinate;\n      } // String ('+={n}', '-={n}')\n\n    } else if (isString(coordinate)) {\n      var m = coordinate.trim().match(reRelativeToken);\n\n      if (!m) {\n        return null;\n      }\n\n      var op = m[1];\n      var val = parseInt(m[2], 10);\n\n      if (op === '+') {\n        res.top = enableVertical ? val : 0;\n        res.left = !enableVertical ? val : 0;\n      } else {\n        res.top = enableVertical ? -val : 0;\n        res.left = !enableVertical ? -val : 0;\n      }\n\n      res.relative = true;\n    } else {\n      return null;\n    }\n\n    return res;\n  };\n\n  var defaultOptions = {\n    trigger: '[data-scroll]',\n    header: '[data-scroll-header]',\n    duration: 1000,\n    easing: 'easeOutQuint',\n    offset: 0,\n    vertical: true,\n    horizontal: false,\n    cancellable: true,\n    updateURL: false,\n    preventDefault: true,\n    stopPropagation: true,\n    // Callbacks\n    before: null,\n    after: null,\n    cancel: null,\n    complete: null,\n    step: null\n  };\n  var CONTAINER_CLICK_EVENT = 'click';\n  var CONTAINER_STOP_EVENT = 'wheel touchstart touchmove';\n\n  var SweetScroll =\n  /** @class */\n  function () {\n    /**\r\n     * Constructor\r\n     */\n    function SweetScroll(options, container) {\n      var _this = this;\n\n      this.$el = null;\n      this.ctx = {\n        $trigger: null,\n        opts: null,\n        progress: false,\n        pos: null,\n        startPos: null,\n        easing: null,\n        start: 0,\n        id: 0,\n        cancel: false,\n        hash: null\n      };\n      /**\r\n       * Handle each frame of the animation.\r\n       */\n\n      this.loop = function (time) {\n        var _a = _this,\n            $el = _a.$el,\n            ctx = _a.ctx;\n\n        if (!ctx.start) {\n          ctx.start = time;\n        }\n\n        if (!ctx.progress || !$el) {\n          _this.stop();\n\n          return;\n        }\n\n        var options = ctx.opts;\n        var offset = ctx.pos;\n        var start = ctx.start;\n        var startOffset = ctx.startPos;\n        var easing = ctx.easing;\n        var duration = options.duration;\n        var directionMap = {\n          top: 'y',\n          left: 'x'\n        };\n        var timeElapsed = time - start;\n        var t = Math.min(1, Math.max(timeElapsed / duration, 0));\n        Object.keys(offset).forEach(function (key) {\n          var value = offset[key];\n          var initial = startOffset[key];\n          var delta = value - initial;\n\n          if (delta !== 0) {\n            var val = easing(t, duration * t, 0, 1, duration);\n            setScroll($el, Math.round(initial + delta * val), directionMap[key]);\n          }\n        });\n\n        if (timeElapsed <= duration) {\n          _this.hook(options, 'step', t);\n\n          ctx.id = SweetScroll.raf(_this.loop);\n        } else {\n          _this.stop(true);\n        }\n      };\n      /**\r\n       * Handling of container click event.\r\n       */\n\n\n      this.handleClick = function (e) {\n        var opts = _this.opts;\n        var $el = e.target;\n\n        for (; $el && $el !== document; $el = $el.parentNode) {\n          if (!matches($el, opts.trigger)) {\n            continue;\n          }\n\n          var dataOptions = JSON.parse($el.getAttribute('data-scroll-options') || '{}');\n          var data = $el.getAttribute('data-scroll');\n          var to = data || $el.getAttribute('href');\n\n          var options = _assign({}, opts, dataOptions);\n\n          var preventDefault = options.preventDefault,\n              stopPropagation = options.stopPropagation,\n              vertical = options.vertical,\n              horizontal = options.horizontal;\n\n          if (preventDefault) {\n            e.preventDefault();\n          }\n\n          if (stopPropagation) {\n            e.stopPropagation();\n          } // Passes the trigger element to callback\n\n\n          _this.ctx.$trigger = $el;\n\n          if (horizontal && vertical) {\n            _this.to(to, options);\n          } else if (vertical) {\n            _this.toTop(to, options);\n          } else if (horizontal) {\n            _this.toLeft(to, options);\n          }\n\n          break;\n        }\n      };\n      /**\r\n       * Handling of container stop events.\r\n       */\n\n\n      this.handleStop = function (e) {\n        var ctx = _this.ctx;\n        var opts = ctx.opts;\n\n        if (opts && opts.cancellable) {\n          ctx.cancel = true;\n\n          _this.stop();\n        } else {\n          e.preventDefault();\n        }\n      };\n\n      this.opts = _assign({}, defaultOptions, options || {});\n      var $container = null;\n\n      if (canUseDOM) {\n        if (typeof container === 'string') {\n          $container = $(container);\n        } else if (container != null) {\n          $container = container;\n        } else {\n          $container = window;\n        }\n      }\n\n      this.$el = $container;\n\n      if ($container) {\n        this.bind(true, false);\n      }\n    }\n    /**\r\n     * SweetScroll instance factory.\r\n     */\n\n\n    SweetScroll.create = function (options, container) {\n      return new SweetScroll(options, container);\n    };\n    /**\r\n     * Scroll animation to the specified position.\r\n     */\n\n\n    SweetScroll.prototype.to = function (distance, options) {\n      if (!canUseDOM) {\n        return;\n      }\n\n      var _a = this,\n          $el = _a.$el,\n          ctx = _a.ctx,\n          currentOptions = _a.opts;\n\n      var $trigger = ctx.$trigger;\n\n      var opts = _assign({}, currentOptions, options || {});\n\n      var optOffset = opts.offset,\n          vertical = opts.vertical,\n          horizontal = opts.horizontal;\n      var $header = isElement(opts.header) ? opts.header : $(opts.header);\n      var reg = /^#/;\n      var hash = isString(distance) && reg.test(distance) ? distance : null;\n      ctx.opts = opts; // Temporary options\n\n      ctx.cancel = false; // Disable the call flag of `cancel`\n\n      ctx.hash = hash; // Stop current animation\n\n      this.stop(); // Does not move if the container is not found\n\n      if (!$el) {\n        return;\n      } // Get scroll offset\n\n\n      var offset = parseCoordinate(optOffset, vertical);\n      var coordinate = parseCoordinate(distance, vertical);\n      var scroll = {\n        top: 0,\n        left: 0\n      };\n\n      if (coordinate) {\n        if (coordinate.relative) {\n          var current = getScroll($el, vertical ? 'y' : 'x');\n          scroll.top = vertical ? current + coordinate.top : coordinate.top;\n          scroll.left = !vertical ? current + coordinate.left : coordinate.left;\n        } else {\n          scroll = coordinate;\n        }\n      } else if (isString(distance) && distance !== '#') {\n        var $target = $(distance);\n\n        if (!$target) {\n          return;\n        }\n\n        scroll = getOffset($target, $el);\n      }\n\n      if (offset) {\n        scroll.top += offset.top;\n        scroll.left += offset.left;\n      }\n\n      if ($header) {\n        scroll.top = Math.max(0, scroll.top - getSize($header).height);\n      } // Normalize scroll offset\n\n\n      var _b = getViewportAndElementSizes($el),\n          viewport = _b.viewport,\n          size = _b.size;\n\n      scroll.top = vertical ? Math.max(0, Math.min(size.height - viewport.height, scroll.top)) : getScroll($el, 'y');\n      scroll.left = horizontal ? Math.max(0, Math.min(size.width - viewport.width, scroll.left)) : getScroll($el, 'x'); // Call `before`\n      // Stop scrolling when it returns false\n\n      if (this.hook(opts, 'before', scroll, $trigger) === false) {\n        ctx.opts = null;\n        return;\n      } // Set offset\n\n\n      ctx.pos = scroll; // Run animation!!\n\n      this.start(opts); // Bind stop events\n\n      this.bind(false, true);\n    };\n    /**\r\n     * Scroll animation to specified left position.\r\n     */\n\n\n    SweetScroll.prototype.toTop = function (distance, options) {\n      this.to(distance, _assign({}, options || {}, {\n        vertical: true,\n        horizontal: false\n      }));\n    };\n    /**\r\n     * Scroll animation to specified top position.\r\n     */\n\n\n    SweetScroll.prototype.toLeft = function (distance, options) {\n      this.to(distance, _assign({}, options || {}, {\n        vertical: false,\n        horizontal: true\n      }));\n    };\n    /**\r\n     * Scroll animation to specified element.\r\n     */\n\n\n    SweetScroll.prototype.toElement = function ($element, options) {\n      var $el = this.$el;\n\n      if (!canUseDOM || !$el) {\n        return;\n      }\n\n      this.to(getOffset($element, $el), options || {});\n    };\n    /**\r\n     * Stop the current scroll animation.\r\n     */\n\n\n    SweetScroll.prototype.stop = function (gotoEnd) {\n      if (gotoEnd === void 0) {\n        gotoEnd = false;\n      }\n\n      var _a = this,\n          $el = _a.$el,\n          ctx = _a.ctx;\n\n      var pos = ctx.pos;\n\n      if (!$el || !ctx.progress) {\n        return;\n      }\n\n      SweetScroll.caf(ctx.id);\n      ctx.progress = false;\n      ctx.start = 0;\n      ctx.id = 0;\n\n      if (gotoEnd && pos) {\n        setScroll($el, pos.left, 'x');\n        setScroll($el, pos.top, 'y');\n      }\n\n      this.complete();\n    };\n    /**\r\n     * Update options.\r\n     */\n\n\n    SweetScroll.prototype.update = function (options) {\n      if (this.$el) {\n        var opts = _assign({}, this.opts, options);\n\n        this.stop();\n        this.unbind(true, true);\n        this.opts = opts;\n        this.bind(true, false);\n      }\n    };\n    /**\r\n     * Destroy instance.\r\n     */\n\n\n    SweetScroll.prototype.destroy = function () {\n      if (this.$el) {\n        this.stop();\n        this.unbind(true, true);\n        this.$el = null;\n      }\n    };\n    /**\r\n     * Callback methods.\r\n     */\n\n    /* tslint:disable:no-empty */\n\n\n    SweetScroll.prototype.onBefore = function (_, __) {\n      return true;\n    };\n\n    SweetScroll.prototype.onStep = function (_) {};\n\n    SweetScroll.prototype.onAfter = function (_, __) {};\n\n    SweetScroll.prototype.onCancel = function () {};\n\n    SweetScroll.prototype.onComplete = function (_) {};\n    /* tslint:enable */\n\n    /**\r\n     * Start scrolling animation.\r\n     */\n\n\n    SweetScroll.prototype.start = function (opts) {\n      var ctx = this.ctx;\n      ctx.opts = opts;\n      ctx.progress = true;\n      ctx.easing = isFunction(opts.easing) ? opts.easing : easings[opts.easing]; // Update start offset.\n\n      var $container = this.$el;\n      var start = {\n        top: getScroll($container, 'y'),\n        left: getScroll($container, 'x')\n      };\n      ctx.startPos = start; // Loop\n\n      ctx.id = SweetScroll.raf(this.loop);\n    };\n    /**\r\n     * Handle the completion of scrolling animation.\r\n     */\n\n\n    SweetScroll.prototype.complete = function () {\n      var _a = this,\n          $el = _a.$el,\n          ctx = _a.ctx;\n\n      var hash = ctx.hash,\n          cancel = ctx.cancel,\n          opts = ctx.opts,\n          pos = ctx.pos,\n          $trigger = ctx.$trigger;\n\n      if (!$el || !opts) {\n        return;\n      }\n\n      if (hash != null && hash !== window.location.hash) {\n        var updateURL = opts.updateURL;\n\n        if (canUseDOM && canUseHistory && updateURL !== false) {\n          window.history[updateURL === 'replace' ? 'replaceState' : 'pushState'](null, '', hash);\n        }\n      }\n\n      this.unbind(false, true);\n      ctx.opts = null;\n      ctx.$trigger = null;\n\n      if (cancel) {\n        this.hook(opts, 'cancel');\n      } else {\n        this.hook(opts, 'after', pos, $trigger);\n      }\n\n      this.hook(opts, 'complete', cancel);\n    };\n    /**\r\n     * Callback function and method call.\r\n     */\n\n\n    SweetScroll.prototype.hook = function (options, type) {\n      var args = [];\n\n      for (var _i = 2; _i < arguments.length; _i++) {\n        args[_i - 2] = arguments[_i];\n      }\n\n      var _a;\n\n      var callback = options[type];\n      var callbackResult;\n      var methodResult; // callback\n\n      if (isFunction(callback)) {\n        callbackResult = callback.apply(this, args.concat([this]));\n      } // method\n\n\n      methodResult = (_a = this)[\"on\" + (type[0].toUpperCase() + type.slice(1))].apply(_a, args);\n      return callbackResult !== undefined ? callbackResult : methodResult;\n    };\n    /**\r\n     * Bind events of container element.\r\n     */\n\n\n    SweetScroll.prototype.bind = function (click, stop) {\n      var _a = this,\n          $el = _a.$el,\n          opts = _a.ctx.opts;\n\n      if ($el) {\n        if (click) {\n          addEvent($el, CONTAINER_CLICK_EVENT, this.handleClick, false);\n        }\n\n        if (stop) {\n          addEvent($el, CONTAINER_STOP_EVENT, this.handleStop, opts ? opts.cancellable : true);\n        }\n      }\n    };\n    /**\r\n     * Unbind events of container element.\r\n     */\n\n\n    SweetScroll.prototype.unbind = function (click, stop) {\n      var _a = this,\n          $el = _a.$el,\n          opts = _a.ctx.opts;\n\n      if ($el) {\n        if (click) {\n          removeEvent($el, CONTAINER_CLICK_EVENT, this.handleClick, false);\n        }\n\n        if (stop) {\n          removeEvent($el, CONTAINER_STOP_EVENT, this.handleStop, opts ? opts.cancellable : true);\n        }\n      }\n    };\n    /**\r\n     * You can set Polyfill (or Ponyfill) for browsers that do not support requestAnimationFrame.\r\n     */\n\n\n    SweetScroll.raf = raf;\n    SweetScroll.caf = caf;\n    return SweetScroll;\n  }();\n\n  return SweetScroll;\n});","import _regeneratorRuntime from \"@babel/runtime/regenerator\";\n\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }\n\nfunction _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err); } _next(undefined); }); }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n(function (global, factory) {\n  (typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = global || self, global.Alpine = factory());\n})(this, function () {\n  'use strict';\n\n  function _defineProperty(obj, key, value) {\n    if (key in obj) {\n      Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    } else {\n      obj[key] = value;\n    }\n\n    return obj;\n  }\n\n  function ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\n\n    if (Object.getOwnPropertySymbols) {\n      var symbols = Object.getOwnPropertySymbols(object);\n      if (enumerableOnly) symbols = symbols.filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n      });\n      keys.push.apply(keys, symbols);\n    }\n\n    return keys;\n  }\n\n  function _objectSpread2(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i] != null ? arguments[i] : {};\n\n      if (i % 2) {\n        ownKeys(Object(source), true).forEach(function (key) {\n          _defineProperty(target, key, source[key]);\n        });\n      } else if (Object.getOwnPropertyDescriptors) {\n        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n      } else {\n        ownKeys(Object(source)).forEach(function (key) {\n          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n        });\n      }\n    }\n\n    return target;\n  } // Thanks @stimulus:\n  // https://github.com/stimulusjs/stimulus/blob/master/packages/%40stimulus/core/src/application.ts\n\n\n  function domReady() {\n    return new Promise(function (resolve) {\n      if (document.readyState == \"loading\") {\n        document.addEventListener(\"DOMContentLoaded\", resolve);\n      } else {\n        resolve();\n      }\n    });\n  }\n\n  function arrayUnique(array) {\n    return Array.from(new Set(array));\n  }\n\n  function isTesting() {\n    return navigator.userAgent.includes(\"Node.js\") || navigator.userAgent.includes(\"jsdom\");\n  }\n\n  function warnIfMalformedTemplate(el, directive) {\n    if (el.tagName.toLowerCase() !== 'template') {\n      console.warn(\"Alpine: [\".concat(directive, \"] directive should only be added to <template> tags. See https://github.com/alpinejs/alpine#\").concat(directive));\n    } else if (el.content.childElementCount !== 1) {\n      console.warn(\"Alpine: <template> tag with [\".concat(directive, \"] encountered with multiple element roots. Make sure <template> only has a single child node.\"));\n    }\n  }\n\n  function kebabCase(subject) {\n    return subject.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[_\\s]/, '-').toLowerCase();\n  }\n\n  function walk(el, callback) {\n    if (callback(el) === false) return;\n    var node = el.firstElementChild;\n\n    while (node) {\n      walk(node, callback);\n      node = node.nextElementSibling;\n    }\n  }\n\n  function debounce(func, wait) {\n    var timeout;\n    return function () {\n      var context = this,\n          args = arguments;\n\n      var later = function later() {\n        timeout = null;\n        func.apply(context, args);\n      };\n\n      clearTimeout(timeout);\n      timeout = setTimeout(later, wait);\n    };\n  }\n\n  function saferEval(expression, dataContext) {\n    var additionalHelperVariables = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n    if (typeof expression === 'function') {\n      return expression.call(dataContext);\n    }\n\n    return new Function(['$data'].concat(_toConsumableArray(Object.keys(additionalHelperVariables))), \"var __alpine_result; with($data) { __alpine_result = \".concat(expression, \" }; return __alpine_result\")).apply(void 0, [dataContext].concat(_toConsumableArray(Object.values(additionalHelperVariables))));\n  }\n\n  function saferEvalNoReturn(expression, dataContext) {\n    var additionalHelperVariables = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n    if (typeof expression === 'function') {\n      return expression.call(dataContext);\n    } // For the cases when users pass only a function reference to the caller: `x-on:click=\"foo\"`\n    // Where \"foo\" is a function. Also, we'll pass the function the event instance when we call it.\n\n\n    if (Object.keys(dataContext).includes(expression)) {\n      var methodReference = new Function(['dataContext'].concat(_toConsumableArray(Object.keys(additionalHelperVariables))), \"with(dataContext) { return \".concat(expression, \" }\")).apply(void 0, [dataContext].concat(_toConsumableArray(Object.values(additionalHelperVariables))));\n\n      if (typeof methodReference === 'function') {\n        return methodReference.call(dataContext, additionalHelperVariables['$event']);\n      }\n    }\n\n    return new Function(['dataContext'].concat(_toConsumableArray(Object.keys(additionalHelperVariables))), \"with(dataContext) { \".concat(expression, \" }\")).apply(void 0, [dataContext].concat(_toConsumableArray(Object.values(additionalHelperVariables))));\n  }\n\n  var xAttrRE = /^x-(on|bind|data|text|html|model|if|for|show|cloak|transition|ref|spread)\\b/;\n\n  function isXAttr(attr) {\n    var name = replaceAtAndColonWithStandardSyntax(attr.name);\n    return xAttrRE.test(name);\n  }\n\n  function getXAttrs(el, component, type) {\n    var directives = Array.from(el.attributes).filter(isXAttr).map(parseHtmlAttribute); // Get an object of directives from x-spread.\n\n    var spreadDirective = directives.filter(function (directive) {\n      return directive.type === 'spread';\n    })[0];\n\n    if (spreadDirective) {\n      var spreadObject = saferEval(spreadDirective.expression, component.$data); // Add x-spread directives to the pile of existing directives.\n\n      directives = directives.concat(Object.entries(spreadObject).map(function (_ref) {\n        var _ref2 = _slicedToArray(_ref, 2),\n            name = _ref2[0],\n            value = _ref2[1];\n\n        return parseHtmlAttribute({\n          name: name,\n          value: value\n        });\n      }));\n    }\n\n    return directives.filter(function (i) {\n      // If no type is passed in for filtering, bypass filter\n      if (!type) return true;\n      return i.type === type;\n    });\n  }\n\n  function parseHtmlAttribute(_ref3) {\n    var name = _ref3.name,\n        value = _ref3.value;\n    var normalizedName = replaceAtAndColonWithStandardSyntax(name);\n    var typeMatch = normalizedName.match(xAttrRE);\n    var valueMatch = normalizedName.match(/:([a-zA-Z\\-:]+)/);\n    var modifiers = normalizedName.match(/\\.[^.\\]]+(?=[^\\]]*$)/g) || [];\n    return {\n      type: typeMatch ? typeMatch[1] : null,\n      value: valueMatch ? valueMatch[1] : null,\n      modifiers: modifiers.map(function (i) {\n        return i.replace('.', '');\n      }),\n      expression: value\n    };\n  }\n\n  function isBooleanAttr(attrName) {\n    // As per HTML spec table https://html.spec.whatwg.org/multipage/indices.html#attributes-3:boolean-attribute\n    // Array roughly ordered by estimated usage\n    var booleanAttributes = ['disabled', 'checked', 'required', 'readonly', 'hidden', 'open', 'selected', 'autofocus', 'itemscope', 'multiple', 'novalidate', 'allowfullscreen', 'allowpaymentrequest', 'formnovalidate', 'autoplay', 'controls', 'loop', 'muted', 'playsinline', 'default', 'ismap', 'reversed', 'async', 'defer', 'nomodule'];\n    return booleanAttributes.includes(attrName);\n  }\n\n  function replaceAtAndColonWithStandardSyntax(name) {\n    if (name.startsWith('@')) {\n      return name.replace('@', 'x-on:');\n    } else if (name.startsWith(':')) {\n      return name.replace(':', 'x-bind:');\n    }\n\n    return name;\n  }\n\n  function convertClassStringToArray(classList) {\n    var filterFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Boolean;\n    return classList.split(' ').filter(filterFn);\n  }\n\n  function transitionIn(el, show, component) {\n    var forceSkip = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n    if (forceSkip) return show();\n    var attrs = getXAttrs(el, component, 'transition');\n    var showAttr = getXAttrs(el, component, 'show')[0]; // If this is triggered by a x-show.transition.\n\n    if (showAttr && showAttr.modifiers.includes('transition')) {\n      var modifiers = showAttr.modifiers; // If x-show.transition.out, we'll skip the \"in\" transition.\n\n      if (modifiers.includes('out') && !modifiers.includes('in')) return show();\n      var settingBothSidesOfTransition = modifiers.includes('in') && modifiers.includes('out'); // If x-show.transition.in...out... only use \"in\" related modifiers for this transition.\n\n      modifiers = settingBothSidesOfTransition ? modifiers.filter(function (i, index) {\n        return index < modifiers.indexOf('out');\n      }) : modifiers;\n      transitionHelperIn(el, modifiers, show); // Otherwise, we can assume x-transition:enter.\n    } else if (attrs.filter(function (attr) {\n      return ['enter', 'enter-start', 'enter-end'].includes(attr.value);\n    }).length > 0) {\n      transitionClassesIn(el, component, attrs, show);\n    } else {\n      // If neither, just show that damn thing.\n      show();\n    }\n  }\n\n  function transitionOut(el, hide, component) {\n    var forceSkip = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return hide();\n    var attrs = getXAttrs(el, component, 'transition');\n    var showAttr = getXAttrs(el, component, 'show')[0];\n\n    if (showAttr && showAttr.modifiers.includes('transition')) {\n      var modifiers = showAttr.modifiers;\n      if (modifiers.includes('in') && !modifiers.includes('out')) return hide();\n      var settingBothSidesOfTransition = modifiers.includes('in') && modifiers.includes('out');\n      modifiers = settingBothSidesOfTransition ? modifiers.filter(function (i, index) {\n        return index > modifiers.indexOf('out');\n      }) : modifiers;\n      transitionHelperOut(el, modifiers, settingBothSidesOfTransition, hide);\n    } else if (attrs.filter(function (attr) {\n      return ['leave', 'leave-start', 'leave-end'].includes(attr.value);\n    }).length > 0) {\n      transitionClassesOut(el, component, attrs, hide);\n    } else {\n      hide();\n    }\n  }\n\n  function transitionHelperIn(el, modifiers, showCallback) {\n    // Default values inspired by: https://material.io/design/motion/speed.html#duration\n    var styleValues = {\n      duration: modifierValue(modifiers, 'duration', 150),\n      origin: modifierValue(modifiers, 'origin', 'center'),\n      first: {\n        opacity: 0,\n        scale: modifierValue(modifiers, 'scale', 95)\n      },\n      second: {\n        opacity: 1,\n        scale: 100\n      }\n    };\n    transitionHelper(el, modifiers, showCallback, function () {}, styleValues);\n  }\n\n  function transitionHelperOut(el, modifiers, settingBothSidesOfTransition, hideCallback) {\n    // Make the \"out\" transition .5x slower than the \"in\". (Visually better)\n    // HOWEVER, if they explicitly set a duration for the \"out\" transition,\n    // use that.\n    var duration = settingBothSidesOfTransition ? modifierValue(modifiers, 'duration', 150) : modifierValue(modifiers, 'duration', 150) / 2;\n    var styleValues = {\n      duration: duration,\n      origin: modifierValue(modifiers, 'origin', 'center'),\n      first: {\n        opacity: 1,\n        scale: 100\n      },\n      second: {\n        opacity: 0,\n        scale: modifierValue(modifiers, 'scale', 95)\n      }\n    };\n    transitionHelper(el, modifiers, function () {}, hideCallback, styleValues);\n  }\n\n  function modifierValue(modifiers, key, fallback) {\n    // If the modifier isn't present, use the default.\n    if (modifiers.indexOf(key) === -1) return fallback; // If it IS present, grab the value after it: x-show.transition.duration.500ms\n\n    var rawValue = modifiers[modifiers.indexOf(key) + 1];\n    if (!rawValue) return fallback;\n\n    if (key === 'scale') {\n      // Check if the very next value is NOT a number and return the fallback.\n      // If x-show.transition.scale, we'll use the default scale value.\n      // That is how a user opts out of the opacity transition.\n      if (!isNumeric(rawValue)) return fallback;\n    }\n\n    if (key === 'duration') {\n      // Support x-show.transition.duration.500ms && duration.500\n      var match = rawValue.match(/([0-9]+)ms/);\n      if (match) return match[1];\n    }\n\n    if (key === 'origin') {\n      // Support chaining origin directions: x-show.transition.top.right\n      if (['top', 'right', 'left', 'center', 'bottom'].includes(modifiers[modifiers.indexOf(key) + 2])) {\n        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(' ');\n      }\n    }\n\n    return rawValue;\n  }\n\n  function transitionHelper(el, modifiers, hook1, hook2, styleValues) {\n    // If the user set these style values, we'll put them back when we're done with them.\n    var opacityCache = el.style.opacity;\n    var transformCache = el.style.transform;\n    var transformOriginCache = el.style.transformOrigin; // If no modifiers are present: x-show.transition, we'll default to both opacity and scale.\n\n    var noModifiers = !modifiers.includes('opacity') && !modifiers.includes('scale');\n    var transitionOpacity = noModifiers || modifiers.includes('opacity');\n    var transitionScale = noModifiers || modifiers.includes('scale'); // These are the explicit stages of a transition (same stages for in and for out).\n    // This way you can get a birds eye view of the hooks, and the differences\n    // between them.\n\n    var stages = {\n      start: function start() {\n        if (transitionOpacity) el.style.opacity = styleValues.first.opacity;\n        if (transitionScale) el.style.transform = \"scale(\".concat(styleValues.first.scale / 100, \")\");\n      },\n      during: function during() {\n        if (transitionScale) el.style.transformOrigin = styleValues.origin;\n        el.style.transitionProperty = [transitionOpacity ? \"opacity\" : \"\", transitionScale ? \"transform\" : \"\"].join(' ').trim();\n        el.style.transitionDuration = \"\".concat(styleValues.duration / 1000, \"s\");\n        el.style.transitionTimingFunction = \"cubic-bezier(0.4, 0.0, 0.2, 1)\";\n      },\n      show: function show() {\n        hook1();\n      },\n      end: function end() {\n        if (transitionOpacity) el.style.opacity = styleValues.second.opacity;\n        if (transitionScale) el.style.transform = \"scale(\".concat(styleValues.second.scale / 100, \")\");\n      },\n      hide: function hide() {\n        hook2();\n      },\n      cleanup: function cleanup() {\n        if (transitionOpacity) el.style.opacity = opacityCache;\n        if (transitionScale) el.style.transform = transformCache;\n        if (transitionScale) el.style.transformOrigin = transformOriginCache;\n        el.style.transitionProperty = null;\n        el.style.transitionDuration = null;\n        el.style.transitionTimingFunction = null;\n      }\n    };\n    transition(el, stages);\n  }\n\n  function transitionClassesIn(el, component, directives, showCallback) {\n    var ensureStringExpression = function ensureStringExpression(expression) {\n      return typeof expression === 'function' ? component.evaluateReturnExpression(el, expression) : expression;\n    };\n\n    var enter = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'enter';\n    }) || {\n      expression: ''\n    }).expression));\n    var enterStart = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'enter-start';\n    }) || {\n      expression: ''\n    }).expression));\n    var enterEnd = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'enter-end';\n    }) || {\n      expression: ''\n    }).expression));\n    transitionClasses(el, enter, enterStart, enterEnd, showCallback, function () {});\n  }\n\n  function transitionClassesOut(el, component, directives, hideCallback) {\n    var leave = convertClassStringToArray((directives.find(function (i) {\n      return i.value === 'leave';\n    }) || {\n      expression: ''\n    }).expression);\n    var leaveStart = convertClassStringToArray((directives.find(function (i) {\n      return i.value === 'leave-start';\n    }) || {\n      expression: ''\n    }).expression);\n    var leaveEnd = convertClassStringToArray((directives.find(function (i) {\n      return i.value === 'leave-end';\n    }) || {\n      expression: ''\n    }).expression);\n    transitionClasses(el, leave, leaveStart, leaveEnd, function () {}, hideCallback);\n  }\n\n  function transitionClasses(el, classesDuring, classesStart, classesEnd, hook1, hook2) {\n    var originalClasses = el.__x_original_classes || [];\n    var stages = {\n      start: function start() {\n        var _el$classList;\n\n        (_el$classList = el.classList).add.apply(_el$classList, _toConsumableArray(classesStart));\n      },\n      during: function during() {\n        var _el$classList2;\n\n        (_el$classList2 = el.classList).add.apply(_el$classList2, _toConsumableArray(classesDuring));\n      },\n      show: function show() {\n        hook1();\n      },\n      end: function end() {\n        var _el$classList3, _el$classList4;\n\n        // Don't remove classes that were in the original class attribute.\n        (_el$classList3 = el.classList).remove.apply(_el$classList3, _toConsumableArray(classesStart.filter(function (i) {\n          return !originalClasses.includes(i);\n        })));\n\n        (_el$classList4 = el.classList).add.apply(_el$classList4, _toConsumableArray(classesEnd));\n      },\n      hide: function hide() {\n        hook2();\n      },\n      cleanup: function cleanup() {\n        var _el$classList5, _el$classList6;\n\n        (_el$classList5 = el.classList).remove.apply(_el$classList5, _toConsumableArray(classesDuring.filter(function (i) {\n          return !originalClasses.includes(i);\n        })));\n\n        (_el$classList6 = el.classList).remove.apply(_el$classList6, _toConsumableArray(classesEnd.filter(function (i) {\n          return !originalClasses.includes(i);\n        })));\n      }\n    };\n    transition(el, stages);\n  }\n\n  function transition(el, stages) {\n    stages.start();\n    stages.during();\n    requestAnimationFrame(function () {\n      // Note: Safari's transitionDuration property will list out comma separated transition durations\n      // for every single transition property. Let's grab the first one and call it a day.\n      var duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, '').replace('s', '')) * 1000;\n\n      if (duration === 0) {\n        duration = Number(getComputedStyle(el).animationDuration.replace('s', '')) * 1000;\n      }\n\n      stages.show();\n      requestAnimationFrame(function () {\n        stages.end(); // Assign current transition to el in case we need to force it.\n\n        setTimeout(function () {\n          stages.hide(); // Adding an \"isConnected\" check, in case the callback\n          // removed the element from the DOM.\n\n          if (el.isConnected) {\n            stages.cleanup();\n          }\n        }, duration);\n      });\n    });\n  }\n\n  function isNumeric(subject) {\n    return !isNaN(subject);\n  }\n\n  function handleForDirective(component, templateEl, expression, initialUpdate, extraVars) {\n    warnIfMalformedTemplate(templateEl, 'x-for');\n    var iteratorNames = typeof expression === 'function' ? parseForExpression(component.evaluateReturnExpression(templateEl, expression)) : parseForExpression(expression);\n    var items = evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement(component, templateEl, iteratorNames, extraVars); // As we walk the array, we'll also walk the DOM (updating/creating as we go).\n\n    var currentEl = templateEl;\n    items.forEach(function (item, index) {\n      var iterationScopeVariables = getIterationScopeVariables(iteratorNames, item, index, items, extraVars());\n      var currentKey = generateKeyForIteration(component, templateEl, index, iterationScopeVariables);\n      var nextEl = lookAheadForMatchingKeyedElementAndMoveItIfFound(currentEl.nextElementSibling, currentKey); // If we haven't found a matching key, insert the element at the current position.\n\n      if (!nextEl) {\n        nextEl = addElementInLoopAfterCurrentEl(templateEl, currentEl); // And transition it in if it's not the first page load.\n\n        transitionIn(nextEl, function () {}, component, initialUpdate);\n        nextEl.__x_for = iterationScopeVariables;\n        component.initializeElements(nextEl, function () {\n          return nextEl.__x_for;\n        }); // Otherwise update the element we found.\n      } else {\n        // Temporarily remove the key indicator to allow the normal \"updateElements\" to work.\n        delete nextEl.__x_for_key;\n        nextEl.__x_for = iterationScopeVariables;\n        component.updateElements(nextEl, function () {\n          return nextEl.__x_for;\n        });\n      }\n\n      currentEl = nextEl;\n      currentEl.__x_for_key = currentKey;\n    });\n    removeAnyLeftOverElementsFromPreviousUpdate(currentEl, component);\n  } // This was taken from VueJS 2.* core. Thanks Vue!\n\n\n  function parseForExpression(expression) {\n    var forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\n    var stripParensRE = /^\\(|\\)$/g;\n    var forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+([\\s\\S]*)/;\n    var inMatch = expression.match(forAliasRE);\n    if (!inMatch) return;\n    var res = {};\n    res.items = inMatch[2].trim();\n    var item = inMatch[1].trim().replace(stripParensRE, '');\n    var iteratorMatch = item.match(forIteratorRE);\n\n    if (iteratorMatch) {\n      res.item = item.replace(forIteratorRE, '').trim();\n      res.index = iteratorMatch[1].trim();\n\n      if (iteratorMatch[2]) {\n        res.collection = iteratorMatch[2].trim();\n      }\n    } else {\n      res.item = item;\n    }\n\n    return res;\n  }\n\n  function getIterationScopeVariables(iteratorNames, item, index, items, extraVars) {\n    // We must create a new object, so each iteration has a new scope\n    var scopeVariables = extraVars ? _objectSpread2({}, extraVars) : {};\n    scopeVariables[iteratorNames.item] = item;\n    if (iteratorNames.index) scopeVariables[iteratorNames.index] = index;\n    if (iteratorNames.collection) scopeVariables[iteratorNames.collection] = items;\n    return scopeVariables;\n  }\n\n  function generateKeyForIteration(component, el, index, iterationScopeVariables) {\n    var bindKeyAttribute = getXAttrs(el, component, 'bind').filter(function (attr) {\n      return attr.value === 'key';\n    })[0]; // If the dev hasn't specified a key, just return the index of the iteration.\n\n    if (!bindKeyAttribute) return index;\n    return component.evaluateReturnExpression(el, bindKeyAttribute.expression, function () {\n      return iterationScopeVariables;\n    });\n  }\n\n  function evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement(component, el, iteratorNames, extraVars) {\n    var ifAttribute = getXAttrs(el, component, 'if')[0];\n\n    if (ifAttribute && !component.evaluateReturnExpression(el, ifAttribute.expression)) {\n      return [];\n    }\n\n    return component.evaluateReturnExpression(el, iteratorNames.items, extraVars);\n  }\n\n  function addElementInLoopAfterCurrentEl(templateEl, currentEl) {\n    var clone = document.importNode(templateEl.content, true);\n    currentEl.parentElement.insertBefore(clone, currentEl.nextElementSibling);\n    return currentEl.nextElementSibling;\n  }\n\n  function lookAheadForMatchingKeyedElementAndMoveItIfFound(nextEl, currentKey) {\n    if (!nextEl) return; // If the the key's DO match, no need to look ahead.\n\n    if (nextEl.__x_for_key === currentKey) return nextEl; // If they don't, we'll look ahead for a match.\n    // If we find it, we'll move it to the current position in the loop.\n\n    var tmpNextEl = nextEl;\n\n    while (tmpNextEl) {\n      if (tmpNextEl.__x_for_key === currentKey) {\n        return tmpNextEl.parentElement.insertBefore(tmpNextEl, nextEl);\n      }\n\n      tmpNextEl = tmpNextEl.nextElementSibling && tmpNextEl.nextElementSibling.__x_for_key !== undefined ? tmpNextEl.nextElementSibling : false;\n    }\n  }\n\n  function removeAnyLeftOverElementsFromPreviousUpdate(currentEl, component) {\n    var nextElementFromOldLoop = currentEl.nextElementSibling && currentEl.nextElementSibling.__x_for_key !== undefined ? currentEl.nextElementSibling : false;\n\n    var _loop = function _loop() {\n      var nextElementFromOldLoopImmutable = nextElementFromOldLoop;\n      var nextSibling = nextElementFromOldLoop.nextElementSibling;\n      transitionOut(nextElementFromOldLoop, function () {\n        nextElementFromOldLoopImmutable.remove();\n      }, component);\n      nextElementFromOldLoop = nextSibling && nextSibling.__x_for_key !== undefined ? nextSibling : false;\n    };\n\n    while (nextElementFromOldLoop) {\n      _loop();\n    }\n  }\n\n  function handleAttributeBindingDirective(component, el, attrName, expression, extraVars, attrType) {\n    var value = component.evaluateReturnExpression(el, expression, extraVars);\n\n    if (attrName === 'value') {\n      // If nested model key is undefined, set the default value to empty string.\n      if (value === undefined && expression.match(/\\./).length) {\n        value = '';\n      }\n\n      if (el.type === 'radio') {\n        // Set radio value from x-bind:value, if no \"value\" attribute exists.\n        // If there are any initial state values, radio will have a correct\n        // \"checked\" value since x-bind:value is processed before x-model.\n        if (el.attributes.value === undefined && attrType === 'bind') {\n          el.value = value;\n        } else if (attrType !== 'bind') {\n          el.checked = el.value == value;\n        }\n      } else if (el.type === 'checkbox') {\n        // If we are explicitly binding a string to the :value, set the string,\n        // If the value is a boolean, leave it alone, it will be set to \"on\"\n        // automatically.\n        if (typeof value === 'string' && attrType === 'bind') {\n          el.value = value;\n        } else if (attrType !== 'bind') {\n          if (Array.isArray(value)) {\n            // I'm purposely not using Array.includes here because it's\n            // strict, and because of Numeric/String mis-casting, I\n            // want the \"includes\" to be \"fuzzy\".\n            el.checked = value.some(function (val) {\n              return val == el.value;\n            });\n          } else {\n            el.checked = !!value;\n          }\n        }\n      } else if (el.tagName === 'SELECT') {\n        updateSelect(el, value);\n      } else {\n        if (el.value === value) return;\n        el.value = value;\n      }\n    } else if (attrName === 'class') {\n      if (Array.isArray(value)) {\n        var originalClasses = el.__x_original_classes || [];\n        el.setAttribute('class', arrayUnique(originalClasses.concat(value)).join(' '));\n      } else if (_typeof(value) === 'object') {\n        // Sorting the keys / class names by their boolean value will ensure that\n        // anything that evaluates to `false` and needs to remove classes is run first.\n        var keysSortedByBooleanValue = Object.keys(value).sort(function (a, b) {\n          return value[a] - value[b];\n        });\n        keysSortedByBooleanValue.forEach(function (classNames) {\n          if (value[classNames]) {\n            convertClassStringToArray(classNames).forEach(function (className) {\n              return el.classList.add(className);\n            });\n          } else {\n            convertClassStringToArray(classNames).forEach(function (className) {\n              return el.classList.remove(className);\n            });\n          }\n        });\n      } else {\n        var _originalClasses = el.__x_original_classes || [];\n\n        var newClasses = convertClassStringToArray(value);\n        el.setAttribute('class', arrayUnique(_originalClasses.concat(newClasses)).join(' '));\n      }\n    } else {\n      // If an attribute's bound value is null, undefined or false, remove the attribute\n      if ([null, undefined, false].includes(value)) {\n        el.removeAttribute(attrName);\n      } else {\n        isBooleanAttr(attrName) ? setIfChanged(el, attrName, attrName) : setIfChanged(el, attrName, value);\n      }\n    }\n  }\n\n  function setIfChanged(el, attrName, value) {\n    if (el.getAttribute(attrName) != value) {\n      el.setAttribute(attrName, value);\n    }\n  }\n\n  function updateSelect(el, value) {\n    var arrayWrappedValue = [].concat(value).map(function (value) {\n      return value + '';\n    });\n    Array.from(el.options).forEach(function (option) {\n      option.selected = arrayWrappedValue.includes(option.value || option.text);\n    });\n  }\n\n  function handleTextDirective(el, output, expression) {\n    // If nested model key is undefined, set the default value to empty string.\n    if (output === undefined && expression.match(/\\./)) {\n      output = '';\n    }\n\n    el.innerText = output;\n  }\n\n  function handleHtmlDirective(component, el, expression, extraVars) {\n    el.innerHTML = component.evaluateReturnExpression(el, expression, extraVars);\n  }\n\n  function handleShowDirective(component, el, value, modifiers) {\n    var initialUpdate = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n    var hide = function hide() {\n      el.style.display = 'none';\n    };\n\n    var show = function show() {\n      if (el.style.length === 1 && el.style.display === 'none') {\n        el.removeAttribute('style');\n      } else {\n        el.style.removeProperty('display');\n      }\n    };\n\n    if (initialUpdate === true) {\n      if (value) {\n        show();\n      } else {\n        hide();\n      }\n\n      return;\n    }\n\n    var handle = function handle(resolve) {\n      if (value) {\n        transitionIn(el, function () {\n          show();\n        }, component);\n        resolve(function () {});\n      } else {\n        if (el.style.display !== 'none') {\n          transitionOut(el, function () {\n            resolve(function () {\n              hide();\n            });\n          }, component);\n        } else {\n          resolve(function () {});\n        }\n      }\n    }; // The working of x-show is a bit complex because we need to\n    // wait for any child transitions to finish before hiding\n    // some element. Also, this has to be done recursively.\n    // If x-show.immediate, foregoe the waiting.\n\n\n    if (modifiers.includes('immediate')) {\n      handle(function (finish) {\n        return finish();\n      });\n      return;\n    } // x-show is encountered during a DOM tree walk. If an element\n    // we encounter is NOT a child of another x-show element we\n    // can execute the previous x-show stack (if one exists).\n\n\n    if (component.showDirectiveLastElement && !component.showDirectiveLastElement.contains(el)) {\n      component.executeAndClearRemainingShowDirectiveStack();\n    }\n\n    component.showDirectiveStack.push(handle);\n    component.showDirectiveLastElement = el;\n  }\n\n  function handleIfDirective(component, el, expressionResult, initialUpdate, extraVars) {\n    warnIfMalformedTemplate(el, 'x-if');\n    var elementHasAlreadyBeenAdded = el.nextElementSibling && el.nextElementSibling.__x_inserted_me === true;\n\n    if (expressionResult && !elementHasAlreadyBeenAdded) {\n      var clone = document.importNode(el.content, true);\n      el.parentElement.insertBefore(clone, el.nextElementSibling);\n      transitionIn(el.nextElementSibling, function () {}, component, initialUpdate);\n      component.initializeElements(el.nextElementSibling, extraVars);\n      el.nextElementSibling.__x_inserted_me = true;\n    } else if (!expressionResult && elementHasAlreadyBeenAdded) {\n      transitionOut(el.nextElementSibling, function () {\n        el.nextElementSibling.remove();\n      }, component, initialUpdate);\n    }\n  }\n\n  function registerListener(component, el, event, modifiers, expression) {\n    var extraVars = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};\n\n    if (modifiers.includes('away')) {\n      var handler = function handler(e) {\n        // Don't do anything if the click came form the element or within it.\n        if (el.contains(e.target)) return; // Don't do anything if this element isn't currently visible.\n\n        if (el.offsetWidth < 1 && el.offsetHeight < 1) return; // Now that we are sure the element is visible, AND the click\n        // is from outside it, let's run the expression.\n\n        runListenerHandler(component, expression, e, extraVars);\n\n        if (modifiers.includes('once')) {\n          document.removeEventListener(event, handler);\n        }\n      }; // Listen for this event at the root level.\n\n\n      document.addEventListener(event, handler);\n    } else {\n      var listenerTarget = modifiers.includes('window') ? window : modifiers.includes('document') ? document : el;\n\n      var _handler2 = function _handler(e) {\n        // Remove this global event handler if the element that declared it\n        // has been removed. It's now stale.\n        if (listenerTarget === window || listenerTarget === document) {\n          if (!document.body.contains(el)) {\n            listenerTarget.removeEventListener(event, _handler2);\n            return;\n          }\n        }\n\n        if (isKeyEvent(event)) {\n          if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {\n            return;\n          }\n        }\n\n        if (modifiers.includes('prevent')) e.preventDefault();\n        if (modifiers.includes('stop')) e.stopPropagation(); // If the .self modifier isn't present, or if it is present and\n        // the target element matches the element we are registering the\n        // event on, run the handler\n\n        if (!modifiers.includes('self') || e.target === el) {\n          var returnValue = runListenerHandler(component, expression, e, extraVars);\n\n          if (returnValue === false) {\n            e.preventDefault();\n          } else {\n            if (modifiers.includes('once')) {\n              listenerTarget.removeEventListener(event, _handler2);\n            }\n          }\n        }\n      };\n\n      if (modifiers.includes('debounce')) {\n        var nextModifier = modifiers[modifiers.indexOf('debounce') + 1] || 'invalid-wait';\n        var wait = isNumeric(nextModifier.split('ms')[0]) ? Number(nextModifier.split('ms')[0]) : 250;\n        _handler2 = debounce(_handler2, wait);\n      }\n\n      listenerTarget.addEventListener(event, _handler2);\n    }\n  }\n\n  function runListenerHandler(component, expression, e, extraVars) {\n    return component.evaluateCommandExpression(e.target, expression, function () {\n      return _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        '$event': e\n      });\n    });\n  }\n\n  function isKeyEvent(event) {\n    return ['keydown', 'keyup'].includes(event);\n  }\n\n  function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {\n    var keyModifiers = modifiers.filter(function (i) {\n      return !['window', 'document', 'prevent', 'stop'].includes(i);\n    });\n\n    if (keyModifiers.includes('debounce')) {\n      var debounceIndex = keyModifiers.indexOf('debounce');\n      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || 'invalid-wait').split('ms')[0]) ? 2 : 1);\n    } // If no modifier is specified, we'll call it a press.\n\n\n    if (keyModifiers.length === 0) return false; // If one is passed, AND it matches the key pressed, we'll call it a press.\n\n    if (keyModifiers.length === 1 && keyModifiers[0] === keyToModifier(e.key)) return false; // The user is listening for key combinations.\n\n    var systemKeyModifiers = ['ctrl', 'shift', 'alt', 'meta', 'cmd', 'super'];\n    var selectedSystemKeyModifiers = systemKeyModifiers.filter(function (modifier) {\n      return keyModifiers.includes(modifier);\n    });\n    keyModifiers = keyModifiers.filter(function (i) {\n      return !selectedSystemKeyModifiers.includes(i);\n    });\n\n    if (selectedSystemKeyModifiers.length > 0) {\n      var activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter(function (modifier) {\n        // Alias \"cmd\" and \"super\" to \"meta\"\n        if (modifier === 'cmd' || modifier === 'super') modifier = 'meta';\n        return e[\"\".concat(modifier, \"Key\")];\n      }); // If all the modifiers selected are pressed, ...\n\n      if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {\n        // AND the remaining key is pressed as well. It's a press.\n        if (keyModifiers[0] === keyToModifier(e.key)) return false;\n      }\n    } // We'll call it NOT a valid keypress.\n\n\n    return true;\n  }\n\n  function keyToModifier(key) {\n    switch (key) {\n      case '/':\n        return 'slash';\n\n      case ' ':\n      case 'Spacebar':\n        return 'space';\n\n      default:\n        return key && kebabCase(key);\n    }\n  }\n\n  function registerModelListener(component, el, modifiers, expression, extraVars) {\n    // If the element we are binding to is a select, a radio, or checkbox\n    // we'll listen for the change event instead of the \"input\" event.\n    var event = el.tagName.toLowerCase() === 'select' || ['checkbox', 'radio'].includes(el.type) || modifiers.includes('lazy') ? 'change' : 'input';\n    var listenerExpression = \"\".concat(expression, \" = rightSideOfExpression($event, \").concat(expression, \")\");\n    registerListener(component, el, event, modifiers, listenerExpression, function () {\n      return _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        rightSideOfExpression: generateModelAssignmentFunction(el, modifiers, expression)\n      });\n    });\n  }\n\n  function generateModelAssignmentFunction(el, modifiers, expression) {\n    if (el.type === 'radio') {\n      // Radio buttons only work properly when they share a name attribute.\n      // People might assume we take care of that for them, because\n      // they already set a shared \"x-model\" attribute.\n      if (!el.hasAttribute('name')) el.setAttribute('name', expression);\n    }\n\n    return function (event, currentValue) {\n      // Check for event.detail due to an issue where IE11 handles other events as a CustomEvent.\n      if (event instanceof CustomEvent && event.detail) {\n        return event.detail;\n      } else if (el.type === 'checkbox') {\n        // If the data we are binding to is an array, toggle its value inside the array.\n        if (Array.isArray(currentValue)) {\n          var newValue = modifiers.includes('number') ? safeParseNumber(event.target.value) : event.target.value;\n          return event.target.checked ? currentValue.concat([newValue]) : currentValue.filter(function (i) {\n            return i !== newValue;\n          });\n        } else {\n          return event.target.checked;\n        }\n      } else if (el.tagName.toLowerCase() === 'select' && el.multiple) {\n        return modifiers.includes('number') ? Array.from(event.target.selectedOptions).map(function (option) {\n          var rawValue = option.value || option.text;\n          return safeParseNumber(rawValue);\n        }) : Array.from(event.target.selectedOptions).map(function (option) {\n          return option.value || option.text;\n        });\n      } else {\n        var rawValue = event.target.value;\n        return modifiers.includes('number') ? safeParseNumber(rawValue) : modifiers.includes('trim') ? rawValue.trim() : rawValue;\n      }\n    };\n  }\n\n  function safeParseNumber(rawValue) {\n    var number = rawValue ? parseFloat(rawValue) : null;\n    return isNumeric(number) ? number : rawValue;\n  }\n  /**\n   * Copyright (C) 2017 salesforce.com, inc.\n   */\n\n\n  var isArray = Array.isArray;\n  var _getPrototypeOf = Object.getPrototypeOf,\n      ObjectCreate = Object.create,\n      ObjectDefineProperty = Object.defineProperty,\n      ObjectDefineProperties = Object.defineProperties,\n      _isExtensible = Object.isExtensible,\n      _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,\n      getOwnPropertyNames = Object.getOwnPropertyNames,\n      getOwnPropertySymbols = Object.getOwnPropertySymbols,\n      _preventExtensions = Object.preventExtensions,\n      hasOwnProperty = Object.hasOwnProperty;\n  var _Array$prototype = Array.prototype,\n      ArrayPush = _Array$prototype.push,\n      ArrayConcat = _Array$prototype.concat,\n      ArrayMap = _Array$prototype.map;\n\n  function isUndefined(obj) {\n    return obj === undefined;\n  }\n\n  function isFunction(obj) {\n    return typeof obj === 'function';\n  }\n\n  function isObject(obj) {\n    return _typeof(obj) === 'object';\n  }\n\n  var proxyToValueMap = new WeakMap();\n\n  function registerProxy(proxy, value) {\n    proxyToValueMap.set(proxy, value);\n  }\n\n  var unwrap = function unwrap(replicaOrAny) {\n    return proxyToValueMap.get(replicaOrAny) || replicaOrAny;\n  };\n\n  function wrapValue(membrane, value) {\n    return membrane.valueIsObservable(value) ? membrane.getProxy(value) : value;\n  }\n  /**\n   * Unwrap property descriptors will set value on original descriptor\n   * We only need to unwrap if value is specified\n   * @param descriptor external descrpitor provided to define new property on original value\n   */\n\n\n  function unwrapDescriptor(descriptor) {\n    if (hasOwnProperty.call(descriptor, 'value')) {\n      descriptor.value = unwrap(descriptor.value);\n    }\n\n    return descriptor;\n  }\n\n  function lockShadowTarget(membrane, shadowTarget, originalTarget) {\n    var targetKeys = ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n    targetKeys.forEach(function (key) {\n      var descriptor = _getOwnPropertyDescriptor(originalTarget, key); // We do not need to wrap the descriptor if configurable\n      // Because we can deal with wrapping it when user goes through\n      // Get own property descriptor. There is also a chance that this descriptor\n      // could change sometime in the future, so we can defer wrapping\n      // until we need to\n\n\n      if (!descriptor.configurable) {\n        descriptor = wrapDescriptor(membrane, descriptor, wrapValue);\n      }\n\n      ObjectDefineProperty(shadowTarget, key, descriptor);\n    });\n\n    _preventExtensions(shadowTarget);\n  }\n\n  var ReactiveProxyHandler = /*#__PURE__*/function () {\n    function ReactiveProxyHandler(membrane, value) {\n      _classCallCheck(this, ReactiveProxyHandler);\n\n      this.originalTarget = value;\n      this.membrane = membrane;\n    }\n\n    _createClass(ReactiveProxyHandler, [{\n      key: \"get\",\n      value: function get(shadowTarget, key) {\n        var originalTarget = this.originalTarget,\n            membrane = this.membrane;\n        var value = originalTarget[key];\n        var valueObserved = membrane.valueObserved;\n        valueObserved(originalTarget, key);\n        return membrane.getProxy(value);\n      }\n    }, {\n      key: \"set\",\n      value: function set(shadowTarget, key, value) {\n        var originalTarget = this.originalTarget,\n            valueMutated = this.membrane.valueMutated;\n        var oldValue = originalTarget[key];\n\n        if (oldValue !== value) {\n          originalTarget[key] = value;\n          valueMutated(originalTarget, key);\n        } else if (key === 'length' && isArray(originalTarget)) {\n          // fix for issue #236: push will add the new index, and by the time length\n          // is updated, the internal length is already equal to the new length value\n          // therefore, the oldValue is equal to the value. This is the forking logic\n          // to support this use case.\n          valueMutated(originalTarget, key);\n        }\n\n        return true;\n      }\n    }, {\n      key: \"deleteProperty\",\n      value: function deleteProperty(shadowTarget, key) {\n        var originalTarget = this.originalTarget,\n            valueMutated = this.membrane.valueMutated;\n        delete originalTarget[key];\n        valueMutated(originalTarget, key);\n        return true;\n      }\n    }, {\n      key: \"apply\",\n      value: function apply(shadowTarget, thisArg, argArray) {\n        /* No op */\n      }\n    }, {\n      key: \"construct\",\n      value: function construct(target, argArray, newTarget) {\n        /* No op */\n      }\n    }, {\n      key: \"has\",\n      value: function has(shadowTarget, key) {\n        var originalTarget = this.originalTarget,\n            valueObserved = this.membrane.valueObserved;\n        valueObserved(originalTarget, key);\n        return key in originalTarget;\n      }\n    }, {\n      key: \"ownKeys\",\n      value: function ownKeys(shadowTarget) {\n        var originalTarget = this.originalTarget;\n        return ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      }\n    }, {\n      key: \"isExtensible\",\n      value: function isExtensible(shadowTarget) {\n        var shadowIsExtensible = _isExtensible(shadowTarget);\n\n        if (!shadowIsExtensible) {\n          return shadowIsExtensible;\n        }\n\n        var originalTarget = this.originalTarget,\n            membrane = this.membrane;\n\n        var targetIsExtensible = _isExtensible(originalTarget);\n\n        if (!targetIsExtensible) {\n          lockShadowTarget(membrane, shadowTarget, originalTarget);\n        }\n\n        return targetIsExtensible;\n      }\n    }, {\n      key: \"setPrototypeOf\",\n      value: function setPrototypeOf(shadowTarget, prototype) {}\n    }, {\n      key: \"getPrototypeOf\",\n      value: function getPrototypeOf(shadowTarget) {\n        var originalTarget = this.originalTarget;\n        return _getPrototypeOf(originalTarget);\n      }\n    }, {\n      key: \"getOwnPropertyDescriptor\",\n      value: function getOwnPropertyDescriptor(shadowTarget, key) {\n        var originalTarget = this.originalTarget,\n            membrane = this.membrane;\n        var valueObserved = this.membrane.valueObserved; // keys looked up via hasOwnProperty need to be reactive\n\n        valueObserved(originalTarget, key);\n\n        var desc = _getOwnPropertyDescriptor(originalTarget, key);\n\n        if (isUndefined(desc)) {\n          return desc;\n        }\n\n        var shadowDescriptor = _getOwnPropertyDescriptor(shadowTarget, key);\n\n        if (!isUndefined(shadowDescriptor)) {\n          return shadowDescriptor;\n        } // Note: by accessing the descriptor, the key is marked as observed\n        // but access to the value, setter or getter (if available) cannot observe\n        // mutations, just like regular methods, in which case we just do nothing.\n\n\n        desc = wrapDescriptor(membrane, desc, wrapValue);\n\n        if (!desc.configurable) {\n          // If descriptor from original target is not configurable,\n          // We must copy the wrapped descriptor over to the shadow target.\n          // Otherwise, proxy will throw an invariant error.\n          // This is our last chance to lock the value.\n          // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor#Invariants\n          ObjectDefineProperty(shadowTarget, key, desc);\n        }\n\n        return desc;\n      }\n    }, {\n      key: \"preventExtensions\",\n      value: function preventExtensions(shadowTarget) {\n        var originalTarget = this.originalTarget,\n            membrane = this.membrane;\n        lockShadowTarget(membrane, shadowTarget, originalTarget);\n\n        _preventExtensions(originalTarget);\n\n        return true;\n      }\n    }, {\n      key: \"defineProperty\",\n      value: function defineProperty(shadowTarget, key, descriptor) {\n        var originalTarget = this.originalTarget,\n            membrane = this.membrane;\n        var valueMutated = membrane.valueMutated;\n        var configurable = descriptor.configurable; // We have to check for value in descriptor\n        // because Object.freeze(proxy) calls this method\n        // with only { configurable: false, writeable: false }\n        // Additionally, method will only be called with writeable:false\n        // if the descriptor has a value, as opposed to getter/setter\n        // So we can just check if writable is present and then see if\n        // value is present. This eliminates getter and setter descriptors\n\n        if (hasOwnProperty.call(descriptor, 'writable') && !hasOwnProperty.call(descriptor, 'value')) {\n          var originalDescriptor = _getOwnPropertyDescriptor(originalTarget, key);\n\n          descriptor.value = originalDescriptor.value;\n        }\n\n        ObjectDefineProperty(originalTarget, key, unwrapDescriptor(descriptor));\n\n        if (configurable === false) {\n          ObjectDefineProperty(shadowTarget, key, wrapDescriptor(membrane, descriptor, wrapValue));\n        }\n\n        valueMutated(originalTarget, key);\n        return true;\n      }\n    }]);\n\n    return ReactiveProxyHandler;\n  }();\n\n  function wrapReadOnlyValue(membrane, value) {\n    return membrane.valueIsObservable(value) ? membrane.getReadOnlyProxy(value) : value;\n  }\n\n  var ReadOnlyHandler = /*#__PURE__*/function () {\n    function ReadOnlyHandler(membrane, value) {\n      _classCallCheck(this, ReadOnlyHandler);\n\n      this.originalTarget = value;\n      this.membrane = membrane;\n    }\n\n    _createClass(ReadOnlyHandler, [{\n      key: \"get\",\n      value: function get(shadowTarget, key) {\n        var membrane = this.membrane,\n            originalTarget = this.originalTarget;\n        var value = originalTarget[key];\n        var valueObserved = membrane.valueObserved;\n        valueObserved(originalTarget, key);\n        return membrane.getReadOnlyProxy(value);\n      }\n    }, {\n      key: \"set\",\n      value: function set(shadowTarget, key, value) {\n        return false;\n      }\n    }, {\n      key: \"deleteProperty\",\n      value: function deleteProperty(shadowTarget, key) {\n        return false;\n      }\n    }, {\n      key: \"apply\",\n      value: function apply(shadowTarget, thisArg, argArray) {\n        /* No op */\n      }\n    }, {\n      key: \"construct\",\n      value: function construct(target, argArray, newTarget) {\n        /* No op */\n      }\n    }, {\n      key: \"has\",\n      value: function has(shadowTarget, key) {\n        var originalTarget = this.originalTarget,\n            valueObserved = this.membrane.valueObserved;\n        valueObserved(originalTarget, key);\n        return key in originalTarget;\n      }\n    }, {\n      key: \"ownKeys\",\n      value: function ownKeys(shadowTarget) {\n        var originalTarget = this.originalTarget;\n        return ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      }\n    }, {\n      key: \"setPrototypeOf\",\n      value: function setPrototypeOf(shadowTarget, prototype) {}\n    }, {\n      key: \"getOwnPropertyDescriptor\",\n      value: function getOwnPropertyDescriptor(shadowTarget, key) {\n        var originalTarget = this.originalTarget,\n            membrane = this.membrane;\n        var valueObserved = membrane.valueObserved; // keys looked up via hasOwnProperty need to be reactive\n\n        valueObserved(originalTarget, key);\n\n        var desc = _getOwnPropertyDescriptor(originalTarget, key);\n\n        if (isUndefined(desc)) {\n          return desc;\n        }\n\n        var shadowDescriptor = _getOwnPropertyDescriptor(shadowTarget, key);\n\n        if (!isUndefined(shadowDescriptor)) {\n          return shadowDescriptor;\n        } // Note: by accessing the descriptor, the key is marked as observed\n        // but access to the value or getter (if available) cannot be observed,\n        // just like regular methods, in which case we just do nothing.\n\n\n        desc = wrapDescriptor(membrane, desc, wrapReadOnlyValue);\n\n        if (hasOwnProperty.call(desc, 'set')) {\n          desc.set = undefined; // readOnly membrane does not allow setters\n        }\n\n        if (!desc.configurable) {\n          // If descriptor from original target is not configurable,\n          // We must copy the wrapped descriptor over to the shadow target.\n          // Otherwise, proxy will throw an invariant error.\n          // This is our last chance to lock the value.\n          // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor#Invariants\n          ObjectDefineProperty(shadowTarget, key, desc);\n        }\n\n        return desc;\n      }\n    }, {\n      key: \"preventExtensions\",\n      value: function preventExtensions(shadowTarget) {\n        return false;\n      }\n    }, {\n      key: \"defineProperty\",\n      value: function defineProperty(shadowTarget, key, descriptor) {\n        return false;\n      }\n    }]);\n\n    return ReadOnlyHandler;\n  }();\n\n  function createShadowTarget(value) {\n    var shadowTarget = undefined;\n\n    if (isArray(value)) {\n      shadowTarget = [];\n    } else if (isObject(value)) {\n      shadowTarget = {};\n    }\n\n    return shadowTarget;\n  }\n\n  var ObjectDotPrototype = Object.prototype;\n\n  function defaultValueIsObservable(value) {\n    // intentionally checking for null\n    if (value === null) {\n      return false;\n    } // treat all non-object types, including undefined, as non-observable values\n\n\n    if (_typeof(value) !== 'object') {\n      return false;\n    }\n\n    if (isArray(value)) {\n      return true;\n    }\n\n    var proto = _getPrototypeOf(value);\n\n    return proto === ObjectDotPrototype || proto === null || _getPrototypeOf(proto) === null;\n  }\n\n  var defaultValueObserved = function defaultValueObserved(obj, key) {\n    /* do nothing */\n  };\n\n  var defaultValueMutated = function defaultValueMutated(obj, key) {\n    /* do nothing */\n  };\n\n  var defaultValueDistortion = function defaultValueDistortion(value) {\n    return value;\n  };\n\n  function wrapDescriptor(membrane, descriptor, getValue) {\n    var set = descriptor.set,\n        get = descriptor.get;\n\n    if (hasOwnProperty.call(descriptor, 'value')) {\n      descriptor.value = getValue(membrane, descriptor.value);\n    } else {\n      if (!isUndefined(get)) {\n        descriptor.get = function () {\n          // invoking the original getter with the original target\n          return getValue(membrane, get.call(unwrap(this)));\n        };\n      }\n\n      if (!isUndefined(set)) {\n        descriptor.set = function (value) {\n          // At this point we don't have a clear indication of whether\n          // or not a valid mutation will occur, we don't have the key,\n          // and we are not sure why and how they are invoking this setter.\n          // Nevertheless we preserve the original semantics by invoking the\n          // original setter with the original target and the unwrapped value\n          set.call(unwrap(this), membrane.unwrapProxy(value));\n        };\n      }\n    }\n\n    return descriptor;\n  }\n\n  var ReactiveMembrane = /*#__PURE__*/function () {\n    function ReactiveMembrane(options) {\n      _classCallCheck(this, ReactiveMembrane);\n\n      this.valueDistortion = defaultValueDistortion;\n      this.valueMutated = defaultValueMutated;\n      this.valueObserved = defaultValueObserved;\n      this.valueIsObservable = defaultValueIsObservable;\n      this.objectGraph = new WeakMap();\n\n      if (!isUndefined(options)) {\n        var valueDistortion = options.valueDistortion,\n            valueMutated = options.valueMutated,\n            valueObserved = options.valueObserved,\n            valueIsObservable = options.valueIsObservable;\n        this.valueDistortion = isFunction(valueDistortion) ? valueDistortion : defaultValueDistortion;\n        this.valueMutated = isFunction(valueMutated) ? valueMutated : defaultValueMutated;\n        this.valueObserved = isFunction(valueObserved) ? valueObserved : defaultValueObserved;\n        this.valueIsObservable = isFunction(valueIsObservable) ? valueIsObservable : defaultValueIsObservable;\n      }\n    }\n\n    _createClass(ReactiveMembrane, [{\n      key: \"getProxy\",\n      value: function getProxy(value) {\n        var unwrappedValue = unwrap(value);\n        var distorted = this.valueDistortion(unwrappedValue);\n\n        if (this.valueIsObservable(distorted)) {\n          var o = this.getReactiveState(unwrappedValue, distorted); // when trying to extract the writable version of a readonly\n          // we return the readonly.\n\n          return o.readOnly === value ? value : o.reactive;\n        }\n\n        return distorted;\n      }\n    }, {\n      key: \"getReadOnlyProxy\",\n      value: function getReadOnlyProxy(value) {\n        value = unwrap(value);\n        var distorted = this.valueDistortion(value);\n\n        if (this.valueIsObservable(distorted)) {\n          return this.getReactiveState(value, distorted).readOnly;\n        }\n\n        return distorted;\n      }\n    }, {\n      key: \"unwrapProxy\",\n      value: function unwrapProxy(p) {\n        return unwrap(p);\n      }\n    }, {\n      key: \"getReactiveState\",\n      value: function getReactiveState(value, distortedValue) {\n        var objectGraph = this.objectGraph;\n        var reactiveState = objectGraph.get(distortedValue);\n\n        if (reactiveState) {\n          return reactiveState;\n        }\n\n        var membrane = this;\n        reactiveState = {\n          get reactive() {\n            var reactiveHandler = new ReactiveProxyHandler(membrane, distortedValue); // caching the reactive proxy after the first time it is accessed\n\n            var proxy = new Proxy(createShadowTarget(distortedValue), reactiveHandler);\n            registerProxy(proxy, value);\n            ObjectDefineProperty(this, 'reactive', {\n              value: proxy\n            });\n            return proxy;\n          },\n\n          get readOnly() {\n            var readOnlyHandler = new ReadOnlyHandler(membrane, distortedValue); // caching the readOnly proxy after the first time it is accessed\n\n            var proxy = new Proxy(createShadowTarget(distortedValue), readOnlyHandler);\n            registerProxy(proxy, value);\n            ObjectDefineProperty(this, 'readOnly', {\n              value: proxy\n            });\n            return proxy;\n          }\n\n        };\n        objectGraph.set(distortedValue, reactiveState);\n        return reactiveState;\n      }\n    }]);\n\n    return ReactiveMembrane;\n  }();\n  /** version: 0.26.0 */\n\n\n  function wrap(data, mutationCallback) {\n    var membrane = new ReactiveMembrane({\n      valueMutated: function valueMutated(target, key) {\n        mutationCallback(target, key);\n      }\n    });\n    return {\n      data: membrane.getProxy(data),\n      membrane: membrane\n    };\n  }\n\n  function unwrap$1(membrane, observable) {\n    var unwrappedData = membrane.unwrapProxy(observable);\n    var copy = {};\n    Object.keys(unwrappedData).forEach(function (key) {\n      if (['$el', '$refs', '$nextTick', '$watch'].includes(key)) return;\n      copy[key] = unwrappedData[key];\n    });\n    return copy;\n  }\n\n  var Component = /*#__PURE__*/function () {\n    function Component(el) {\n      var _this = this;\n\n      var seedDataForCloning = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n\n      _classCallCheck(this, Component);\n\n      this.$el = el;\n      var dataAttr = this.$el.getAttribute('x-data');\n      var dataExpression = dataAttr === '' ? '{}' : dataAttr;\n      var initExpression = this.$el.getAttribute('x-init');\n      this.unobservedData = seedDataForCloning ? seedDataForCloning : saferEval(dataExpression, {\n        $el: this.$el\n      }); // Construct a Proxy-based observable. This will be used to handle reactivity.\n\n      var _this$wrapDataInObser = this.wrapDataInObservable(this.unobservedData),\n          membrane = _this$wrapDataInObser.membrane,\n          data = _this$wrapDataInObser.data;\n\n      this.$data = data;\n      this.membrane = membrane; // After making user-supplied data methods reactive, we can now add\n      // our magic properties to the original data for access.\n\n      this.unobservedData.$el = this.$el;\n      this.unobservedData.$refs = this.getRefsProxy();\n      this.nextTickStack = [];\n\n      this.unobservedData.$nextTick = function (callback) {\n        _this.nextTickStack.push(callback);\n      };\n\n      this.watchers = {};\n\n      this.unobservedData.$watch = function (property, callback) {\n        if (!_this.watchers[property]) _this.watchers[property] = [];\n\n        _this.watchers[property].push(callback);\n      };\n\n      this.showDirectiveStack = [];\n      this.showDirectiveLastElement;\n      var initReturnedCallback; // If x-init is present AND we aren't cloning (skip x-init on clone)\n\n      if (initExpression && !seedDataForCloning) {\n        // We want to allow data manipulation, but not trigger DOM updates just yet.\n        // We haven't even initialized the elements with their Alpine bindings. I mean c'mon.\n        this.pauseReactivity = true;\n        initReturnedCallback = this.evaluateReturnExpression(this.$el, initExpression);\n        this.pauseReactivity = false;\n      } // Register all our listeners and set all our attribute bindings.\n\n\n      this.initializeElements(this.$el); // Use mutation observer to detect new elements being added within this component at run-time.\n      // Alpine's just so darn flexible amirite?\n\n      this.listenForNewElementsToInitialize();\n\n      if (typeof initReturnedCallback === 'function') {\n        // Run the callback returned from the \"x-init\" hook to allow the user to do stuff after\n        // Alpine's got it's grubby little paws all over everything.\n        initReturnedCallback.call(this.$data);\n      }\n    }\n\n    _createClass(Component, [{\n      key: \"getUnobservedData\",\n      value: function getUnobservedData() {\n        return unwrap$1(this.membrane, this.$data);\n      }\n    }, {\n      key: \"wrapDataInObservable\",\n      value: function wrapDataInObservable(data) {\n        var self = this;\n        var updateDom = debounce(function () {\n          self.updateElements(self.$el);\n        }, 0);\n        return wrap(data, function (target, key) {\n          if (self.watchers[key]) {\n            // If there's a watcher for this specific key, run it.\n            self.watchers[key].forEach(function (callback) {\n              return callback(target[key]);\n            });\n          } else {\n            // Let's walk through the watchers with \"dot-notation\" (foo.bar) and see\n            // if this mutation fits any of them.\n            Object.keys(self.watchers).filter(function (i) {\n              return i.includes('.');\n            }).forEach(function (fullDotNotationKey) {\n              var dotNotationParts = fullDotNotationKey.split('.'); // If this dot-notation watcher's last \"part\" doesn't match the current\n              // key, then skip it early for performance reasons.\n\n              if (key !== dotNotationParts[dotNotationParts.length - 1]) return; // Now, walk through the dot-notation \"parts\" recursively to find\n              // a match, and call the watcher if one's found.\n\n              dotNotationParts.reduce(function (comparisonData, part) {\n                if (Object.is(target, comparisonData)) {\n                  // Run the watchers.\n                  self.watchers[fullDotNotationKey].forEach(function (callback) {\n                    return callback(target[key]);\n                  });\n                }\n\n                return comparisonData[part];\n              }, self.getUnobservedData());\n            });\n          } // Don't react to data changes for cases like the `x-created` hook.\n\n\n          if (self.pauseReactivity) return;\n          updateDom();\n        });\n      }\n    }, {\n      key: \"walkAndSkipNestedComponents\",\n      value: function walkAndSkipNestedComponents(el, callback) {\n        var _this2 = this;\n\n        var initializeComponentCallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};\n        walk(el, function (el) {\n          // We've hit a component.\n          if (el.hasAttribute('x-data')) {\n            // If it's not the current one.\n            if (!el.isSameNode(_this2.$el)) {\n              // Initialize it if it's not.\n              if (!el.__x) initializeComponentCallback(el); // Now we'll let that sub-component deal with itself.\n\n              return false;\n            }\n          }\n\n          return callback(el);\n        });\n      }\n    }, {\n      key: \"initializeElements\",\n      value: function initializeElements(rootEl) {\n        var _this3 = this;\n\n        var extraVars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};\n        this.walkAndSkipNestedComponents(rootEl, function (el) {\n          // Don't touch spawns from for loop\n          if (el.__x_for_key !== undefined) return false; // Don't touch spawns from if directives\n\n          if (el.__x_inserted_me !== undefined) return false;\n\n          _this3.initializeElement(el, extraVars);\n        }, function (el) {\n          el.__x = new Component(el);\n        });\n        this.executeAndClearRemainingShowDirectiveStack();\n        this.executeAndClearNextTickStack(rootEl);\n      }\n    }, {\n      key: \"initializeElement\",\n      value: function initializeElement(el, extraVars) {\n        // To support class attribute merging, we have to know what the element's\n        // original class attribute looked like for reference.\n        if (el.hasAttribute('class') && getXAttrs(el, this).length > 0) {\n          el.__x_original_classes = convertClassStringToArray(el.getAttribute('class'));\n        }\n\n        this.registerListeners(el, extraVars);\n        this.resolveBoundAttributes(el, true, extraVars);\n      }\n    }, {\n      key: \"updateElements\",\n      value: function updateElements(rootEl) {\n        var _this4 = this;\n\n        var extraVars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};\n        this.walkAndSkipNestedComponents(rootEl, function (el) {\n          // Don't touch spawns from for loop (and check if the root is actually a for loop in a parent, don't skip it.)\n          if (el.__x_for_key !== undefined && !el.isSameNode(_this4.$el)) return false;\n\n          _this4.updateElement(el, extraVars);\n        }, function (el) {\n          el.__x = new Component(el);\n        });\n        this.executeAndClearRemainingShowDirectiveStack();\n        this.executeAndClearNextTickStack(rootEl);\n      }\n    }, {\n      key: \"executeAndClearNextTickStack\",\n      value: function executeAndClearNextTickStack(el) {\n        var _this5 = this;\n\n        // Skip spawns from alpine directives\n        if (el === this.$el && this.nextTickStack.length > 0) {\n          // We run the tick stack after the next frame to allow any\n          // running transitions to pass the initial show stage.\n          requestAnimationFrame(function () {\n            while (_this5.nextTickStack.length > 0) {\n              _this5.nextTickStack.shift()();\n            }\n          });\n        }\n      }\n    }, {\n      key: \"executeAndClearRemainingShowDirectiveStack\",\n      value: function executeAndClearRemainingShowDirectiveStack() {\n        // The goal here is to start all the x-show transitions\n        // and build a nested promise chain so that elements\n        // only hide when the children are finished hiding.\n        this.showDirectiveStack.reverse().map(function (thing) {\n          return new Promise(function (resolve) {\n            thing(function (finish) {\n              resolve(finish);\n            });\n          });\n        }).reduce(function (nestedPromise, promise) {\n          return nestedPromise.then(function () {\n            return promise.then(function (finish) {\n              return finish();\n            });\n          });\n        }, Promise.resolve(function () {})); // We've processed the handler stack. let's clear it.\n\n        this.showDirectiveStack = [];\n        this.showDirectiveLastElement = undefined;\n      }\n    }, {\n      key: \"updateElement\",\n      value: function updateElement(el, extraVars) {\n        this.resolveBoundAttributes(el, false, extraVars);\n      }\n    }, {\n      key: \"registerListeners\",\n      value: function registerListeners(el, extraVars) {\n        var _this6 = this;\n\n        getXAttrs(el, this).forEach(function (_ref4) {\n          var type = _ref4.type,\n              value = _ref4.value,\n              modifiers = _ref4.modifiers,\n              expression = _ref4.expression;\n\n          switch (type) {\n            case 'on':\n              registerListener(_this6, el, value, modifiers, expression, extraVars);\n              break;\n\n            case 'model':\n              registerModelListener(_this6, el, modifiers, expression, extraVars);\n              break;\n          }\n        });\n      }\n    }, {\n      key: \"resolveBoundAttributes\",\n      value: function resolveBoundAttributes(el) {\n        var _this7 = this;\n\n        var initialUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n        var extraVars = arguments.length > 2 ? arguments[2] : undefined;\n        var attrs = getXAttrs(el, this);\n\n        if (el.type !== undefined && el.type === 'radio') {\n          // If there's an x-model on a radio input, move it to end of attribute list\n          // to ensure that x-bind:value (if present) is processed first.\n          var modelIdx = attrs.findIndex(function (attr) {\n            return attr.type === 'model';\n          });\n\n          if (modelIdx > -1) {\n            attrs.push(attrs.splice(modelIdx, 1)[0]);\n          }\n        }\n\n        attrs.forEach(function (_ref5) {\n          var type = _ref5.type,\n              value = _ref5.value,\n              modifiers = _ref5.modifiers,\n              expression = _ref5.expression;\n\n          switch (type) {\n            case 'model':\n              handleAttributeBindingDirective(_this7, el, 'value', expression, extraVars, type);\n              break;\n\n            case 'bind':\n              // The :key binding on an x-for is special, ignore it.\n              if (el.tagName.toLowerCase() === 'template' && value === 'key') return;\n              handleAttributeBindingDirective(_this7, el, value, expression, extraVars, type);\n              break;\n\n            case 'text':\n              var output = _this7.evaluateReturnExpression(el, expression, extraVars);\n\n              handleTextDirective(el, output, expression);\n              break;\n\n            case 'html':\n              handleHtmlDirective(_this7, el, expression, extraVars);\n              break;\n\n            case 'show':\n              var output = _this7.evaluateReturnExpression(el, expression, extraVars);\n\n              handleShowDirective(_this7, el, output, modifiers, initialUpdate);\n              break;\n\n            case 'if':\n              // If this element also has x-for on it, don't process x-if.\n              // We will let the \"x-for\" directive handle the \"if\"ing.\n              if (attrs.filter(function (i) {\n                return i.type === 'for';\n              }).length > 0) return;\n\n              var output = _this7.evaluateReturnExpression(el, expression, extraVars);\n\n              handleIfDirective(_this7, el, output, initialUpdate, extraVars);\n              break;\n\n            case 'for':\n              handleForDirective(_this7, el, expression, initialUpdate, extraVars);\n              break;\n\n            case 'cloak':\n              el.removeAttribute('x-cloak');\n              break;\n          }\n        });\n      }\n    }, {\n      key: \"evaluateReturnExpression\",\n      value: function evaluateReturnExpression(el, expression) {\n        var extraVars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};\n        return saferEval(expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n          $dispatch: this.getDispatchFunction(el)\n        }));\n      }\n    }, {\n      key: \"evaluateCommandExpression\",\n      value: function evaluateCommandExpression(el, expression) {\n        var extraVars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};\n        return saferEvalNoReturn(expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n          $dispatch: this.getDispatchFunction(el)\n        }));\n      }\n    }, {\n      key: \"getDispatchFunction\",\n      value: function getDispatchFunction(el) {\n        return function (event) {\n          var detail = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n          el.dispatchEvent(new CustomEvent(event, {\n            detail: detail,\n            bubbles: true\n          }));\n        };\n      }\n    }, {\n      key: \"listenForNewElementsToInitialize\",\n      value: function listenForNewElementsToInitialize() {\n        var _this8 = this;\n\n        var targetNode = this.$el;\n        var observerOptions = {\n          childList: true,\n          attributes: true,\n          subtree: true\n        };\n        var observer = new MutationObserver(function (mutations) {\n          for (var i = 0; i < mutations.length; i++) {\n            // Filter out mutations triggered from child components.\n            var closestParentComponent = mutations[i].target.closest('[x-data]');\n            if (!(closestParentComponent && closestParentComponent.isSameNode(_this8.$el))) continue;\n\n            if (mutations[i].type === 'attributes' && mutations[i].attributeName === 'x-data') {\n              (function () {\n                var rawData = saferEval(mutations[i].target.getAttribute('x-data'), {\n                  $el: _this8.$el\n                });\n                Object.keys(rawData).forEach(function (key) {\n                  if (_this8.$data[key] !== rawData[key]) {\n                    _this8.$data[key] = rawData[key];\n                  }\n                });\n              })();\n            }\n\n            if (mutations[i].addedNodes.length > 0) {\n              mutations[i].addedNodes.forEach(function (node) {\n                if (node.nodeType !== 1 || node.__x_inserted_me) return;\n\n                if (node.matches('[x-data]') && !node.__x) {\n                  node.__x = new Component(node);\n                  return;\n                }\n\n                _this8.initializeElements(node);\n              });\n            }\n          }\n        });\n        observer.observe(targetNode, observerOptions);\n      }\n    }, {\n      key: \"getRefsProxy\",\n      value: function getRefsProxy() {\n        var self = this;\n        var refObj = {}; // One of the goals of this is to not hold elements in memory, but rather re-evaluate\n        // the DOM when the system needs something from it. This way, the framework is flexible and\n        // friendly to outside DOM changes from libraries like Vue/Livewire.\n        // For this reason, I'm using an \"on-demand\" proxy to fake a \"$refs\" object.\n\n        return new Proxy(refObj, {\n          get: function get(object, property) {\n            if (property === '$isAlpineProxy') return true;\n            var ref; // We can't just query the DOM because it's hard to filter out refs in\n            // nested components.\n\n            self.walkAndSkipNestedComponents(self.$el, function (el) {\n              if (el.hasAttribute('x-ref') && el.getAttribute('x-ref') === property) {\n                ref = el;\n              }\n            });\n            return ref;\n          }\n        });\n      }\n    }]);\n\n    return Component;\n  }();\n\n  var Alpine = {\n    version: \"2.4.1\",\n    pauseMutationObserver: false,\n    start: function () {\n      var _start = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        var _this9 = this;\n\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                if (isTesting()) {\n                  _context.next = 3;\n                  break;\n                }\n\n                _context.next = 3;\n                return domReady();\n\n              case 3:\n                this.discoverComponents(function (el) {\n                  _this9.initializeComponent(el);\n                }); // It's easier and more performant to just support Turbolinks than listen\n                // to MutationObserver mutations at the document level.\n\n                document.addEventListener(\"turbolinks:load\", function () {\n                  _this9.discoverUninitializedComponents(function (el) {\n                    _this9.initializeComponent(el);\n                  });\n                });\n                this.listenForNewUninitializedComponentsAtRunTime(function (el) {\n                  _this9.initializeComponent(el);\n                });\n\n              case 6:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function start() {\n        return _start.apply(this, arguments);\n      }\n\n      return start;\n    }(),\n    discoverComponents: function discoverComponents(callback) {\n      var rootEls = document.querySelectorAll('[x-data]');\n      rootEls.forEach(function (rootEl) {\n        callback(rootEl);\n      });\n    },\n    discoverUninitializedComponents: function discoverUninitializedComponents(callback) {\n      var el = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n      var rootEls = (el || document).querySelectorAll('[x-data]');\n      Array.from(rootEls).filter(function (el) {\n        return el.__x === undefined;\n      }).forEach(function (rootEl) {\n        callback(rootEl);\n      });\n    },\n    listenForNewUninitializedComponentsAtRunTime: function listenForNewUninitializedComponentsAtRunTime(callback) {\n      var _this10 = this;\n\n      var targetNode = document.querySelector('body');\n      var observerOptions = {\n        childList: true,\n        attributes: true,\n        subtree: true\n      };\n      var observer = new MutationObserver(function (mutations) {\n        if (_this10.pauseMutationObserver) return;\n\n        for (var i = 0; i < mutations.length; i++) {\n          if (mutations[i].addedNodes.length > 0) {\n            mutations[i].addedNodes.forEach(function (node) {\n              // Discard non-element nodes (like line-breaks)\n              if (node.nodeType !== 1) return; // Discard any changes happening within an existing component.\n              // They will take care of themselves.\n\n              if (node.parentElement && node.parentElement.closest('[x-data]')) return;\n\n              _this10.discoverUninitializedComponents(function (el) {\n                _this10.initializeComponent(el);\n              }, node.parentElement);\n            });\n          }\n        }\n      });\n      observer.observe(targetNode, observerOptions);\n    },\n    initializeComponent: function initializeComponent(el) {\n      if (!el.__x) {\n        // Wrap in a try/catch so that we don't prevent other components\n        // from initializing when one component contains an error.\n        try {\n          el.__x = new Component(el);\n        } catch (error) {\n          setTimeout(function () {\n            throw error;\n          }, 0);\n        }\n      }\n    },\n    clone: function clone(component, newEl) {\n      if (!newEl.__x) {\n        newEl.__x = new Component(newEl, component.getUnobservedData());\n      }\n    }\n  };\n\n  if (!isTesting()) {\n    window.Alpine = Alpine;\n\n    if (window.deferLoadingAlpine) {\n      window.deferLoadingAlpine(function () {\n        window.Alpine.start();\n      });\n    } else {\n      window.Alpine.start();\n    }\n  }\n\n  return Alpine;\n});","module.exports = function (originalModule) {\n  if (!originalModule.webpackPolyfill) {\n    var module = Object.create(originalModule); // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    Object.defineProperty(module, \"exports\", {\n      enumerable: true\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","var map = {\n\t\"./about\": 2,\n\t\"./about.jpg\": 2,\n\t\"./ballet\": 3,\n\t\"./ballet.svg\": 3,\n\t\"./banner\": 4,\n\t\"./banner.jpg\": 4,\n\t\"./bizx-award\": 5,\n\t\"./bizx-award.png\": 5,\n\t\"./cd-badge\": 6,\n\t\"./cd-badge.png\": 6,\n\t\"./equipment\": 7,\n\t\"./equipment.svg\": 7,\n\t\"./external-link\": 8,\n\t\"./external-link.svg\": 8,\n\t\"./facebook-cover\": 9,\n\t\"./facebook-cover.png\": 9,\n\t\"./favicon\": 10,\n\t\"./favicon.png\": 10,\n\t\"./football\": 11,\n\t\"./football.svg\": 11,\n\t\"./karate\": 12,\n\t\"./karate.svg\": 12,\n\t\"./logo\": 13,\n\t\"./logo-alt\": 14,\n\t\"./logo-alt.png\": 14,\n\t\"./logo-white\": 15,\n\t\"./logo-white.svg\": 15,\n\t\"./logo.svg\": 13,\n\t\"./medal\": 16,\n\t\"./medal.svg\": 16,\n\t\"./netball\": 17,\n\t\"./netball.svg\": 17,\n\t\"./sports\": 18,\n\t\"./sports.jpg\": 18,\n\t\"./tactic\": 19,\n\t\"./tactic.svg\": 19,\n\t\"./tennis\": 20,\n\t\"./tennis.svg\": 20\n};\n\n\nfunction webpackContext(req) {\n\tvar id = webpackContextResolve(req);\n\treturn __webpack_require__(id);\n}\nfunction webpackContextResolve(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\n\treturn map[req];\n}\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = 28;","function _typeof2(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof2(obj); }\n\n/*!\n * Glide.js v3.4.1\n * (c) 2013-2019 Jędrzej Chałubek <jedrzej.chalubek@gmail.com> (http://jedrzejchalubek.com/)\n * Released under the MIT License.\n */\nvar defaults = {\n  /**\n   * Type of the movement.\n   *\n   * Available types:\n   * `slider` - Rewinds slider to the start/end when it reaches the first or last slide.\n   * `carousel` - Changes slides without starting over when it reaches the first or last slide.\n   *\n   * @type {String}\n   */\n  type: 'slider',\n\n  /**\n   * Start at specific slide number defined with zero-based index.\n   *\n   * @type {Number}\n   */\n  startAt: 0,\n\n  /**\n   * A number of slides visible on the single viewport.\n   *\n   * @type {Number}\n   */\n  perView: 1,\n\n  /**\n   * Focus currently active slide at a specified position in the track.\n   *\n   * Available inputs:\n   * `center` - Current slide will be always focused at the center of a track.\n   * `0,1,2,3...` - Current slide will be focused on the specified zero-based index.\n   *\n   * @type {String|Number}\n   */\n  focusAt: 0,\n\n  /**\n   * A size of the gap added between slides.\n   *\n   * @type {Number}\n   */\n  gap: 10,\n\n  /**\n   * Change slides after a specified interval. Use `false` for turning off autoplay.\n   *\n   * @type {Number|Boolean}\n   */\n  autoplay: false,\n\n  /**\n   * Stop autoplay on mouseover event.\n   *\n   * @type {Boolean}\n   */\n  hoverpause: true,\n\n  /**\n   * Allow for changing slides with left and right keyboard arrows.\n   *\n   * @type {Boolean}\n   */\n  keyboard: true,\n\n  /**\n   * Stop running `perView` number of slides from the end. Use this\n   * option if you don't want to have an empty space after\n   * a slider. Works only with `slider` type and a\n   * non-centered `focusAt` setting.\n   *\n   * @type {Boolean}\n   */\n  bound: false,\n\n  /**\n   * Minimal swipe distance needed to change the slide. Use `false` for turning off a swiping.\n   *\n   * @type {Number|Boolean}\n   */\n  swipeThreshold: 80,\n\n  /**\n   * Minimal mouse drag distance needed to change the slide. Use `false` for turning off a dragging.\n   *\n   * @type {Number|Boolean}\n   */\n  dragThreshold: 120,\n\n  /**\n   * A maximum number of slides to which movement will be made on swiping or dragging. Use `false` for unlimited.\n   *\n   * @type {Number|Boolean}\n   */\n  perTouch: false,\n\n  /**\n   * Moving distance ratio of the slides on a swiping and dragging.\n   *\n   * @type {Number}\n   */\n  touchRatio: 0.5,\n\n  /**\n   * Angle required to activate slides moving on swiping or dragging.\n   *\n   * @type {Number}\n   */\n  touchAngle: 45,\n\n  /**\n   * Duration of the animation in milliseconds.\n   *\n   * @type {Number}\n   */\n  animationDuration: 400,\n\n  /**\n   * Allows looping the `slider` type. Slider will rewind to the first/last slide when it's at the start/end.\n   *\n   * @type {Boolean}\n   */\n  rewind: true,\n\n  /**\n   * Duration of the rewinding animation of the `slider` type in milliseconds.\n   *\n   * @type {Number}\n   */\n  rewindDuration: 800,\n\n  /**\n   * Easing function for the animation.\n   *\n   * @type {String}\n   */\n  animationTimingFunc: 'cubic-bezier(.165, .840, .440, 1)',\n\n  /**\n   * Throttle costly events at most once per every wait milliseconds.\n   *\n   * @type {Number}\n   */\n  throttle: 10,\n\n  /**\n   * Moving direction mode.\n   *\n   * Available inputs:\n   * - 'ltr' - left to right movement,\n   * - 'rtl' - right to left movement.\n   *\n   * @type {String}\n   */\n  direction: 'ltr',\n\n  /**\n   * The distance value of the next and previous viewports which\n   * have to peek in the current view. Accepts number and\n   * pixels as a string. Left and right peeking can be\n   * set up separately with a directions object.\n   *\n   * For example:\n   * `100` - Peek 100px on the both sides.\n   * { before: 100, after: 50 }` - Peek 100px on the left side and 50px on the right side.\n   *\n   * @type {Number|String|Object}\n   */\n  peek: 0,\n\n  /**\n   * Collection of options applied at specified media breakpoints.\n   * For example: display two slides per view under 800px.\n   * `{\n   *   '800px': {\n   *     perView: 2\n   *   }\n   * }`\n   */\n  breakpoints: {},\n\n  /**\n   * Collection of internally used HTML classes.\n   *\n   * @todo Refactor `slider` and `carousel` properties to single `type: { slider: '', carousel: '' }` object\n   * @type {Object}\n   */\n  classes: {\n    direction: {\n      ltr: 'glide--ltr',\n      rtl: 'glide--rtl'\n    },\n    slider: 'glide--slider',\n    carousel: 'glide--carousel',\n    swipeable: 'glide--swipeable',\n    dragging: 'glide--dragging',\n    cloneSlide: 'glide__slide--clone',\n    activeNav: 'glide__bullet--active',\n    activeSlide: 'glide__slide--active',\n    disabledArrow: 'glide__arrow--disabled'\n  }\n};\n/**\n * Outputs warning message to the bowser console.\n *\n * @param  {String} msg\n * @return {Void}\n */\n\nfunction warn(msg) {\n  console.error(\"[Glide warn]: \" + msg);\n}\n\nvar _typeof = typeof Symbol === \"function\" && _typeof2(Symbol.iterator) === \"symbol\" ? function (obj) {\n  return _typeof2(obj);\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : _typeof2(obj);\n};\n\nvar classCallCheck = function classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar get = function get(object, property, receiver) {\n  if (object === null) object = Function.prototype;\n  var desc = Object.getOwnPropertyDescriptor(object, property);\n\n  if (desc === undefined) {\n    var parent = Object.getPrototypeOf(object);\n\n    if (parent === null) {\n      return undefined;\n    } else {\n      return get(parent, property, receiver);\n    }\n  } else if (\"value\" in desc) {\n    return desc.value;\n  } else {\n    var getter = desc.get;\n\n    if (getter === undefined) {\n      return undefined;\n    }\n\n    return getter.call(receiver);\n  }\n};\n\nvar inherits = function inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + _typeof2(superClass));\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar possibleConstructorReturn = function possibleConstructorReturn(self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (_typeof2(call) === \"object\" || typeof call === \"function\") ? call : self;\n};\n/**\n * Converts value entered as number\n * or string to integer value.\n *\n * @param {String} value\n * @returns {Number}\n */\n\n\nfunction toInt(value) {\n  return parseInt(value);\n}\n/**\n * Converts value entered as number\n * or string to flat value.\n *\n * @param {String} value\n * @returns {Number}\n */\n\n\nfunction toFloat(value) {\n  return parseFloat(value);\n}\n/**\n * Indicates whether the specified value is a string.\n *\n * @param  {*}   value\n * @return {Boolean}\n */\n\n\nfunction isString(value) {\n  return typeof value === 'string';\n}\n/**\n * Indicates whether the specified value is an object.\n *\n * @param  {*} value\n * @return {Boolean}\n *\n * @see https://github.com/jashkenas/underscore\n */\n\n\nfunction isObject(value) {\n  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n  return type === 'function' || type === 'object' && !!value; // eslint-disable-line no-mixed-operators\n}\n/**\n * Indicates whether the specified value is a number.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isNumber(value) {\n  return typeof value === 'number';\n}\n/**\n * Indicates whether the specified value is a function.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isFunction(value) {\n  return typeof value === 'function';\n}\n/**\n * Indicates whether the specified value is undefined.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isUndefined(value) {\n  return typeof value === 'undefined';\n}\n/**\n * Indicates whether the specified value is an array.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isArray(value) {\n  return value.constructor === Array;\n}\n/**\n * Creates and initializes specified collection of extensions.\n * Each extension receives access to instance of glide and rest of components.\n *\n * @param {Object} glide\n * @param {Object} extensions\n *\n * @returns {Object}\n */\n\n\nfunction mount(glide, extensions, events) {\n  var components = {};\n\n  for (var name in extensions) {\n    if (isFunction(extensions[name])) {\n      components[name] = extensions[name](glide, components, events);\n    } else {\n      warn('Extension must be a function');\n    }\n  }\n\n  for (var _name in components) {\n    if (isFunction(components[_name].mount)) {\n      components[_name].mount();\n    }\n  }\n\n  return components;\n}\n/**\n * Defines getter and setter property on the specified object.\n *\n * @param  {Object} obj         Object where property has to be defined.\n * @param  {String} prop        Name of the defined property.\n * @param  {Object} definition  Get and set definitions for the property.\n * @return {Void}\n */\n\n\nfunction define(obj, prop, definition) {\n  Object.defineProperty(obj, prop, definition);\n}\n/**\n * Sorts aphabetically object keys.\n *\n * @param  {Object} obj\n * @return {Object}\n */\n\n\nfunction sortKeys(obj) {\n  return Object.keys(obj).sort().reduce(function (r, k) {\n    r[k] = obj[k];\n    return r[k], r;\n  }, {});\n}\n/**\n * Merges passed settings object with default options.\n *\n * @param  {Object} defaults\n * @param  {Object} settings\n * @return {Object}\n */\n\n\nfunction mergeOptions(defaults, settings) {\n  var options = _extends({}, defaults, settings); // `Object.assign` do not deeply merge objects, so we\n  // have to do it manually for every nested object\n  // in options. Although it does not look smart,\n  // it's smaller and faster than some fancy\n  // merging deep-merge algorithm script.\n\n\n  if (settings.hasOwnProperty('classes')) {\n    options.classes = _extends({}, defaults.classes, settings.classes);\n\n    if (settings.classes.hasOwnProperty('direction')) {\n      options.classes.direction = _extends({}, defaults.classes.direction, settings.classes.direction);\n    }\n  }\n\n  if (settings.hasOwnProperty('breakpoints')) {\n    options.breakpoints = _extends({}, defaults.breakpoints, settings.breakpoints);\n  }\n\n  return options;\n}\n\nvar EventsBus = function () {\n  /**\n   * Construct a EventBus instance.\n   *\n   * @param {Object} events\n   */\n  function EventsBus() {\n    var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    classCallCheck(this, EventsBus);\n    this.events = events;\n    this.hop = events.hasOwnProperty;\n  }\n  /**\n   * Adds listener to the specifed event.\n   *\n   * @param {String|Array} event\n   * @param {Function} handler\n   */\n\n\n  createClass(EventsBus, [{\n    key: 'on',\n    value: function on(event, handler) {\n      if (isArray(event)) {\n        for (var i = 0; i < event.length; i++) {\n          this.on(event[i], handler);\n        }\n      } // Create the event's object if not yet created\n\n\n      if (!this.hop.call(this.events, event)) {\n        this.events[event] = [];\n      } // Add the handler to queue\n\n\n      var index = this.events[event].push(handler) - 1; // Provide handle back for removal of event\n\n      return {\n        remove: function remove() {\n          delete this.events[event][index];\n        }\n      };\n    }\n    /**\n     * Runs registered handlers for specified event.\n     *\n     * @param {String|Array} event\n     * @param {Object=} context\n     */\n\n  }, {\n    key: 'emit',\n    value: function emit(event, context) {\n      if (isArray(event)) {\n        for (var i = 0; i < event.length; i++) {\n          this.emit(event[i], context);\n        }\n      } // If the event doesn't exist, or there's no handlers in queue, just leave\n\n\n      if (!this.hop.call(this.events, event)) {\n        return;\n      } // Cycle through events queue, fire!\n\n\n      this.events[event].forEach(function (item) {\n        item(context || {});\n      });\n    }\n  }]);\n  return EventsBus;\n}();\n\nvar Glide = function () {\n  /**\r\n   * Construct glide.\r\n   *\r\n   * @param  {String} selector\r\n   * @param  {Object} options\r\n   */\n  function Glide(selector) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    classCallCheck(this, Glide);\n    this._c = {};\n    this._t = [];\n    this._e = new EventsBus();\n    this.disabled = false;\n    this.selector = selector;\n    this.settings = mergeOptions(defaults, options);\n    this.index = this.settings.startAt;\n  }\n  /**\r\n   * Initializes glide.\r\n   *\r\n   * @param {Object} extensions Collection of extensions to initialize.\r\n   * @return {Glide}\r\n   */\n\n\n  createClass(Glide, [{\n    key: 'mount',\n    value: function mount$$1() {\n      var extensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n      this._e.emit('mount.before');\n\n      if (isObject(extensions)) {\n        this._c = mount(this, extensions, this._e);\n      } else {\n        warn('You need to provide a object on `mount()`');\n      }\n\n      this._e.emit('mount.after');\n\n      return this;\n    }\n    /**\r\n     * Collects an instance `translate` transformers.\r\n     *\r\n     * @param  {Array} transformers Collection of transformers.\r\n     * @return {Void}\r\n     */\n\n  }, {\n    key: 'mutate',\n    value: function mutate() {\n      var transformers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n\n      if (isArray(transformers)) {\n        this._t = transformers;\n      } else {\n        warn('You need to provide a array on `mutate()`');\n      }\n\n      return this;\n    }\n    /**\r\n     * Updates glide with specified settings.\r\n     *\r\n     * @param {Object} settings\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'update',\n    value: function update() {\n      var settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      this.settings = mergeOptions(this.settings, settings);\n\n      if (settings.hasOwnProperty('startAt')) {\n        this.index = settings.startAt;\n      }\n\n      this._e.emit('update');\n\n      return this;\n    }\n    /**\r\n     * Change slide with specified pattern. A pattern must be in the special format:\r\n     * `>` - Move one forward\r\n     * `<` - Move one backward\r\n     * `={i}` - Go to {i} zero-based slide (eq. '=1', will go to second slide)\r\n     * `>>` - Rewinds to end (last slide)\r\n     * `<<` - Rewinds to start (first slide)\r\n     *\r\n     * @param {String} pattern\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'go',\n    value: function go(pattern) {\n      this._c.Run.make(pattern);\n\n      return this;\n    }\n    /**\r\n     * Move track by specified distance.\r\n     *\r\n     * @param {String} distance\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'move',\n    value: function move(distance) {\n      this._c.Transition.disable();\n\n      this._c.Move.make(distance);\n\n      return this;\n    }\n    /**\r\n     * Destroy instance and revert all changes done by this._c.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      this._e.emit('destroy');\n\n      return this;\n    }\n    /**\r\n     * Start instance autoplaying.\r\n     *\r\n     * @param {Boolean|Number} interval Run autoplaying with passed interval regardless of `autoplay` settings\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'play',\n    value: function play() {\n      var interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n      if (interval) {\n        this.settings.autoplay = interval;\n      }\n\n      this._e.emit('play');\n\n      return this;\n    }\n    /**\r\n     * Stop instance autoplaying.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'pause',\n    value: function pause() {\n      this._e.emit('pause');\n\n      return this;\n    }\n    /**\r\n     * Sets glide into a idle status.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'disable',\n    value: function disable() {\n      this.disabled = true;\n      return this;\n    }\n    /**\r\n     * Sets glide into a active status.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'enable',\n    value: function enable() {\n      this.disabled = false;\n      return this;\n    }\n    /**\r\n     * Adds cuutom event listener with handler.\r\n     *\r\n     * @param  {String|Array} event\r\n     * @param  {Function} handler\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'on',\n    value: function on(event, handler) {\n      this._e.on(event, handler);\n\n      return this;\n    }\n    /**\r\n     * Checks if glide is a precised type.\r\n     *\r\n     * @param  {String} name\r\n     * @return {Boolean}\r\n     */\n\n  }, {\n    key: 'isType',\n    value: function isType(name) {\n      return this.settings.type === name;\n    }\n    /**\r\n     * Gets value of the core options.\r\n     *\r\n     * @return {Object}\r\n     */\n\n  }, {\n    key: 'settings',\n    get: function get$$1() {\n      return this._o;\n    }\n    /**\r\n     * Sets value of the core options.\r\n     *\r\n     * @param  {Object} o\r\n     * @return {Void}\r\n     */\n    ,\n    set: function set$$1(o) {\n      if (isObject(o)) {\n        this._o = o;\n      } else {\n        warn('Options must be an `object` instance.');\n      }\n    }\n    /**\r\n     * Gets current index of the slider.\r\n     *\r\n     * @return {Object}\r\n     */\n\n  }, {\n    key: 'index',\n    get: function get$$1() {\n      return this._i;\n    }\n    /**\r\n     * Sets current index a slider.\r\n     *\r\n     * @return {Object}\r\n     */\n    ,\n    set: function set$$1(i) {\n      this._i = toInt(i);\n    }\n    /**\r\n     * Gets type name of the slider.\r\n     *\r\n     * @return {String}\r\n     */\n\n  }, {\n    key: 'type',\n    get: function get$$1() {\n      return this.settings.type;\n    }\n    /**\r\n     * Gets value of the idle status.\r\n     *\r\n     * @return {Boolean}\r\n     */\n\n  }, {\n    key: 'disabled',\n    get: function get$$1() {\n      return this._d;\n    }\n    /**\r\n     * Sets value of the idle status.\r\n     *\r\n     * @return {Boolean}\r\n     */\n    ,\n    set: function set$$1(status) {\n      this._d = !!status;\n    }\n  }]);\n  return Glide;\n}();\n\nfunction Run(Glide, Components, Events) {\n  var Run = {\n    /**\n     * Initializes autorunning of the glide.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this._o = false;\n    },\n\n    /**\n     * Makes glides running based on the passed moving schema.\n     *\n     * @param {String} move\n     */\n    make: function make(move) {\n      var _this = this;\n\n      if (!Glide.disabled) {\n        Glide.disable();\n        this.move = move;\n        Events.emit('run.before', this.move);\n        this.calculate();\n        Events.emit('run', this.move);\n        Components.Transition.after(function () {\n          if (_this.isStart()) {\n            Events.emit('run.start', _this.move);\n          }\n\n          if (_this.isEnd()) {\n            Events.emit('run.end', _this.move);\n          }\n\n          if (_this.isOffset('<') || _this.isOffset('>')) {\n            _this._o = false;\n            Events.emit('run.offset', _this.move);\n          }\n\n          Events.emit('run.after', _this.move);\n          Glide.enable();\n        });\n      }\n    },\n\n    /**\n     * Calculates current index based on defined move.\n     *\n     * @return {Void}\n     */\n    calculate: function calculate() {\n      var move = this.move,\n          length = this.length;\n      var steps = move.steps,\n          direction = move.direction;\n      var countableSteps = isNumber(toInt(steps)) && toInt(steps) !== 0;\n\n      switch (direction) {\n        case '>':\n          if (steps === '>') {\n            Glide.index = length;\n          } else if (this.isEnd()) {\n            if (!(Glide.isType('slider') && !Glide.settings.rewind)) {\n              this._o = true;\n              Glide.index = 0;\n            }\n          } else if (countableSteps) {\n            Glide.index += Math.min(length - Glide.index, -toInt(steps));\n          } else {\n            Glide.index++;\n          }\n\n          break;\n\n        case '<':\n          if (steps === '<') {\n            Glide.index = 0;\n          } else if (this.isStart()) {\n            if (!(Glide.isType('slider') && !Glide.settings.rewind)) {\n              this._o = true;\n              Glide.index = length;\n            }\n          } else if (countableSteps) {\n            Glide.index -= Math.min(Glide.index, toInt(steps));\n          } else {\n            Glide.index--;\n          }\n\n          break;\n\n        case '=':\n          Glide.index = steps;\n          break;\n\n        default:\n          warn('Invalid direction pattern [' + direction + steps + '] has been used');\n          break;\n      }\n    },\n\n    /**\n     * Checks if we are on the first slide.\n     *\n     * @return {Boolean}\n     */\n    isStart: function isStart() {\n      return Glide.index === 0;\n    },\n\n    /**\n     * Checks if we are on the last slide.\n     *\n     * @return {Boolean}\n     */\n    isEnd: function isEnd() {\n      return Glide.index === this.length;\n    },\n\n    /**\n     * Checks if we are making a offset run.\n     *\n     * @param {String} direction\n     * @return {Boolean}\n     */\n    isOffset: function isOffset(direction) {\n      return this._o && this.move.direction === direction;\n    }\n  };\n  define(Run, 'move', {\n    /**\n     * Gets value of the move schema.\n     *\n     * @returns {Object}\n     */\n    get: function get() {\n      return this._m;\n    },\n\n    /**\n     * Sets value of the move schema.\n     *\n     * @returns {Object}\n     */\n    set: function set(value) {\n      var step = value.substr(1);\n      this._m = {\n        direction: value.substr(0, 1),\n        steps: step ? toInt(step) ? toInt(step) : step : 0\n      };\n    }\n  });\n  define(Run, 'length', {\n    /**\n     * Gets value of the running distance based\n     * on zero-indexing number of slides.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var settings = Glide.settings;\n      var length = Components.Html.slides.length; // If the `bound` option is acitve, a maximum running distance should be\n      // reduced by `perView` and `focusAt` settings. Running distance\n      // should end before creating an empty space after instance.\n\n      if (Glide.isType('slider') && settings.focusAt !== 'center' && settings.bound) {\n        return length - 1 - (toInt(settings.perView) - 1) + toInt(settings.focusAt);\n      }\n\n      return length - 1;\n    }\n  });\n  define(Run, 'offset', {\n    /**\n     * Gets status of the offsetting flag.\n     *\n     * @return {Boolean}\n     */\n    get: function get() {\n      return this._o;\n    }\n  });\n  return Run;\n}\n/**\n * Returns a current time.\n *\n * @return {Number}\n */\n\n\nfunction now() {\n  return new Date().getTime();\n}\n/**\n * Returns a function, that, when invoked, will only be triggered\n * at most once during a given window of time.\n *\n * @param {Function} func\n * @param {Number} wait\n * @param {Object=} options\n * @return {Function}\n *\n * @see https://github.com/jashkenas/underscore\n */\n\n\nfunction throttle(func, wait, options) {\n  var timeout = void 0,\n      context = void 0,\n      args = void 0,\n      result = void 0;\n  var previous = 0;\n  if (!options) options = {};\n\n  var later = function later() {\n    previous = options.leading === false ? 0 : now();\n    timeout = null;\n    result = func.apply(context, args);\n    if (!timeout) context = args = null;\n  };\n\n  var throttled = function throttled() {\n    var at = now();\n    if (!previous && options.leading === false) previous = at;\n    var remaining = wait - (at - previous);\n    context = this;\n    args = arguments;\n\n    if (remaining <= 0 || remaining > wait) {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = null;\n      }\n\n      previous = at;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    } else if (!timeout && options.trailing !== false) {\n      timeout = setTimeout(later, remaining);\n    }\n\n    return result;\n  };\n\n  throttled.cancel = function () {\n    clearTimeout(timeout);\n    previous = 0;\n    timeout = context = args = null;\n  };\n\n  return throttled;\n}\n\nvar MARGIN_TYPE = {\n  ltr: ['marginLeft', 'marginRight'],\n  rtl: ['marginRight', 'marginLeft']\n};\n\nfunction Gaps(Glide, Components, Events) {\n  var Gaps = {\n    /**\n     * Applies gaps between slides. First and last\n     * slides do not receive it's edge margins.\n     *\n     * @param {HTMLCollection} slides\n     * @return {Void}\n     */\n    apply: function apply(slides) {\n      for (var i = 0, len = slides.length; i < len; i++) {\n        var style = slides[i].style;\n        var direction = Components.Direction.value;\n\n        if (i !== 0) {\n          style[MARGIN_TYPE[direction][0]] = this.value / 2 + 'px';\n        } else {\n          style[MARGIN_TYPE[direction][0]] = '';\n        }\n\n        if (i !== slides.length - 1) {\n          style[MARGIN_TYPE[direction][1]] = this.value / 2 + 'px';\n        } else {\n          style[MARGIN_TYPE[direction][1]] = '';\n        }\n      }\n    },\n\n    /**\n     * Removes gaps from the slides.\n     *\n     * @param {HTMLCollection} slides\n     * @returns {Void}\n    */\n    remove: function remove(slides) {\n      for (var i = 0, len = slides.length; i < len; i++) {\n        var style = slides[i].style;\n        style.marginLeft = '';\n        style.marginRight = '';\n      }\n    }\n  };\n  define(Gaps, 'value', {\n    /**\n     * Gets value of the gap.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      return toInt(Glide.settings.gap);\n    }\n  });\n  define(Gaps, 'grow', {\n    /**\n     * Gets additional dimentions value caused by gaps.\n     * Used to increase width of the slides wrapper.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      return Gaps.value * (Components.Sizes.length - 1);\n    }\n  });\n  define(Gaps, 'reductor', {\n    /**\n     * Gets reduction value caused by gaps.\n     * Used to subtract width of the slides.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      var perView = Glide.settings.perView;\n      return Gaps.value * (perView - 1) / perView;\n    }\n  });\n  /**\n   * Apply calculated gaps:\n   * - after building, so slides (including clones) will receive proper margins\n   * - on updating via API, to recalculate gaps with new options\n   */\n\n  Events.on(['build.after', 'update'], throttle(function () {\n    Gaps.apply(Components.Html.wrapper.children);\n  }, 30));\n  /**\n   * Remove gaps:\n   * - on destroying to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Gaps.remove(Components.Html.wrapper.children);\n  });\n  return Gaps;\n}\n/**\n * Finds siblings nodes of the passed node.\n *\n * @param  {Element} node\n * @return {Array}\n */\n\n\nfunction siblings(node) {\n  if (node && node.parentNode) {\n    var n = node.parentNode.firstChild;\n    var matched = [];\n\n    for (; n; n = n.nextSibling) {\n      if (n.nodeType === 1 && n !== node) {\n        matched.push(n);\n      }\n    }\n\n    return matched;\n  }\n\n  return [];\n}\n/**\n * Checks if passed node exist and is a valid element.\n *\n * @param  {Element} node\n * @return {Boolean}\n */\n\n\nfunction exist(node) {\n  if (node && node instanceof window.HTMLElement) {\n    return true;\n  }\n\n  return false;\n}\n\nvar TRACK_SELECTOR = '[data-glide-el=\"track\"]';\n\nfunction Html(Glide, Components) {\n  var Html = {\n    /**\n     * Setup slider HTML nodes.\n     *\n     * @param {Glide} glide\n     */\n    mount: function mount() {\n      this.root = Glide.selector;\n      this.track = this.root.querySelector(TRACK_SELECTOR);\n      this.slides = Array.prototype.slice.call(this.wrapper.children).filter(function (slide) {\n        return !slide.classList.contains(Glide.settings.classes.cloneSlide);\n      });\n    }\n  };\n  define(Html, 'root', {\n    /**\n     * Gets node of the glide main element.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Html._r;\n    },\n\n    /**\n     * Sets node of the glide main element.\n     *\n     * @return {Object}\n     */\n    set: function set(r) {\n      if (isString(r)) {\n        r = document.querySelector(r);\n      }\n\n      if (exist(r)) {\n        Html._r = r;\n      } else {\n        warn('Root element must be a existing Html node');\n      }\n    }\n  });\n  define(Html, 'track', {\n    /**\n     * Gets node of the glide track with slides.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Html._t;\n    },\n\n    /**\n     * Sets node of the glide track with slides.\n     *\n     * @return {Object}\n     */\n    set: function set(t) {\n      if (exist(t)) {\n        Html._t = t;\n      } else {\n        warn('Could not find track element. Please use ' + TRACK_SELECTOR + ' attribute.');\n      }\n    }\n  });\n  define(Html, 'wrapper', {\n    /**\n     * Gets node of the slides wrapper.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Html.track.children[0];\n    }\n  });\n  return Html;\n}\n\nfunction Peek(Glide, Components, Events) {\n  var Peek = {\n    /**\n     * Setups how much to peek based on settings.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.value = Glide.settings.peek;\n    }\n  };\n  define(Peek, 'value', {\n    /**\n     * Gets value of the peek.\n     *\n     * @returns {Number|Object}\n     */\n    get: function get() {\n      return Peek._v;\n    },\n\n    /**\n     * Sets value of the peek.\n     *\n     * @param {Number|Object} value\n     * @return {Void}\n     */\n    set: function set(value) {\n      if (isObject(value)) {\n        value.before = toInt(value.before);\n        value.after = toInt(value.after);\n      } else {\n        value = toInt(value);\n      }\n\n      Peek._v = value;\n    }\n  });\n  define(Peek, 'reductor', {\n    /**\n     * Gets reduction value caused by peek.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      var value = Peek.value;\n      var perView = Glide.settings.perView;\n\n      if (isObject(value)) {\n        return value.before / perView + value.after / perView;\n      }\n\n      return value * 2 / perView;\n    }\n  });\n  /**\n   * Recalculate peeking sizes on:\n   * - when resizing window to update to proper percents\n   */\n\n  Events.on(['resize', 'update'], function () {\n    Peek.mount();\n  });\n  return Peek;\n}\n\nfunction Move(Glide, Components, Events) {\n  var Move = {\n    /**\n     * Constructs move component.\n     *\n     * @returns {Void}\n     */\n    mount: function mount() {\n      this._o = 0;\n    },\n\n    /**\n     * Calculates a movement value based on passed offset and currently active index.\n     *\n     * @param  {Number} offset\n     * @return {Void}\n     */\n    make: function make() {\n      var _this = this;\n\n      var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n      this.offset = offset;\n      Events.emit('move', {\n        movement: this.value\n      });\n      Components.Transition.after(function () {\n        Events.emit('move.after', {\n          movement: _this.value\n        });\n      });\n    }\n  };\n  define(Move, 'offset', {\n    /**\n     * Gets an offset value used to modify current translate.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Move._o;\n    },\n\n    /**\n     * Sets an offset value used to modify current translate.\n     *\n     * @return {Object}\n     */\n    set: function set(value) {\n      Move._o = !isUndefined(value) ? toInt(value) : 0;\n    }\n  });\n  define(Move, 'translate', {\n    /**\n     * Gets a raw movement value.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Components.Sizes.slideWidth * Glide.index;\n    }\n  });\n  define(Move, 'value', {\n    /**\n     * Gets an actual movement value corrected by offset.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var offset = this.offset;\n      var translate = this.translate;\n\n      if (Components.Direction.is('rtl')) {\n        return translate + offset;\n      }\n\n      return translate - offset;\n    }\n  });\n  /**\n   * Make movement to proper slide on:\n   * - before build, so glide will start at `startAt` index\n   * - on each standard run to move to newly calculated index\n   */\n\n  Events.on(['build.before', 'run'], function () {\n    Move.make();\n  });\n  return Move;\n}\n\nfunction Sizes(Glide, Components, Events) {\n  var Sizes = {\n    /**\n     * Setups dimentions of slides.\n     *\n     * @return {Void}\n     */\n    setupSlides: function setupSlides() {\n      var width = this.slideWidth + 'px';\n      var slides = Components.Html.slides;\n\n      for (var i = 0; i < slides.length; i++) {\n        slides[i].style.width = width;\n      }\n    },\n\n    /**\n     * Setups dimentions of slides wrapper.\n     *\n     * @return {Void}\n     */\n    setupWrapper: function setupWrapper(dimention) {\n      Components.Html.wrapper.style.width = this.wrapperSize + 'px';\n    },\n\n    /**\n     * Removes applied styles from HTML elements.\n     *\n     * @returns {Void}\n     */\n    remove: function remove() {\n      var slides = Components.Html.slides;\n\n      for (var i = 0; i < slides.length; i++) {\n        slides[i].style.width = '';\n      }\n\n      Components.Html.wrapper.style.width = '';\n    }\n  };\n  define(Sizes, 'length', {\n    /**\n     * Gets count number of the slides.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Components.Html.slides.length;\n    }\n  });\n  define(Sizes, 'width', {\n    /**\n     * Gets width value of the glide.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Components.Html.root.offsetWidth;\n    }\n  });\n  define(Sizes, 'wrapperSize', {\n    /**\n     * Gets size of the slides wrapper.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Sizes.slideWidth * Sizes.length + Components.Gaps.grow + Components.Clones.grow;\n    }\n  });\n  define(Sizes, 'slideWidth', {\n    /**\n     * Gets width value of the single slide.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Sizes.width / Glide.settings.perView - Components.Peek.reductor - Components.Gaps.reductor;\n    }\n  });\n  /**\n   * Apply calculated glide's dimensions:\n   * - before building, so other dimentions (e.g. translate) will be calculated propertly\n   * - when resizing window to recalculate sildes dimensions\n   * - on updating via API, to calculate dimensions based on new options\n   */\n\n  Events.on(['build.before', 'resize', 'update'], function () {\n    Sizes.setupSlides();\n    Sizes.setupWrapper();\n  });\n  /**\n   * Remove calculated glide's dimensions:\n   * - on destoting to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Sizes.remove();\n  });\n  return Sizes;\n}\n\nfunction Build(Glide, Components, Events) {\n  var Build = {\n    /**\n     * Init glide building. Adds classes, sets\n     * dimensions and setups initial state.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      Events.emit('build.before');\n      this.typeClass();\n      this.activeClass();\n      Events.emit('build.after');\n    },\n\n    /**\n     * Adds `type` class to the glide element.\n     *\n     * @return {Void}\n     */\n    typeClass: function typeClass() {\n      Components.Html.root.classList.add(Glide.settings.classes[Glide.settings.type]);\n    },\n\n    /**\n     * Sets active class to current slide.\n     *\n     * @return {Void}\n     */\n    activeClass: function activeClass() {\n      var classes = Glide.settings.classes;\n      var slide = Components.Html.slides[Glide.index];\n\n      if (slide) {\n        slide.classList.add(classes.activeSlide);\n        siblings(slide).forEach(function (sibling) {\n          sibling.classList.remove(classes.activeSlide);\n        });\n      }\n    },\n\n    /**\n     * Removes HTML classes applied at building.\n     *\n     * @return {Void}\n     */\n    removeClasses: function removeClasses() {\n      var classes = Glide.settings.classes;\n      Components.Html.root.classList.remove(classes[Glide.settings.type]);\n      Components.Html.slides.forEach(function (sibling) {\n        sibling.classList.remove(classes.activeSlide);\n      });\n    }\n  };\n  /**\n   * Clear building classes:\n   * - on destroying to bring HTML to its initial state\n   * - on updating to remove classes before remounting component\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Build.removeClasses();\n  });\n  /**\n   * Remount component:\n   * - on resizing of the window to calculate new dimentions\n   * - on updating settings via API\n   */\n\n  Events.on(['resize', 'update'], function () {\n    Build.mount();\n  });\n  /**\n   * Swap active class of current slide:\n   * - after each move to the new index\n   */\n\n  Events.on('move.after', function () {\n    Build.activeClass();\n  });\n  return Build;\n}\n\nfunction Clones(Glide, Components, Events) {\n  var Clones = {\n    /**\n     * Create pattern map and collect slides to be cloned.\n     */\n    mount: function mount() {\n      this.items = [];\n\n      if (Glide.isType('carousel')) {\n        this.items = this.collect();\n      }\n    },\n\n    /**\n     * Collect clones with pattern.\n     *\n     * @return {Void}\n     */\n    collect: function collect() {\n      var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n      var slides = Components.Html.slides;\n      var _Glide$settings = Glide.settings,\n          perView = _Glide$settings.perView,\n          classes = _Glide$settings.classes;\n      var peekIncrementer = +!!Glide.settings.peek;\n      var part = perView + peekIncrementer;\n      var start = slides.slice(0, part);\n      var end = slides.slice(-part);\n\n      for (var r = 0; r < Math.max(1, Math.floor(perView / slides.length)); r++) {\n        for (var i = 0; i < start.length; i++) {\n          var clone = start[i].cloneNode(true);\n          clone.classList.add(classes.cloneSlide);\n          items.push(clone);\n        }\n\n        for (var _i = 0; _i < end.length; _i++) {\n          var _clone = end[_i].cloneNode(true);\n\n          _clone.classList.add(classes.cloneSlide);\n\n          items.unshift(_clone);\n        }\n      }\n\n      return items;\n    },\n\n    /**\n     * Append cloned slides with generated pattern.\n     *\n     * @return {Void}\n     */\n    append: function append() {\n      var items = this.items;\n      var _Components$Html = Components.Html,\n          wrapper = _Components$Html.wrapper,\n          slides = _Components$Html.slides;\n      var half = Math.floor(items.length / 2);\n      var prepend = items.slice(0, half).reverse();\n      var append = items.slice(half, items.length);\n      var width = Components.Sizes.slideWidth + 'px';\n\n      for (var i = 0; i < append.length; i++) {\n        wrapper.appendChild(append[i]);\n      }\n\n      for (var _i2 = 0; _i2 < prepend.length; _i2++) {\n        wrapper.insertBefore(prepend[_i2], slides[0]);\n      }\n\n      for (var _i3 = 0; _i3 < items.length; _i3++) {\n        items[_i3].style.width = width;\n      }\n    },\n\n    /**\n     * Remove all cloned slides.\n     *\n     * @return {Void}\n     */\n    remove: function remove() {\n      var items = this.items;\n\n      for (var i = 0; i < items.length; i++) {\n        Components.Html.wrapper.removeChild(items[i]);\n      }\n    }\n  };\n  define(Clones, 'grow', {\n    /**\n     * Gets additional dimentions value caused by clones.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return (Components.Sizes.slideWidth + Components.Gaps.value) * Clones.items.length;\n    }\n  });\n  /**\n   * Append additional slide's clones:\n   * - while glide's type is `carousel`\n   */\n\n  Events.on('update', function () {\n    Clones.remove();\n    Clones.mount();\n    Clones.append();\n  });\n  /**\n   * Append additional slide's clones:\n   * - while glide's type is `carousel`\n   */\n\n  Events.on('build.before', function () {\n    if (Glide.isType('carousel')) {\n      Clones.append();\n    }\n  });\n  /**\n   * Remove clones HTMLElements:\n   * - on destroying, to bring HTML to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Clones.remove();\n  });\n  return Clones;\n}\n\nvar EventsBinder = function () {\n  /**\n   * Construct a EventsBinder instance.\n   */\n  function EventsBinder() {\n    var listeners = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    classCallCheck(this, EventsBinder);\n    this.listeners = listeners;\n  }\n  /**\n   * Adds events listeners to arrows HTML elements.\n   *\n   * @param  {String|Array} events\n   * @param  {Element|Window|Document} el\n   * @param  {Function} closure\n   * @param  {Boolean|Object} capture\n   * @return {Void}\n   */\n\n\n  createClass(EventsBinder, [{\n    key: 'on',\n    value: function on(events, el, closure) {\n      var capture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n\n      if (isString(events)) {\n        events = [events];\n      }\n\n      for (var i = 0; i < events.length; i++) {\n        this.listeners[events[i]] = closure;\n        el.addEventListener(events[i], this.listeners[events[i]], capture);\n      }\n    }\n    /**\n     * Removes event listeners from arrows HTML elements.\n     *\n     * @param  {String|Array} events\n     * @param  {Element|Window|Document} el\n     * @param  {Boolean|Object} capture\n     * @return {Void}\n     */\n\n  }, {\n    key: 'off',\n    value: function off(events, el) {\n      var capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n      if (isString(events)) {\n        events = [events];\n      }\n\n      for (var i = 0; i < events.length; i++) {\n        el.removeEventListener(events[i], this.listeners[events[i]], capture);\n      }\n    }\n    /**\n     * Destroy collected listeners.\n     *\n     * @returns {Void}\n     */\n\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      delete this.listeners;\n    }\n  }]);\n  return EventsBinder;\n}();\n\nfunction Resize(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Resize = {\n    /**\n     * Initializes window bindings.\n     */\n    mount: function mount() {\n      this.bind();\n    },\n\n    /**\n     * Binds `rezsize` listener to the window.\n     * It's a costly event, so we are debouncing it.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('resize', window, throttle(function () {\n        Events.emit('resize');\n      }, Glide.settings.throttle));\n    },\n\n    /**\n     * Unbinds listeners from the window.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('resize', window);\n    }\n  };\n  /**\n   * Remove bindings from window:\n   * - on destroying, to remove added EventListener\n   */\n\n  Events.on('destroy', function () {\n    Resize.unbind();\n    Binder.destroy();\n  });\n  return Resize;\n}\n\nvar VALID_DIRECTIONS = ['ltr', 'rtl'];\nvar FLIPED_MOVEMENTS = {\n  '>': '<',\n  '<': '>',\n  '=': '='\n};\n\nfunction Direction(Glide, Components, Events) {\n  var Direction = {\n    /**\n     * Setups gap value based on settings.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.value = Glide.settings.direction;\n    },\n\n    /**\n     * Resolves pattern based on direction value\n     *\n     * @param {String} pattern\n     * @returns {String}\n     */\n    resolve: function resolve(pattern) {\n      var token = pattern.slice(0, 1);\n\n      if (this.is('rtl')) {\n        return pattern.split(token).join(FLIPED_MOVEMENTS[token]);\n      }\n\n      return pattern;\n    },\n\n    /**\n     * Checks value of direction mode.\n     *\n     * @param {String} direction\n     * @returns {Boolean}\n     */\n    is: function is(direction) {\n      return this.value === direction;\n    },\n\n    /**\n     * Applies direction class to the root HTML element.\n     *\n     * @return {Void}\n     */\n    addClass: function addClass() {\n      Components.Html.root.classList.add(Glide.settings.classes.direction[this.value]);\n    },\n\n    /**\n     * Removes direction class from the root HTML element.\n     *\n     * @return {Void}\n     */\n    removeClass: function removeClass() {\n      Components.Html.root.classList.remove(Glide.settings.classes.direction[this.value]);\n    }\n  };\n  define(Direction, 'value', {\n    /**\n     * Gets value of the direction.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      return Direction._v;\n    },\n\n    /**\n     * Sets value of the direction.\n     *\n     * @param {String} value\n     * @return {Void}\n     */\n    set: function set(value) {\n      if (VALID_DIRECTIONS.indexOf(value) > -1) {\n        Direction._v = value;\n      } else {\n        warn('Direction value must be `ltr` or `rtl`');\n      }\n    }\n  });\n  /**\n   * Clear direction class:\n   * - on destroy to bring HTML to its initial state\n   * - on update to remove class before reappling bellow\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Direction.removeClass();\n  });\n  /**\n   * Remount component:\n   * - on update to reflect changes in direction value\n   */\n\n  Events.on('update', function () {\n    Direction.mount();\n  });\n  /**\n   * Apply direction class:\n   * - before building to apply class for the first time\n   * - on updating to reapply direction class that may changed\n   */\n\n  Events.on(['build.before', 'update'], function () {\n    Direction.addClass();\n  });\n  return Direction;\n}\n/**\n * Reflects value of glide movement.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Rtl(Glide, Components) {\n  return {\n    /**\n     * Negates the passed translate if glide is in RTL option.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      if (Components.Direction.is('rtl')) {\n        return -translate;\n      }\n\n      return translate;\n    }\n  };\n}\n/**\n * Updates glide movement with a `gap` settings.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Gap(Glide, Components) {\n  return {\n    /**\n     * Modifies passed translate value with number in the `gap` settings.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      return translate + Components.Gaps.value * Glide.index;\n    }\n  };\n}\n/**\n * Updates glide movement with width of additional clones width.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Grow(Glide, Components) {\n  return {\n    /**\n     * Adds to the passed translate width of the half of clones.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      return translate + Components.Clones.grow / 2;\n    }\n  };\n}\n/**\n * Updates glide movement with a `peek` settings.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Peeking(Glide, Components) {\n  return {\n    /**\n     * Modifies passed translate value with a `peek` setting.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      if (Glide.settings.focusAt >= 0) {\n        var peek = Components.Peek.value;\n\n        if (isObject(peek)) {\n          return translate - peek.before;\n        }\n\n        return translate - peek;\n      }\n\n      return translate;\n    }\n  };\n}\n/**\n * Updates glide movement with a `focusAt` settings.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Focusing(Glide, Components) {\n  return {\n    /**\n     * Modifies passed translate value with index in the `focusAt` setting.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      var gap = Components.Gaps.value;\n      var width = Components.Sizes.width;\n      var focusAt = Glide.settings.focusAt;\n      var slideWidth = Components.Sizes.slideWidth;\n\n      if (focusAt === 'center') {\n        return translate - (width / 2 - slideWidth / 2);\n      }\n\n      return translate - slideWidth * focusAt - gap * focusAt;\n    }\n  };\n}\n/**\n * Applies diffrent transformers on translate value.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction mutator(Glide, Components, Events) {\n  /**\n   * Merge instance transformers with collection of default transformers.\n   * It's important that the Rtl component be last on the list,\n   * so it reflects all previous transformations.\n   *\n   * @type {Array}\n   */\n  var TRANSFORMERS = [Gap, Grow, Peeking, Focusing].concat(Glide._t, [Rtl]);\n  return {\n    /**\n     * Piplines translate value with registered transformers.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    mutate: function mutate(translate) {\n      for (var i = 0; i < TRANSFORMERS.length; i++) {\n        var transformer = TRANSFORMERS[i];\n\n        if (isFunction(transformer) && isFunction(transformer().modify)) {\n          translate = transformer(Glide, Components, Events).modify(translate);\n        } else {\n          warn('Transformer should be a function that returns an object with `modify()` method');\n        }\n      }\n\n      return translate;\n    }\n  };\n}\n\nfunction Translate(Glide, Components, Events) {\n  var Translate = {\n    /**\n     * Sets value of translate on HTML element.\n     *\n     * @param {Number} value\n     * @return {Void}\n     */\n    set: function set(value) {\n      var transform = mutator(Glide, Components).mutate(value);\n      Components.Html.wrapper.style.transform = 'translate3d(' + -1 * transform + 'px, 0px, 0px)';\n    },\n\n    /**\n     * Removes value of translate from HTML element.\n     *\n     * @return {Void}\n     */\n    remove: function remove() {\n      Components.Html.wrapper.style.transform = '';\n    }\n  };\n  /**\n   * Set new translate value:\n   * - on move to reflect index change\n   * - on updating via API to reflect possible changes in options\n   */\n\n  Events.on('move', function (context) {\n    var gap = Components.Gaps.value;\n    var length = Components.Sizes.length;\n    var width = Components.Sizes.slideWidth;\n\n    if (Glide.isType('carousel') && Components.Run.isOffset('<')) {\n      Components.Transition.after(function () {\n        Events.emit('translate.jump');\n        Translate.set(width * (length - 1));\n      });\n      return Translate.set(-width - gap * length);\n    }\n\n    if (Glide.isType('carousel') && Components.Run.isOffset('>')) {\n      Components.Transition.after(function () {\n        Events.emit('translate.jump');\n        Translate.set(0);\n      });\n      return Translate.set(width * length + gap * length);\n    }\n\n    return Translate.set(context.movement);\n  });\n  /**\n   * Remove translate:\n   * - on destroying to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Translate.remove();\n  });\n  return Translate;\n}\n\nfunction Transition(Glide, Components, Events) {\n  /**\n   * Holds inactivity status of transition.\n   * When true transition is not applied.\n   *\n   * @type {Boolean}\n   */\n  var disabled = false;\n  var Transition = {\n    /**\n     * Composes string of the CSS transition.\n     *\n     * @param {String} property\n     * @return {String}\n     */\n    compose: function compose(property) {\n      var settings = Glide.settings;\n\n      if (!disabled) {\n        return property + ' ' + this.duration + 'ms ' + settings.animationTimingFunc;\n      }\n\n      return property + ' 0ms ' + settings.animationTimingFunc;\n    },\n\n    /**\n     * Sets value of transition on HTML element.\n     *\n     * @param {String=} property\n     * @return {Void}\n     */\n    set: function set() {\n      var property = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n      Components.Html.wrapper.style.transition = this.compose(property);\n    },\n\n    /**\n     * Removes value of transition from HTML element.\n     *\n     * @return {Void}\n     */\n    remove: function remove() {\n      Components.Html.wrapper.style.transition = '';\n    },\n\n    /**\n     * Runs callback after animation.\n     *\n     * @param  {Function} callback\n     * @return {Void}\n     */\n    after: function after(callback) {\n      setTimeout(function () {\n        callback();\n      }, this.duration);\n    },\n\n    /**\n     * Enable transition.\n     *\n     * @return {Void}\n     */\n    enable: function enable() {\n      disabled = false;\n      this.set();\n    },\n\n    /**\n     * Disable transition.\n     *\n     * @return {Void}\n     */\n    disable: function disable() {\n      disabled = true;\n      this.set();\n    }\n  };\n  define(Transition, 'duration', {\n    /**\n     * Gets duration of the transition based\n     * on currently running animation type.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var settings = Glide.settings;\n\n      if (Glide.isType('slider') && Components.Run.offset) {\n        return settings.rewindDuration;\n      }\n\n      return settings.animationDuration;\n    }\n  });\n  /**\n   * Set transition `style` value:\n   * - on each moving, because it may be cleared by offset move\n   */\n\n  Events.on('move', function () {\n    Transition.set();\n  });\n  /**\n   * Disable transition:\n   * - before initial build to avoid transitioning from `0` to `startAt` index\n   * - while resizing window and recalculating dimentions\n   * - on jumping from offset transition at start and end edges in `carousel` type\n   */\n\n  Events.on(['build.before', 'resize', 'translate.jump'], function () {\n    Transition.disable();\n  });\n  /**\n   * Enable transition:\n   * - on each running, because it may be disabled by offset move\n   */\n\n  Events.on('run', function () {\n    Transition.enable();\n  });\n  /**\n   * Remove transition:\n   * - on destroying to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Transition.remove();\n  });\n  return Transition;\n}\n/**\n * Test via a getter in the options object to see\n * if the passive property is accessed.\n *\n * @see https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection\n */\n\n\nvar supportsPassive = false;\n\ntry {\n  var opts = Object.defineProperty({}, 'passive', {\n    get: function get() {\n      supportsPassive = true;\n    }\n  });\n  window.addEventListener('testPassive', null, opts);\n  window.removeEventListener('testPassive', null, opts);\n} catch (e) {}\n\nvar supportsPassive$1 = supportsPassive;\nvar START_EVENTS = ['touchstart', 'mousedown'];\nvar MOVE_EVENTS = ['touchmove', 'mousemove'];\nvar END_EVENTS = ['touchend', 'touchcancel', 'mouseup', 'mouseleave'];\nvar MOUSE_EVENTS = ['mousedown', 'mousemove', 'mouseup', 'mouseleave'];\n\nfunction Swipe(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var swipeSin = 0;\n  var swipeStartX = 0;\n  var swipeStartY = 0;\n  var disabled = false;\n  var capture = supportsPassive$1 ? {\n    passive: true\n  } : false;\n  var Swipe = {\n    /**\n     * Initializes swipe bindings.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.bindSwipeStart();\n    },\n\n    /**\n     * Handler for `swipestart` event. Calculates entry points of the user's tap.\n     *\n     * @param {Object} event\n     * @return {Void}\n     */\n    start: function start(event) {\n      if (!disabled && !Glide.disabled) {\n        this.disable();\n        var swipe = this.touches(event);\n        swipeSin = null;\n        swipeStartX = toInt(swipe.pageX);\n        swipeStartY = toInt(swipe.pageY);\n        this.bindSwipeMove();\n        this.bindSwipeEnd();\n        Events.emit('swipe.start');\n      }\n    },\n\n    /**\n     * Handler for `swipemove` event. Calculates user's tap angle and distance.\n     *\n     * @param {Object} event\n     */\n    move: function move(event) {\n      if (!Glide.disabled) {\n        var _Glide$settings = Glide.settings,\n            touchAngle = _Glide$settings.touchAngle,\n            touchRatio = _Glide$settings.touchRatio,\n            classes = _Glide$settings.classes;\n        var swipe = this.touches(event);\n        var subExSx = toInt(swipe.pageX) - swipeStartX;\n        var subEySy = toInt(swipe.pageY) - swipeStartY;\n        var powEX = Math.abs(subExSx << 2);\n        var powEY = Math.abs(subEySy << 2);\n        var swipeHypotenuse = Math.sqrt(powEX + powEY);\n        var swipeCathetus = Math.sqrt(powEY);\n        swipeSin = Math.asin(swipeCathetus / swipeHypotenuse);\n\n        if (swipeSin * 180 / Math.PI < touchAngle) {\n          event.stopPropagation();\n          Components.Move.make(subExSx * toFloat(touchRatio));\n          Components.Html.root.classList.add(classes.dragging);\n          Events.emit('swipe.move');\n        } else {\n          return false;\n        }\n      }\n    },\n\n    /**\n     * Handler for `swipeend` event. Finitializes user's tap and decides about glide move.\n     *\n     * @param {Object} event\n     * @return {Void}\n     */\n    end: function end(event) {\n      if (!Glide.disabled) {\n        var settings = Glide.settings;\n        var swipe = this.touches(event);\n        var threshold = this.threshold(event);\n        var swipeDistance = swipe.pageX - swipeStartX;\n        var swipeDeg = swipeSin * 180 / Math.PI;\n        var steps = Math.round(swipeDistance / Components.Sizes.slideWidth);\n        this.enable();\n\n        if (swipeDistance > threshold && swipeDeg < settings.touchAngle) {\n          // While swipe is positive and greater than threshold move backward.\n          if (settings.perTouch) {\n            steps = Math.min(steps, toInt(settings.perTouch));\n          }\n\n          if (Components.Direction.is('rtl')) {\n            steps = -steps;\n          }\n\n          Components.Run.make(Components.Direction.resolve('<' + steps));\n        } else if (swipeDistance < -threshold && swipeDeg < settings.touchAngle) {\n          // While swipe is negative and lower than negative threshold move forward.\n          if (settings.perTouch) {\n            steps = Math.max(steps, -toInt(settings.perTouch));\n          }\n\n          if (Components.Direction.is('rtl')) {\n            steps = -steps;\n          }\n\n          Components.Run.make(Components.Direction.resolve('>' + steps));\n        } else {\n          // While swipe don't reach distance apply previous transform.\n          Components.Move.make();\n        }\n\n        Components.Html.root.classList.remove(settings.classes.dragging);\n        this.unbindSwipeMove();\n        this.unbindSwipeEnd();\n        Events.emit('swipe.end');\n      }\n    },\n\n    /**\n     * Binds swipe's starting event.\n     *\n     * @return {Void}\n     */\n    bindSwipeStart: function bindSwipeStart() {\n      var _this = this;\n\n      var settings = Glide.settings;\n\n      if (settings.swipeThreshold) {\n        Binder.on(START_EVENTS[0], Components.Html.wrapper, function (event) {\n          _this.start(event);\n        }, capture);\n      }\n\n      if (settings.dragThreshold) {\n        Binder.on(START_EVENTS[1], Components.Html.wrapper, function (event) {\n          _this.start(event);\n        }, capture);\n      }\n    },\n\n    /**\n     * Unbinds swipe's starting event.\n     *\n     * @return {Void}\n     */\n    unbindSwipeStart: function unbindSwipeStart() {\n      Binder.off(START_EVENTS[0], Components.Html.wrapper, capture);\n      Binder.off(START_EVENTS[1], Components.Html.wrapper, capture);\n    },\n\n    /**\n     * Binds swipe's moving event.\n     *\n     * @return {Void}\n     */\n    bindSwipeMove: function bindSwipeMove() {\n      var _this2 = this;\n\n      Binder.on(MOVE_EVENTS, Components.Html.wrapper, throttle(function (event) {\n        _this2.move(event);\n      }, Glide.settings.throttle), capture);\n    },\n\n    /**\n     * Unbinds swipe's moving event.\n     *\n     * @return {Void}\n     */\n    unbindSwipeMove: function unbindSwipeMove() {\n      Binder.off(MOVE_EVENTS, Components.Html.wrapper, capture);\n    },\n\n    /**\n     * Binds swipe's ending event.\n     *\n     * @return {Void}\n     */\n    bindSwipeEnd: function bindSwipeEnd() {\n      var _this3 = this;\n\n      Binder.on(END_EVENTS, Components.Html.wrapper, function (event) {\n        _this3.end(event);\n      });\n    },\n\n    /**\n     * Unbinds swipe's ending event.\n     *\n     * @return {Void}\n     */\n    unbindSwipeEnd: function unbindSwipeEnd() {\n      Binder.off(END_EVENTS, Components.Html.wrapper);\n    },\n\n    /**\n     * Normalizes event touches points accorting to different types.\n     *\n     * @param {Object} event\n     */\n    touches: function touches(event) {\n      if (MOUSE_EVENTS.indexOf(event.type) > -1) {\n        return event;\n      }\n\n      return event.touches[0] || event.changedTouches[0];\n    },\n\n    /**\n     * Gets value of minimum swipe distance settings based on event type.\n     *\n     * @return {Number}\n     */\n    threshold: function threshold(event) {\n      var settings = Glide.settings;\n\n      if (MOUSE_EVENTS.indexOf(event.type) > -1) {\n        return settings.dragThreshold;\n      }\n\n      return settings.swipeThreshold;\n    },\n\n    /**\n     * Enables swipe event.\n     *\n     * @return {self}\n     */\n    enable: function enable() {\n      disabled = false;\n      Components.Transition.enable();\n      return this;\n    },\n\n    /**\n     * Disables swipe event.\n     *\n     * @return {self}\n     */\n    disable: function disable() {\n      disabled = true;\n      Components.Transition.disable();\n      return this;\n    }\n  };\n  /**\n   * Add component class:\n   * - after initial building\n   */\n\n  Events.on('build.after', function () {\n    Components.Html.root.classList.add(Glide.settings.classes.swipeable);\n  });\n  /**\n   * Remove swiping bindings:\n   * - on destroying, to remove added EventListeners\n   */\n\n  Events.on('destroy', function () {\n    Swipe.unbindSwipeStart();\n    Swipe.unbindSwipeMove();\n    Swipe.unbindSwipeEnd();\n    Binder.destroy();\n  });\n  return Swipe;\n}\n\nfunction Images(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Images = {\n    /**\n     * Binds listener to glide wrapper.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.bind();\n    },\n\n    /**\n     * Binds `dragstart` event on wrapper to prevent dragging images.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('dragstart', Components.Html.wrapper, this.dragstart);\n    },\n\n    /**\n     * Unbinds `dragstart` event on wrapper.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('dragstart', Components.Html.wrapper);\n    },\n\n    /**\n     * Event handler. Prevents dragging.\n     *\n     * @return {Void}\n     */\n    dragstart: function dragstart(event) {\n      event.preventDefault();\n    }\n  };\n  /**\n   * Remove bindings from images:\n   * - on destroying, to remove added EventListeners\n   */\n\n  Events.on('destroy', function () {\n    Images.unbind();\n    Binder.destroy();\n  });\n  return Images;\n}\n\nfunction Anchors(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  /**\n   * Holds detaching status of anchors.\n   * Prevents detaching of already detached anchors.\n   *\n   * @private\n   * @type {Boolean}\n   */\n\n  var detached = false;\n  /**\n   * Holds preventing status of anchors.\n   * If `true` redirection after click will be disabled.\n   *\n   * @private\n   * @type {Boolean}\n   */\n\n  var prevented = false;\n  var Anchors = {\n    /**\n     * Setups a initial state of anchors component.\n     *\n     * @returns {Void}\n     */\n    mount: function mount() {\n      /**\n       * Holds collection of anchors elements.\n       *\n       * @private\n       * @type {HTMLCollection}\n       */\n      this._a = Components.Html.wrapper.querySelectorAll('a');\n      this.bind();\n    },\n\n    /**\n     * Binds events to anchors inside a track.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('click', Components.Html.wrapper, this.click);\n    },\n\n    /**\n     * Unbinds events attached to anchors inside a track.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('click', Components.Html.wrapper);\n    },\n\n    /**\n     * Handler for click event. Prevents clicks when glide is in `prevent` status.\n     *\n     * @param  {Object} event\n     * @return {Void}\n     */\n    click: function click(event) {\n      if (prevented) {\n        event.stopPropagation();\n        event.preventDefault();\n      }\n    },\n\n    /**\n     * Detaches anchors click event inside glide.\n     *\n     * @return {self}\n     */\n    detach: function detach() {\n      prevented = true;\n\n      if (!detached) {\n        for (var i = 0; i < this.items.length; i++) {\n          this.items[i].draggable = false;\n          this.items[i].setAttribute('data-href', this.items[i].getAttribute('href'));\n          this.items[i].removeAttribute('href');\n        }\n\n        detached = true;\n      }\n\n      return this;\n    },\n\n    /**\n     * Attaches anchors click events inside glide.\n     *\n     * @return {self}\n     */\n    attach: function attach() {\n      prevented = false;\n\n      if (detached) {\n        for (var i = 0; i < this.items.length; i++) {\n          this.items[i].draggable = true;\n          this.items[i].setAttribute('href', this.items[i].getAttribute('data-href'));\n        }\n\n        detached = false;\n      }\n\n      return this;\n    }\n  };\n  define(Anchors, 'items', {\n    /**\n     * Gets collection of the arrows HTML elements.\n     *\n     * @return {HTMLElement[]}\n     */\n    get: function get() {\n      return Anchors._a;\n    }\n  });\n  /**\n   * Detach anchors inside slides:\n   * - on swiping, so they won't redirect to its `href` attributes\n   */\n\n  Events.on('swipe.move', function () {\n    Anchors.detach();\n  });\n  /**\n   * Attach anchors inside slides:\n   * - after swiping and transitions ends, so they can redirect after click again\n   */\n\n  Events.on('swipe.end', function () {\n    Components.Transition.after(function () {\n      Anchors.attach();\n    });\n  });\n  /**\n   * Unbind anchors inside slides:\n   * - on destroying, to bring anchors to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Anchors.attach();\n    Anchors.unbind();\n    Binder.destroy();\n  });\n  return Anchors;\n}\n\nvar NAV_SELECTOR = '[data-glide-el=\"controls[nav]\"]';\nvar CONTROLS_SELECTOR = '[data-glide-el^=\"controls\"]';\n\nfunction Controls(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var capture = supportsPassive$1 ? {\n    passive: true\n  } : false;\n  var Controls = {\n    /**\n     * Inits arrows. Binds events listeners\n     * to the arrows HTML elements.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      /**\n       * Collection of navigation HTML elements.\n       *\n       * @private\n       * @type {HTMLCollection}\n       */\n      this._n = Components.Html.root.querySelectorAll(NAV_SELECTOR);\n      /**\n       * Collection of controls HTML elements.\n       *\n       * @private\n       * @type {HTMLCollection}\n       */\n\n      this._c = Components.Html.root.querySelectorAll(CONTROLS_SELECTOR);\n      this.addBindings();\n    },\n\n    /**\n     * Sets active class to current slide.\n     *\n     * @return {Void}\n     */\n    setActive: function setActive() {\n      for (var i = 0; i < this._n.length; i++) {\n        this.addClass(this._n[i].children);\n      }\n    },\n\n    /**\n     * Removes active class to current slide.\n     *\n     * @return {Void}\n     */\n    removeActive: function removeActive() {\n      for (var i = 0; i < this._n.length; i++) {\n        this.removeClass(this._n[i].children);\n      }\n    },\n\n    /**\n     * Toggles active class on items inside navigation.\n     *\n     * @param  {HTMLElement} controls\n     * @return {Void}\n     */\n    addClass: function addClass(controls) {\n      var settings = Glide.settings;\n      var item = controls[Glide.index];\n\n      if (item) {\n        item.classList.add(settings.classes.activeNav);\n        siblings(item).forEach(function (sibling) {\n          sibling.classList.remove(settings.classes.activeNav);\n        });\n      }\n    },\n\n    /**\n     * Removes active class from active control.\n     *\n     * @param  {HTMLElement} controls\n     * @return {Void}\n     */\n    removeClass: function removeClass(controls) {\n      var item = controls[Glide.index];\n\n      if (item) {\n        item.classList.remove(Glide.settings.classes.activeNav);\n      }\n    },\n\n    /**\n     * Adds handles to the each group of controls.\n     *\n     * @return {Void}\n     */\n    addBindings: function addBindings() {\n      for (var i = 0; i < this._c.length; i++) {\n        this.bind(this._c[i].children);\n      }\n    },\n\n    /**\n     * Removes handles from the each group of controls.\n     *\n     * @return {Void}\n     */\n    removeBindings: function removeBindings() {\n      for (var i = 0; i < this._c.length; i++) {\n        this.unbind(this._c[i].children);\n      }\n    },\n\n    /**\n     * Binds events to arrows HTML elements.\n     *\n     * @param {HTMLCollection} elements\n     * @return {Void}\n     */\n    bind: function bind(elements) {\n      for (var i = 0; i < elements.length; i++) {\n        Binder.on('click', elements[i], this.click);\n        Binder.on('touchstart', elements[i], this.click, capture);\n      }\n    },\n\n    /**\n     * Unbinds events binded to the arrows HTML elements.\n     *\n     * @param {HTMLCollection} elements\n     * @return {Void}\n     */\n    unbind: function unbind(elements) {\n      for (var i = 0; i < elements.length; i++) {\n        Binder.off(['click', 'touchstart'], elements[i]);\n      }\n    },\n\n    /**\n     * Handles `click` event on the arrows HTML elements.\n     * Moves slider in driection precised in\n     * `data-glide-dir` attribute.\n     *\n     * @param {Object} event\n     * @return {Void}\n     */\n    click: function click(event) {\n      event.preventDefault();\n      Components.Run.make(Components.Direction.resolve(event.currentTarget.getAttribute('data-glide-dir')));\n    }\n  };\n  define(Controls, 'items', {\n    /**\n     * Gets collection of the controls HTML elements.\n     *\n     * @return {HTMLElement[]}\n     */\n    get: function get() {\n      return Controls._c;\n    }\n  });\n  /**\n   * Swap active class of current navigation item:\n   * - after mounting to set it to initial index\n   * - after each move to the new index\n   */\n\n  Events.on(['mount.after', 'move.after'], function () {\n    Controls.setActive();\n  });\n  /**\n   * Remove bindings and HTML Classes:\n   * - on destroying, to bring markup to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Controls.removeBindings();\n    Controls.removeActive();\n    Binder.destroy();\n  });\n  return Controls;\n}\n\nfunction Keyboard(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Keyboard = {\n    /**\n     * Binds keyboard events on component mount.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      if (Glide.settings.keyboard) {\n        this.bind();\n      }\n    },\n\n    /**\n     * Adds keyboard press events.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('keyup', document, this.press);\n    },\n\n    /**\n     * Removes keyboard press events.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('keyup', document);\n    },\n\n    /**\n     * Handles keyboard's arrows press and moving glide foward and backward.\n     *\n     * @param  {Object} event\n     * @return {Void}\n     */\n    press: function press(event) {\n      if (event.keyCode === 39) {\n        Components.Run.make(Components.Direction.resolve('>'));\n      }\n\n      if (event.keyCode === 37) {\n        Components.Run.make(Components.Direction.resolve('<'));\n      }\n    }\n  };\n  /**\n   * Remove bindings from keyboard:\n   * - on destroying to remove added events\n   * - on updating to remove events before remounting\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Keyboard.unbind();\n  });\n  /**\n   * Remount component\n   * - on updating to reflect potential changes in settings\n   */\n\n  Events.on('update', function () {\n    Keyboard.mount();\n  });\n  /**\n   * Destroy binder:\n   * - on destroying to remove listeners\n   */\n\n  Events.on('destroy', function () {\n    Binder.destroy();\n  });\n  return Keyboard;\n}\n\nfunction Autoplay(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Autoplay = {\n    /**\n     * Initializes autoplaying and events.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.start();\n\n      if (Glide.settings.hoverpause) {\n        this.bind();\n      }\n    },\n\n    /**\n     * Starts autoplaying in configured interval.\n     *\n     * @param {Boolean|Number} force Run autoplaying with passed interval regardless of `autoplay` settings\n     * @return {Void}\n     */\n    start: function start() {\n      var _this = this;\n\n      if (Glide.settings.autoplay) {\n        if (isUndefined(this._i)) {\n          this._i = setInterval(function () {\n            _this.stop();\n\n            Components.Run.make('>');\n\n            _this.start();\n          }, this.time);\n        }\n      }\n    },\n\n    /**\n     * Stops autorunning of the glide.\n     *\n     * @return {Void}\n     */\n    stop: function stop() {\n      this._i = clearInterval(this._i);\n    },\n\n    /**\n     * Stops autoplaying while mouse is over glide's area.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      var _this2 = this;\n\n      Binder.on('mouseover', Components.Html.root, function () {\n        _this2.stop();\n      });\n      Binder.on('mouseout', Components.Html.root, function () {\n        _this2.start();\n      });\n    },\n\n    /**\n     * Unbind mouseover events.\n     *\n     * @returns {Void}\n     */\n    unbind: function unbind() {\n      Binder.off(['mouseover', 'mouseout'], Components.Html.root);\n    }\n  };\n  define(Autoplay, 'time', {\n    /**\n     * Gets time period value for the autoplay interval. Prioritizes\n     * times in `data-glide-autoplay` attrubutes over options.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var autoplay = Components.Html.slides[Glide.index].getAttribute('data-glide-autoplay');\n\n      if (autoplay) {\n        return toInt(autoplay);\n      }\n\n      return toInt(Glide.settings.autoplay);\n    }\n  });\n  /**\n   * Stop autoplaying and unbind events:\n   * - on destroying, to clear defined interval\n   * - on updating via API to reset interval that may changed\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Autoplay.unbind();\n  });\n  /**\n   * Stop autoplaying:\n   * - before each run, to restart autoplaying\n   * - on pausing via API\n   * - on destroying, to clear defined interval\n   * - while starting a swipe\n   * - on updating via API to reset interval that may changed\n   */\n\n  Events.on(['run.before', 'pause', 'destroy', 'swipe.start', 'update'], function () {\n    Autoplay.stop();\n  });\n  /**\n   * Start autoplaying:\n   * - after each run, to restart autoplaying\n   * - on playing via API\n   * - while ending a swipe\n   */\n\n  Events.on(['run.after', 'play', 'swipe.end'], function () {\n    Autoplay.start();\n  });\n  /**\n   * Remount autoplaying:\n   * - on updating via API to reset interval that may changed\n   */\n\n  Events.on('update', function () {\n    Autoplay.mount();\n  });\n  /**\n   * Destroy a binder:\n   * - on destroying glide instance to clearup listeners\n   */\n\n  Events.on('destroy', function () {\n    Binder.destroy();\n  });\n  return Autoplay;\n}\n/**\n * Sorts keys of breakpoint object so they will be ordered from lower to bigger.\n *\n * @param {Object} points\n * @returns {Object}\n */\n\n\nfunction sortBreakpoints(points) {\n  if (isObject(points)) {\n    return sortKeys(points);\n  } else {\n    warn('Breakpoints option must be an object');\n  }\n\n  return {};\n}\n\nfunction Breakpoints(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  /**\n   * Holds reference to settings.\n   *\n   * @type {Object}\n   */\n\n  var settings = Glide.settings;\n  /**\n   * Holds reference to breakpoints object in settings. Sorts breakpoints\n   * from smaller to larger. It is required in order to proper\n   * matching currently active breakpoint settings.\n   *\n   * @type {Object}\n   */\n\n  var points = sortBreakpoints(settings.breakpoints);\n  /**\n   * Cache initial settings before overwritting.\n   *\n   * @type {Object}\n   */\n\n  var defaults = _extends({}, settings);\n\n  var Breakpoints = {\n    /**\n     * Matches settings for currectly matching media breakpoint.\n     *\n     * @param {Object} points\n     * @returns {Object}\n     */\n    match: function match(points) {\n      if (typeof window.matchMedia !== 'undefined') {\n        for (var point in points) {\n          if (points.hasOwnProperty(point)) {\n            if (window.matchMedia('(max-width: ' + point + 'px)').matches) {\n              return points[point];\n            }\n          }\n        }\n      }\n\n      return defaults;\n    }\n  };\n  /**\n   * Overwrite instance settings with currently matching breakpoint settings.\n   * This happens right after component initialization.\n   */\n\n  _extends(settings, Breakpoints.match(points));\n  /**\n   * Update glide with settings of matched brekpoint:\n   * - window resize to update slider\n   */\n\n\n  Binder.on('resize', window, throttle(function () {\n    Glide.settings = mergeOptions(settings, Breakpoints.match(points));\n  }, Glide.settings.throttle));\n  /**\n   * Resort and update default settings:\n   * - on reinit via API, so breakpoint matching will be performed with options\n   */\n\n  Events.on('update', function () {\n    points = sortBreakpoints(points);\n    defaults = _extends({}, settings);\n  });\n  /**\n   * Unbind resize listener:\n   * - on destroying, to bring markup to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Binder.off('resize', window);\n  });\n  return Breakpoints;\n}\n\nvar COMPONENTS = {\n  // Required\n  Html: Html,\n  Translate: Translate,\n  Transition: Transition,\n  Direction: Direction,\n  Peek: Peek,\n  Sizes: Sizes,\n  Gaps: Gaps,\n  Move: Move,\n  Clones: Clones,\n  Resize: Resize,\n  Build: Build,\n  Run: Run,\n  // Optional\n  Swipe: Swipe,\n  Images: Images,\n  Anchors: Anchors,\n  Controls: Controls,\n  Keyboard: Keyboard,\n  Autoplay: Autoplay,\n  Breakpoints: Breakpoints\n};\n\nvar Glide$1 = function (_Core) {\n  inherits(Glide$$1, _Core);\n\n  function Glide$$1() {\n    classCallCheck(this, Glide$$1);\n    return possibleConstructorReturn(this, (Glide$$1.__proto__ || Object.getPrototypeOf(Glide$$1)).apply(this, arguments));\n  }\n\n  createClass(Glide$$1, [{\n    key: 'mount',\n    value: function mount() {\n      var extensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      return get(Glide$$1.prototype.__proto__ || Object.getPrototypeOf(Glide$$1.prototype), 'mount', this).call(this, _extends({}, COMPONENTS, extensions));\n    }\n  }]);\n  return Glide$$1;\n}(Glide);\n\nexport default Glide$1;","import Rails from 'rails-ujs'\nimport Turbolinks from 'turbolinks'\nimport Glide from '@glidejs/glide'\nimport SweetScroll from 'sweet-scroll'\nimport 'alpinejs'\n\nrequire.context('../images', true)\nimport '../css/application.scss'\n\nRails.start()\nTurbolinks.start()\n\ndocument.addEventListener('turbolinks:load', function () {\n  new SweetScroll()\n\n  if (document.querySelector('#activities_slider')) {\n    const glideSlide = new Glide('#activities_slider', {\n      type: 'carousel',\n      perView: 5,\n      focusAt: 'center',\n      gap: 32,\n      hoverpause: true,\n      breakpoints: {\n        1024: {\n          perView: 3,\n        },\n        600: {\n          perView: 1,\n        },\n      },\n    })\n\n    glideSlide.mount()\n\n    let currentSlide = document.querySelector('.glide__slide--active')\n    let slideTitle = currentSlide.getAttribute('data-slide-title')\n    const activityTitle = document.querySelector('#activities_title')\n\n    activityTitle.innerText = slideTitle\n\n    glideSlide.on('run.after', function () {\n      currentSlide = document.querySelector('.glide__slide--active')\n      slideTitle = currentSlide.getAttribute('data-slide-title')\n      activityTitle.innerText = slideTitle\n    })\n  }\n\n  if (document.querySelector('#team_slider')) {\n    const glideSlide = new Glide('#team_slider', {\n      type: 'carousel',\n      perView: 3,\n      gap: 32,\n      hoverpause: true,\n      breakpoints: {\n        1024: {\n          perView: 2,\n        },\n        640: {\n          perView: 1,\n        },\n      },\n      rewind: true,\n    })\n\n    glideSlide.mount()\n  }\n\n  function fixedHeader() {\n    const scrollTop = window.pageYOffset || document.documentElement.scrollTop\n    const navigationEl = document.querySelector('#navigation')\n    if (scrollTop > 0) navigationEl.classList.add('is-stuck')\n    else navigationEl.classList.remove('is-stuck')\n  }\n\n  fixedHeader()\n  document.addEventListener('scroll', () => fixedHeader())\n})\n"],"sourceRoot":""}