{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/deploy/paul-anton/shared/node_modules/@babel/runtime/regenerator/index.js","webpack:///./app/javascript/images/ups.png","webpack:///./app/javascript/images/24hours.svg","webpack:///./app/javascript/images/airport-grayscale.jpg","webpack:///./app/javascript/images/alarm-card.svg","webpack:///./app/javascript/images/blur-bg.jpg","webpack:///./app/javascript/images/bypass-switch.svg","webpack:///./app/javascript/images/call.svg","webpack:///./app/javascript/images/chas.png","webpack:///./app/javascript/images/cooling-solution.svg","webpack:///./app/javascript/images/eca.png","webpack:///./app/javascript/images/emergency-lighting.svg","webpack:///./app/javascript/images/facebook-image.png","webpack:///./app/javascript/images/favicon.png","webpack:///./app/javascript/images/generator.svg","webpack:///./app/javascript/images/generator-single.png","webpack:///./app/javascript/images/iso-14001.jpg","webpack:///./app/javascript/images/iso-45001.jpg","webpack:///./app/javascript/images/iso-9001.jpg","webpack:///./app/javascript/images/logo.svg","webpack:///./app/javascript/images/logo-mobile.svg","webpack:///./app/javascript/images/logo-stack.svg","webpack:///./app/javascript/images/mail.svg","webpack:///./app/javascript/images/nic.png","webpack:///./app/javascript/images/nqa.png","webpack:///./app/javascript/images/pdu.svg","webpack:///./app/javascript/images/safe-contractor.png","webpack:///./app/javascript/images/tower.png","webpack:///./app/javascript/images/transfer-switch.svg","webpack:///./app/javascript/images/ups-grayscale.jpg","webpack:///./app/javascript/images/ups-single.png","webpack:////home/deploy/paul-anton/shared/node_modules/turbolinks/dist/turbolinks.js","webpack:////home/deploy/paul-anton/shared/node_modules/sweet-scroll/sweet-scroll.js","webpack:///(webpack)/buildin/module.js","webpack:////home/deploy/paul-anton/shared/node_modules/alpinejs/dist/alpine.js","webpack:///(webpack)/buildin/harmony-module.js","webpack:////home/deploy/paul-anton/shared/node_modules/regenerator-runtime/runtime.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./app/javascript/images sync ^\\.\\/.*$","webpack:///./app/javascript/images/ups.svg","webpack:////home/deploy/paul-anton/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","_typeof","iterator","obj","constructor","this","Turbolinks","supported","window","history","pushState","requestAnimationFrame","addEventListener","visit","e","controller","clearCache","setProgressBarDelay","slice","copyObject","closest","document","documentElement","nodeType","Node","ELEMENT_NODE","parentNode","defer","setTimeout","throttle","arguments","length","apply","dispatch","a","u","target","cancelable","data","createEvent","initEvent","preventDefault","defaultPrevented","dispatchEvent","match","matchesSelector","webkitMatchesSelector","msMatchesSelector","mozMatchesSelector","uuid","Math","floor","random","toString","Location","createElement","href","absoluteURL","hash","requestURL","anchor","wrap","getOrigin","split","join","getPath","getPathComponents","getLastPathComponent","getExtension","isHTML","isPrefixedBy","isEqualTo","toCacheKey","toJSON","valueOf","_t","HttpRequest","delegate","requestCanceled","requestTimedOut","requestFailed","requestLoaded","requestProgressed","url","referrer","createXHR","NETWORK_FAILURE","TIMEOUT_FAILURE","timeout","send","xhr","sent","notifyApplicationBeforeRequestStart","setProgress","requestStarted","cancel","abort","lengthComputable","loaded","total","endRequest","status","requestCompletedWithResponse","responseText","getResponseHeader","failed","requestFailedWithStatusCode","notifyApplicationAfterRequestEnd","XMLHttpRequest","open","setRequestHeader","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","head","insertBefore","firstChild","style","width","opacity","body","removeChild","trickleInterval","setInterval","clearInterval","type","textContent","className","BrowserAdapter","showProgressBar","_t3","progressBar","visitProposedToLocationWithAction","startVisitToLocationWithAction","visitStarted","issueRequest","changeHistory","loadCachedSnapshot","visitRequestStarted","hasCachedSnapshot","action","showProgressBarAfterDelay","visitRequestProgressed","visitRequestCompleted","loadResponse","visitRequestFailedWithStatusCode","reload","visitRequestFinished","hideProgressBar","visitCompleted","followRedirect","pageInvalidated","progressBarTimeout","progressBarDelay","clearTimeout","location","_t4","History","onPageLoad","onPopState","start","started","stop","removeEventListener","push","update","replace","shouldHandlePopState","state","turbolinks","restorationIdentifier","historyPoppedToLocationWithRestorationIdentifier","pageLoaded","pageIsLoaded","readyState","HeadDetails","elements","outerHTML","tracked","fromHeadElement","childNodes","hasElementWithKey","getTrackedElementSignature","getScriptElementsNotInDetails","getElementsMatchingTypeNotInDetails","getStylesheetElementsNotInDetails","getProvisionalElements","getMetaValue","findMetaElementByName","getAttribute","tagName","toLowerCase","_e","Snapshot","headDetails","bodyElement","fromHTMLString","fromHTMLElement","innerHTML","querySelector","clone","cloneNode","getRootLocation","getSetting","getCacheControlValue","getElementForAnchor","getPermanentElements","querySelectorAll","getPermanentElementById","getPermanentElementsPresentInSnapshot","id","findFirstAutofocusableElement","hasAnchor","isPreviewable","isCacheable","isVisitable","Renderer","render","renderView","viewWillRender","newBody","viewRendered","invalidateView","viewInvalidated","createScriptElement","async","attributes","setAttribute","__super__","SnapshotRenderer","currentSnapshot","newSnapshot","isPreview","currentHeadDetails","newHeadDetails","currentBody","shouldRender","mergeHead","replaceBody","focusFirstAutofocusableElement","copyNewHeadStylesheetElements","copyNewHeadScriptElements","removeCurrentHeadProvisionalElements","copyNewHeadProvisionalElements","relocateCurrentBodyPermanentElements","activateNewBodyScriptElements","assignNewBody","replacePlaceholderElementsWithClonedPermanentElements","trackedElementsAreIdentical","getNewHeadStylesheetElements","appendChild","getNewHeadScriptElements","getCurrentHeadProvisionalElements","getNewHeadProvisionalElements","getCurrentBodyPermanentElements","element","permanentElement","getNewBodyScriptElements","focus","_t5","replaceChild","_t6","ErrorRenderer","newHead","replaceHeadAndBody","activateBodyScriptElements","getScriptElements","View","htmlElement","getSnapshot","snapshot","error","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","indexOf","splice","unshift","trim","Visit","performScroll","_t8","identifier","adapter","timingMetrics","recordTimingMetric","request","cancelRender","complete","fail","visitFailed","historyChanged","shouldIssueRequest","getCachedSnapshot","getCachedSnapshotForLocation","cacheSnapshot","visitRendered","response","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","ctrlKey","metaKey","shiftKey","nodeIsVisitable","currentScript","hasAttribute","console","warn","factory","_assign","assign","canUseDOM","canUseHistory","protocol","canUsePassiveOption","support","win","opts","isString","isFunction","isArray","Array","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","$$","selector","$","shift","isElement","Element","isWindow","$el","isRootContainer","matches","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","method","event","listener","passive","forEach","eventName","addEvent","removeEvent","reRelativeToken","parseCoordinate","coordinate","enableVertical","res","relative","parseFloat","op","val","parseInt","defaultOptions","trigger","header","duration","easing","vertical","horizontal","cancellable","updateURL","stopPropagation","before","after","step","SweetScroll","options","container","_this","ctx","$trigger","pos","startPos","loop","time","_a","startOffset","directionMap","timeElapsed","min","initial","delta","round","hook","handleClick","dataOptions","JSON","parse","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","args","_i","callbackResult","methodResult","callback","concat","toUpperCase","undefined","click","webpackPolyfill","deprecate","paths","children","global","_classCallCheck","instance","Constructor","TypeError","_defineProperties","props","descriptor","configurable","writable","_createClass","protoProps","staticProps","_slicedToArray","arr","_arrayWithHoles","_s","_arr","_n","_d","next","done","err","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","Promise","then","_asyncToGenerator","fn","self","_toConsumableArray","_arrayLikeToArray","_arrayWithoutHoles","iter","from","_iterableToArray","_nonIterableSpread","minLen","len","arr2","_defineProperty","ownKeys","enumerableOnly","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","_objectSpread2","source","getOwnPropertyDescriptors","defineProperties","arrayUnique","array","Set","isTesting","navigator","userAgent","includes","checkedAttrLooseCompare","valueA","valueB","warnIfMalformedTemplate","el","directive","content","childElementCount","camelCase","subject","char","walk","node","firstElementChild","nextElementSibling","debounce","func","wait","context","later","handleError","expression","tryCatch","cb","_ref","catch","saferEval","dataContext","additionalHelperVariables","Function","values","saferEvalNoReturn","AsyncFunction","getPrototypeOf","mark","_callee","_context","prev","methodReference","xAttrRE","isXAttr","attr","replaceAtAndColonWithStandardSyntax","getXAttrs","component","directives","map","parseHtmlAttribute","spreadDirective","spreadObject","$data","entries","_ref3","_ref4","directiveOrder","sort","typeA","typeB","sortDirectives","_ref5","normalizedName","typeMatch","valueMatch","modifiers","startsWith","convertClassStringToArray","classList","filterFn","Boolean","transitionIn","forceSkip","__x_transition","attrs","showAttr","settingBothSidesOfTransition","transitionHelperIn","index","some","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","transitionClasses","find","classesDuring","classesStart","classesEnd","originalClasses","__x_original_classes","_el$classList","add","_el$classList2","_el$classList3","_el$classList4","remove","_el$classList5","_el$classList6","finish","once","isConnected","nextFrame","Number","getComputedStyle","animationDuration","isNaN","called","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","String","iteratorMatch","handleAttributeBindingDirective","attrName","attrType","Alpine","ignoreFocusedForValueBinding","activeElement","isSameNode","checked","arrayWrappedValue","option","selected","text","updateSelect","classNames","_originalClasses","newClasses","isBooleanAttr","setIfChanged","handleTextDirective","output","handleHtmlDirective","handleShowDirective","display","__x_is_shown","removeProperty","handle","showDirectiveLastElement","contains","executeAndClearRemainingShowDirectiveStack","showDirectiveStack","handleIfDirective","expressionResult","elementHasAlreadyBeenAdded","__x_inserted_me","registerListener","_handler2","listenerTarget","runListenerHandler","isKeyEvent","isListeningForASpecificKeyThatHasntBeenPressed","nextModifier","evaluateCommandExpression","keyModifiers","debounceIndex","keyToModifier","selectedSystemKeyModifiers","modifier","generateModelAssignmentFunction","currentValue","CustomEvent","detail","newValue","safeParseNumber","multiple","selectedOptions","number","_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","_start","ReactiveMembrane","valueDistortion","objectGraph","unwrappedValue","distorted","getReactiveState","readOnly","reactive","distortedValue","reactiveState","reactiveHandler","Proxy","readOnlyHandler","Component","componentForClone","dataAttr","dataExpression","initExpression","dataExtras","canonicalComponentElementReference","magicProperties","_ref6","_ref7","unobservedData","getUnobservedData","initReturnedCallback","_this$wrapDataInObser","wrapDataInObservable","$refs","getRefsProxy","nextTickStack","$nextTick","watchers","$watch","_ref8","_ref9","onBeforeComponentInitializeds","pauseReactivity","listenForNewElementsToInitialize","onComponentInitializeds","observable","unwrappedData","copy","updateDom","mutationCallback","fullDotNotationKey","dotNotationParts","reduce","comparisonData","part","is","_this2","initializeComponentCallback","__x","rootEl","_this3","walkAndSkipNestedComponents","initializeElement","executeAndClearNextTickStack","shouldRegisterListeners","registerListeners","resolveBoundAttributes","_this4","updateElement","_this5","reverse","handler","promiseChain","promise","finishElement","_this6","_ref10","listenerExpression","rightSideOfExpression","registerModelListener","_this7","_ref11","$dispatch","getDispatchFunction","bubbles","_this8","targetNode","MutationObserver","mutations","closestParentComponent","attributeName","xAttr","rawData","addedNodes","observe","childList","subtree","ref","version","pauseMutationObserver","_callee2","_this9","_context2","discoverComponents","initializeComponent","discoverUninitializedComponents","listenForNewUninitializedComponentsAtRunTime","rootEls","_this10","newEl","addMagicProperty","onComponentInitialized","onBeforeComponentInitialized","deferLoadingAlpine","define","originalModule","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","Context","_invoke","Error","doneResult","delegateResult","maybeInvokeDelegate","ContinueSentinel","_sent","dispatchException","abrupt","record","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","result","__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","globalThis","__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","disabled","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","token","addClass","removeClass","_v","setupSlides","setupWrapper","dimention","wrapperSize","reductor","marginLeft","marginRight","collect","_Glide$settings","peekIncrementer","_clone","append","_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"],"mappings":"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","file":"js/application-43263459b10821b100d4.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 = 43);\n","module.exports = require(\"regenerator-runtime\");\n","module.exports = __webpack_public_path__ + \"media/images/ups-f617b50fde0f25aaed83d5f4ea00761d.png\";","module.exports = __webpack_public_path__ + \"media/images/24hours-fc68dc4c6a9d2fceb7755262ad1fa4ea.svg\";","module.exports = __webpack_public_path__ + \"media/images/airport-grayscale-b09a2a63c933681415630f00bcdefad8.jpg\";","module.exports = __webpack_public_path__ + \"media/images/alarm-card-797983726919b497018a6d0a465ad2d0.svg\";","module.exports = __webpack_public_path__ + \"media/images/blur-bg-f294f0fe7df99349dafe779d4b8c3074.jpg\";","module.exports = __webpack_public_path__ + \"media/images/bypass-switch-77a5db0b688180c8d685163eb9cf0f90.svg\";","module.exports = __webpack_public_path__ + \"media/images/call-51b7212775eadf1393f5d30e795dd961.svg\";","module.exports = __webpack_public_path__ + \"media/images/chas-d988f5bd44f74c86bb48d2e07ab6fe4e.png\";","module.exports = __webpack_public_path__ + \"media/images/cooling-solution-366555851149e6ccc367f957f593f7e0.svg\";","module.exports = __webpack_public_path__ + \"media/images/eca-e9f6a8ab1b467f8752c492b3a3b87dba.png\";","module.exports = __webpack_public_path__ + \"media/images/emergency-lighting-34f38e8382c194a8a044dc32d343a72d.svg\";","module.exports = __webpack_public_path__ + \"media/images/facebook-image-00e5bc8c3dc4c8d79f7de1e3ef5601a4.png\";","module.exports = __webpack_public_path__ + \"media/images/favicon-04985418ae3f9a2ffbee16100542ceb0.png\";","module.exports = __webpack_public_path__ + \"media/images/generator-adaeb922c54b5363e0c91a6e4d2976f9.svg\";","module.exports = __webpack_public_path__ + \"media/images/generator-single-e0de417f08ec695a9e7fa3c6b53d6613.png\";","module.exports = __webpack_public_path__ + \"media/images/iso-14001-227c73bf501e913dc7b75879ba79edeb.jpg\";","module.exports = __webpack_public_path__ + \"media/images/iso-45001-b01f4ddcf446d4d19fd80230dff7bb18.jpg\";","module.exports = __webpack_public_path__ + \"media/images/iso-9001-e0d3b7a8811ecb40c82f876ed80000d8.jpg\";","module.exports = __webpack_public_path__ + \"media/images/logo-25100b91a97a57ae0259db77e83583d0.svg\";","module.exports = __webpack_public_path__ + \"media/images/logo-mobile-a424333a7b4c16b040b048802e40702a.svg\";","module.exports = __webpack_public_path__ + \"media/images/logo-stack-e006ebcbeb4b48ad75f4d471edac1c3f.svg\";","module.exports = __webpack_public_path__ + \"media/images/mail-48464ab469ead179d7804232bb0b801f.svg\";","module.exports = __webpack_public_path__ + \"media/images/nic-9a7b0ff30a6ad45c98e1985f8f47e295.png\";","module.exports = __webpack_public_path__ + \"media/images/nqa-ba3191daf69e361e00eaa5366733c5af.png\";","module.exports = __webpack_public_path__ + \"media/images/pdu-21f8108f18c034027307c8c2d197bc1b.svg\";","module.exports = __webpack_public_path__ + \"media/images/safe-contractor-52af6d766ca1a875fdaaf977ae36e5e6.png\";","module.exports = __webpack_public_path__ + \"media/images/tower-79ceeb706f093793f47996f80ec52389.png\";","module.exports = __webpack_public_path__ + \"media/images/transfer-switch-43fb26d0ace7236244c0cea22b3b86bd.svg\";","module.exports = __webpack_public_path__ + \"media/images/ups-grayscale-5ad466dd31042bac7bde6115f268f552.jpg\";","module.exports = __webpack_public_path__ + \"media/images/ups-single-8206a9fa1c43655907d5f82400a8974f.png\";","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});","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};","function _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) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_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\nimport _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 _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\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) 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 checkedAttrLooseCompare(valueA, valueB) {\n    return valueA == valueB;\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 an unexpected number of root elements. Make sure <template> has a single root element. \"));\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 camelCase(subject) {\n    return subject.toLowerCase().replace(/-(\\w)/g, function (match, char) {\n      return char.toUpperCase();\n    });\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  var handleError = function handleError(el, expression, error) {\n    console.warn(\"Alpine Error: \\\"\".concat(error, \"\\\"\\n\\nExpression: \\\"\").concat(expression, \"\\\"\\nElement:\"), el);\n\n    if (!isTesting()) {\n      Object.assign(error, {\n        el: el,\n        expression: expression\n      });\n      throw error;\n    }\n  };\n\n  function tryCatch(cb, _ref) {\n    var el = _ref.el,\n        expression = _ref.expression;\n\n    try {\n      var value = cb();\n      return value instanceof Promise ? value.catch(function (e) {\n        return handleError(el, expression, e);\n      }) : value;\n    } catch (e) {\n      handleError(el, expression, e);\n    }\n  }\n\n  function saferEval(el, expression, dataContext) {\n    var additionalHelperVariables = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n    return tryCatch(function () {\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      el: el,\n      expression: expression\n    });\n  }\n\n  function saferEvalNoReturn(el, expression, dataContext) {\n    var additionalHelperVariables = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n    return tryCatch(function () {\n      if (typeof expression === 'function') {\n        return Promise.resolve(expression.call(dataContext, additionalHelperVariables['$event']));\n      }\n\n      var AsyncFunction = Function;\n      /* MODERN-ONLY:START */\n\n      AsyncFunction = Object.getPrototypeOf( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee);\n      }))).constructor;\n      /* MODERN-ONLY:END */\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      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 Promise.resolve(methodReference.call(dataContext, additionalHelperVariables['$event']));\n        } else {\n          return Promise.resolve();\n        }\n      }\n\n      return Promise.resolve(new AsyncFunction(['dataContext'].concat(_toConsumableArray(Object.keys(additionalHelperVariables))), \"with(dataContext) { \".concat(expression, \" }\")).apply(void 0, [dataContext].concat(_toConsumableArray(Object.values(additionalHelperVariables)))));\n    }, {\n      el: el,\n      expression: expression\n    });\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(el, spreadDirective.expression, component.$data); // Add x-spread directives to the pile of existing directives.\n\n      directives = directives.concat(Object.entries(spreadObject).map(function (_ref3) {\n        var _ref4 = _slicedToArray(_ref3, 2),\n            name = _ref4[0],\n            value = _ref4[1];\n\n        return parseHtmlAttribute({\n          name: name,\n          value: value\n        });\n      }));\n    }\n\n    if (type) return directives.filter(function (i) {\n      return i.type === type;\n    });\n    return sortDirectives(directives);\n  }\n\n  function sortDirectives(directives) {\n    var directiveOrder = ['bind', 'model', 'show', 'catch-all'];\n    return directives.sort(function (a, b) {\n      var typeA = directiveOrder.indexOf(a.type) === -1 ? 'catch-all' : a.type;\n      var typeB = directiveOrder.indexOf(b.type) === -1 ? 'catch-all' : b.type;\n      return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);\n    });\n  }\n\n  function parseHtmlAttribute(_ref5) {\n    var name = _ref5.name,\n        value = _ref5.value;\n    var normalizedName = replaceAtAndColonWithStandardSyntax(name);\n    var typeMatch = normalizedName.match(xAttrRE);\n    var valueMatch = normalizedName.match(/:([a-zA-Z0-9\\-:]+)/);\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  var TRANSITION_TYPE_IN = 'in';\n  var TRANSITION_TYPE_OUT = 'out';\n  var TRANSITION_CANCELLED = 'cancelled';\n\n  function transitionIn(el, show, reject, component) {\n    var forceSkip = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return show();\n\n    if (el.__x_transition && el.__x_transition.type === TRANSITION_TYPE_IN) {\n      // there is already a similar transition going on, this was probably triggered by\n      // a change in a different property, let's just leave the previous one doing its job\n      return;\n    }\n\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, reject); // Otherwise, we can assume x-transition:enter.\n    } else if (attrs.some(function (attr) {\n      return ['enter', 'enter-start', 'enter-end'].includes(attr.value);\n    })) {\n      transitionClassesIn(el, component, attrs, show, reject);\n    } else {\n      // If neither, just show that damn thing.\n      show();\n    }\n  }\n\n  function transitionOut(el, hide, reject, component) {\n    var forceSkip = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return hide();\n\n    if (el.__x_transition && el.__x_transition.type === TRANSITION_TYPE_OUT) {\n      // there is already a similar transition going on, this was probably triggered by\n      // a change in a different property, let's just leave the previous one doing its job\n      return;\n    }\n\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, reject);\n    } else if (attrs.some(function (attr) {\n      return ['leave', 'leave-start', 'leave-end'].includes(attr.value);\n    })) {\n      transitionClassesOut(el, component, attrs, hide, reject);\n    } else {\n      hide();\n    }\n  }\n\n  function transitionHelperIn(el, modifiers, showCallback, reject) {\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 () {}, reject, styleValues, TRANSITION_TYPE_IN);\n  }\n\n  function transitionHelperOut(el, modifiers, settingBothSidesOfTransition, hideCallback, reject) {\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, reject, styleValues, TRANSITION_TYPE_OUT);\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, reject, styleValues, type) {\n    // clear the previous transition if exists to avoid caching the wrong styles\n    if (el.__x_transition) {\n      el.__x_transition.cancel && el.__x_transition.cancel();\n    } // If the user set these style values, we'll put them back when we're done with them.\n\n\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, type, reject);\n  }\n\n  var ensureStringExpression = function ensureStringExpression(expression, el, component) {\n    return typeof expression === 'function' ? component.evaluateReturnExpression(el, expression) : expression;\n  };\n\n  function transitionClassesIn(el, component, directives, showCallback, reject) {\n    var enter = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'enter';\n    }) || {\n      expression: ''\n    }).expression, el, component));\n    var enterStart = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'enter-start';\n    }) || {\n      expression: ''\n    }).expression, el, component));\n    var enterEnd = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'enter-end';\n    }) || {\n      expression: ''\n    }).expression, el, component));\n    transitionClasses(el, enter, enterStart, enterEnd, showCallback, function () {}, TRANSITION_TYPE_IN, reject);\n  }\n\n  function transitionClassesOut(el, component, directives, hideCallback, reject) {\n    var leave = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'leave';\n    }) || {\n      expression: ''\n    }).expression, el, component));\n    var leaveStart = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'leave-start';\n    }) || {\n      expression: ''\n    }).expression, el, component));\n    var leaveEnd = convertClassStringToArray(ensureStringExpression((directives.find(function (i) {\n      return i.value === 'leave-end';\n    }) || {\n      expression: ''\n    }).expression, el, component));\n    transitionClasses(el, leave, leaveStart, leaveEnd, function () {}, hideCallback, TRANSITION_TYPE_OUT, reject);\n  }\n\n  function transitionClasses(el, classesDuring, classesStart, classesEnd, hook1, hook2, type, reject) {\n    // clear the previous transition if exists to avoid caching the wrong classes\n    if (el.__x_transition) {\n      el.__x_transition.cancel && el.__x_transition.cancel();\n    }\n\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, type, reject);\n  }\n\n  function transition(el, stages, type, reject) {\n    var finish = once(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\n      delete el.__x_transition;\n    });\n    el.__x_transition = {\n      // Set transition type so we can avoid clearing transition if the direction is the same\n      type: type,\n      // create a callback for the last stages of the transition so we can call it\n      // from different point and early terminate it. Once will ensure that function\n      // is only called one time.\n      cancel: once(function () {\n        reject(TRANSITION_CANCELLED);\n        finish();\n      }),\n      finish: finish,\n      // This store the next animation frame so we can cancel it\n      nextFrame: null\n    };\n    stages.start();\n    stages.during();\n    el.__x_transition.nextFrame = 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      el.__x_transition.nextFrame = requestAnimationFrame(function () {\n        stages.end();\n        setTimeout(el.__x_transition.finish, duration);\n      });\n    });\n  }\n\n  function isNumeric(subject) {\n    return !Array.isArray(subject) && !isNaN(subject);\n  } // Thanks @vuejs\n  // https://github.com/vuejs/vue/blob/4de4649d9637262a9b007720b59f80ac72a5620c/src/shared/util.js\n\n\n  function once(callback) {\n    var called = false;\n    return function () {\n      if (!called) {\n        called = true;\n        callback.apply(this, arguments);\n      }\n    };\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 () {}, 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 = String(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    var items = component.evaluateReturnExpression(el, iteratorNames.items, extraVars); // This adds support for the `i in n` syntax.\n\n    if (isNumeric(items) && items >= 0) {\n      items = Array.from(Array(items).keys(), function (i) {\n        return i + 1;\n      });\n    }\n\n    return items;\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 we are already past the x-for generated elements, we don't need to look ahead.\n\n    if (nextEl.__x_for_key === undefined) 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      }, function () {}, 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, modifiers) {\n    var value = component.evaluateReturnExpression(el, expression, extraVars);\n\n    if (attrName === 'value') {\n      if (Alpine.ignoreFocusedForValueBinding && document.activeElement.isSameNode(el)) return; // If nested model key is undefined, set the default value to empty string.\n\n      if (value === undefined && String(expression).match(/\\./)) {\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 = checkedAttrLooseCompare(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 !== 'boolean' && ![null, undefined].includes(value) && attrType === 'bind') {\n          el.value = String(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 checkedAttrLooseCompare(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 = value ? convertClassStringToArray(value) : [];\n        el.setAttribute('class', arrayUnique(_originalClasses.concat(newClasses)).join(' '));\n      }\n    } else {\n      attrName = modifiers.includes('camel') ? camelCase(attrName) : attrName; // If an attribute's bound value is null, undefined or false, remove the attribute\n\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 && String(expression).match(/\\./)) {\n      output = '';\n    }\n\n    el.textContent = 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      el.__x_is_shown = false;\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      el.__x_is_shown = true;\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, reject) {\n      if (value) {\n        if (el.style.display === 'none' || el.__x_transition) {\n          transitionIn(el, function () {\n            show();\n          }, reject, component);\n        }\n\n        resolve(function () {});\n      } else {\n        if (el.style.display !== 'none') {\n          transitionOut(el, function () {\n            resolve(function () {\n              hide();\n            });\n          }, reject, 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      }, function () {});\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 || el.__x_transition)) {\n      var clone = document.importNode(el.content, true);\n      el.parentElement.insertBefore(clone, el.nextElementSibling);\n      transitionIn(el.nextElementSibling, function () {}, 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      }, function () {}, 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    var options = {\n      passive: modifiers.includes('passive')\n    };\n\n    if (modifiers.includes('camel')) {\n      event = camelCase(event);\n    }\n\n    var _handler2, listenerTarget;\n\n    if (modifiers.includes('away')) {\n      listenerTarget = document;\n\n      _handler2 = function handler(e) {\n        // Don't do anything if the click came from 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, _handler2, options);\n        }\n      };\n    } else {\n      listenerTarget = modifiers.includes('window') ? window : modifiers.includes('document') ? document : el;\n\n      _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, options);\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          returnValue.then(function (value) {\n            if (value === false) {\n              e.preventDefault();\n            } else {\n              if (modifiers.includes('once')) {\n                listenerTarget.removeEventListener(event, _handler2, options);\n              }\n            }\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, options);\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 (el) {\n            return !checkedAttrLooseCompare(el, 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 componentForClone = 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      var dataExtras = {\n        $el: this.$el\n      };\n      var canonicalComponentElementReference = componentForClone ? componentForClone.$el : this.$el;\n      Object.entries(Alpine.magicProperties).forEach(function (_ref6) {\n        var _ref7 = _slicedToArray(_ref6, 2),\n            name = _ref7[0],\n            callback = _ref7[1];\n\n        Object.defineProperty(dataExtras, \"$\".concat(name), {\n          get: function get() {\n            return callback(canonicalComponentElementReference);\n          }\n        });\n      });\n      this.unobservedData = componentForClone ? componentForClone.getUnobservedData() : saferEval(el, dataExpression, dataExtras); // 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      /* MODERN-ONLY:START */\n      // We remove this piece of code from the legacy build.\n      // In IE11, we have already defined our helpers at this point.\n      // Register custom magic properties.\n\n\n      Object.entries(Alpine.magicProperties).forEach(function (_ref8) {\n        var _ref9 = _slicedToArray(_ref8, 2),\n            name = _ref9[0],\n            callback = _ref9[1];\n\n        Object.defineProperty(_this.unobservedData, \"$\".concat(name), {\n          get: function get() {\n            return callback(canonicalComponentElementReference, this.$el);\n          }\n        });\n      });\n      /* MODERN-ONLY:END */\n\n      this.showDirectiveStack = [];\n      this.showDirectiveLastElement;\n      componentForClone || Alpine.onBeforeComponentInitializeds.forEach(function (callback) {\n        return callback(_this);\n      });\n      var initReturnedCallback; // If x-init is present AND we aren't cloning (skip x-init on clone)\n\n      if (initExpression && !componentForClone) {\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      // If we're cloning a component, the third parameter ensures no duplicate\n      // event listeners are registered (the mutation observer will take care of them)\n\n\n      this.initializeElements(this.$el, function () {}, componentForClone); // 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      componentForClone || setTimeout(function () {\n        Alpine.onComponentInitializeds.forEach(function (callback) {\n          return callback(_this);\n        });\n      }, 0);\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 if (Array.isArray(target)) {\n            // Arrays are special cases, if any of the items change, we consider the array as mutated.\n            Object.keys(self.watchers).forEach(function (fullDotNotationKey) {\n              var dotNotationParts = fullDotNotationKey.split('.'); // Ignore length mutations since they would result in duplicate calls.\n              // For example, when calling push, we would get a mutation for the item's key\n              // and a second mutation for the length property.\n\n              if (key === 'length') return;\n              dotNotationParts.reduce(function (comparisonData, part) {\n                if (Object.is(target, comparisonData[part])) {\n                  self.watchers[fullDotNotationKey].forEach(function (callback) {\n                    return callback(target);\n                  });\n                }\n\n                return comparisonData[part];\n              }, self.unobservedData);\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.unobservedData);\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        var componentForClone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\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, componentForClone ? false : true);\n        }, function (el) {\n          if (!componentForClone) 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        var shouldRegisterListeners = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n\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        shouldRegisterListeners && 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 (handler) {\n          return new Promise(function (resolve, reject) {\n            handler(resolve, reject);\n          });\n        }).reduce(function (promiseChain, promise) {\n          return promiseChain.then(function () {\n            return promise.then(function (finishElement) {\n              finishElement();\n            });\n          });\n        }, Promise.resolve(function () {})).catch(function (e) {\n          if (e !== TRANSITION_CANCELLED) throw e;\n        }); // 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 (_ref10) {\n          var type = _ref10.type,\n              value = _ref10.value,\n              modifiers = _ref10.modifiers,\n              expression = _ref10.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        attrs.forEach(function (_ref11) {\n          var type = _ref11.type,\n              value = _ref11.value,\n              modifiers = _ref11.modifiers,\n              expression = _ref11.expression;\n\n          switch (type) {\n            case 'model':\n              handleAttributeBindingDirective(_this7, el, 'value', expression, extraVars, type, modifiers);\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, modifiers);\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.some(function (i) {\n                return i.type === 'for';\n              })) 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(el, 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(el, 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 xAttr = mutations[i].target.getAttribute('x-data') || '{}';\n                var rawData = saferEval(_this8.$el, xAttr, {\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.8.2\",\n    pauseMutationObserver: false,\n    magicProperties: {},\n    onComponentInitializeds: [],\n    onBeforeComponentInitializeds: [],\n    ignoreFocusedForValueBinding: false,\n    start: function () {\n      var _start = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n        var _this9 = this;\n\n        return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                if (isTesting()) {\n                  _context2.next = 3;\n                  break;\n                }\n\n                _context2.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();\n\n              case 6:\n              case \"end\":\n                return _context2.stop();\n            }\n          }\n        }, _callee2, 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() {\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);\n      }\n    },\n    addMagicProperty: function addMagicProperty(name, callback) {\n      this.magicProperties[name] = callback;\n    },\n    onComponentInitialized: function onComponentInitialized(callback) {\n      this.onComponentInitializeds.push(callback);\n    },\n    onBeforeComponentInitialized: function onBeforeComponentInitialized(callback) {\n      this.onBeforeComponentInitializeds.push(callback);\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 define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\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  define(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 = GeneratorFunctionPrototype;\n  define(Gp, \"constructor\", GeneratorFunctionPrototype);\n  define(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction);\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\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      define(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      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\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  define(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  define(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  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(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, in modern engines\n  // we can explicitly access globalThis. In older engines 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  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","var map = {\n\t\"./24hours\": 2,\n\t\"./24hours.svg\": 2,\n\t\"./airport-grayscale\": 3,\n\t\"./airport-grayscale.jpg\": 3,\n\t\"./alarm-card\": 4,\n\t\"./alarm-card.svg\": 4,\n\t\"./blur-bg\": 5,\n\t\"./blur-bg.jpg\": 5,\n\t\"./bypass-switch\": 6,\n\t\"./bypass-switch.svg\": 6,\n\t\"./call\": 7,\n\t\"./call.svg\": 7,\n\t\"./chas\": 8,\n\t\"./chas.png\": 8,\n\t\"./cooling-solution\": 9,\n\t\"./cooling-solution.svg\": 9,\n\t\"./eca\": 10,\n\t\"./eca.png\": 10,\n\t\"./emergency-lighting\": 11,\n\t\"./emergency-lighting.svg\": 11,\n\t\"./facebook-image\": 12,\n\t\"./facebook-image.png\": 12,\n\t\"./favicon\": 13,\n\t\"./favicon.png\": 13,\n\t\"./generator\": 14,\n\t\"./generator-single\": 15,\n\t\"./generator-single.png\": 15,\n\t\"./generator.svg\": 14,\n\t\"./iso-14001\": 16,\n\t\"./iso-14001.jpg\": 16,\n\t\"./iso-45001\": 17,\n\t\"./iso-45001.jpg\": 17,\n\t\"./iso-9001\": 18,\n\t\"./iso-9001.jpg\": 18,\n\t\"./logo\": 19,\n\t\"./logo-mobile\": 20,\n\t\"./logo-mobile.svg\": 20,\n\t\"./logo-stack\": 21,\n\t\"./logo-stack.svg\": 21,\n\t\"./logo.svg\": 19,\n\t\"./mail\": 22,\n\t\"./mail.svg\": 22,\n\t\"./nic\": 23,\n\t\"./nic.png\": 23,\n\t\"./nqa\": 24,\n\t\"./nqa.png\": 24,\n\t\"./pdu\": 25,\n\t\"./pdu.svg\": 25,\n\t\"./safe-contractor\": 26,\n\t\"./safe-contractor.png\": 26,\n\t\"./tower\": 27,\n\t\"./tower.png\": 27,\n\t\"./transfer-switch\": 28,\n\t\"./transfer-switch.svg\": 28,\n\t\"./ups\": 1,\n\t\"./ups-grayscale\": 29,\n\t\"./ups-grayscale.jpg\": 29,\n\t\"./ups-single\": 30,\n\t\"./ups-single.png\": 30,\n\t\"./ups.png\": 1,\n\t\"./ups.svg\": 42\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 = 41;","module.exports = __webpack_public_path__ + \"media/images/ups-affe300736dcaaef347ea271fb636e03.svg\";","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 Turbolinks from 'turbolinks'\nimport Glide from '@glidejs/glide'\nimport SweetScroll from 'sweet-scroll'\nimport 'alpinejs'\nimport 'typeface-open-sans'\nimport 'typeface-titillium-web'\n\nimport '../css/application.scss'\nrequire.context('../images', true)\n\nTurbolinks.start()\n\ndocument.addEventListener('turbolinks:load', function () {\n  if (document.querySelector(\"[data-glide='clients']\")) {\n    new Glide(\n        \"[data-glide='clients']\", {\n            type: 'carousel',\n            autoplay: 2000,\n            animationDuration: 6000,\n        }).mount();\n  }\n\n  if (document.querySelector(\"[data-glide='products']\")) {\n    new Glide(\n        \"[data-glide='products']\", {\n            type: 'carousel',\n            autoplay: 2000,\n            animationDuration: 6000,\n        }).mount();\n  }\n\n  new SweetScroll()\n})\n"],"sourceRoot":""}