{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///audi-ui.min.js","webpack:///webpack/bootstrap 9f4e75109a8376f38dab","webpack:///./src/index.js","webpack:///./src/alert/alert.js","webpack:///./src/component/component.js","webpack:///./src/util/resize-observer.js","webpack:///./src/util/signal.js","webpack:///./src/audioplayer/audioplayer.js","webpack:///./src/popover/popover.js","webpack:///./src/util/reflow.js","webpack:///./src/util/closest.js","webpack:///./src/util/transition-end-event.js","webpack:///./~/tether/dist/js/tether.js","webpack:///./src/breadcrumb/breadcrumb.js","webpack:///./src/checkbox/checkbox.js","webpack:///./src/dropdown/dropdown.js","webpack:///./src/flyout/flyout.js","webpack:///./src/header/header.js","webpack:///./src/util/scroll-observer.js","webpack:///./src/modal/modal.js","webpack:///./src/modal/modal-default.js","webpack:///./src/modal/modal-dialog.js","webpack:///./src/modal/modal-morph.js","webpack:///./src/nav/nav.js","webpack:///./src/nav/nav-bar.js","webpack:///./src/util/scroll-observer-element.js","webpack:///./src/util/limit.js","webpack:///./src/nav/nav-dropdown.js","webpack:///./src/sticky/sticky.js","webpack:///./src/util/is-none.js","webpack:///./src/nav/nav-list.js","webpack:///./src/notification/notification.js","webpack:///./src/pagination/pagination.js","webpack:///./src/player/player.js","webpack:///./src/progress/progress.js","webpack:///./src/radio/radio.js","webpack:///./src/response/response.js","webpack:///./src/util/animation-end-event.js","webpack:///./src/select/select.js","webpack:///./src/slider/slider.js","webpack:///./src/util/map-linear.js","webpack:///./~/nouislider/distribute/nouislider.js","webpack:///./src/indicator/indicator.js","webpack:///./src/util/clamp.js","webpack:///./src/spinner/spinner.js","webpack:///./src/util/object-resize.js","webpack:///./~/bezier-easing/src/index.js","webpack:///./src/textfield/textfield.js","webpack:///./src/tooltip/tooltip.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","_interopRequireDefault","obj","__esModule","default","_classCallCheck","instance","Constructor","TypeError","Object","defineProperty","value","Tooltip","Textfield","Spinner","Indicator","Slider","Select","Response","Radio","Progress","Popover","Player","Pagination","Notification","Nav","Modal","Header","Flyout","Dropdown","Checkbox","Breadcrumb","Audioplayer","Alert","undefined","_alert","_alert2","_audioplayer","_audioplayer2","_breadcrumb","_breadcrumb2","_checkbox","_checkbox2","_dropdown","_dropdown2","_flyout","_flyout2","_header","_header2","_modal","_modal2","_nav","_nav2","_notification","_notification2","_pagination","_pagination2","_player","_player2","_popover","_popover2","_progress","_progress2","_radio","_radio2","_response","_response2","_select","_select2","_slider","_slider2","_indicator","_indicator2","_spinner","_spinner2","_textfield","_textfield2","_tooltip","_tooltip2","ComponentHandler","document","createElement","window","Array","prototype","forEach","documentElement","classList","add","upgradeAllElements","upgradeElements","componentHandler","_possibleConstructorReturn","self","ReferenceError","_inherits","subClass","superClass","create","constructor","enumerable","writable","configurable","setPrototypeOf","__proto__","_component","_component2","_resizeObserver","_resizeObserver2","SELECTOR_COMPONENT","CLASS_CONTENT","CLASS_CLOSE_BUTTON","CLASS_IS_CLOSED","CLASS_IS_OPEN","ATTR_CLOSE","ATTR_OPENDELAY","_Component","element","components","from","querySelectorAll","Component","isElementUpgraded","push","init","_this2","_content","_element","querySelector","_closeButton","setAttribute","appendChild","hasAttribute","delay","parseInt","getAttribute","openingTimeout","setTimeout","open","ResizeObserver","resized","_resizedHandler","update","animate","_this3","addEventListener","_clickHandler","event","_onClick","_animateOpen","remove","_this4","clearTimeout","getComputedStyle","height","style","requestAnimationFrame","close","removeEventListener","offsetHeight","_animateClose","_this5","target","contains","dispose","removeChild","resizeObserver","_createClass","defineProperties","props","i","length","descriptor","key","protoProps","staticProps","CLASS_IS_UPGRADED","SVG_NS","namespace","childNode","parentNode","isIE","removeNode","tagName","classes","attributes","apply","attr","createSvgNode","qualifiedName","createElementNS","setAttributeNS","ua","navigator","userAgent","msie","indexOf","trident","get","_signal","_signal2","_this","_ticking","Signal","_resizeHandler","_onResize","dispatch","SignalBinding","signal","listener","isOnce","priority","_listener","_isOnce","_priority","_active","_isBound","execute","params","handlerReturn","_context","detach","toString","isBound","_bindings","_prevParams","_validateListener","_registerListener","addOnce","_indexOfListener","splice","removeAll","n","has","slice","arguments","bindings","prevIndex","binding","Error","_addBinding","memorize","fnName","current","formatCurrentTime","currentTime","Math","floor","currentTrack","scrobble","embed","preload","tracks","JSON","parse","cancelProgress","next","pause","updateProgress","innerHTML","duration","play","isPlaying","mute","isMuted","unmute","previous","slider","noUiSlider","on","abs","muted","paused","restartPlayback","src","load","set","title","cover","tick","cancelAnimationFrame","_reflow","_reflow2","_closest","_closest2","_transitionEndEvent","_transitionEndEvent2","_tether","_tether2","SELECTOR_DISMISS","CLASS_ARROW","CLASS_ARROW_SHAPE","CLASS_ACTIVE","CLASS_SHOWN","CLASS_POPOVER_IS_OPEN","ARROW_SIZE","AttachmentMap","top","right","bottom","left","_body","_id","_trigger","getElementById","placement","_attachement","toLowerCase","content","arrowColor","backgroundColor","_arrow","_addArrow","_boundClickHandler","toggle","hide","performToggle","show","preventDefault","Tether","currentTarget","attachment","classPrefix","offset","constraints","to","pin","optimizations","gpu","position","_boundWindowClickHandler","_onClickOutside","transitionend","_boundAnimationendHandler","_onHideComplete","_cleanupTether","destroy","removeAttribute","parent","color","svg","class","width","viewBox","path","d","fill","reflow","Function","closest","selector","context","matchesFn","some","fn","body","parentElement","whichTransitionEvent","t","el","transitions","transition","OTransition","MozTransition","WebkitTransition","TRANSITION_EVENT","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","getActualBoundingClientRect","node","boundingRect","getBoundingClientRect","rect","k","ownerDocument","_frameElement","defaultView","frameElement","frameRect","getScrollParents","computedStyle","parents","nodeType","err","_style","overflow","overflowX","overflowY","test","removeUtilElements","zeroElement","getBounds","doc","docEl","box","origin","getOrigin","scrollWidth","scrollHeight","clientTop","clientLeft","clientWidth","clientHeight","getOffsetParent","offsetParent","getScrollBarSize","_scrollBarSize","inner","outer","extend","pointerEvents","visibility","widthContained","offsetWidth","widthScroll","out","args","hasOwnProperty","removeClass","name","split","cls","trim","regex","RegExp","join","className","getClassName","replace","setClassName","addClass","hasClass","SVGAnimatedString","baseVal","updateClasses","all","within","a","b","diff","now","performance","Date","addOffset","_len","offsets","_key","_ref","parseFloat","offsetToPx","size","getBoundingRect","tether","scrollParents","pageXOffset","pageYOffset","innerWidth","innerHeight","pos","win","BOUNDS_FORMAT","side","toUpperCase","substr","TetherBase","uniqueId","zeroPosCache","defer","deferred","flush","pop","Evented","handler","ctx","once","_bindings$event$i","Utils","_slicedToArray","sliceIterator","arr","_arr","_n","_d","_e","_s","_i","Symbol","iterator","done","isArray","_get","_x6","_x7","_x8","_again","object","property","receiver","desc","getOwnPropertyDescriptor","getter","getPrototypeOf","_TetherBase$Utils","transformKey","transforms","tethers","lastCall","lastDuration","pendingTimeout","min","MIRROR_LR","center","MIRROR_TB","middle","OFFSET_MAP","autoToFixedAttachment","relativeToAttachment","attachmentToOffset","parseOffset","_value$split","_value$split2","parseAttachment","TetherClass","_Evented","options","bind","history","setOptions","initialize","defaults","targetOffset","targetAttachment","_options","targetModifier","jquery","getClass","addTargetClasses","disable","enabled","enable","bounds","hasBottomScroll","scrollBottom","borderTopWidth","borderBottomWidth","borderLeftWidth","fitAdj","pow","max","scrollPercentage","scrollTop","_cache","elementAttach","targetAttach","_this6","sides","_addAttachClasses","_this7","flushChanges","clearCache","updateAttachClasses","elementPos","cache","lastSize","_lastSize","targetPos","getTargetBounds","targetSize","manualOffset","manualTargetOffset","_module2","ret","scrollbarSize","page","viewport","moveElement","offsetPosition","offsetParentStyle","offsetParentSize","offsetBorder","scrollLeft","move","unshift","_this8","same","type","found","point","css","transcribe","_same","_pos","hasOptimizations","yPos","xPos","matchMedia","retina","matches","round","moved","bodyElement","offsetParentIsBody","currentNode","writeCSS","write","val","elVal","trigger","targetHeight","targetWidth","allClasses","constraint","outOfBoundsClass","pinnedClass","addClasses","tAttachment","eAttachment","changeAttachX","changeAttachY","_attachment$split","_attachment$split2","map","pinned","oob","oobClass","abutted","targetPosSide","shift","shiftTop","shiftLeft","_shift","_shift2","CLASS_ITEMS","CLASS_IS_OVERSIZED","_items","_checkSize","NAMESPACE","CLASS_INPUT","CLASS_LABEL","CLASS_BOX","CLASS_TICK","CLASS_IS_FOCUS","CLASS_IS_CHECKED","CLASS_IS_DISABLED","container","auiCheckbox","_input","_changeHandler","_onChange","_focusHandler","_onFocus","_blurHandler","_onBlur","_label","insertBefore","nextSibling","checkDisabled","checkToggleState","checkFocus","disabled","checked","Boolean","check","uncheck","SELECTOR_OPTION_INPUT","CLASS_ANIMATED_LIST_ITEMS","CLASS_VALUE","CLASS_FOCUS_LINE","CLASS_OPTION","CLASS_MULTIPLE","CLASS_IS_DIRTY","CLASS_IS_ACTIVE","multiple","_isActive","_valueField","_inputHandler","_onInput","_resetHandler","_onReset","itemsAnimated","transitionDelay","webkitTransitionDelay","focusLine","optionClicked","option","_getOptionValue","updateInput","values","input","_getOptionTitle","_clickHandlerWindow","toggleOpen","checkDirty","isOption","currentElement","checkbox","CLASS_TOGGLE","CLASS_TRIANGLE","CLASS_HEADER","CLASS_PANEL","CLASS_FLYOUT_IS_OPEN","TOGGLE_THRESHOLD","_activationTime","_toggle","_panel","_triangle","_closeBtn","_boundClickClose","_onClickClose","_boundClickToggle","_onClickToggle","_boundClickWindow","_boundTouchendWindow","_onTouchOutside","elapsed","_onMouseEnter","clientX","_onMouseLeave","_onTouch","stopPropagation","_scrollObserver","_scrollObserver2","CLASS_STICKYABLE","CLASS_IS_STICKY","ScrollObserver","scrolled","_scrollHandler","checkStickiness","_sticky","stick","release","SCROLL_END_THRESHOLD","_scrollX","_scrollY","scrollEnded","scrollHandler","onScroll","scrollX","scrollY","_scrollEndTimeout","_modalDefault","_modalDefault2","_modalMorph","_modalMorph2","CLASS_MORPH","modalComponents","currentModal","getModalById","closeCurrentModal","_decorator","ModalMorph","ModalDefault","_modalDialog","_modalDialog2","CLASS_MODAL_IS_OPEN","CLASS_WINDOW","CLASS_DIALOG_BODY","_ModalDialog","_addBackdrop","_dialogBody","_repositionCloseButton","_prepareOpenTransition","_backdrop","transitionendEvent","_backdropCloseTransitionendHandler","_onBackdropCloseTransitionend","ModalDialog","CLOSE_BUTTON_SIZE_SMALL","CLOSE_BUTTON_SIZE_LARGE","CLOSE_ICON_SIZE_SMALL","CLOSE_ICON_SIZE_LARGE","CLASS_BACKDROP","CLASS_CLOSE","_addCloseButton","_removeBackdrop","diagonalHalf","sqrt","btnSize","small","group","transform","x1","y1","x2","y2","stroke","large","CLASS_MORPH_DIALOG","CLASS_IS_MORPHING","console","log","_morph","_getMorphElement","_startOpenTransition","_applyBoundingRectToElement","_boundTransitionendElementIn","_onTransitionendElementIn","_boundTransitionendMorphOut","_onTransitionendMorphOut","_startCloseTransition","_onMorpBodyCloseTransitionend","_morphBody","_morpBodyCloseTransitionendHandler","append","_navBar","_navBar2","_navDropdown","_navDropdown2","_navList","_navList2","CLASS_LIST","CLASS_BAR","CLASS_TAB","CLASS_DROPDOWN","_originModifier","MODIFIER_BAR","MODIFIER_TAB","MODIFIER_DROPDOWN","MODIFIER_LIST","_layoutBreakpoint","getPropertyValue","_boundResize","_resized","setModifier","modifier","_modifier","NavBar","NavDropdown","NavList","viewportWidth","index","_scrollObserverElement","_scrollObserverElement2","_limit","_limit2","CLASS_ACTION","CLASS_INDICATOR","CLASS_PADDLES","CLASS_PADDLE_LEFT","CLASS_PADDLE_RIGHT","CLASS_IS_ANIMATED","SHOW_INDICATOR_DELAY","INDICATOR_HIDDEN_X","INDICATOR_HIDDEN_WIDTH","SCROLL_THRESHOLD","SCROLL_PADDING","SCROLL_EASING","_actionElements","_paddles","_paddleLeft","_addPaddle","_paddleRight","ScrollObserverElement","_onScrollElement","setActive","_scrollActive","_updatePaddleVisibility","setActiveByIndex","activeTarget","item","indicatorLeft","indicatorWidth","containerBounds","rectTarget","_index","scroll","scrollRight","dir","elementBounds","elementLeft","ceil","elementRight","_animateScroll","_scrollStart","_scrollDelta","_scrollRatio","_animateScrollTick","ratio","cssClass","paddle","_onScroll","limit","x","_sticky2","_isNone","_isNone2","CLASS_UNDERLINE","CLASS_ITEM","CLASS_TOGGLE_LABEL","CLASS_STICKY","_actions","_toggleLabel","_underline","_stickyHandler","Sticky","force","isNone","active","checkOpeningPreparation","marginTop","marginBottom","checkClosingPreparation","_boundResized","_boundClick","_repositionIndicator","linkElement","rectContainer","SELECTOR_PROGRESS_CONTROL","SELECTOR_SEEK_HOLDER","SELECTOR_PREVIEW","CLASS_SEEKING","_progressControl","progressControlOverListener","progressControlOverHandler","progressControlOutListener","progressControlOutHandler","_seekHolder","_preview","moveListener","progressControlMoveListener","progressControlMoveHandler","updateSeek","boundings","offsetX","ratioPercentStr","CLASS_CONTINUOUS","CLASS_IS_PENDING","CLASS_IS_LOADING","CLASS_IS_COMPLETE","_continuous","_bar","progress","_radios","groupName","button","_animationEndEvent","_animationEndEvent2","CLASS_BUTTON_PRIMARY","CLASS_BUTTON_SECONDARY","CLASS_BUTTON_ICON","CLASS_BUTTON_FLOATING","CLASS_RESPONSE","CLASS_RESPONSE_MASKED","CLASS_EFFECT","CLASS_EFFECT_LARGE","CLASS_IS_ANIMATING","boxedButton","_useTriggerX","_useTriggerY","_masked","_large","_responseContainer","_responseEffect","_mousedownHandler","_onMousedown","animationEndEvent","_animationendHandler","_onAnimationend","srcElement","offsetY","clientY","whichAnimationEvent","animations","animation","OAnimation","MozAnimation","WebkitAnimation","ANIMATION_EVENT","selectedIndex","_typeof","_mapLinear","_mapLinear2","_nouislider","_nouislider2","SELECTOR_HIDDEN_FIELD","SELECTOR_OUTPUT","CLASS_COMPONENT","EVENT_NAMESPACE","_hiddenField","_output","firstChild","_value","_parseData","_rangeMin","_rangeMax","start","range","connect","behaviour","cssPrefix","handle","unencoded","tap","positions","_onUpdate","_centerOutput","off","sliderAverage","reduce","previousValue","currentValue","maxRight","handleSize","mapLinear","a1","a2","b1","b2","addNodeTo","div","unique","array","filter","elem","orientation","docElem","pageOffset","getPageOffset","y","isNumeric","isNaN","isFinite","addClassFor","asArray","countDecimals","numStr","String","pieces","supportPageOffset","isCSS1Compat","compatMode","getActions","pointerEnabled","end","msPointerEnabled","subRangeRatio","pa","pb","fromPercentage","toPercentage","isPercentage","getJ","j","toStepping","xVal","xPct","va","vb","fromStepping","getStep","xSteps","snap","handleEntryPoint","that","percentage","VERSION","xHighestCompleteStep","handleStepPoint","totalSteps","xNumSteps","highestStep","Number","toFixed","step","Spectrum","entry","direction","singleStep","ordered","sort","testStep","parsed","testRange","spectrum","testStart","handles","testSnap","testAnimate","testAnimationDuration","animationDuration","testConnect","testOrientation","ort","testMargin","margin","getMargin","testLimit","testPadding","padding","testDirection","testBehaviour","drag","fixed","hover","events","testTooltips","tooltips","formatter","testFormat","format","testCssPrefix","testCssClasses","cssClasses","testUseRaf","useRequestAnimationFrame","testOptions","defaultFormatter","tests","r","base","handleLower","handleUpper","horizontal","vertical","background","ltr","rtl","draggable","tooltip","pips","pipsHorizontal","pipsVertical","marker","markerHorizontal","markerVertical","markerNormal","markerLarge","markerSub","valueHorizontal","valueVertical","valueNormal","valueLarge","valueSub","keys","styles","styleOposite","closure","originalOptions","addOrigin","handleNumber","addConnect","addElements","connectOptions","scope_Handles","scope_Connects","scope_HandleNumbers","addSlider","scope_Base","addTooltip","tips","bindEvent","formattedValue","getGroup","mode","stepped","scope_Spectrum","v","spread","generateSpread","density","safeIncrement","increment","indexes","firstInRange","lastInRange","ignoreFirst","ignoreLast","prevPct","q","newPct","pctDifference","pctPos","steps","realSteps","stepsize","low","high","addMarking","filterFunc","getClasses","source","orientationClasses","valueOrientationClasses","markerOrientationClasses","sizeClasses","valueSizeClasses","markerSizeClasses","getTags","addSpread","grid","scope_Target","baseSize","alt","attachEvent","callback","data","method","e","fixEvent","actions","buttons","calcPoint","points","methods","eventName","touch","mouse","pointer","touches","changedTouches","pageX","pageY","cursor","calcPointToPercentage","location","proposal","getClosestHandle","scope_Locations","moveHandles","upward","locations","handleNumbers","proposals","f","reverse","o","checkHandlePosition","state","setHandle","fireEvent","scope_Events","targetEvent","eventType","scope_Self","scope_Values","documentLeave","nodeName","relatedTarget","eventEnd","eventMove","appVersion","buttonsProperty","movement","startCalcPoint","scope_ActiveHandle","noUiListener","noUiListeners","setZindex","eventStart","children","moveEvent","endEvent","outEvent","concat","eventTap","eventHover","bindSliderEvents","handleBefore","handleAfter","eventHolders","eventHolder","reference","lookBackward","lookForward","toPct","pct","updateHandlePosition","stateUpdate","updateConnect","zIndex","childNodes","l","h","setValue","valueSet","fireSetEvent","isInit","valueReset","valueGet","getCurrentStep","nearbySteps","getNearbySteps","thisStep","decrement","stepAfter","startValue","stepBefore","stepDecimals","countStepDecimals","namespacedEvent","removeEvent","substring","tEvent","tNamespace","updateOptions","optionsToUpdate","updateAble","newOptions","reset","__moveHandles","api","convert","version","_clamp","_clamp2","_listItems","clickHandler","selectAction","actionElement","listItem","select","activeItem","clamp","number","lower","upper","_objectResize","_objectResize2","_bezierEasing","_bezierEasing2","CLASS_SHAPE","CLASS_PATH","CLASS_PATH_PROGRESS","CLASS_GROUP","CLASS_GROUP_BASE_PATH","CLASS_GROUP_PROGRESS_PATH","SIZE","RADIUS","STROKE_WIDTH","LOOP_ANIMATION_DURATION","LOOP_ANIMATION","dashLength","dashOffset","rotate","ObjectResize","resize","shape","groupCircle1","groupCircle2","circle1","cx","cy","circle2","_shape","_group","_progressPath","_basePath","_groupProgress","_easing","_easingDasharray","strokeOpacity","pathLength","_getCircleLength","strokeDasharray","_updateClasses","loop","timestamp","_animateLoop","stop","radius","_loopStart","progressRatio","_animationEndSet","_dashLengthStart","_dashOffsetStart","_dashLengthEnd","_dashOffsetEnd","ease","_dashLengthRatio","_dashOffsetRatio","_rotate","strokeDashoffset","circle","PI","callbackScope","match","_parent","_helperElement","onload","_onLoad","_callback","_callbackScope","contentDocument","A","aA1","aA2","B","C","calcBezier","aT","getSlope","binarySubdivide","aX","aA","aB","mX1","mX2","currentX","currentT","SUBDIVISION_PRECISION","SUBDIVISION_MAX_ITERATIONS","newtonRaphsonIterate","aGuessT","NEWTON_ITERATIONS","currentSlope","LinearEasing","NEWTON_MIN_SLOPE","kSplineTableSize","kSampleStepSize","float32ArraySupported","Float32Array","mY1","mY2","getTForX","intervalStart","currentSample","lastSample","sampleValues","dist","guessForT","initialSlope","CLASS_FIELD","CLASS_COUNTER","CLASS_COUNTER_VALUE","CLASS_IS_INVALID","CLASS_IS_EQUAL_MAX_CHARS","CLASS_IS_GREATER_MAX_CHARS","ATTR_AUTOSIZE","_maxChars","_counter","_counterValue","_hasCounter","_inputPadding","paddingTop","paddingBottom","_inputBorder","borderTop","borderBottom","_keyupHandler","_onKeyup","_autosize","updateCounter","adjustHeightToContent","numChars","remainingChars","htmlTop","bodyTop","originalHeight","CLASS_IS_TOP","OFFSET_VIEWPORT_X","OFFSET_TARGET_TOP","OFFSET_TARGET_BOTTOM","OPEN_DELAY","forId","_boundMouseenter","_onTriggerEnter","_boundMouseleave","_onTriggerLeave","_boundfocusin","_boundfocusout","_boundTouchstart","_onTriggerLeaveOutside","_boundMouseMove","_boundScrollWindow","triggerX","yTop","yBottom","triangleX","_scrolled","_onScrollWindow","openTimeout","openPositionX","_onTriggerMove"],"mappings":"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","file":"audi-ui.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"audi-ui\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"audi-ui\"] = factory();\n\telse\n\t\troot[\"audi-ui\"] = factory();\n})(this, function() {\nreturn \n\n\n/** WEBPACK FOOTER **\n ** webpack/universalModuleDefinition\n **/","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"audi-ui\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"audi-ui\"] = factory();\n\telse\n\t\troot[\"audi-ui\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \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/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\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.loaded = 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// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.Tooltip = exports.Textfield = exports.Spinner = exports.Indicator = exports.Slider = exports.Select = exports.Response = exports.Radio = exports.Progress = exports.Popover = exports.Player = exports.Pagination = exports.Notification = exports.Nav = exports.Modal = exports.Header = exports.Flyout = exports.Dropdown = exports.Checkbox = exports.Breadcrumb = exports.Audioplayer = exports.Alert = undefined;\n\t\n\tvar _alert = __webpack_require__(1);\n\t\n\tvar _alert2 = _interopRequireDefault(_alert);\n\t\n\tvar _audioplayer = __webpack_require__(5);\n\t\n\tvar _audioplayer2 = _interopRequireDefault(_audioplayer);\n\t\n\tvar _breadcrumb = __webpack_require__(11);\n\t\n\tvar _breadcrumb2 = _interopRequireDefault(_breadcrumb);\n\t\n\tvar _checkbox = __webpack_require__(12);\n\t\n\tvar _checkbox2 = _interopRequireDefault(_checkbox);\n\t\n\tvar _dropdown = __webpack_require__(13);\n\t\n\tvar _dropdown2 = _interopRequireDefault(_dropdown);\n\t\n\tvar _flyout = __webpack_require__(14);\n\t\n\tvar _flyout2 = _interopRequireDefault(_flyout);\n\t\n\tvar _header = __webpack_require__(15);\n\t\n\tvar _header2 = _interopRequireDefault(_header);\n\t\n\tvar _modal = __webpack_require__(17);\n\t\n\tvar _modal2 = _interopRequireDefault(_modal);\n\t\n\tvar _nav = __webpack_require__(21);\n\t\n\tvar _nav2 = _interopRequireDefault(_nav);\n\t\n\tvar _notification = __webpack_require__(29);\n\t\n\tvar _notification2 = _interopRequireDefault(_notification);\n\t\n\tvar _pagination = __webpack_require__(30);\n\t\n\tvar _pagination2 = _interopRequireDefault(_pagination);\n\t\n\tvar _player = __webpack_require__(31);\n\t\n\tvar _player2 = _interopRequireDefault(_player);\n\t\n\tvar _popover = __webpack_require__(6);\n\t\n\tvar _popover2 = _interopRequireDefault(_popover);\n\t\n\tvar _progress = __webpack_require__(32);\n\t\n\tvar _progress2 = _interopRequireDefault(_progress);\n\t\n\tvar _radio = __webpack_require__(33);\n\t\n\tvar _radio2 = _interopRequireDefault(_radio);\n\t\n\tvar _response = __webpack_require__(34);\n\t\n\tvar _response2 = _interopRequireDefault(_response);\n\t\n\tvar _select = __webpack_require__(36);\n\t\n\tvar _select2 = _interopRequireDefault(_select);\n\t\n\tvar _slider = __webpack_require__(37);\n\t\n\tvar _slider2 = _interopRequireDefault(_slider);\n\t\n\tvar _indicator = __webpack_require__(40);\n\t\n\tvar _indicator2 = _interopRequireDefault(_indicator);\n\t\n\tvar _spinner = __webpack_require__(42);\n\t\n\tvar _spinner2 = _interopRequireDefault(_spinner);\n\t\n\tvar _textfield = __webpack_require__(45);\n\t\n\tvar _textfield2 = _interopRequireDefault(_textfield);\n\t\n\tvar _tooltip = __webpack_require__(46);\n\t\n\tvar _tooltip2 = _interopRequireDefault(_tooltip);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } // TODO Add ComponentHandler.upgradeAllRegistered components e.g. to update them when all fonts are loaded.\n\t// TODO Perform a `Cutting the mustard` test once. audiui-head.js\n\t// TODO Outsource dependencies Tether, nouislider, bezier-easing\n\t\n\t/**\n\t * Import all AUI components.\n\t */\n\t\n\t\n\t/**\n\t * Export all AUI components to make them accessible through npm.\n\t * @example\n\t * import {Alert} from 'audi-ui';\n\t * Alert.upgradeElements();\n\t */\n\texports.Alert = _alert2.default;\n\texports.Audioplayer = _audioplayer2.default;\n\texports.Breadcrumb = _breadcrumb2.default;\n\texports.Checkbox = _checkbox2.default;\n\texports.Dropdown = _dropdown2.default;\n\texports.Flyout = _flyout2.default;\n\texports.Header = _header2.default;\n\texports.Modal = _modal2.default;\n\texports.Nav = _nav2.default;\n\texports.Notification = _notification2.default;\n\texports.Pagination = _pagination2.default;\n\texports.Player = _player2.default;\n\texports.Popover = _popover2.default;\n\texports.Progress = _progress2.default;\n\texports.Radio = _radio2.default;\n\texports.Response = _response2.default;\n\texports.Select = _select2.default;\n\texports.Slider = _slider2.default;\n\texports.Indicator = _indicator2.default;\n\texports.Spinner = _spinner2.default;\n\texports.Textfield = _textfield2.default;\n\texports.Tooltip = _tooltip2.default;\n\t\n\t/**\n\t * Export Component Handler as default to have access to all components.\n\t * @example\n\t * import auiHandler from 'audi-ui';\n\t * auiHandler.upgradeAllElements();\n\t */\n\t\n\tvar ComponentHandler = function () {\n\t  function ComponentHandler() {\n\t    _classCallCheck(this, ComponentHandler);\n\t\n\t    /**\n\t     * Performs a \"Cutting the mustard\" test. If the browser supports the features\n\t     * tested, adds a aui-js class to the <html> element.\n\t     */\n\t    if ('classList' in document.createElement('div') && 'querySelector' in document && 'addEventListener' in window && Array.prototype.forEach) {\n\t      document.documentElement.classList.add('aui-js');\n\t    }\n\t\n\t    this.upgradeAllElements();\n\t  }\n\t\n\t  ComponentHandler.prototype.upgradeAllElements = function upgradeAllElements() {\n\t    _alert2.default.upgradeElements();\n\t    _audioplayer2.default.upgradeElements();\n\t    _breadcrumb2.default.upgradeElements();\n\t    _checkbox2.default.upgradeElements();\n\t    _dropdown2.default.upgradeElements();\n\t    _flyout2.default.upgradeElements();\n\t    _header2.default.upgradeElements();\n\t    // Modal.upgradeElements();\n\t    _nav2.default.upgradeElements();\n\t    _notification2.default.upgradeElements();\n\t    _pagination2.default.upgradeElements();\n\t    _player2.default.upgradeElements();\n\t    _popover2.default.upgradeElements();\n\t    // Progress.upgradeElements();\n\t    _radio2.default.upgradeElements();\n\t    _response2.default.upgradeElements();\n\t    _select2.default.upgradeElements();\n\t    _slider2.default.upgradeElements();\n\t    _indicator2.default.upgradeElements();\n\t    // Spinner.upgradeElements();\n\t    _textfield2.default.upgradeElements();\n\t    _tooltip2.default.upgradeElements();\n\t  };\n\t\n\t  return ComponentHandler;\n\t}();\n\t\n\tvar componentHandler = new ComponentHandler();\n\t\n\texports.default = componentHandler;\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _resizeObserver = __webpack_require__(3);\n\t\n\tvar _resizeObserver2 = _interopRequireDefault(_resizeObserver);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-alert';\n\tvar CLASS_CONTENT = 'aui-alert__content';\n\tvar CLASS_CLOSE_BUTTON = 'aui-alert__close';\n\tvar CLASS_IS_CLOSED = 'is-closed';\n\tvar CLASS_IS_OPEN = 'is-open';\n\tvar ATTR_CLOSE = 'data-close';\n\tvar ATTR_OPENDELAY = 'data-opendelay';\n\t\n\t/**\n\t * Class constructor for Alert AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Alert = function (_Component) {\n\t  _inherits(Alert, _Component);\n\t\n\t  /**\n\t   * Upgrades all Alert AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Alert.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Alert(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function Alert(element) {\n\t    _classCallCheck(this, Alert);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t\n\t\n\t  Alert.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._content = this._element.querySelector('.' + CLASS_CONTENT);\n\t\n\t    // Add close button\n\t    this._closeButton = document.createElement('button');\n\t    this._closeButton.setAttribute('type', 'button');\n\t    this._closeButton.classList.add(CLASS_CLOSE_BUTTON);\n\t    if (this._content) {\n\t      this._content.appendChild(this._closeButton);\n\t    }\n\t\n\t    if (this._element.hasAttribute(ATTR_OPENDELAY)) {\n\t      var delay = parseInt(this._element.getAttribute(ATTR_OPENDELAY));\n\t      this._element.classList.add(CLASS_IS_CLOSED);\n\t      this.openingTimeout = setTimeout(function () {\n\t        return _this2.open(true);\n\t      }, delay);\n\t    } else {\n\t      this.open();\n\t    }\n\t\n\t    this._resizeObserver = new _resizeObserver2.default();\n\t    this._resizeObserver.resized.add(this._resizedHandler = function () {\n\t      return _this2.update();\n\t    });\n\t\n\t    this.update();\n\t  };\n\t\n\t  /**\n\t   * Open an Alert\n\t   * @param {boolean} animate True, if the opening should be animated. Default: false\n\t   */\n\t\n\t\n\t  Alert.prototype.open = function open(animate) {\n\t    var _this3 = this;\n\t\n\t    animate = animate || false;\n\t    this._element.addEventListener('click', this._clickHandler = function (event) {\n\t      return _this3._onClick(event);\n\t    });\n\t    if (animate) {\n\t      this._animateOpen();\n\t    } else {\n\t      this._element.classList.add(CLASS_IS_OPEN);\n\t      this._element.classList.remove(CLASS_IS_CLOSED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Animate opening of Alert\n\t   */\n\t\n\t\n\t  Alert.prototype._animateOpen = function _animateOpen() {\n\t    var _this4 = this;\n\t\n\t    clearTimeout(this.openingTimeout);\n\t    // Loop until start height is set and correctly rendered\n\t    if (window.getComputedStyle(this._element).height && this._element.style.height) {\n\t      this._element.classList.add(CLASS_IS_OPEN);\n\t      this._element.classList.remove(CLASS_IS_CLOSED);\n\t    } else {\n\t      window.requestAnimationFrame(function () {\n\t        return _this4._animateOpen();\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Close this Alert\n\t   */\n\t\n\t\n\t  Alert.prototype.close = function close() {\n\t    this._element.removeEventListener('click', this._clickHandler);\n\t    this._element.style.height = this._content.offsetHeight + 'px';\n\t    this._animateClose();\n\t  };\n\t\n\t  /**\n\t   * Animate closing of Alert\n\t   */\n\t\n\t\n\t  Alert.prototype._animateClose = function _animateClose() {\n\t    var _this5 = this;\n\t\n\t    clearTimeout(this.openingTimeout);\n\t    // Loop until start height is set and correctly rendered\n\t    if (window.getComputedStyle(this._element).height && this._element.style.height) {\n\t      this._element.classList.remove(CLASS_IS_OPEN);\n\t      this._element.classList.add(CLASS_IS_CLOSED);\n\t    } else {\n\t      window.requestAnimationFrame(function () {\n\t        return _this5._animateClose();\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Update Alert.\n\t   * Equalize element height with containing content.\n\t   */\n\t\n\t\n\t  Alert.prototype.update = function update() {\n\t    this._element.style.height = this._content.offsetHeight + 'px';\n\t  };\n\t\n\t  /**\n\t   * Handle click of element.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  Alert.prototype._onClick = function _onClick(event) {\n\t    if (event.target.classList.contains(CLASS_CLOSE_BUTTON) || event.target.hasAttribute(ATTR_CLOSE)) {\n\t      this.close();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Alert.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t    clearTimeout(this.openingTimeout);\n\t    this._element.classList.remove(CLASS_IS_CLOSED);\n\t    this._element.classList.remove(CLASS_IS_OPEN);\n\t    this._element.removeEventListener('click', this._clickHandler);\n\t    this._element.style.height = '';\n\t    this.removeChild(this._closeButton);\n\t    this.resizeObserver.resized.remove(this._resizedHandler);\n\t  };\n\t\n\t  return Alert;\n\t}(_component2.default);\n\t\n\texports.default = Alert;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 2 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tvar CLASS_IS_UPGRADED = 'is-upgraded';\n\t\n\tvar SVG_NS = 'http://www.w3.org/2000/svg';\n\t\n\t/**\n\t * Class constructor for abstract AUI Component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Component = function () {\n\t\n\t  /**\n\t   * Check if an element is upgraded.\n\t   * @param {HTMLElement} element The element to test if its already be upgraded.\n\t   * @returns {boolean} Returns true if element is already upgraded\n\t   */\n\t  Component.isElementUpgraded = function isElementUpgraded(element) {\n\t    return element.classList.contains(CLASS_IS_UPGRADED);\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   * @param {String} namespace The namespace of the AUI component, like `auiComponent`.\n\t   */\n\t\n\t\n\t  function Component(element, namespace) {\n\t    _classCallCheck(this, Component);\n\t\n\t    this._element = element;\n\t\n\t    if (this._element) {\n\t      if (namespace) {\n\t        this._element[namespace] = this;\n\t      }\n\t      this.init();\n\t    }\n\t  }\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t\n\t\n\t  Component.prototype.init = function init() {\n\t    this._element.classList.add(CLASS_IS_UPGRADED);\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Component.prototype.dispose = function dispose() {\n\t    this._element.classList.remove(CLASS_IS_UPGRADED);\n\t  };\n\t\n\t  /**\n\t   * Remove a child element from its parent.\n\t   * @param {HTMLElement} childNode The element to remove.\n\t   */\n\t\n\t\n\t  Component.prototype.removeChild = function removeChild(childNode) {\n\t    if (childNode && childNode.parentNode) {\n\t      if (this.isIE()) {\n\t        childNode.removeNode(true);\n\t      } else {\n\t        childNode.remove();\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Creates an HTML element and sets the given CSS classes and attributes.\n\t   * @param {string} tagName is a string that specifies the type of element to be created.\n\t   * @param {Array} classes is an array of class names to set, e.g. ['aui-class-1', 'aui-class-2'].\n\t   * @param {Object} attributes is an object with attributes to set, e.g. {width: 100}.\n\t   * @returns {HTMLElement} The created element.\n\t   */\n\t\n\t\n\t  Component.prototype.createElement = function createElement(tagName, classes, attributes) {\n\t    var element = document.createElement(tagName);\n\t    if (classes && classes.length) {\n\t      element.classList.add.apply(element.classList, classes);\n\t    }\n\t    for (var attr in attributes) {\n\t      element.setAttribute(attr, attributes[attr]);\n\t    }\n\t    return element;\n\t  };\n\t\n\t  /**\n\t   * Creates an SVG element and sets the given attributes.\n\t   * @param {string} qualifiedName is a string that specifies the type of element to be created.\n\t   * @param {Object} attributes is an object with attributes to set, e.g. {width: 100}.\n\t   * @returns {SVGElement} The created element.\n\t   */\n\t\n\t\n\t  Component.prototype.createSvgNode = function createSvgNode(qualifiedName, attributes) {\n\t    var element = document.createElementNS(SVG_NS, qualifiedName);\n\t    for (var attr in attributes) {\n\t      element.setAttributeNS(null,\n\t      // Replaces viewBox with view-box\n\t      // attr.replace(/[A-Z]/g, function(match) {\n\t      //   return '-' + match.toLowerCase();\n\t      // }),\n\t      attr, attributes[attr]);\n\t    }\n\t    return element;\n\t  };\n\t\n\t  /**\n\t   * Returns the HTMLElement of component.\n\t   */\n\t\n\t\n\t  /**\n\t   * Returns boolean if browser is Internet Explorer. Other browser (also Edge) return false.\n\t   */\n\t  Component.prototype.isIE = function isIE() {\n\t    var ua = window.navigator.userAgent;\n\t    var msie = ua.indexOf('MSIE ');\n\t    if (msie > 0) {\n\t      // IE 10 or older\n\t      return true;\n\t    }\n\t\n\t    var trident = ua.indexOf('Trident/');\n\t    if (trident > 0) {\n\t      // IE 11\n\t      var rv = ua.indexOf('rv:');\n\t      return true;\n\t    }\n\t\n\t    var edge = ua.indexOf('Edge/');\n\t    if (edge > 0) {\n\t      // Edge (IE 12+)\n\t      return false;\n\t    }\n\t\n\t    // other browser\n\t    return false;\n\t  };\n\t\n\t  _createClass(Component, [{\n\t    key: 'element',\n\t    get: function get() {\n\t      return this._element;\n\t    }\n\t  }]);\n\t\n\t  return Component;\n\t}();\n\t\n\texports.default = Component;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _signal = __webpack_require__(4);\n\t\n\tvar _signal2 = _interopRequireDefault(_signal);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tvar instance = null;\n\t\n\tvar ResizeObserver = function () {\n\t  function ResizeObserver() {\n\t    _classCallCheck(this, ResizeObserver);\n\t\n\t    if (!instance) {\n\t      instance = this;\n\t      this.init();\n\t    }\n\t\n\t    return instance;\n\t  }\n\t\n\t  ResizeObserver.prototype.init = function init() {\n\t    var _this = this;\n\t\n\t    this._ticking = false;\n\t\n\t    this.resized = new _signal2.default();\n\t\n\t    window.addEventListener('resize', this._resizeHandler = function (event) {\n\t      return _this._onResize(event);\n\t    });\n\t  };\n\t\n\t  ResizeObserver.prototype._onResize = function _onResize(event) {\n\t    var _this2 = this;\n\t\n\t    if (!this._ticking) {\n\t      window.requestAnimationFrame(function () {\n\t        _this2._ticking = false;\n\t        _this2.resized.dispatch();\n\t      });\n\t    }\n\t    this._ticking = true;\n\t  };\n\t\n\t  return ResizeObserver;\n\t}();\n\t\n\texports.default = ResizeObserver;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 4 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t// TODO Fork https://github.com/thomaseckhardt/js-signals translate to ES6\n\t\n\tvar SignalBinding = function () {\n\t  function SignalBinding(signal, listener, isOnce, priority) {\n\t    _classCallCheck(this, SignalBinding);\n\t\n\t    // Handler function bound to the signal.\n\t    this._listener = listener;\n\t\n\t    // If binding should be executed just once.\n\t    this._isOnce = isOnce;\n\t\n\t    // Reference to Signal object that listener is currently bound to.\n\t    this._signal = signal;\n\t\n\t    // Listener priority\n\t    this._priority = priority || 0;\n\t\n\t    // If binding is active and should be executed.\n\t    this._active = true;\n\t  }\n\t\n\t  SignalBinding.prototype._isBound = function _isBound() {\n\t    return !!this._signal && !!this._listener;\n\t  };\n\t\n\t  /**\n\t   * Call listener passing arbitrary parameters.\n\t   * If binding was added using `Signal.addOnce()` it will be automatically\n\t   * removed from signal dispatch queue, this method is used internally for\n\t   * the signal dispatch.\n\t   * @param {Array} Array of parameters that should be passed to the listener\n\t   * @return {*} Value returned by the listener.\n\t   */\n\t\n\t\n\t  SignalBinding.prototype.execute = function execute(params) {\n\t    var handlerReturn = void 0;\n\t    if (this._active && !!this._listener) {\n\t      handlerReturn = this._listener.apply(this._context, params);\n\t      if (this._isOnce) {\n\t        this.detach();\n\t      }\n\t    }\n\t    return handlerReturn;\n\t  };\n\t\n\t  /**\n\t   * Detach binding from signal.\n\t   * - alias to: mySignal.remove(myBinding.getListener());\n\t   * @return {Function|null} Handler function bound to the signal or `null` if binding was previously detached.\n\t   */\n\t\n\t\n\t  SignalBinding.prototype.detach = function detach() {\n\t    return this._isBound() ? this._signal.remove(this._listener) : null;\n\t  };\n\t\n\t  SignalBinding.prototype.dispose = function dispose() {\n\t    delete this._signal;\n\t    delete this._listener;\n\t  };\n\t\n\t  SignalBinding.prototype.toString = function toString() {\n\t    return '[SignalBinding isOnce:' + this._isOnce + ', isBound:' + this.isBound() + ', active:' + this._active + ']';\n\t  };\n\t\n\t  _createClass(SignalBinding, [{\n\t    key: 'isOnce',\n\t    get: function get() {\n\t      return this._isOnce;\n\t    }\n\t  }, {\n\t    key: 'listener',\n\t    get: function get() {\n\t      return this._listener;\n\t    }\n\t  }, {\n\t    key: 'signal',\n\t    get: function get() {\n\t      return this._signal;\n\t    }\n\t  }, {\n\t    key: 'priority',\n\t    get: function get() {\n\t      return this._priority;\n\t    }\n\t  }]);\n\t\n\t  return SignalBinding;\n\t}();\n\t\n\tvar Signal = function () {\n\t  function Signal() {\n\t    _classCallCheck(this, Signal);\n\t\n\t    this._bindings = [];\n\t    this._prevParams = null;\n\t    this._active = true;\n\t  }\n\t\n\t  /**\n\t   * Add a listener to the signal.\n\t   * @param {Function} listener Signal handler function.\n\t   * @param {Object} [listenerContext] Context on which listener will be executed (object that should represent the `this` variable inside listener function).\n\t   * @param {Number} [priority] The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added. (default = 0)\n\t   * @return {SignalBinding} An Object representing the binding between the Signal and listener.\n\t   */\n\t\n\t\n\t  Signal.prototype.add = function add(listener, priority) {\n\t    this._validateListener(listener, 'add');\n\t    return this._registerListener(listener, false, priority);\n\t  };\n\t\n\t  Signal.prototype.addOnce = function addOnce(listener, priority) {\n\t    this._validateListener(listener, 'addOnce');\n\t    return this._registerListener(listener, true, priority);\n\t  };\n\t\n\t  Signal.prototype.remove = function remove(listener) {\n\t    this._validateListener(listener, 'remove');\n\t\n\t    var i = this._indexOfListener(listener);\n\t    if (i !== -1) {\n\t      this._bindings[i].dispose(); //no reason to a SignalBinding exist if it isn't attached to a signal\n\t      this._bindings.splice(i, 1);\n\t    }\n\t    return listener;\n\t  };\n\t\n\t  Signal.prototype.removeAll = function removeAll() {\n\t    var n = this._bindings.length;\n\t    while (n--) {\n\t      this._bindings[n].dispose();\n\t    }\n\t    this._bindings.length = 0;\n\t  };\n\t\n\t  Signal.prototype.has = function has(listener) {\n\t    return this._indexOfListener(listener) !== -1;\n\t  };\n\t\n\t  Signal.prototype.dispatch = function dispatch() {\n\t    if (!this._active) {\n\t      return;\n\t    }\n\t\n\t    var n = this._bindings.length;\n\t    if (!n) {\n\t      return;\n\t    }\n\t\n\t    var params = Array.prototype.slice.call(arguments);\n\t    var bindings = void 0;\n\t\n\t    bindings = this._bindings.slice(); //clone array in case add/remove items during dispatch\n\t\n\t    //execute all callbacks until end of the list or until a callback returns `false` or stops propagation\n\t    //reverse loop since listeners with higher priority will be added at the end of the list\n\t    do {\n\t      n--;\n\t    } while (bindings[n] && bindings[n].execute(params) !== false);\n\t  };\n\t\n\t  Signal.prototype.dispose = function dispose() {\n\t    this.removeAll();\n\t    delete this._bindings;\n\t    delete this._prevParams;\n\t  };\n\t\n\t  Signal.prototype._registerListener = function _registerListener(listener, isOnce, priority) {\n\t    var prevIndex = this._indexOfListener(listener);\n\t    var binding = void 0;\n\t\n\t    if (prevIndex !== -1) {\n\t      binding = this._bindings[prevIndex];\n\t      if (binding.isOnce() !== isOnce) {\n\t        throw new Error('You cannot add' + (isOnce ? '' : 'Once') + '() then add' + (!isOnce ? '' : 'Once') + '() the same listener without removing the relationship first.');\n\t      }\n\t    } else {\n\t      binding = new SignalBinding(this, listener, isOnce, priority);\n\t      this._addBinding(binding);\n\t    }\n\t\n\t    if (this.memorize && this._prevParams) {\n\t      binding.execute(this._prevParams);\n\t    }\n\t\n\t    return binding;\n\t  };\n\t\n\t  Signal.prototype._validateListener = function _validateListener(listener, fnName) {\n\t    if (typeof listener !== 'function') {\n\t      throw new Error('listener is a required param of ' + fnName + '() and should be a Function.');\n\t    }\n\t  };\n\t\n\t  Signal.prototype._indexOfListener = function _indexOfListener(listener) {\n\t    var n = this._bindings.length;\n\t    var current = void 0;\n\t    while (n--) {\n\t      current = this._bindings[n];\n\t      if (current.listener === listener) {\n\t        return n;\n\t      }\n\t    }\n\t    return -1;\n\t  };\n\t\n\t  Signal.prototype._addBinding = function _addBinding(binding) {\n\t    var n = this._bindings.length;\n\t    do {\n\t      --n;\n\t    } while (this._bindings[n] && binding.priority <= this._bindings[n].priority);\n\t    this._bindings.splice(n + 1, 0, binding);\n\t  };\n\t\n\t  return Signal;\n\t}();\n\t\n\texports.default = Signal;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _popover = __webpack_require__(6);\n\t\n\tvar _popover2 = _interopRequireDefault(_popover);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-audioplayer';\n\t\n\tvar Audioplayer = function (_Component) {\n\t  _inherits(Audioplayer, _Component);\n\t\n\t  function Audioplayer() {\n\t    _classCallCheck(this, Audioplayer);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Audioplayer components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Audioplayer.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Audioplayer(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  Audioplayer.prototype.formatCurrentTime = function formatCurrentTime(currentTime) {\n\t    return ('0' + Math.floor(currentTime % 3600 / 60)).slice(-2) + ':' + ('0' + Math.floor(currentTime % 3600 % 60)).slice(-2);\n\t  };\n\t\n\t  Audioplayer.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t    this.currentTrack = 0;\n\t    this.scrobble = false;\n\t    this.embed = this.element.querySelector('.aui-audioplayer__embed');\n\t    this.embed.preload = true;\n\t    this.tracks = JSON.parse(this.element.querySelector('.aui-audioplayer__tracks').value);\n\t    this.embed.addEventListener('ended', function (event) {\n\t      _this2.cancelProgress();\n\t      if (_this2.tracks.length > 1) {\n\t        _this2.next();\n\t      } else {\n\t        _this2.pause();\n\t        _this2.element.classList.add('has-ended');\n\t      }\n\t      _this2.updateProgress();\n\t    });\n\t    this.embed.addEventListener('canplay', function (event) {\n\t      _this2.element.querySelector('.aui-audioplayer__time').innerHTML = _this2.formatCurrentTime(_this2.embed.duration);\n\t    });\n\t    this.embed.addEventListener('timeupdate', function (event) {\n\t      _this2.element.querySelector('.aui-audioplayer__time').innerHTML = _this2.formatCurrentTime(_this2.embed.currentTime);\n\t    });\n\t    var play = this.element.querySelector('.aui-audioplayer__play');\n\t    if (play) {\n\t      play.addEventListener('click', function (event) {\n\t        if (_this2.isPlaying()) {\n\t          _this2.pause();\n\t        } else {\n\t          _this2.play();\n\t        }\n\t      });\n\t    }\n\t    var mute = this.element.querySelector('.aui-audioplayer__mute');\n\t    if (mute) {\n\t      mute.addEventListener('click', function (event) {\n\t        if (_this2.isMuted()) {\n\t          _this2.unmute();\n\t        } else {\n\t          _this2.mute();\n\t        }\n\t      });\n\t    }\n\t    var next = this.element.querySelector('.aui-audioplayer__next');\n\t    if (next) {\n\t      next.addEventListener('click', function (event) {\n\t        _this2.next();\n\t      });\n\t    }\n\t    var previous = this.element.querySelector('.aui-audioplayer__previous');\n\t    if (previous) {\n\t      previous.addEventListener('click', function (event) {\n\t        _this2.previous();\n\t      });\n\t    }\n\t    window.setTimeout(function () {\n\t      _this2.slider = _this2.element.querySelector('.aui-slider__target').noUiSlider;\n\t      _this2.slider.on('start', function () {\n\t        _this2.scrobble = true;\n\t      });\n\t      _this2.slider.on('end', function () {\n\t        _this2.scrobble = false;\n\t      });\n\t      _this2.slider.on('change', function (value) {\n\t        _this2.embed.currentTime = Math.abs(value) * _this2.embed.duration / 100;\n\t      });\n\t    }, 400);\n\t  };\n\t\n\t  Audioplayer.prototype.isMuted = function isMuted() {\n\t    return this.embed.muted;\n\t  };\n\t\n\t  Audioplayer.prototype.isPlaying = function isPlaying() {\n\t    return !this.embed.paused;\n\t  };\n\t\n\t  Audioplayer.prototype.mute = function mute() {\n\t    this.element.classList.add('is-mute');\n\t    this.embed.muted = true;\n\t  };\n\t\n\t  Audioplayer.prototype.next = function next() {\n\t    if (this.tracks.length > 1) {\n\t      var restartPlayback = this.isPlaying();\n\t      this.pause();\n\t\n\t      if (this.currentTrack >= this.tracks.length - 1) {\n\t        this.currentTrack = 0;\n\t      } else {\n\t        this.currentTrack = this.currentTrack + 1;\n\t      }\n\t      this.embed.src = this.tracks[this.currentTrack].src;\n\t      this.embed.load();\n\t      this.slider.set(0);\n\t      this.element.querySelector('.aui-audioplayer__time').innerHTML = this.formatCurrentTime(this.embed.duration);\n\t      if (restartPlayback) this.play();\n\t\n\t      this.element.querySelector('.aui-audioplayer__time').innerHTML = '00:00';\n\t      this.element.querySelector('.aui-audioplayer__title').innerHTML = this.tracks[this.currentTrack].title;\n\t      var cover = this.element.querySelector('.aui-audioplayer__cover');\n\t      if (cover) {\n\t        cover.querySelector('.aui-audioplayer__cover-image').setAttribute('src', this.tracks[this.currentTrack].cover);\n\t      }\n\t    }\n\t  };\n\t\n\t  Audioplayer.prototype.pause = function pause() {\n\t    this.cancelProgress();\n\t    this.element.classList.remove('is-playing');\n\t    this.embed.pause();\n\t  };\n\t\n\t  Audioplayer.prototype.play = function play() {\n\t    this.updateProgress();\n\t    this.element.classList.add('is-playing');\n\t    this.element.classList.remove('has-ended');\n\t    this.embed.play();\n\t  };\n\t\n\t  Audioplayer.prototype.previous = function previous() {\n\t    if (this.tracks.length > 1) {\n\t      var restartPlayback = this.isPlaying();\n\t      this.pause();\n\t\n\t      if (this.currentTrack === 0) {\n\t        this.currentTrack = this.tracks.length - 1;\n\t      } else {\n\t        this.currentTrack = this.currentTrack - 1;\n\t      }\n\t      this.embed.src = this.tracks[this.currentTrack].src;\n\t      this.embed.load();\n\t      this.slider.set(0);\n\t      this.element.querySelector('.aui-audioplayer__time').innerHTML = this.formatCurrentTime(this.embed.duration);\n\t      if (restartPlayback) this.play();\n\t\n\t      this.element.querySelector('.aui-audioplayer__time').innerHTML = '00:00';\n\t      this.element.querySelector('.aui-audioplayer__title').innerHTML = this.tracks[this.currentTrack].title;\n\t      var cover = this.element.querySelector('.aui-audioplayer__cover');\n\t      if (cover) {\n\t        cover.querySelector('.aui-audioplayer__cover-image').setAttribute('src', this.tracks[this.currentTrack].cover);\n\t      }\n\t    }\n\t  };\n\t\n\t  Audioplayer.prototype.unmute = function unmute() {\n\t    this.element.classList.remove('is-mute');\n\t    this.embed.muted = false;\n\t  };\n\t\n\t  Audioplayer.prototype.cancelProgress = function cancelProgress() {\n\t    if (this.tick) {\n\t      window.cancelAnimationFrame(this.tick);\n\t      this.tick = undefined;\n\t    }\n\t  };\n\t\n\t  Audioplayer.prototype.updateProgress = function updateProgress() {\n\t    var _this3 = this;\n\t\n\t    this.tick = window.requestAnimationFrame(function () {\n\t      if (!_this3.scrobble) _this3.slider.set(Math.abs(_this3.embed.currentTime * 100 / _this3.embed.duration));\n\t      _this3.updateProgress();\n\t    });\n\t  };\n\t\n\t  return Audioplayer;\n\t}(_component2.default);\n\t\n\texports.default = Audioplayer;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _reflow = __webpack_require__(7);\n\t\n\tvar _reflow2 = _interopRequireDefault(_reflow);\n\t\n\tvar _closest = __webpack_require__(8);\n\t\n\tvar _closest2 = _interopRequireDefault(_closest);\n\t\n\tvar _transitionEndEvent = __webpack_require__(9);\n\t\n\tvar _transitionEndEvent2 = _interopRequireDefault(_transitionEndEvent);\n\t\n\tvar _tether = __webpack_require__(10);\n\t\n\tvar _tether2 = _interopRequireDefault(_tether);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-popover';\n\tvar SELECTOR_DISMISS = '[data-dismiss=\"popover\"]';\n\tvar CLASS_ARROW = 'aui-popover__arrow';\n\tvar CLASS_ARROW_SHAPE = 'aui-popover__arrow-shape';\n\tvar CLASS_ACTIVE = 'is-active';\n\tvar CLASS_SHOWN = 'is-shown';\n\tvar CLASS_POPOVER_IS_OPEN = 'aui-popover-is-open';\n\tvar ARROW_SIZE = 20;\n\t\n\tvar AttachmentMap = {\n\t  top: 'bottom center',\n\t  right: 'middle left',\n\t  bottom: 'top center',\n\t  left: 'middle right'\n\t\n\t  /**\n\t   * Class constructor for Popover AUI component.\n\t   * Implements AUI component design pattern defined at:\n\t   * https://github.com/...\n\t   *\n\t   * @param {HTMLElement} element The element that will be upgraded.\n\t   */\n\t};\n\tvar Popover = function (_Component) {\n\t  _inherits(Popover, _Component);\n\t\n\t  function Popover() {\n\t    _classCallCheck(this, Popover);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Popover AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Popover.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Popover(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  Popover.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._body = document.querySelector('body');\n\t\n\t    this._id = this._element.getAttribute('id');\n\t    this._trigger = document.getElementById(this._element.getAttribute('for'));\n\t    this._tether = null;\n\t    var placement = this._element.hasAttribute('data-placement') ? this._element.getAttribute('data-placement') : 'top';\n\t    this._attachement = AttachmentMap[placement.toLowerCase()];\n\t\n\t    var content = this._element.querySelector('.aui-popover__content');\n\t    var arrowColor = this._element.hasAttribute('data-arrow-color') ? this._element.getAttribute('data-arrow-color') : window.getComputedStyle(content).backgroundColor;\n\t    this._arrow = this._addArrow(content, arrowColor);\n\t\n\t    if (this._trigger) {\n\t      this._trigger.addEventListener('click', this._boundClickHandler = function (event) {\n\t        return _this2.toggle(event);\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Popover.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this.hide();\n\t    this.removeChild(this._arrow);\n\t\n\t    if (this._trigger) {\n\t      this._trigger.removeEventListener('click', this._boundClickHandler);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Toggle show/hide Popover\n\t   * @param {Event} event Click event of trigger element (optional)\n\t   */\n\t\n\t\n\t  Popover.prototype.toggle = function toggle(event) {\n\t    var _this3 = this;\n\t\n\t    var performToggle = function performToggle() {\n\t      if (!_this3._element.classList.contains(CLASS_ACTIVE) && _this3._tether) {\n\t        _this3.show();\n\t      } else {\n\t        _this3.hide();\n\t      }\n\t    };\n\t\n\t    if (event) {\n\t      event.preventDefault();\n\t\n\t      if (this._tether === null) {\n\t        this._tether = new _tether2.default({\n\t          element: this._element,\n\t          target: event.currentTarget,\n\t          attachment: this._attachement,\n\t          classPrefix: 'aui-tether',\n\t          // NOTE We set an offset in CSS, because this offset wouln't be\n\t          // flipped as it should:\n\t          // https://github.com/HubSpot/tether/issues/106\n\t          offset: '0 0',\n\t          constraints: [{\n\t            to: 'window',\n\t            pin: ['left', 'right'],\n\t            attachment: 'together'\n\t          }],\n\t          optimizations: {\n\t            gpu: false\n\t          }\n\t        });\n\t        (0, _reflow2.default)(this._element); // REVIEW Do we need this anymore?\n\t        this._tether.position();\n\t      }\n\t      performToggle();\n\t    } else {\n\t      performToggle();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Show Popover\n\t   */\n\t\n\t\n\t  Popover.prototype.show = function show() {\n\t    var _this4 = this;\n\t\n\t    this._body.classList.add(CLASS_POPOVER_IS_OPEN);\n\t    this._element.classList.add(CLASS_ACTIVE);\n\t    this._element.classList.add(CLASS_SHOWN);\n\t    setTimeout(function () {\n\t      window.addEventListener('click', _this4._boundWindowClickHandler = function (event) {\n\t        return _this4._onClickOutside(event);\n\t      });\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Hide Popover\n\t   */\n\t\n\t\n\t  Popover.prototype.hide = function hide() {\n\t    var _this5 = this;\n\t\n\t    this._element.classList.remove(CLASS_SHOWN);\n\t    this._element.addEventListener(_transitionEndEvent2.default, this._boundAnimationendHandler = function (event) {\n\t      return _this5._onHideComplete(event);\n\t    });\n\t    window.removeEventListener('click', this._boundWindowClickHandler);\n\t  };\n\t\n\t  /**\n\t   * Clean up Tether instance\n\t   * @private\n\t   */\n\t\n\t\n\t  Popover.prototype._cleanupTether = function _cleanupTether() {\n\t    if (this._tether) {\n\t      this._tether.destroy();\n\t      this._tether = null;\n\t    }\n\t    this._element.removeAttribute('style');\n\t  };\n\t\n\t  /**\n\t   * Handle click of window.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  Popover.prototype._onClickOutside = function _onClickOutside(event) {\n\t    // Hide if target dismisses Popover\n\t    if ((0, _closest2.default)(event.target, SELECTOR_DISMISS, this._element)) {\n\t      this.hide();\n\t\n\t      // Hide if target is not inside Popover and is not a trigger element\n\t    } else if (!this._element.contains(event.target) && event.target !== this._trigger) {\n\t      this.hide();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Handle hide transition complete.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  Popover.prototype._onHideComplete = function _onHideComplete(event) {\n\t    this._body.classList.remove(CLASS_POPOVER_IS_OPEN);\n\t    this._element.classList.remove(CLASS_ACTIVE);\n\t    this._element.removeEventListener(_transitionEndEvent2.default, this._boundAnimationendHandler);\n\t    this._cleanupTether();\n\t  };\n\t\n\t  /**\n\t   * Adds an arrow SVG element\n\t   * <span class=\"…\"><svg … ><path … /></svg></span>\n\t   *\n\t   * @param {HTMLElement} parent element to append arrow to.\n\t   * @param {string} color used as value of fill property.\n\t   * @returns {HTMLElement} the added arrow element.\n\t   */\n\t\n\t\n\t  Popover.prototype._addArrow = function _addArrow(parent, color) {\n\t    var element = document.createElement('span');\n\t    element.classList.add(CLASS_ARROW);\n\t    var svg = this.createSvgNode('svg', {\n\t      class: CLASS_ARROW_SHAPE,\n\t      width: ARROW_SIZE,\n\t      height: ARROW_SIZE,\n\t      viewBox: '0 0 ' + ARROW_SIZE + ' ' + ARROW_SIZE\n\t    });\n\t    // Draw a diamond square ◆\n\t    var path = this.createSvgNode('path', {\n\t      d: 'M' + ARROW_SIZE / 2 + ' 0 L ' + ARROW_SIZE + ' ' + ARROW_SIZE / 2 + ' L ' + ARROW_SIZE / 2 + ' ' + ARROW_SIZE + ' L 0 ' + ARROW_SIZE / 2 + ' Z',\n\t      fill: color\n\t    });\n\t    svg.appendChild(path);\n\t    element.appendChild(svg);\n\t    parent.appendChild(element);\n\t    return element;\n\t  };\n\t\n\t  return Popover;\n\t}(_component2.default);\n\t\n\texports.default = Popover;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 7 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.default = reflow;\n\t/**\n\t * Trigger a reflow\n\t * @param {HTMLElement} element to trigger a reflow.\n\t */\n\tfunction reflow(element) {\n\t  new Function('bs', 'return bs')(element.offsetHeight);\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 8 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.default = closest;\n\t/**\n\t * Get the first element that matches the selector by testing the element itself\n\t * and traversing up through its ancestors in the DOM tree.\n\t * @param {HTMLElement} element to search wherefrom\n\t * @param {string} selector A string containing a selector expression to match elements against.\n\t * @param {HTMLElement} context A DOM element within which a matching element may be found.\n\t * @returns {HTMLElement} found element or null\n\t */\n\tfunction closest(element, selector, context) {\n\t  var matchesFn = void 0;\n\t\n\t  ['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'].some(function (fn) {\n\t    if (typeof document.body[fn] === 'function') {\n\t      matchesFn = fn;\n\t      return true;\n\t    }\n\t    return false;\n\t  });\n\t\n\t  var parent = void 0;\n\t\n\t  // traverse parents\n\t  parent = element;\n\t  while (parent) {\n\t    if (parent && parent[matchesFn](selector)) {\n\t      return parent;\n\t    }\n\t    if (parent === context) {\n\t      return null;\n\t    }\n\t    parent = parent.parentElement;\n\t  }\n\t\n\t  return null;\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 9 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t// From Modernizr\n\tfunction whichTransitionEvent() {\n\t  var t;\n\t  var el = document.createElement('fakeelement');\n\t  var transitions = {\n\t    'transition': 'transitionend',\n\t    'OTransition': 'oTransitionEnd',\n\t    'MozTransition': 'transitionend',\n\t    'WebkitTransition': 'webkitTransitionEnd'\n\t  };\n\t\n\t  for (t in transitions) {\n\t    if (el.style[t] !== undefined) {\n\t      return transitions[t];\n\t    }\n\t  }\n\t}\n\t\n\tvar TRANSITION_EVENT = whichTransitionEvent();\n\t\n\texports.default = TRANSITION_EVENT;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 10 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! tether 1.4.4 */\n\t\n\t(function(root, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports === 'object') {\n\t    module.exports = factory();\n\t  } else {\n\t    root.Tether = factory();\n\t  }\n\t}(this, function() {\n\t\n\t'use strict';\n\t\n\tvar _createClass = (function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tvar TetherBase = undefined;\n\tif (typeof TetherBase === 'undefined') {\n\t  TetherBase = { modules: [] };\n\t}\n\t\n\tvar zeroElement = null;\n\t\n\t// Same as native getBoundingClientRect, except it takes into account parent <frame> offsets\n\t// if the element lies within a nested document (<frame> or <iframe>-like).\n\tfunction getActualBoundingClientRect(node) {\n\t  var boundingRect = node.getBoundingClientRect();\n\t\n\t  // The original object returned by getBoundingClientRect is immutable, so we clone it\n\t  // We can't use extend because the properties are not considered part of the object by hasOwnProperty in IE9\n\t  var rect = {};\n\t  for (var k in boundingRect) {\n\t    rect[k] = boundingRect[k];\n\t  }\n\t\n\t  if (node.ownerDocument !== document) {\n\t    var _frameElement = node.ownerDocument.defaultView.frameElement;\n\t    if (_frameElement) {\n\t      var frameRect = getActualBoundingClientRect(_frameElement);\n\t      rect.top += frameRect.top;\n\t      rect.bottom += frameRect.top;\n\t      rect.left += frameRect.left;\n\t      rect.right += frameRect.left;\n\t    }\n\t  }\n\t\n\t  return rect;\n\t}\n\t\n\tfunction getScrollParents(el) {\n\t  // In firefox if the el is inside an iframe with display: none; window.getComputedStyle() will return null;\n\t  // https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n\t  var computedStyle = getComputedStyle(el) || {};\n\t  var position = computedStyle.position;\n\t  var parents = [];\n\t\n\t  if (position === 'fixed') {\n\t    return [el];\n\t  }\n\t\n\t  var parent = el;\n\t  while ((parent = parent.parentNode) && parent && parent.nodeType === 1) {\n\t    var style = undefined;\n\t    try {\n\t      style = getComputedStyle(parent);\n\t    } catch (err) {}\n\t\n\t    if (typeof style === 'undefined' || style === null) {\n\t      parents.push(parent);\n\t      return parents;\n\t    }\n\t\n\t    var _style = style;\n\t    var overflow = _style.overflow;\n\t    var overflowX = _style.overflowX;\n\t    var overflowY = _style.overflowY;\n\t\n\t    if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {\n\t      if (position !== 'absolute' || ['relative', 'absolute', 'fixed'].indexOf(style.position) >= 0) {\n\t        parents.push(parent);\n\t      }\n\t    }\n\t  }\n\t\n\t  parents.push(el.ownerDocument.body);\n\t\n\t  // If the node is within a frame, account for the parent window scroll\n\t  if (el.ownerDocument !== document) {\n\t    parents.push(el.ownerDocument.defaultView);\n\t  }\n\t\n\t  return parents;\n\t}\n\t\n\tvar uniqueId = (function () {\n\t  var id = 0;\n\t  return function () {\n\t    return ++id;\n\t  };\n\t})();\n\t\n\tvar zeroPosCache = {};\n\tvar getOrigin = function getOrigin() {\n\t  // getBoundingClientRect is unfortunately too accurate.  It introduces a pixel or two of\n\t  // jitter as the user scrolls that messes with our ability to detect if two positions\n\t  // are equivilant or not.  We place an element at the top left of the page that will\n\t  // get the same jitter, so we can cancel the two out.\n\t  var node = zeroElement;\n\t  if (!node || !document.body.contains(node)) {\n\t    node = document.createElement('div');\n\t    node.setAttribute('data-tether-id', uniqueId());\n\t    extend(node.style, {\n\t      top: 0,\n\t      left: 0,\n\t      position: 'absolute'\n\t    });\n\t\n\t    document.body.appendChild(node);\n\t\n\t    zeroElement = node;\n\t  }\n\t\n\t  var id = node.getAttribute('data-tether-id');\n\t  if (typeof zeroPosCache[id] === 'undefined') {\n\t    zeroPosCache[id] = getActualBoundingClientRect(node);\n\t\n\t    // Clear the cache when this position call is done\n\t    defer(function () {\n\t      delete zeroPosCache[id];\n\t    });\n\t  }\n\t\n\t  return zeroPosCache[id];\n\t};\n\t\n\tfunction removeUtilElements() {\n\t  if (zeroElement) {\n\t    document.body.removeChild(zeroElement);\n\t  }\n\t  zeroElement = null;\n\t};\n\t\n\tfunction getBounds(el) {\n\t  var doc = undefined;\n\t  if (el === document) {\n\t    doc = document;\n\t    el = document.documentElement;\n\t  } else {\n\t    doc = el.ownerDocument;\n\t  }\n\t\n\t  var docEl = doc.documentElement;\n\t\n\t  var box = getActualBoundingClientRect(el);\n\t\n\t  var origin = getOrigin();\n\t\n\t  box.top -= origin.top;\n\t  box.left -= origin.left;\n\t\n\t  if (typeof box.width === 'undefined') {\n\t    box.width = document.body.scrollWidth - box.left - box.right;\n\t  }\n\t  if (typeof box.height === 'undefined') {\n\t    box.height = document.body.scrollHeight - box.top - box.bottom;\n\t  }\n\t\n\t  box.top = box.top - docEl.clientTop;\n\t  box.left = box.left - docEl.clientLeft;\n\t  box.right = doc.body.clientWidth - box.width - box.left;\n\t  box.bottom = doc.body.clientHeight - box.height - box.top;\n\t\n\t  return box;\n\t}\n\t\n\tfunction getOffsetParent(el) {\n\t  return el.offsetParent || document.documentElement;\n\t}\n\t\n\tvar _scrollBarSize = null;\n\tfunction getScrollBarSize() {\n\t  if (_scrollBarSize) {\n\t    return _scrollBarSize;\n\t  }\n\t  var inner = document.createElement('div');\n\t  inner.style.width = '100%';\n\t  inner.style.height = '200px';\n\t\n\t  var outer = document.createElement('div');\n\t  extend(outer.style, {\n\t    position: 'absolute',\n\t    top: 0,\n\t    left: 0,\n\t    pointerEvents: 'none',\n\t    visibility: 'hidden',\n\t    width: '200px',\n\t    height: '150px',\n\t    overflow: 'hidden'\n\t  });\n\t\n\t  outer.appendChild(inner);\n\t\n\t  document.body.appendChild(outer);\n\t\n\t  var widthContained = inner.offsetWidth;\n\t  outer.style.overflow = 'scroll';\n\t  var widthScroll = inner.offsetWidth;\n\t\n\t  if (widthContained === widthScroll) {\n\t    widthScroll = outer.clientWidth;\n\t  }\n\t\n\t  document.body.removeChild(outer);\n\t\n\t  var width = widthContained - widthScroll;\n\t\n\t  _scrollBarSize = { width: width, height: width };\n\t  return _scrollBarSize;\n\t}\n\t\n\tfunction extend() {\n\t  var out = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\t\n\t  var args = [];\n\t\n\t  Array.prototype.push.apply(args, arguments);\n\t\n\t  args.slice(1).forEach(function (obj) {\n\t    if (obj) {\n\t      for (var key in obj) {\n\t        if (({}).hasOwnProperty.call(obj, key)) {\n\t          out[key] = obj[key];\n\t        }\n\t      }\n\t    }\n\t  });\n\t\n\t  return out;\n\t}\n\t\n\tfunction removeClass(el, name) {\n\t  if (typeof el.classList !== 'undefined') {\n\t    name.split(' ').forEach(function (cls) {\n\t      if (cls.trim()) {\n\t        el.classList.remove(cls);\n\t      }\n\t    });\n\t  } else {\n\t    var regex = new RegExp('(^| )' + name.split(' ').join('|') + '( |$)', 'gi');\n\t    var className = getClassName(el).replace(regex, ' ');\n\t    setClassName(el, className);\n\t  }\n\t}\n\t\n\tfunction addClass(el, name) {\n\t  if (typeof el.classList !== 'undefined') {\n\t    name.split(' ').forEach(function (cls) {\n\t      if (cls.trim()) {\n\t        el.classList.add(cls);\n\t      }\n\t    });\n\t  } else {\n\t    removeClass(el, name);\n\t    var cls = getClassName(el) + (' ' + name);\n\t    setClassName(el, cls);\n\t  }\n\t}\n\t\n\tfunction hasClass(el, name) {\n\t  if (typeof el.classList !== 'undefined') {\n\t    return el.classList.contains(name);\n\t  }\n\t  var className = getClassName(el);\n\t  return new RegExp('(^| )' + name + '( |$)', 'gi').test(className);\n\t}\n\t\n\tfunction getClassName(el) {\n\t  // Can't use just SVGAnimatedString here since nodes within a Frame in IE have\n\t  // completely separately SVGAnimatedString base classes\n\t  if (el.className instanceof el.ownerDocument.defaultView.SVGAnimatedString) {\n\t    return el.className.baseVal;\n\t  }\n\t  return el.className;\n\t}\n\t\n\tfunction setClassName(el, className) {\n\t  el.setAttribute('class', className);\n\t}\n\t\n\tfunction updateClasses(el, add, all) {\n\t  // Of the set of 'all' classes, we need the 'add' classes, and only the\n\t  // 'add' classes to be set.\n\t  all.forEach(function (cls) {\n\t    if (add.indexOf(cls) === -1 && hasClass(el, cls)) {\n\t      removeClass(el, cls);\n\t    }\n\t  });\n\t\n\t  add.forEach(function (cls) {\n\t    if (!hasClass(el, cls)) {\n\t      addClass(el, cls);\n\t    }\n\t  });\n\t}\n\t\n\tvar deferred = [];\n\t\n\tvar defer = function defer(fn) {\n\t  deferred.push(fn);\n\t};\n\t\n\tvar flush = function flush() {\n\t  var fn = undefined;\n\t  while (fn = deferred.pop()) {\n\t    fn();\n\t  }\n\t};\n\t\n\tvar Evented = (function () {\n\t  function Evented() {\n\t    _classCallCheck(this, Evented);\n\t  }\n\t\n\t  _createClass(Evented, [{\n\t    key: 'on',\n\t    value: function on(event, handler, ctx) {\n\t      var once = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];\n\t\n\t      if (typeof this.bindings === 'undefined') {\n\t        this.bindings = {};\n\t      }\n\t      if (typeof this.bindings[event] === 'undefined') {\n\t        this.bindings[event] = [];\n\t      }\n\t      this.bindings[event].push({ handler: handler, ctx: ctx, once: once });\n\t    }\n\t  }, {\n\t    key: 'once',\n\t    value: function once(event, handler, ctx) {\n\t      this.on(event, handler, ctx, true);\n\t    }\n\t  }, {\n\t    key: 'off',\n\t    value: function off(event, handler) {\n\t      if (typeof this.bindings === 'undefined' || typeof this.bindings[event] === 'undefined') {\n\t        return;\n\t      }\n\t\n\t      if (typeof handler === 'undefined') {\n\t        delete this.bindings[event];\n\t      } else {\n\t        var i = 0;\n\t        while (i < this.bindings[event].length) {\n\t          if (this.bindings[event][i].handler === handler) {\n\t            this.bindings[event].splice(i, 1);\n\t          } else {\n\t            ++i;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }, {\n\t    key: 'trigger',\n\t    value: function trigger(event) {\n\t      if (typeof this.bindings !== 'undefined' && this.bindings[event]) {\n\t        var i = 0;\n\t\n\t        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n\t          args[_key - 1] = arguments[_key];\n\t        }\n\t\n\t        while (i < this.bindings[event].length) {\n\t          var _bindings$event$i = this.bindings[event][i];\n\t          var handler = _bindings$event$i.handler;\n\t          var ctx = _bindings$event$i.ctx;\n\t          var once = _bindings$event$i.once;\n\t\n\t          var context = ctx;\n\t          if (typeof context === 'undefined') {\n\t            context = this;\n\t          }\n\t\n\t          handler.apply(context, args);\n\t\n\t          if (once) {\n\t            this.bindings[event].splice(i, 1);\n\t          } else {\n\t            ++i;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }]);\n\t\n\t  return Evented;\n\t})();\n\t\n\tTetherBase.Utils = {\n\t  getActualBoundingClientRect: getActualBoundingClientRect,\n\t  getScrollParents: getScrollParents,\n\t  getBounds: getBounds,\n\t  getOffsetParent: getOffsetParent,\n\t  extend: extend,\n\t  addClass: addClass,\n\t  removeClass: removeClass,\n\t  hasClass: hasClass,\n\t  updateClasses: updateClasses,\n\t  defer: defer,\n\t  flush: flush,\n\t  uniqueId: uniqueId,\n\t  Evented: Evented,\n\t  getScrollBarSize: getScrollBarSize,\n\t  removeUtilElements: removeUtilElements\n\t};\n\t/* globals TetherBase, performance */\n\t\n\t'use strict';\n\t\n\tvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\t\n\tvar _createClass = (function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tvar _get = function get(_x6, _x7, _x8) { var _again = true; _function: while (_again) { var object = _x6, property = _x7, receiver = _x8; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x6 = parent; _x7 = property; _x8 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tif (typeof TetherBase === 'undefined') {\n\t  throw new Error('You must include the utils.js file before tether.js');\n\t}\n\t\n\tvar _TetherBase$Utils = TetherBase.Utils;\n\tvar getScrollParents = _TetherBase$Utils.getScrollParents;\n\tvar getBounds = _TetherBase$Utils.getBounds;\n\tvar getOffsetParent = _TetherBase$Utils.getOffsetParent;\n\tvar extend = _TetherBase$Utils.extend;\n\tvar addClass = _TetherBase$Utils.addClass;\n\tvar removeClass = _TetherBase$Utils.removeClass;\n\tvar updateClasses = _TetherBase$Utils.updateClasses;\n\tvar defer = _TetherBase$Utils.defer;\n\tvar flush = _TetherBase$Utils.flush;\n\tvar getScrollBarSize = _TetherBase$Utils.getScrollBarSize;\n\tvar removeUtilElements = _TetherBase$Utils.removeUtilElements;\n\t\n\tfunction within(a, b) {\n\t  var diff = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];\n\t\n\t  return a + diff >= b && b >= a - diff;\n\t}\n\t\n\tvar transformKey = (function () {\n\t  if (typeof document === 'undefined') {\n\t    return '';\n\t  }\n\t  var el = document.createElement('div');\n\t\n\t  var transforms = ['transform', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform'];\n\t  for (var i = 0; i < transforms.length; ++i) {\n\t    var key = transforms[i];\n\t    if (el.style[key] !== undefined) {\n\t      return key;\n\t    }\n\t  }\n\t})();\n\t\n\tvar tethers = [];\n\t\n\tvar position = function position() {\n\t  tethers.forEach(function (tether) {\n\t    tether.position(false);\n\t  });\n\t  flush();\n\t};\n\t\n\tfunction now() {\n\t  if (typeof performance === 'object' && typeof performance.now === 'function') {\n\t    return performance.now();\n\t  }\n\t  return +new Date();\n\t}\n\t\n\t(function () {\n\t  var lastCall = null;\n\t  var lastDuration = null;\n\t  var pendingTimeout = null;\n\t\n\t  var tick = function tick() {\n\t    if (typeof lastDuration !== 'undefined' && lastDuration > 16) {\n\t      // We voluntarily throttle ourselves if we can't manage 60fps\n\t      lastDuration = Math.min(lastDuration - 16, 250);\n\t\n\t      // Just in case this is the last event, remember to position just once more\n\t      pendingTimeout = setTimeout(tick, 250);\n\t      return;\n\t    }\n\t\n\t    if (typeof lastCall !== 'undefined' && now() - lastCall < 10) {\n\t      // Some browsers call events a little too frequently, refuse to run more than is reasonable\n\t      return;\n\t    }\n\t\n\t    if (pendingTimeout != null) {\n\t      clearTimeout(pendingTimeout);\n\t      pendingTimeout = null;\n\t    }\n\t\n\t    lastCall = now();\n\t    position();\n\t    lastDuration = now() - lastCall;\n\t  };\n\t\n\t  if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {\n\t    ['resize', 'scroll', 'touchmove'].forEach(function (event) {\n\t      window.addEventListener(event, tick);\n\t    });\n\t  }\n\t})();\n\t\n\tvar MIRROR_LR = {\n\t  center: 'center',\n\t  left: 'right',\n\t  right: 'left'\n\t};\n\t\n\tvar MIRROR_TB = {\n\t  middle: 'middle',\n\t  top: 'bottom',\n\t  bottom: 'top'\n\t};\n\t\n\tvar OFFSET_MAP = {\n\t  top: 0,\n\t  left: 0,\n\t  middle: '50%',\n\t  center: '50%',\n\t  bottom: '100%',\n\t  right: '100%'\n\t};\n\t\n\tvar autoToFixedAttachment = function autoToFixedAttachment(attachment, relativeToAttachment) {\n\t  var left = attachment.left;\n\t  var top = attachment.top;\n\t\n\t  if (left === 'auto') {\n\t    left = MIRROR_LR[relativeToAttachment.left];\n\t  }\n\t\n\t  if (top === 'auto') {\n\t    top = MIRROR_TB[relativeToAttachment.top];\n\t  }\n\t\n\t  return { left: left, top: top };\n\t};\n\t\n\tvar attachmentToOffset = function attachmentToOffset(attachment) {\n\t  var left = attachment.left;\n\t  var top = attachment.top;\n\t\n\t  if (typeof OFFSET_MAP[attachment.left] !== 'undefined') {\n\t    left = OFFSET_MAP[attachment.left];\n\t  }\n\t\n\t  if (typeof OFFSET_MAP[attachment.top] !== 'undefined') {\n\t    top = OFFSET_MAP[attachment.top];\n\t  }\n\t\n\t  return { left: left, top: top };\n\t};\n\t\n\tfunction addOffset() {\n\t  var out = { top: 0, left: 0 };\n\t\n\t  for (var _len = arguments.length, offsets = Array(_len), _key = 0; _key < _len; _key++) {\n\t    offsets[_key] = arguments[_key];\n\t  }\n\t\n\t  offsets.forEach(function (_ref) {\n\t    var top = _ref.top;\n\t    var left = _ref.left;\n\t\n\t    if (typeof top === 'string') {\n\t      top = parseFloat(top, 10);\n\t    }\n\t    if (typeof left === 'string') {\n\t      left = parseFloat(left, 10);\n\t    }\n\t\n\t    out.top += top;\n\t    out.left += left;\n\t  });\n\t\n\t  return out;\n\t}\n\t\n\tfunction offsetToPx(offset, size) {\n\t  if (typeof offset.left === 'string' && offset.left.indexOf('%') !== -1) {\n\t    offset.left = parseFloat(offset.left, 10) / 100 * size.width;\n\t  }\n\t  if (typeof offset.top === 'string' && offset.top.indexOf('%') !== -1) {\n\t    offset.top = parseFloat(offset.top, 10) / 100 * size.height;\n\t  }\n\t\n\t  return offset;\n\t}\n\t\n\tvar parseOffset = function parseOffset(value) {\n\t  var _value$split = value.split(' ');\n\t\n\t  var _value$split2 = _slicedToArray(_value$split, 2);\n\t\n\t  var top = _value$split2[0];\n\t  var left = _value$split2[1];\n\t\n\t  return { top: top, left: left };\n\t};\n\tvar parseAttachment = parseOffset;\n\t\n\tvar TetherClass = (function (_Evented) {\n\t  _inherits(TetherClass, _Evented);\n\t\n\t  function TetherClass(options) {\n\t    var _this = this;\n\t\n\t    _classCallCheck(this, TetherClass);\n\t\n\t    _get(Object.getPrototypeOf(TetherClass.prototype), 'constructor', this).call(this);\n\t    this.position = this.position.bind(this);\n\t\n\t    tethers.push(this);\n\t\n\t    this.history = [];\n\t\n\t    this.setOptions(options, false);\n\t\n\t    TetherBase.modules.forEach(function (module) {\n\t      if (typeof module.initialize !== 'undefined') {\n\t        module.initialize.call(_this);\n\t      }\n\t    });\n\t\n\t    this.position();\n\t  }\n\t\n\t  _createClass(TetherClass, [{\n\t    key: 'getClass',\n\t    value: function getClass() {\n\t      var key = arguments.length <= 0 || arguments[0] === undefined ? '' : arguments[0];\n\t      var classes = this.options.classes;\n\t\n\t      if (typeof classes !== 'undefined' && classes[key]) {\n\t        return this.options.classes[key];\n\t      } else if (this.options.classPrefix) {\n\t        return this.options.classPrefix + '-' + key;\n\t      } else {\n\t        return key;\n\t      }\n\t    }\n\t  }, {\n\t    key: 'setOptions',\n\t    value: function setOptions(options) {\n\t      var _this2 = this;\n\t\n\t      var pos = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];\n\t\n\t      var defaults = {\n\t        offset: '0 0',\n\t        targetOffset: '0 0',\n\t        targetAttachment: 'auto auto',\n\t        classPrefix: 'tether'\n\t      };\n\t\n\t      this.options = extend(defaults, options);\n\t\n\t      var _options = this.options;\n\t      var element = _options.element;\n\t      var target = _options.target;\n\t      var targetModifier = _options.targetModifier;\n\t\n\t      this.element = element;\n\t      this.target = target;\n\t      this.targetModifier = targetModifier;\n\t\n\t      if (this.target === 'viewport') {\n\t        this.target = document.body;\n\t        this.targetModifier = 'visible';\n\t      } else if (this.target === 'scroll-handle') {\n\t        this.target = document.body;\n\t        this.targetModifier = 'scroll-handle';\n\t      }\n\t\n\t      ['element', 'target'].forEach(function (key) {\n\t        if (typeof _this2[key] === 'undefined') {\n\t          throw new Error('Tether Error: Both element and target must be defined');\n\t        }\n\t\n\t        if (typeof _this2[key].jquery !== 'undefined') {\n\t          _this2[key] = _this2[key][0];\n\t        } else if (typeof _this2[key] === 'string') {\n\t          _this2[key] = document.querySelector(_this2[key]);\n\t        }\n\t      });\n\t\n\t      addClass(this.element, this.getClass('element'));\n\t      if (!(this.options.addTargetClasses === false)) {\n\t        addClass(this.target, this.getClass('target'));\n\t      }\n\t\n\t      if (!this.options.attachment) {\n\t        throw new Error('Tether Error: You must provide an attachment');\n\t      }\n\t\n\t      this.targetAttachment = parseAttachment(this.options.targetAttachment);\n\t      this.attachment = parseAttachment(this.options.attachment);\n\t      this.offset = parseOffset(this.options.offset);\n\t      this.targetOffset = parseOffset(this.options.targetOffset);\n\t\n\t      if (typeof this.scrollParents !== 'undefined') {\n\t        this.disable();\n\t      }\n\t\n\t      if (this.targetModifier === 'scroll-handle') {\n\t        this.scrollParents = [this.target];\n\t      } else {\n\t        this.scrollParents = getScrollParents(this.target);\n\t      }\n\t\n\t      if (!(this.options.enabled === false)) {\n\t        this.enable(pos);\n\t      }\n\t    }\n\t  }, {\n\t    key: 'getTargetBounds',\n\t    value: function getTargetBounds() {\n\t      if (typeof this.targetModifier !== 'undefined') {\n\t        if (this.targetModifier === 'visible') {\n\t          if (this.target === document.body) {\n\t            return { top: pageYOffset, left: pageXOffset, height: innerHeight, width: innerWidth };\n\t          } else {\n\t            var bounds = getBounds(this.target);\n\t\n\t            var out = {\n\t              height: bounds.height,\n\t              width: bounds.width,\n\t              top: bounds.top,\n\t              left: bounds.left\n\t            };\n\t\n\t            out.height = Math.min(out.height, bounds.height - (pageYOffset - bounds.top));\n\t            out.height = Math.min(out.height, bounds.height - (bounds.top + bounds.height - (pageYOffset + innerHeight)));\n\t            out.height = Math.min(innerHeight, out.height);\n\t            out.height -= 2;\n\t\n\t            out.width = Math.min(out.width, bounds.width - (pageXOffset - bounds.left));\n\t            out.width = Math.min(out.width, bounds.width - (bounds.left + bounds.width - (pageXOffset + innerWidth)));\n\t            out.width = Math.min(innerWidth, out.width);\n\t            out.width -= 2;\n\t\n\t            if (out.top < pageYOffset) {\n\t              out.top = pageYOffset;\n\t            }\n\t            if (out.left < pageXOffset) {\n\t              out.left = pageXOffset;\n\t            }\n\t\n\t            return out;\n\t          }\n\t        } else if (this.targetModifier === 'scroll-handle') {\n\t          var bounds = undefined;\n\t          var target = this.target;\n\t          if (target === document.body) {\n\t            target = document.documentElement;\n\t\n\t            bounds = {\n\t              left: pageXOffset,\n\t              top: pageYOffset,\n\t              height: innerHeight,\n\t              width: innerWidth\n\t            };\n\t          } else {\n\t            bounds = getBounds(target);\n\t          }\n\t\n\t          var style = getComputedStyle(target);\n\t\n\t          var hasBottomScroll = target.scrollWidth > target.clientWidth || [style.overflow, style.overflowX].indexOf('scroll') >= 0 || this.target !== document.body;\n\t\n\t          var scrollBottom = 0;\n\t          if (hasBottomScroll) {\n\t            scrollBottom = 15;\n\t          }\n\t\n\t          var height = bounds.height - parseFloat(style.borderTopWidth) - parseFloat(style.borderBottomWidth) - scrollBottom;\n\t\n\t          var out = {\n\t            width: 15,\n\t            height: height * 0.975 * (height / target.scrollHeight),\n\t            left: bounds.left + bounds.width - parseFloat(style.borderLeftWidth) - 15\n\t          };\n\t\n\t          var fitAdj = 0;\n\t          if (height < 408 && this.target === document.body) {\n\t            fitAdj = -0.00011 * Math.pow(height, 2) - 0.00727 * height + 22.58;\n\t          }\n\t\n\t          if (this.target !== document.body) {\n\t            out.height = Math.max(out.height, 24);\n\t          }\n\t\n\t          var scrollPercentage = this.target.scrollTop / (target.scrollHeight - height);\n\t          out.top = scrollPercentage * (height - out.height - fitAdj) + bounds.top + parseFloat(style.borderTopWidth);\n\t\n\t          if (this.target === document.body) {\n\t            out.height = Math.max(out.height, 24);\n\t          }\n\t\n\t          return out;\n\t        }\n\t      } else {\n\t        return getBounds(this.target);\n\t      }\n\t    }\n\t  }, {\n\t    key: 'clearCache',\n\t    value: function clearCache() {\n\t      this._cache = {};\n\t    }\n\t  }, {\n\t    key: 'cache',\n\t    value: function cache(k, getter) {\n\t      // More than one module will often need the same DOM info, so\n\t      // we keep a cache which is cleared on each position call\n\t      if (typeof this._cache === 'undefined') {\n\t        this._cache = {};\n\t      }\n\t\n\t      if (typeof this._cache[k] === 'undefined') {\n\t        this._cache[k] = getter.call(this);\n\t      }\n\t\n\t      return this._cache[k];\n\t    }\n\t  }, {\n\t    key: 'enable',\n\t    value: function enable() {\n\t      var _this3 = this;\n\t\n\t      var pos = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];\n\t\n\t      if (!(this.options.addTargetClasses === false)) {\n\t        addClass(this.target, this.getClass('enabled'));\n\t      }\n\t      addClass(this.element, this.getClass('enabled'));\n\t      this.enabled = true;\n\t\n\t      this.scrollParents.forEach(function (parent) {\n\t        if (parent !== _this3.target.ownerDocument) {\n\t          parent.addEventListener('scroll', _this3.position);\n\t        }\n\t      });\n\t\n\t      if (pos) {\n\t        this.position();\n\t      }\n\t    }\n\t  }, {\n\t    key: 'disable',\n\t    value: function disable() {\n\t      var _this4 = this;\n\t\n\t      removeClass(this.target, this.getClass('enabled'));\n\t      removeClass(this.element, this.getClass('enabled'));\n\t      this.enabled = false;\n\t\n\t      if (typeof this.scrollParents !== 'undefined') {\n\t        this.scrollParents.forEach(function (parent) {\n\t          parent.removeEventListener('scroll', _this4.position);\n\t        });\n\t      }\n\t    }\n\t  }, {\n\t    key: 'destroy',\n\t    value: function destroy() {\n\t      var _this5 = this;\n\t\n\t      this.disable();\n\t\n\t      tethers.forEach(function (tether, i) {\n\t        if (tether === _this5) {\n\t          tethers.splice(i, 1);\n\t        }\n\t      });\n\t\n\t      // Remove any elements we were using for convenience from the DOM\n\t      if (tethers.length === 0) {\n\t        removeUtilElements();\n\t      }\n\t    }\n\t  }, {\n\t    key: 'updateAttachClasses',\n\t    value: function updateAttachClasses(elementAttach, targetAttach) {\n\t      var _this6 = this;\n\t\n\t      elementAttach = elementAttach || this.attachment;\n\t      targetAttach = targetAttach || this.targetAttachment;\n\t      var sides = ['left', 'top', 'bottom', 'right', 'middle', 'center'];\n\t\n\t      if (typeof this._addAttachClasses !== 'undefined' && this._addAttachClasses.length) {\n\t        // updateAttachClasses can be called more than once in a position call, so\n\t        // we need to clean up after ourselves such that when the last defer gets\n\t        // ran it doesn't add any extra classes from previous calls.\n\t        this._addAttachClasses.splice(0, this._addAttachClasses.length);\n\t      }\n\t\n\t      if (typeof this._addAttachClasses === 'undefined') {\n\t        this._addAttachClasses = [];\n\t      }\n\t      var add = this._addAttachClasses;\n\t\n\t      if (elementAttach.top) {\n\t        add.push(this.getClass('element-attached') + '-' + elementAttach.top);\n\t      }\n\t      if (elementAttach.left) {\n\t        add.push(this.getClass('element-attached') + '-' + elementAttach.left);\n\t      }\n\t      if (targetAttach.top) {\n\t        add.push(this.getClass('target-attached') + '-' + targetAttach.top);\n\t      }\n\t      if (targetAttach.left) {\n\t        add.push(this.getClass('target-attached') + '-' + targetAttach.left);\n\t      }\n\t\n\t      var all = [];\n\t      sides.forEach(function (side) {\n\t        all.push(_this6.getClass('element-attached') + '-' + side);\n\t        all.push(_this6.getClass('target-attached') + '-' + side);\n\t      });\n\t\n\t      defer(function () {\n\t        if (!(typeof _this6._addAttachClasses !== 'undefined')) {\n\t          return;\n\t        }\n\t\n\t        updateClasses(_this6.element, _this6._addAttachClasses, all);\n\t        if (!(_this6.options.addTargetClasses === false)) {\n\t          updateClasses(_this6.target, _this6._addAttachClasses, all);\n\t        }\n\t\n\t        delete _this6._addAttachClasses;\n\t      });\n\t    }\n\t  }, {\n\t    key: 'position',\n\t    value: function position() {\n\t      var _this7 = this;\n\t\n\t      var flushChanges = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];\n\t\n\t      // flushChanges commits the changes immediately, leave true unless you are positioning multiple\n\t      // tethers (in which case call Tether.Utils.flush yourself when you're done)\n\t\n\t      if (!this.enabled) {\n\t        return;\n\t      }\n\t\n\t      this.clearCache();\n\t\n\t      // Turn 'auto' attachments into the appropriate corner or edge\n\t      var targetAttachment = autoToFixedAttachment(this.targetAttachment, this.attachment);\n\t\n\t      this.updateAttachClasses(this.attachment, targetAttachment);\n\t\n\t      var elementPos = this.cache('element-bounds', function () {\n\t        return getBounds(_this7.element);\n\t      });\n\t\n\t      var width = elementPos.width;\n\t      var height = elementPos.height;\n\t\n\t      if (width === 0 && height === 0 && typeof this.lastSize !== 'undefined') {\n\t        var _lastSize = this.lastSize;\n\t\n\t        // We cache the height and width to make it possible to position elements that are\n\t        // getting hidden.\n\t        width = _lastSize.width;\n\t        height = _lastSize.height;\n\t      } else {\n\t        this.lastSize = { width: width, height: height };\n\t      }\n\t\n\t      var targetPos = this.cache('target-bounds', function () {\n\t        return _this7.getTargetBounds();\n\t      });\n\t      var targetSize = targetPos;\n\t\n\t      // Get an actual px offset from the attachment\n\t      var offset = offsetToPx(attachmentToOffset(this.attachment), { width: width, height: height });\n\t      var targetOffset = offsetToPx(attachmentToOffset(targetAttachment), targetSize);\n\t\n\t      var manualOffset = offsetToPx(this.offset, { width: width, height: height });\n\t      var manualTargetOffset = offsetToPx(this.targetOffset, targetSize);\n\t\n\t      // Add the manually provided offset\n\t      offset = addOffset(offset, manualOffset);\n\t      targetOffset = addOffset(targetOffset, manualTargetOffset);\n\t\n\t      // It's now our goal to make (element position + offset) == (target position + target offset)\n\t      var left = targetPos.left + targetOffset.left - offset.left;\n\t      var top = targetPos.top + targetOffset.top - offset.top;\n\t\n\t      for (var i = 0; i < TetherBase.modules.length; ++i) {\n\t        var _module2 = TetherBase.modules[i];\n\t        var ret = _module2.position.call(this, {\n\t          left: left,\n\t          top: top,\n\t          targetAttachment: targetAttachment,\n\t          targetPos: targetPos,\n\t          elementPos: elementPos,\n\t          offset: offset,\n\t          targetOffset: targetOffset,\n\t          manualOffset: manualOffset,\n\t          manualTargetOffset: manualTargetOffset,\n\t          scrollbarSize: scrollbarSize,\n\t          attachment: this.attachment\n\t        });\n\t\n\t        if (ret === false) {\n\t          return false;\n\t        } else if (typeof ret === 'undefined' || typeof ret !== 'object') {\n\t          continue;\n\t        } else {\n\t          top = ret.top;\n\t          left = ret.left;\n\t        }\n\t      }\n\t\n\t      // We describe the position three different ways to give the optimizer\n\t      // a chance to decide the best possible way to position the element\n\t      // with the fewest repaints.\n\t      var next = {\n\t        // It's position relative to the page (absolute positioning when\n\t        // the element is a child of the body)\n\t        page: {\n\t          top: top,\n\t          left: left\n\t        },\n\t\n\t        // It's position relative to the viewport (fixed positioning)\n\t        viewport: {\n\t          top: top - pageYOffset,\n\t          bottom: pageYOffset - top - height + innerHeight,\n\t          left: left - pageXOffset,\n\t          right: pageXOffset - left - width + innerWidth\n\t        }\n\t      };\n\t\n\t      var doc = this.target.ownerDocument;\n\t      var win = doc.defaultView;\n\t\n\t      var scrollbarSize = undefined;\n\t      if (win.innerHeight > doc.documentElement.clientHeight) {\n\t        scrollbarSize = this.cache('scrollbar-size', getScrollBarSize);\n\t        next.viewport.bottom -= scrollbarSize.height;\n\t      }\n\t\n\t      if (win.innerWidth > doc.documentElement.clientWidth) {\n\t        scrollbarSize = this.cache('scrollbar-size', getScrollBarSize);\n\t        next.viewport.right -= scrollbarSize.width;\n\t      }\n\t\n\t      if (['', 'static'].indexOf(doc.body.style.position) === -1 || ['', 'static'].indexOf(doc.body.parentElement.style.position) === -1) {\n\t        // Absolute positioning in the body will be relative to the page, not the 'initial containing block'\n\t        next.page.bottom = doc.body.scrollHeight - top - height;\n\t        next.page.right = doc.body.scrollWidth - left - width;\n\t      }\n\t\n\t      if (typeof this.options.optimizations !== 'undefined' && this.options.optimizations.moveElement !== false && !(typeof this.targetModifier !== 'undefined')) {\n\t        (function () {\n\t          var offsetParent = _this7.cache('target-offsetparent', function () {\n\t            return getOffsetParent(_this7.target);\n\t          });\n\t          var offsetPosition = _this7.cache('target-offsetparent-bounds', function () {\n\t            return getBounds(offsetParent);\n\t          });\n\t          var offsetParentStyle = getComputedStyle(offsetParent);\n\t          var offsetParentSize = offsetPosition;\n\t\n\t          var offsetBorder = {};\n\t          ['Top', 'Left', 'Bottom', 'Right'].forEach(function (side) {\n\t            offsetBorder[side.toLowerCase()] = parseFloat(offsetParentStyle['border' + side + 'Width']);\n\t          });\n\t\n\t          offsetPosition.right = doc.body.scrollWidth - offsetPosition.left - offsetParentSize.width + offsetBorder.right;\n\t          offsetPosition.bottom = doc.body.scrollHeight - offsetPosition.top - offsetParentSize.height + offsetBorder.bottom;\n\t\n\t          if (next.page.top >= offsetPosition.top + offsetBorder.top && next.page.bottom >= offsetPosition.bottom) {\n\t            if (next.page.left >= offsetPosition.left + offsetBorder.left && next.page.right >= offsetPosition.right) {\n\t              // We're within the visible part of the target's scroll parent\n\t              var scrollTop = offsetParent.scrollTop;\n\t              var scrollLeft = offsetParent.scrollLeft;\n\t\n\t              // It's position relative to the target's offset parent (absolute positioning when\n\t              // the element is moved to be a child of the target's offset parent).\n\t              next.offset = {\n\t                top: next.page.top - offsetPosition.top + scrollTop - offsetBorder.top,\n\t                left: next.page.left - offsetPosition.left + scrollLeft - offsetBorder.left\n\t              };\n\t            }\n\t          }\n\t        })();\n\t      }\n\t\n\t      // We could also travel up the DOM and try each containing context, rather than only\n\t      // looking at the body, but we're gonna get diminishing returns.\n\t\n\t      this.move(next);\n\t\n\t      this.history.unshift(next);\n\t\n\t      if (this.history.length > 3) {\n\t        this.history.pop();\n\t      }\n\t\n\t      if (flushChanges) {\n\t        flush();\n\t      }\n\t\n\t      return true;\n\t    }\n\t\n\t    // THE ISSUE\n\t  }, {\n\t    key: 'move',\n\t    value: function move(pos) {\n\t      var _this8 = this;\n\t\n\t      if (!(typeof this.element.parentNode !== 'undefined')) {\n\t        return;\n\t      }\n\t\n\t      var same = {};\n\t\n\t      for (var type in pos) {\n\t        same[type] = {};\n\t\n\t        for (var key in pos[type]) {\n\t          var found = false;\n\t\n\t          for (var i = 0; i < this.history.length; ++i) {\n\t            var point = this.history[i];\n\t            if (typeof point[type] !== 'undefined' && !within(point[type][key], pos[type][key])) {\n\t              found = true;\n\t              break;\n\t            }\n\t          }\n\t\n\t          if (!found) {\n\t            same[type][key] = true;\n\t          }\n\t        }\n\t      }\n\t\n\t      var css = { top: '', left: '', right: '', bottom: '' };\n\t\n\t      var transcribe = function transcribe(_same, _pos) {\n\t        var hasOptimizations = typeof _this8.options.optimizations !== 'undefined';\n\t        var gpu = hasOptimizations ? _this8.options.optimizations.gpu : null;\n\t        if (gpu !== false) {\n\t          var yPos = undefined,\n\t              xPos = undefined;\n\t          if (_same.top) {\n\t            css.top = 0;\n\t            yPos = _pos.top;\n\t          } else {\n\t            css.bottom = 0;\n\t            yPos = -_pos.bottom;\n\t          }\n\t\n\t          if (_same.left) {\n\t            css.left = 0;\n\t            xPos = _pos.left;\n\t          } else {\n\t            css.right = 0;\n\t            xPos = -_pos.right;\n\t          }\n\t\n\t          if (window.matchMedia) {\n\t            // HubSpot/tether#207\n\t            var retina = window.matchMedia('only screen and (min-resolution: 1.3dppx)').matches || window.matchMedia('only screen and (-webkit-min-device-pixel-ratio: 1.3)').matches;\n\t            if (!retina) {\n\t              xPos = Math.round(xPos);\n\t              yPos = Math.round(yPos);\n\t            }\n\t          }\n\t\n\t          css[transformKey] = 'translateX(' + xPos + 'px) translateY(' + yPos + 'px)';\n\t\n\t          if (transformKey !== 'msTransform') {\n\t            // The Z transform will keep this in the GPU (faster, and prevents artifacts),\n\t            // but IE9 doesn't support 3d transforms and will choke.\n\t            css[transformKey] += \" translateZ(0)\";\n\t          }\n\t        } else {\n\t          if (_same.top) {\n\t            css.top = _pos.top + 'px';\n\t          } else {\n\t            css.bottom = _pos.bottom + 'px';\n\t          }\n\t\n\t          if (_same.left) {\n\t            css.left = _pos.left + 'px';\n\t          } else {\n\t            css.right = _pos.right + 'px';\n\t          }\n\t        }\n\t      };\n\t\n\t      var moved = false;\n\t      if ((same.page.top || same.page.bottom) && (same.page.left || same.page.right)) {\n\t        css.position = 'absolute';\n\t        transcribe(same.page, pos.page);\n\t      } else if ((same.viewport.top || same.viewport.bottom) && (same.viewport.left || same.viewport.right)) {\n\t        css.position = 'fixed';\n\t        transcribe(same.viewport, pos.viewport);\n\t      } else if (typeof same.offset !== 'undefined' && same.offset.top && same.offset.left) {\n\t        (function () {\n\t          css.position = 'absolute';\n\t          var offsetParent = _this8.cache('target-offsetparent', function () {\n\t            return getOffsetParent(_this8.target);\n\t          });\n\t\n\t          if (getOffsetParent(_this8.element) !== offsetParent) {\n\t            defer(function () {\n\t              _this8.element.parentNode.removeChild(_this8.element);\n\t              offsetParent.appendChild(_this8.element);\n\t            });\n\t          }\n\t\n\t          transcribe(same.offset, pos.offset);\n\t          moved = true;\n\t        })();\n\t      } else {\n\t        css.position = 'absolute';\n\t        transcribe({ top: true, left: true }, pos.page);\n\t      }\n\t\n\t      if (!moved) {\n\t        if (this.options.bodyElement) {\n\t          if (this.element.parentNode !== this.options.bodyElement) {\n\t            this.options.bodyElement.appendChild(this.element);\n\t          }\n\t        } else {\n\t          var offsetParentIsBody = true;\n\t          var currentNode = this.element.parentNode;\n\t          while (currentNode && currentNode.nodeType === 1 && currentNode.tagName !== 'BODY') {\n\t            if (getComputedStyle(currentNode).position !== 'static') {\n\t              offsetParentIsBody = false;\n\t              break;\n\t            }\n\t\n\t            currentNode = currentNode.parentNode;\n\t          }\n\t\n\t          if (!offsetParentIsBody) {\n\t            this.element.parentNode.removeChild(this.element);\n\t            this.element.ownerDocument.body.appendChild(this.element);\n\t          }\n\t        }\n\t      }\n\t\n\t      // Any css change will trigger a repaint, so let's avoid one if nothing changed\n\t      var writeCSS = {};\n\t      var write = false;\n\t      for (var key in css) {\n\t        var val = css[key];\n\t        var elVal = this.element.style[key];\n\t\n\t        if (elVal !== val) {\n\t          write = true;\n\t          writeCSS[key] = val;\n\t        }\n\t      }\n\t\n\t      if (write) {\n\t        defer(function () {\n\t          extend(_this8.element.style, writeCSS);\n\t          _this8.trigger('repositioned');\n\t        });\n\t      }\n\t    }\n\t  }]);\n\t\n\t  return TetherClass;\n\t})(Evented);\n\t\n\tTetherClass.modules = [];\n\t\n\tTetherBase.position = position;\n\t\n\tvar Tether = extend(TetherClass, TetherBase);\n\t/* globals TetherBase */\n\t\n\t'use strict';\n\t\n\tvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\t\n\tvar _TetherBase$Utils = TetherBase.Utils;\n\tvar getBounds = _TetherBase$Utils.getBounds;\n\tvar extend = _TetherBase$Utils.extend;\n\tvar updateClasses = _TetherBase$Utils.updateClasses;\n\tvar defer = _TetherBase$Utils.defer;\n\t\n\tvar BOUNDS_FORMAT = ['left', 'top', 'right', 'bottom'];\n\t\n\tfunction getBoundingRect(tether, to) {\n\t  if (to === 'scrollParent') {\n\t    to = tether.scrollParents[0];\n\t  } else if (to === 'window') {\n\t    to = [pageXOffset, pageYOffset, innerWidth + pageXOffset, innerHeight + pageYOffset];\n\t  }\n\t\n\t  if (to === document) {\n\t    to = to.documentElement;\n\t  }\n\t\n\t  if (typeof to.nodeType !== 'undefined') {\n\t    (function () {\n\t      var node = to;\n\t      var size = getBounds(to);\n\t      var pos = size;\n\t      var style = getComputedStyle(to);\n\t\n\t      to = [pos.left, pos.top, size.width + pos.left, size.height + pos.top];\n\t\n\t      // Account any parent Frames scroll offset\n\t      if (node.ownerDocument !== document) {\n\t        var win = node.ownerDocument.defaultView;\n\t        to[0] += win.pageXOffset;\n\t        to[1] += win.pageYOffset;\n\t        to[2] += win.pageXOffset;\n\t        to[3] += win.pageYOffset;\n\t      }\n\t\n\t      BOUNDS_FORMAT.forEach(function (side, i) {\n\t        side = side[0].toUpperCase() + side.substr(1);\n\t        if (side === 'Top' || side === 'Left') {\n\t          to[i] += parseFloat(style['border' + side + 'Width']);\n\t        } else {\n\t          to[i] -= parseFloat(style['border' + side + 'Width']);\n\t        }\n\t      });\n\t    })();\n\t  }\n\t\n\t  return to;\n\t}\n\t\n\tTetherBase.modules.push({\n\t  position: function position(_ref) {\n\t    var _this = this;\n\t\n\t    var top = _ref.top;\n\t    var left = _ref.left;\n\t    var targetAttachment = _ref.targetAttachment;\n\t\n\t    if (!this.options.constraints) {\n\t      return true;\n\t    }\n\t\n\t    var _cache = this.cache('element-bounds', function () {\n\t      return getBounds(_this.element);\n\t    });\n\t\n\t    var height = _cache.height;\n\t    var width = _cache.width;\n\t\n\t    if (width === 0 && height === 0 && typeof this.lastSize !== 'undefined') {\n\t      var _lastSize = this.lastSize;\n\t\n\t      // Handle the item getting hidden as a result of our positioning without glitching\n\t      // the classes in and out\n\t      width = _lastSize.width;\n\t      height = _lastSize.height;\n\t    }\n\t\n\t    var targetSize = this.cache('target-bounds', function () {\n\t      return _this.getTargetBounds();\n\t    });\n\t\n\t    var targetHeight = targetSize.height;\n\t    var targetWidth = targetSize.width;\n\t\n\t    var allClasses = [this.getClass('pinned'), this.getClass('out-of-bounds')];\n\t\n\t    this.options.constraints.forEach(function (constraint) {\n\t      var outOfBoundsClass = constraint.outOfBoundsClass;\n\t      var pinnedClass = constraint.pinnedClass;\n\t\n\t      if (outOfBoundsClass) {\n\t        allClasses.push(outOfBoundsClass);\n\t      }\n\t      if (pinnedClass) {\n\t        allClasses.push(pinnedClass);\n\t      }\n\t    });\n\t\n\t    allClasses.forEach(function (cls) {\n\t      ['left', 'top', 'right', 'bottom'].forEach(function (side) {\n\t        allClasses.push(cls + '-' + side);\n\t      });\n\t    });\n\t\n\t    var addClasses = [];\n\t\n\t    var tAttachment = extend({}, targetAttachment);\n\t    var eAttachment = extend({}, this.attachment);\n\t\n\t    this.options.constraints.forEach(function (constraint) {\n\t      var to = constraint.to;\n\t      var attachment = constraint.attachment;\n\t      var pin = constraint.pin;\n\t\n\t      if (typeof attachment === 'undefined') {\n\t        attachment = '';\n\t      }\n\t\n\t      var changeAttachX = undefined,\n\t          changeAttachY = undefined;\n\t      if (attachment.indexOf(' ') >= 0) {\n\t        var _attachment$split = attachment.split(' ');\n\t\n\t        var _attachment$split2 = _slicedToArray(_attachment$split, 2);\n\t\n\t        changeAttachY = _attachment$split2[0];\n\t        changeAttachX = _attachment$split2[1];\n\t      } else {\n\t        changeAttachX = changeAttachY = attachment;\n\t      }\n\t\n\t      var bounds = getBoundingRect(_this, to);\n\t\n\t      if (changeAttachY === 'target' || changeAttachY === 'both') {\n\t        if (top < bounds[1] && tAttachment.top === 'top') {\n\t          top += targetHeight;\n\t          tAttachment.top = 'bottom';\n\t        }\n\t\n\t        if (top + height > bounds[3] && tAttachment.top === 'bottom') {\n\t          top -= targetHeight;\n\t          tAttachment.top = 'top';\n\t        }\n\t      }\n\t\n\t      if (changeAttachY === 'together') {\n\t        if (tAttachment.top === 'top') {\n\t          if (eAttachment.top === 'bottom' && top < bounds[1]) {\n\t            top += targetHeight;\n\t            tAttachment.top = 'bottom';\n\t\n\t            top += height;\n\t            eAttachment.top = 'top';\n\t          } else if (eAttachment.top === 'top' && top + height > bounds[3] && top - (height - targetHeight) >= bounds[1]) {\n\t            top -= height - targetHeight;\n\t            tAttachment.top = 'bottom';\n\t\n\t            eAttachment.top = 'bottom';\n\t          }\n\t        }\n\t\n\t        if (tAttachment.top === 'bottom') {\n\t          if (eAttachment.top === 'top' && top + height > bounds[3]) {\n\t            top -= targetHeight;\n\t            tAttachment.top = 'top';\n\t\n\t            top -= height;\n\t            eAttachment.top = 'bottom';\n\t          } else if (eAttachment.top === 'bottom' && top < bounds[1] && top + (height * 2 - targetHeight) <= bounds[3]) {\n\t            top += height - targetHeight;\n\t            tAttachment.top = 'top';\n\t\n\t            eAttachment.top = 'top';\n\t          }\n\t        }\n\t\n\t        if (tAttachment.top === 'middle') {\n\t          if (top + height > bounds[3] && eAttachment.top === 'top') {\n\t            top -= height;\n\t            eAttachment.top = 'bottom';\n\t          } else if (top < bounds[1] && eAttachment.top === 'bottom') {\n\t            top += height;\n\t            eAttachment.top = 'top';\n\t          }\n\t        }\n\t      }\n\t\n\t      if (changeAttachX === 'target' || changeAttachX === 'both') {\n\t        if (left < bounds[0] && tAttachment.left === 'left') {\n\t          left += targetWidth;\n\t          tAttachment.left = 'right';\n\t        }\n\t\n\t        if (left + width > bounds[2] && tAttachment.left === 'right') {\n\t          left -= targetWidth;\n\t          tAttachment.left = 'left';\n\t        }\n\t      }\n\t\n\t      if (changeAttachX === 'together') {\n\t        if (left < bounds[0] && tAttachment.left === 'left') {\n\t          if (eAttachment.left === 'right') {\n\t            left += targetWidth;\n\t            tAttachment.left = 'right';\n\t\n\t            left += width;\n\t            eAttachment.left = 'left';\n\t          } else if (eAttachment.left === 'left') {\n\t            left += targetWidth;\n\t            tAttachment.left = 'right';\n\t\n\t            left -= width;\n\t            eAttachment.left = 'right';\n\t          }\n\t        } else if (left + width > bounds[2] && tAttachment.left === 'right') {\n\t          if (eAttachment.left === 'left') {\n\t            left -= targetWidth;\n\t            tAttachment.left = 'left';\n\t\n\t            left -= width;\n\t            eAttachment.left = 'right';\n\t          } else if (eAttachment.left === 'right') {\n\t            left -= targetWidth;\n\t            tAttachment.left = 'left';\n\t\n\t            left += width;\n\t            eAttachment.left = 'left';\n\t          }\n\t        } else if (tAttachment.left === 'center') {\n\t          if (left + width > bounds[2] && eAttachment.left === 'left') {\n\t            left -= width;\n\t            eAttachment.left = 'right';\n\t          } else if (left < bounds[0] && eAttachment.left === 'right') {\n\t            left += width;\n\t            eAttachment.left = 'left';\n\t          }\n\t        }\n\t      }\n\t\n\t      if (changeAttachY === 'element' || changeAttachY === 'both') {\n\t        if (top < bounds[1] && eAttachment.top === 'bottom') {\n\t          top += height;\n\t          eAttachment.top = 'top';\n\t        }\n\t\n\t        if (top + height > bounds[3] && eAttachment.top === 'top') {\n\t          top -= height;\n\t          eAttachment.top = 'bottom';\n\t        }\n\t      }\n\t\n\t      if (changeAttachX === 'element' || changeAttachX === 'both') {\n\t        if (left < bounds[0]) {\n\t          if (eAttachment.left === 'right') {\n\t            left += width;\n\t            eAttachment.left = 'left';\n\t          } else if (eAttachment.left === 'center') {\n\t            left += width / 2;\n\t            eAttachment.left = 'left';\n\t          }\n\t        }\n\t\n\t        if (left + width > bounds[2]) {\n\t          if (eAttachment.left === 'left') {\n\t            left -= width;\n\t            eAttachment.left = 'right';\n\t          } else if (eAttachment.left === 'center') {\n\t            left -= width / 2;\n\t            eAttachment.left = 'right';\n\t          }\n\t        }\n\t      }\n\t\n\t      if (typeof pin === 'string') {\n\t        pin = pin.split(',').map(function (p) {\n\t          return p.trim();\n\t        });\n\t      } else if (pin === true) {\n\t        pin = ['top', 'left', 'right', 'bottom'];\n\t      }\n\t\n\t      pin = pin || [];\n\t\n\t      var pinned = [];\n\t      var oob = [];\n\t\n\t      if (top < bounds[1]) {\n\t        if (pin.indexOf('top') >= 0) {\n\t          top = bounds[1];\n\t          pinned.push('top');\n\t        } else {\n\t          oob.push('top');\n\t        }\n\t      }\n\t\n\t      if (top + height > bounds[3]) {\n\t        if (pin.indexOf('bottom') >= 0) {\n\t          top = bounds[3] - height;\n\t          pinned.push('bottom');\n\t        } else {\n\t          oob.push('bottom');\n\t        }\n\t      }\n\t\n\t      if (left < bounds[0]) {\n\t        if (pin.indexOf('left') >= 0) {\n\t          left = bounds[0];\n\t          pinned.push('left');\n\t        } else {\n\t          oob.push('left');\n\t        }\n\t      }\n\t\n\t      if (left + width > bounds[2]) {\n\t        if (pin.indexOf('right') >= 0) {\n\t          left = bounds[2] - width;\n\t          pinned.push('right');\n\t        } else {\n\t          oob.push('right');\n\t        }\n\t      }\n\t\n\t      if (pinned.length) {\n\t        (function () {\n\t          var pinnedClass = undefined;\n\t          if (typeof _this.options.pinnedClass !== 'undefined') {\n\t            pinnedClass = _this.options.pinnedClass;\n\t          } else {\n\t            pinnedClass = _this.getClass('pinned');\n\t          }\n\t\n\t          addClasses.push(pinnedClass);\n\t          pinned.forEach(function (side) {\n\t            addClasses.push(pinnedClass + '-' + side);\n\t          });\n\t        })();\n\t      }\n\t\n\t      if (oob.length) {\n\t        (function () {\n\t          var oobClass = undefined;\n\t          if (typeof _this.options.outOfBoundsClass !== 'undefined') {\n\t            oobClass = _this.options.outOfBoundsClass;\n\t          } else {\n\t            oobClass = _this.getClass('out-of-bounds');\n\t          }\n\t\n\t          addClasses.push(oobClass);\n\t          oob.forEach(function (side) {\n\t            addClasses.push(oobClass + '-' + side);\n\t          });\n\t        })();\n\t      }\n\t\n\t      if (pinned.indexOf('left') >= 0 || pinned.indexOf('right') >= 0) {\n\t        eAttachment.left = tAttachment.left = false;\n\t      }\n\t      if (pinned.indexOf('top') >= 0 || pinned.indexOf('bottom') >= 0) {\n\t        eAttachment.top = tAttachment.top = false;\n\t      }\n\t\n\t      if (tAttachment.top !== targetAttachment.top || tAttachment.left !== targetAttachment.left || eAttachment.top !== _this.attachment.top || eAttachment.left !== _this.attachment.left) {\n\t        _this.updateAttachClasses(eAttachment, tAttachment);\n\t        _this.trigger('update', {\n\t          attachment: eAttachment,\n\t          targetAttachment: tAttachment\n\t        });\n\t      }\n\t    });\n\t\n\t    defer(function () {\n\t      if (!(_this.options.addTargetClasses === false)) {\n\t        updateClasses(_this.target, addClasses, allClasses);\n\t      }\n\t      updateClasses(_this.element, addClasses, allClasses);\n\t    });\n\t\n\t    return { top: top, left: left };\n\t  }\n\t});\n\t/* globals TetherBase */\n\t\n\t'use strict';\n\t\n\tvar _TetherBase$Utils = TetherBase.Utils;\n\tvar getBounds = _TetherBase$Utils.getBounds;\n\tvar updateClasses = _TetherBase$Utils.updateClasses;\n\tvar defer = _TetherBase$Utils.defer;\n\t\n\tTetherBase.modules.push({\n\t  position: function position(_ref) {\n\t    var _this = this;\n\t\n\t    var top = _ref.top;\n\t    var left = _ref.left;\n\t\n\t    var _cache = this.cache('element-bounds', function () {\n\t      return getBounds(_this.element);\n\t    });\n\t\n\t    var height = _cache.height;\n\t    var width = _cache.width;\n\t\n\t    var targetPos = this.getTargetBounds();\n\t\n\t    var bottom = top + height;\n\t    var right = left + width;\n\t\n\t    var abutted = [];\n\t    if (top <= targetPos.bottom && bottom >= targetPos.top) {\n\t      ['left', 'right'].forEach(function (side) {\n\t        var targetPosSide = targetPos[side];\n\t        if (targetPosSide === left || targetPosSide === right) {\n\t          abutted.push(side);\n\t        }\n\t      });\n\t    }\n\t\n\t    if (left <= targetPos.right && right >= targetPos.left) {\n\t      ['top', 'bottom'].forEach(function (side) {\n\t        var targetPosSide = targetPos[side];\n\t        if (targetPosSide === top || targetPosSide === bottom) {\n\t          abutted.push(side);\n\t        }\n\t      });\n\t    }\n\t\n\t    var allClasses = [];\n\t    var addClasses = [];\n\t\n\t    var sides = ['left', 'top', 'right', 'bottom'];\n\t    allClasses.push(this.getClass('abutted'));\n\t    sides.forEach(function (side) {\n\t      allClasses.push(_this.getClass('abutted') + '-' + side);\n\t    });\n\t\n\t    if (abutted.length) {\n\t      addClasses.push(this.getClass('abutted'));\n\t    }\n\t\n\t    abutted.forEach(function (side) {\n\t      addClasses.push(_this.getClass('abutted') + '-' + side);\n\t    });\n\t\n\t    defer(function () {\n\t      if (!(_this.options.addTargetClasses === false)) {\n\t        updateClasses(_this.target, addClasses, allClasses);\n\t      }\n\t      updateClasses(_this.element, addClasses, allClasses);\n\t    });\n\t\n\t    return true;\n\t  }\n\t});\n\t/* globals TetherBase */\n\t\n\t'use strict';\n\t\n\tvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\t\n\tTetherBase.modules.push({\n\t  position: function position(_ref) {\n\t    var top = _ref.top;\n\t    var left = _ref.left;\n\t\n\t    if (!this.options.shift) {\n\t      return;\n\t    }\n\t\n\t    var shift = this.options.shift;\n\t    if (typeof this.options.shift === 'function') {\n\t      shift = this.options.shift.call(this, { top: top, left: left });\n\t    }\n\t\n\t    var shiftTop = undefined,\n\t        shiftLeft = undefined;\n\t    if (typeof shift === 'string') {\n\t      shift = shift.split(' ');\n\t      shift[1] = shift[1] || shift[0];\n\t\n\t      var _shift = shift;\n\t\n\t      var _shift2 = _slicedToArray(_shift, 2);\n\t\n\t      shiftTop = _shift2[0];\n\t      shiftLeft = _shift2[1];\n\t\n\t      shiftTop = parseFloat(shiftTop, 10);\n\t      shiftLeft = parseFloat(shiftLeft, 10);\n\t    } else {\n\t      shiftTop = shift.top;\n\t      shiftLeft = shift.left;\n\t    }\n\t\n\t    top += shiftTop;\n\t    left += shiftLeft;\n\t\n\t    return { top: top, left: left };\n\t  }\n\t});\n\treturn Tether;\n\t\n\t}));\n\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _resizeObserver = __webpack_require__(3);\n\t\n\tvar _resizeObserver2 = _interopRequireDefault(_resizeObserver);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-breadcrumb';\n\tvar CLASS_ITEMS = 'aui-breadcrumb__items';\n\tvar CLASS_IS_OVERSIZED = 'is-oversized';\n\t\n\t/**\n\t * Class constructor for Breadcrumb AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Breadcrumb = function (_Component) {\n\t  _inherits(Breadcrumb, _Component);\n\t\n\t  /**\n\t   * Upgrades all Breadcrumb AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Breadcrumb.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Breadcrumb(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Breadcrumb(element) {\n\t    _classCallCheck(this, Breadcrumb);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  Breadcrumb.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._items = this._element.querySelector('.' + CLASS_ITEMS);\n\t\n\t    this._resizeObserver = new _resizeObserver2.default();\n\t    this._resizeObserver.resized.add(this._resizedHandler = function () {\n\t      return _this2.update();\n\t    });\n\t\n\t    this.update();\n\t  };\n\t\n\t  Breadcrumb.prototype.update = function update() {\n\t    this._checkSize();\n\t  };\n\t\n\t  Breadcrumb.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._resizeObserver.resized.remove(this._resizedHandler);\n\t  };\n\t\n\t  Breadcrumb.prototype._checkSize = function _checkSize() {\n\t    if (this._items.scrollWidth > this._items.offsetWidth) {\n\t      this._items.scrollLeft = 9999;\n\t      this._element.classList.add(CLASS_IS_OVERSIZED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_OVERSIZED);\n\t    }\n\t  };\n\t\n\t  return Breadcrumb;\n\t}(_component2.default);\n\t\n\texports.default = Breadcrumb;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 12 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar NAMESPACE = 'auiCheckbox';\n\tvar SELECTOR_COMPONENT = '.aui-js-checkbox';\n\tvar CLASS_INPUT = 'aui-checkbox__input';\n\tvar CLASS_LABEL = 'aui-checkbox__label';\n\tvar CLASS_BOX = 'aui-checkbox__box';\n\tvar CLASS_TICK = 'aui-checkbox__tick';\n\tvar CLASS_IS_FOCUS = 'is-focused';\n\tvar CLASS_IS_CHECKED = 'is-checked';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\t\n\t/**\n\t * Class constructor for Checkbox AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Checkbox = function (_Component) {\n\t  _inherits(Checkbox, _Component);\n\t\n\t  /**\n\t   * Upgrades all Checkbox AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Checkbox.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Checkbox(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Returns all AUI component instances within the given container\n\t   * @param {HTMLElement} container The container element to search for components\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Checkbox.get = function get() {\n\t    var container = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;\n\t\n\t    var components = [];\n\t    if (container) {\n\t      Array.from(container.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t        components.push(element.auiCheckbox);\n\t      });\n\t    }\n\t    return components;\n\t  };\n\t\n\t  function Checkbox(element) {\n\t    _classCallCheck(this, Checkbox);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element, NAMESPACE));\n\t  }\n\t\n\t  Checkbox.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._input = this._element.querySelector('.' + CLASS_INPUT);\n\t    this._input.addEventListener('change', this._changeHandler = function (event) {\n\t      return _this2._onChange(event);\n\t    });\n\t    this._input.addEventListener('focus', this._focusHandler = function (event) {\n\t      return _this2._onFocus(event);\n\t    });\n\t    this._input.addEventListener('blur', this._blurHandler = function (event) {\n\t      return _this2._onBlur(event);\n\t    });\n\t\n\t    // Insert box with tick after label element:\n\t    this._label = this._element.querySelector('.' + CLASS_LABEL);\n\t    var box = document.createElement('span');\n\t    box.classList.add(CLASS_BOX);\n\t    this._label.parentNode.insertBefore(box, this._label.nextSibling);\n\t    var tick = document.createElement('span');\n\t    tick.classList.add(CLASS_TICK);\n\t    box.appendChild(tick);\n\t\n\t    this.updateClasses();\n\t  };\n\t\n\t  Checkbox.prototype.updateClasses = function updateClasses() {\n\t    this.checkDisabled();\n\t    this.checkToggleState();\n\t    this.checkFocus();\n\t  };\n\t\n\t  /**\n\t   * Check the disabled state and update field accordingly.\n\t   */\n\t\n\t\n\t  Checkbox.prototype.checkDisabled = function checkDisabled() {\n\t    if (this._input.disabled) {\n\t      this._element.classList.add(CLASS_IS_DISABLED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DISABLED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the toggle state and update field accordingly.\n\t   */\n\t\n\t\n\t  Checkbox.prototype.checkToggleState = function checkToggleState() {\n\t    if (this._input.checked) {\n\t      this._element.classList.add(CLASS_IS_CHECKED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_CHECKED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the focus state and update field accordingly.\n\t   */\n\t\n\t\n\t  Checkbox.prototype.checkFocus = function checkFocus() {\n\t    if (Boolean(this._element.querySelector(':focus'))) {\n\t      this._element.classList.add(CLASS_IS_FOCUS);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_FOCUS);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Enable checkbox\n\t   */\n\t\n\t\n\t  Checkbox.prototype.enable = function enable() {\n\t    this._input.disabled = false;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Disable checkbox\n\t   */\n\t\n\t\n\t  Checkbox.prototype.disable = function disable() {\n\t    this._input.disabled = true;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Check checkbox\n\t   */\n\t\n\t\n\t  Checkbox.prototype.check = function check() {\n\t    this._input.checked = true;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Uncheck checkbox\n\t   */\n\t\n\t\n\t  Checkbox.prototype.uncheck = function uncheck() {\n\t    this._input.checked = false;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Uncheck checkbox\n\t   */\n\t\n\t\n\t  Checkbox.prototype.toggle = function toggle() {\n\t    if (this._input.checked) {\n\t      this.uncheck();\n\t    } else {\n\t      this.check();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Checkbox.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._input.removeEventListener('change', this._changeHandler);\n\t    this._input.removeEventListener('focus', this._focusHandler);\n\t    this._input.removeEventListener('blur', this._blurHandler);\n\t\n\t    this._element.removeChild(this._element.querySelector('.' + CLASS_BOX));\n\t  };\n\t\n\t  /**\n\t   * Event Handler\n\t   */\n\t\n\t  Checkbox.prototype._onChange = function _onChange(event) {\n\t    this.updateClasses();\n\t  };\n\t\n\t  // TODO Find out why unfocus is triggered on mousedown\n\t\n\t\n\t  Checkbox.prototype._onFocus = function _onFocus(event) {\n\t    this._element.classList.add(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  Checkbox.prototype._onBlur = function _onBlur(event) {\n\t    this._element.classList.remove(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  /**\n\t   * Getter and Setter\n\t   */\n\t\n\t  _createClass(Checkbox, [{\n\t    key: 'input',\n\t    get: function get() {\n\t      return this._input;\n\t    }\n\t  }, {\n\t    key: 'checked',\n\t    get: function get() {\n\t      return this._input.checked = true;\n\t    },\n\t    set: function set(value) {\n\t      if (value) {\n\t        this.check();\n\t      } else {\n\t        this.uncheck();\n\t      }\n\t    }\n\t  }, {\n\t    key: 'disabled',\n\t    get: function get() {\n\t      return this._input.disabled = true;\n\t    },\n\t    set: function set(value) {\n\t      if (value) {\n\t        this.disable();\n\t      } else {\n\t        this.enable();\n\t      }\n\t    }\n\t  }]);\n\t\n\t  return Checkbox;\n\t}(_component2.default);\n\t\n\texports.default = Checkbox;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 13 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _checkbox = __webpack_require__(12);\n\t\n\tvar _checkbox2 = _interopRequireDefault(_checkbox);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-dropdown';\n\tvar SELECTOR_OPTION_INPUT = 'input';\n\tvar CLASS_ANIMATED_LIST_ITEMS = 'aui-dropdown__list-item--animate';\n\tvar CLASS_LABEL = 'aui-dropdown__label';\n\tvar CLASS_INPUT = 'aui-dropdown__input';\n\tvar CLASS_VALUE = 'aui-dropdown__value';\n\tvar CLASS_FOCUS_LINE = 'aui-dropdown__focus-line';\n\tvar CLASS_OPTION = 'aui-dropdown__option';\n\tvar CLASS_MULTIPLE = 'aui-dropdown--multiple';\n\tvar CLASS_IS_FOCUS = 'is-focused';\n\tvar CLASS_IS_DIRTY = 'is-dirty';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\t\n\t/**\n\t * Class constructor for Dropdown AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Dropdown = function (_Component) {\n\t  _inherits(Dropdown, _Component);\n\t\n\t  /**\n\t   * Upgrades all Dropdown AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Dropdown.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Dropdown(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function Dropdown(element) {\n\t    _classCallCheck(this, Dropdown);\n\t\n\t    var _this = _possibleConstructorReturn(this, _Component.call(this, element));\n\t\n\t    _this._element.addEventListener('click', _this._clickHandler = function (event) {\n\t      return _this._onClick(event);\n\t    });\n\t\n\t    _this.multiple = _this._element.classList.contains(CLASS_MULTIPLE);\n\t    _this._isActive = false;\n\t\n\t    _this._valueField = _this._element.querySelector('.' + CLASS_VALUE);\n\t\n\t    _this._input = _this._element.querySelector('.' + CLASS_INPUT);\n\t    _this._input.addEventListener('input', _this._inputHandler = function (event) {\n\t      return _this._onInput(event);\n\t    });\n\t    _this._input.addEventListener('focus', _this._focusHandler = function (event) {\n\t      return _this._onFocus(event);\n\t    });\n\t    _this._input.addEventListener('blur', _this._blurHandler = function (event) {\n\t      return _this._onBlur(event);\n\t    });\n\t    _this._input.addEventListener('reset', _this._resetHandler = function (event) {\n\t      return _this._onReset(event);\n\t    });\n\t\n\t    var itemsAnimated = _this._element.querySelectorAll('.' + CLASS_ANIMATED_LIST_ITEMS);\n\t    for (var i = 0; i < itemsAnimated.length; i++) {\n\t      itemsAnimated[i].style.transitionDelay = itemsAnimated[i].style.webkitTransitionDelay = .05 * i + 's';\n\t    }\n\t\n\t    // Insert thick focus line after label element:\n\t    _this._label = _this._element.querySelector('.' + CLASS_LABEL);\n\t    var focusLine = document.createElement('span');\n\t    focusLine.classList.add(CLASS_FOCUS_LINE);\n\t    _this._label.parentNode.insertBefore(focusLine, _this._label.nextSibling);\n\t\n\t    _this.updateClasses();\n\t    return _this;\n\t  }\n\t\n\t  Dropdown.prototype.optionClicked = function optionClicked(option) {\n\t    if (this._valueField) {\n\t      this._valueField.value = this._getOptionValue(option);\n\t    }\n\t\n\t    this.updateInput(option);\n\t\n\t    if (!this.multiple) {\n\t      this.close();\n\t    }\n\t  };\n\t\n\t  Dropdown.prototype.updateInput = function updateInput(option) {\n\t    var _this2 = this;\n\t\n\t    var value = '';\n\t    if (this.multiple) {\n\t      var values = [];\n\t      Array.from(this._element.querySelectorAll('.' + CLASS_OPTION)).forEach(function (element) {\n\t        var input = element.querySelector(SELECTOR_OPTION_INPUT);\n\t        if (input && input.checked) {\n\t          values.push(_this2._getOptionTitle(element));\n\t        }\n\t      });\n\t      value = values.length > 0 ? '(' + values.length + ') ' + values.join(', ') : '';\n\t    } else {\n\t      value = this._getOptionTitle(option);\n\t    }\n\t    this._input.value = value;\n\t    this.updateClasses();\n\t  };\n\t\n\t  Dropdown.prototype._getOptionTitle = function _getOptionTitle(option) {\n\t    var title = '';\n\t    if (option) {\n\t      title = option.hasAttribute('data-title') ? option.getAttribute('data-title') : '';\n\t    }\n\t    return title;\n\t  };\n\t\n\t  Dropdown.prototype._getOptionValue = function _getOptionValue(option) {\n\t    var value = '';\n\t    if (option) {\n\t      value = option.hasAttribute('data-value') ? option.getAttribute('data-value') : '';\n\t    }\n\t    return value;\n\t  };\n\t\n\t  Dropdown.prototype.open = function open() {\n\t    var _this3 = this;\n\t\n\t    if (!this._element.classList.contains(CLASS_IS_DISABLED)) {\n\t      this._isActive = true;\n\t      this._element.classList.add(CLASS_IS_ACTIVE);\n\t      window.addEventListener('click', this._clickHandlerWindow = function (event) {\n\t        return _this3._onClickOutside(event);\n\t      });\n\t    }\n\t  };\n\t\n\t  Dropdown.prototype.close = function close() {\n\t    this._isActive = false;\n\t    this._element.classList.remove(CLASS_IS_ACTIVE);\n\t    window.removeEventListener('click', this.close);\n\t  };\n\t\n\t  Dropdown.prototype.toggleOpen = function toggleOpen() {\n\t    if (this._isActive) {\n\t      this.close();\n\t    } else {\n\t      this.open();\n\t    }\n\t  };\n\t\n\t  Dropdown.prototype.updateClasses = function updateClasses() {\n\t    this.checkDisabled();\n\t    this.checkDirty();\n\t    this.checkFocus();\n\t  };\n\t\n\t  /**\n\t   * Check the disabled state and update field accordingly.\n\t   */\n\t\n\t\n\t  Dropdown.prototype.checkDisabled = function checkDisabled() {\n\t    if (this._input.disabled) {\n\t      this._element.classList.add(CLASS_IS_DISABLED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DISABLED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the dirty state and update field accordingly.\n\t   */\n\t\n\t\n\t  Dropdown.prototype.checkDirty = function checkDirty() {\n\t    if (this._input.value && this._input.value.length > 0) {\n\t      this._element.classList.add(CLASS_IS_DIRTY);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DIRTY);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the focus state and update field accordingly.\n\t   */\n\t\n\t\n\t  Dropdown.prototype.checkFocus = function checkFocus() {\n\t    if (Boolean(this._element.querySelector(':focus'))) {\n\t      this._element.classList.add(CLASS_IS_FOCUS);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_FOCUS);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Disable text field.\n\t   */\n\t\n\t\n\t  Dropdown.prototype.disable = function disable() {\n\t    this._input.disabled = true;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Dropdown.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._input.removeEventListener('input', this._inputHandler);\n\t    this._input.removeEventListener('focus', this._focusHandler);\n\t    this._input.removeEventListener('blur', this._blurHandler);\n\t    this._input.removeEventListener('reset', this._resetHandler);\n\t\n\t    window.removeEventListener('click', this.close);\n\t  };\n\t\n\t  /**\n\t   * Event Handler\n\t   */\n\t\n\t  Dropdown.prototype._onClick = function _onClick(event) {\n\t    var _this4 = this;\n\t\n\t    var isOption = false;\n\t\n\t    // Find closest action element\n\t    var currentElement = event.target;\n\t    while (currentElement !== event.currentTarget) {\n\t      if (currentElement.classList.contains(CLASS_OPTION)) {\n\t        isOption = true;\n\t        break;\n\t      }\n\t      currentElement = currentElement.parentNode;\n\t    }\n\t\n\t    if (!isOption) {\n\t      this.toggleOpen();\n\t    } else {\n\t      // Toggle the Checkbox contained\n\t      _checkbox2.default.get(currentElement).forEach(function (checkbox) {\n\t        checkbox.toggle();\n\t        _this4.optionClicked(currentElement);\n\t      });\n\t    }\n\t  };\n\t\n\t  Dropdown.prototype._onClickOutside = function _onClickOutside(event) {\n\t    if (!this._element.contains(event.target)) {\n\t      this.close();\n\t      this.updateClasses();\n\t    }\n\t  };\n\t\n\t  Dropdown.prototype._onInput = function _onInput(event) {\n\t    this.updateClasses();\n\t  };\n\t\n\t  Dropdown.prototype._onFocus = function _onFocus(event) {\n\t    this._element.classList.add(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  Dropdown.prototype._onBlur = function _onBlur(event) {\n\t    this._element.classList.remove(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  Dropdown.prototype._onReset = function _onReset(event) {\n\t    this.updateClasses();\n\t  };\n\t\n\t  return Dropdown;\n\t}(_component2.default);\n\t\n\texports.default = Dropdown;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 14 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-flyout';\n\tvar CLASS_TOGGLE = 'aui-flyout__toggle';\n\tvar CLASS_TRIANGLE = 'aui-flyout__triangle';\n\tvar CLASS_HEADER = 'aui-flyout__header';\n\tvar CLASS_CLOSE_BUTTON = 'aui-flyout__close';\n\tvar CLASS_PANEL = 'aui-flyout__panel';\n\tvar CLASS_IS_UPGRADED = 'is-upgraded';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\tvar CLASS_FLYOUT_IS_OPEN = 'aui-flyout-is-open';\n\tvar TOGGLE_THRESHOLD = 250; // in ms\n\t\n\t/**\n\t * Class constructor for Flyout AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Flyout = function (_Component) {\n\t  _inherits(Flyout, _Component);\n\t\n\t  function Flyout() {\n\t    _classCallCheck(this, Flyout);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Flyout AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Flyout.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Flyout(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  Flyout.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._activationTime = 0;\n\t\n\t    this._body = document.querySelector('body');\n\t    this._toggle = this._element.querySelector('.' + CLASS_TOGGLE);\n\t    this._panel = this._element.querySelector('.' + CLASS_PANEL);\n\t\n\t    // Add triangle shape\n\t    this._triangle = document.createElement('span');\n\t    this._triangle.classList.add(CLASS_TRIANGLE);\n\t    this._panel.appendChild(this._triangle);\n\t\n\t    // Add panel header with close button\n\t    this._header = document.createElement('div');\n\t    this._header.classList.add(CLASS_HEADER);\n\t    this._header.innerHTML = '<button class=\"' + CLASS_CLOSE_BUTTON + '\" type=\"button\"></button>';\n\t    this._panel.appendChild(this._header);\n\t\n\t    this._closeBtn = this._header.querySelector('.' + CLASS_CLOSE_BUTTON);\n\t    this._closeBtn.addEventListener('click', this._boundClickClose = function (event) {\n\t      return _this2._onClickClose(event);\n\t    });\n\t    this._toggle.addEventListener('click', this._boundClickToggle = function (event) {\n\t      return _this2._onClickToggle(event);\n\t    });\n\t\n\t    if (this._element.classList.contains(CLASS_IS_ACTIVE)) {\n\t      this.open();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Flyout.prototype.dispose = function dispose() {\n\t    this._toggle.removeEventListener('click', this._boundClickToggle);\n\t    this._closeBtn.removeEventListener('click', this._boundClickClose);\n\t    window.removeEventListener('click', this._boundClickWindow);\n\t    window.removeEventListener('touchend', this._boundTouchendWindow);\n\t\n\t    this._panel.removeChild(this._triangle);\n\t\n\t    this._element.classList.remove(CLASS_IS_ACTIVE, CLASS_IS_UPGRADED);\n\t    this._element.removeAttribute('style');\n\t  };\n\t\n\t  /**\n\t   * Open Flyout\n\t   */\n\t\n\t\n\t  Flyout.prototype.open = function open() {\n\t    var _this3 = this;\n\t\n\t    this._body.classList.add(CLASS_FLYOUT_IS_OPEN);\n\t    this._activationTime = Date.now();\n\t    this._isActive = true;\n\t    this._element.classList.add(CLASS_IS_ACTIVE);\n\t    window.addEventListener('click', this._boundClickWindow = function (event) {\n\t      return _this3._onTouchOutside(event);\n\t    }, true);\n\t    window.addEventListener('touchend', this._boundTouchendWindow = function (event) {\n\t      return _this3._onTouchOutside(event);\n\t    }, true);\n\t  };\n\t\n\t  /**\n\t   * Close Flyout\n\t   */\n\t\n\t\n\t  Flyout.prototype.close = function close() {\n\t    this._body.classList.remove(CLASS_FLYOUT_IS_OPEN);\n\t    this._isActive = false;\n\t    this._element.classList.remove(CLASS_IS_ACTIVE);\n\t    window.removeEventListener('click', this._boundClickWindow, true);\n\t    window.removeEventListener('touchend', this._boundTouchendWindow, true);\n\t  };\n\t\n\t  /**\n\t   * Toggle open/close Flyout\n\t   */\n\t\n\t\n\t  Flyout.prototype.toggle = function toggle() {\n\t    var elapsed = Date.now() - this._activationTime;\n\t    if (elapsed < TOGGLE_THRESHOLD) {\n\t      return;\n\t    }\n\t\n\t    if (this._isActive) {\n\t      this.close();\n\t    } else {\n\t      this.open();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Handle click of close button.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Flyout.prototype._onClickClose = function _onClickClose(event) {\n\t    this.close();\n\t  };\n\t\n\t  /**\n\t   * Handle click of toggle.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Flyout.prototype._onClickToggle = function _onClickToggle(event) {\n\t    this.toggle();\n\t  };\n\t\n\t  /**\n\t   * Handle mouseneter.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Flyout.prototype._onMouseEnter = function _onMouseEnter(event) {\n\t    this.open(event.target, event.clientX);\n\t  };\n\t\n\t  /**\n\t   * Handle mouseleave.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Flyout.prototype._onMouseLeave = function _onMouseLeave(event) {\n\t    this.close();\n\t  };\n\t\n\t  /**\n\t   * Handle touch.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Flyout.prototype._onTouch = function _onTouch(event) {\n\t    event.stopPropagation();\n\t    this.open();\n\t  };\n\t\n\t  /**\n\t   * Handle touch outside.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Flyout.prototype._onTouchOutside = function _onTouchOutside(event) {\n\t    if (!this._element.contains(event.target)) {\n\t      this.close();\n\t    }\n\t  };\n\t\n\t  return Flyout;\n\t}(_component2.default);\n\t\n\texports.default = Flyout;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 15 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _scrollObserver = __webpack_require__(16);\n\t\n\tvar _scrollObserver2 = _interopRequireDefault(_scrollObserver);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-header';\n\tvar CLASS_STICKYABLE = 'aui-header--sticky';\n\tvar CLASS_IS_STICKY = 'is-sticky';\n\t\n\t/**\n\t * Class constructor for Header AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Header = function (_Component) {\n\t  _inherits(Header, _Component);\n\t\n\t  /**\n\t   * Upgrades all Header AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Header.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Header(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function Header(element) {\n\t    _classCallCheck(this, Header);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component.\n\t   */\n\t\n\t\n\t  Header.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    // If Header ist not sticky, there is nothing todo.\n\t    if (!this._element.classList.contains(CLASS_STICKYABLE)) {\n\t      return;\n\t    }\n\t\n\t    // REVIEW position:sticky currently not working. See also SCSS.\n\t    // If browser supports position:sticky, it will handle positioning and\n\t    // we can skip here.\n\t    // if (window.getComputedStyle(this._element).position.indexOf('sticky') !== -1) {\n\t    //   return;\n\t    // }\n\t\n\t    this._scrollObserver = new _scrollObserver2.default();\n\t    this._scrollObserver.scrolled.add(this._scrollHandler = function () {\n\t      return _this2.checkStickiness();\n\t    });\n\t\n\t    this._sticky = false;\n\t    this.checkStickiness();\n\t  };\n\t\n\t  /**\n\t  * Dispose component.\n\t  */\n\t\n\t\n\t  Header.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._scrollObserver.resized.remove(this._scrollHandler);\n\t    this._resizeObserver.resized.remove(this._resizedHandler);\n\t  };\n\t\n\t  /**\n\t   * Check if position.top is negative. If so stick otherwise release component.\n\t   */\n\t\n\t\n\t  Header.prototype.checkStickiness = function checkStickiness() {\n\t    if (this._element.getBoundingClientRect().top <= 0) {\n\t      if (!this._sticky) {\n\t        this.stick();\n\t      }\n\t    } else {\n\t      if (this._sticky) {\n\t        this.release();\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Stick component to top of viewport in adding sticky class.\n\t   */\n\t\n\t\n\t  Header.prototype.stick = function stick() {\n\t    if (!this._sticky) {\n\t      this._element.classList.add(CLASS_IS_STICKY);\n\t    }\n\t    this._sticky = true;\n\t  };\n\t\n\t  /**\n\t   * Release component and position not fixed in removing sticky class.\n\t   */\n\t\n\t\n\t  Header.prototype.release = function release() {\n\t    if (this._sticky) {\n\t      this._element.classList.remove(CLASS_IS_STICKY);\n\t    }\n\t    this._sticky = false;\n\t  };\n\t\n\t  return Header;\n\t}(_component2.default);\n\t\n\texports.default = Header;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 16 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _signal = __webpack_require__(4);\n\t\n\tvar _signal2 = _interopRequireDefault(_signal);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tvar instance = null;\n\t\n\tvar SCROLL_END_THRESHOLD = 100; // in ms\n\t\n\tvar ScrollObserver = function () {\n\t  function ScrollObserver() {\n\t    _classCallCheck(this, ScrollObserver);\n\t\n\t    if (!instance) {\n\t      instance = this;\n\t      this.init();\n\t    }\n\t\n\t    return instance;\n\t  }\n\t\n\t  ScrollObserver.prototype.init = function init() {\n\t    var _this = this;\n\t\n\t    this._scrollX = 0;\n\t    this._scrollY = 0;\n\t    this._ticking = false;\n\t\n\t    this.scrolled = new _signal2.default();\n\t    this.scrollEnded = new _signal2.default();\n\t\n\t    window.addEventListener('scroll', this.scrollHandler = function (event) {\n\t      return _this.onScroll(event);\n\t    });\n\t  };\n\t\n\t  ScrollObserver.prototype.onScroll = function onScroll(event) {\n\t    var _this2 = this;\n\t\n\t    this._scrollX = window.scrollX;\n\t    this._scrollY = window.scrollY;\n\t\n\t    if (!this._ticking) {\n\t      window.requestAnimationFrame(function () {\n\t        _this2._ticking = false;\n\t        _this2.scrolled.dispatch(_this2._scrollX, _this2._scrollY);\n\t        clearTimeout(_this2._scrollEndTimeout);\n\t        _this2._scrollEndTimeout = setTimeout(function () {\n\t          _this2.scrollEnded.dispatch(_this2._scrollX, _this2._scrollY);\n\t        }, SCROLL_END_THRESHOLD);\n\t      });\n\t    }\n\t    this._ticking = true;\n\t  };\n\t\n\t  _createClass(ScrollObserver, [{\n\t    key: 'scrollX',\n\t    get: function get() {\n\t      return this._scrollX;\n\t    }\n\t  }, {\n\t    key: 'scrollY',\n\t    get: function get() {\n\t      return this._scrollY;\n\t    }\n\t  }]);\n\t\n\t  return ScrollObserver;\n\t}();\n\t\n\texports.default = ScrollObserver;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 17 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _modalDefault = __webpack_require__(18);\n\t\n\tvar _modalDefault2 = _interopRequireDefault(_modalDefault);\n\t\n\tvar _modalMorph = __webpack_require__(20);\n\t\n\tvar _modalMorph2 = _interopRequireDefault(_modalMorph);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-modal';\n\tvar CLASS_MORPH = 'aui-modal--morph';\n\t\n\tvar modalComponents = void 0;\n\tvar currentModal = void 0;\n\t\n\t/**\n\t * Class constructor for Modal AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Modal = function (_Component) {\n\t  _inherits(Modal, _Component);\n\t\n\t  function Modal() {\n\t    _classCallCheck(this, Modal);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Modal AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Modal.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Modal(element));\n\t      }\n\t    });\n\t    modalComponents = components;\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Get a modal component by element ID.\n\t   * @param {string} id The id attribute of the components HTML element.\n\t   * @returns {Modal} Returns a modal with the given ID.\n\t   */\n\t  Modal.getModalById = function getModalById(id) {\n\t    for (var i = 0; i < modalComponents.length; i++) {\n\t      if (modalComponents[i].id === id) {\n\t        return modalComponents[i];\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Close current modal.\n\t   */\n\t\n\t\n\t  Modal.closeCurrentModal = function closeCurrentModal() {\n\t    if (currentModal) {\n\t      currentModal.close();\n\t      currentModal = null;\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Returns modifier `morph`\n\t   */\n\t\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  Modal.prototype.init = function init() {\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._id = this._element.getAttribute('id');\n\t\n\t    // Initialize with appropriate decorator depending on modifier,\n\t    // represented by according CSS class:\n\t    if (this._element.classList.contains(CLASS_MORPH)) {\n\t      this._decorator = new _modalMorph2.default(this._element);\n\t    } else {\n\t      this._decorator = new _modalDefault2.default(this._element);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Opens this modal.\n\t   * @param {HTMLElement} trigger The element which opens the modal.\n\t   */\n\t\n\t\n\t  Modal.prototype.open = function open(trigger) {\n\t    currentModal = this;\n\t    this._decorator.open(trigger);\n\t  };\n\t\n\t  /**\n\t   * Closes this modal.\n\t   */\n\t\n\t\n\t  Modal.prototype.close = function close() {\n\t    currentModal = null;\n\t    this._decorator.close();\n\t  };\n\t\n\t  /**\n\t   * @returns {string} Returns the ID of the modal\n\t   */\n\t\n\t\n\t  _createClass(Modal, [{\n\t    key: 'id',\n\t    get: function get() {\n\t      return this._id;\n\t    }\n\t  }], [{\n\t    key: 'MODIFIER_MORPH',\n\t    get: function get() {\n\t      return CLASS_MORPH;\n\t    }\n\t\n\t    /**\n\t     * Returns modifier `default`\n\t     */\n\t\n\t  }, {\n\t    key: 'MODIFIER_DEFAULT',\n\t    get: function get() {\n\t      return '';\n\t    }\n\t  }]);\n\t\n\t  return Modal;\n\t}(_component2.default);\n\t\n\texports.default = Modal;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 18 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _modalDialog = __webpack_require__(19);\n\t\n\tvar _modalDialog2 = _interopRequireDefault(_modalDialog);\n\t\n\tvar _resizeObserver = __webpack_require__(3);\n\t\n\tvar _resizeObserver2 = _interopRequireDefault(_resizeObserver);\n\t\n\tvar _transitionEndEvent = __webpack_require__(9);\n\t\n\tvar _transitionEndEvent2 = _interopRequireDefault(_transitionEndEvent);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar CLASS_MODAL_IS_OPEN = 'aui-modal-open';\n\tvar CLASS_WINDOW = 'aui-modal-dialog--window';\n\tvar CLASS_DIALOG_BODY = 'aui-modal-dialog__body';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\t\n\t/**\n\t * Class constructor for ModalDefault AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar ModalDefault = function (_ModalDialog) {\n\t  _inherits(ModalDefault, _ModalDialog);\n\t\n\t  function ModalDefault() {\n\t    _classCallCheck(this, ModalDefault);\n\t\n\t    return _possibleConstructorReturn(this, _ModalDialog.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Opens this modal.\n\t   * @param {HTMLElement} trigger The element which opens the modal.\n\t   */\n\t  ModalDefault.prototype.open = function open(trigger) {\n\t    var _this2 = this;\n\t\n\t    _ModalDialog.prototype.open.call(this);\n\t    this._trigger = trigger;\n\t\n\t    // Make modal element visible\n\t    this._element.classList.add(CLASS_IS_ACTIVE);\n\t    this._element.scrollTop = 0;\n\t    this._addBackdrop();\n\t\n\t    // If dialog acts as window, we have to reposition the close button to\n\t    // stick with the dialog.\n\t    if (this._element.querySelector('.' + CLASS_WINDOW) && this._closeButton) {\n\t      if (this._resizeObserver === undefined) {\n\t        this._resizeObserver = new _resizeObserver2.default();\n\t        this._dialogBody = this._element.querySelector('.' + CLASS_DIALOG_BODY);\n\t      }\n\t      this._resizeObserver.resized.add(this._resizedHandler = function () {\n\t        return _this2._repositionCloseButton();\n\t      });\n\t      this._repositionCloseButton();\n\t    }\n\t\n\t    window.requestAnimationFrame(function () {\n\t      return _this2._prepareOpenTransition();\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Prepare the open transition.\n\t   */\n\t\n\t\n\t  ModalDefault.prototype._prepareOpenTransition = function _prepareOpenTransition() {\n\t    var _this3 = this;\n\t\n\t    // Loops until modal is really visible.\n\t    // That's required to make transitions work as aspected.\n\t    if (this._element.offsetWidth > 0) {\n\t\n\t      // Start opening animation\n\t      this._body.classList.add(CLASS_MODAL_IS_OPEN);\n\t    } else {\n\t      window.requestAnimationFrame(function () {\n\t        return _this3._prepareOpenTransition();\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Closes this modal.\n\t   */\n\t\n\t\n\t  ModalDefault.prototype.close = function close() {\n\t    var _this4 = this;\n\t\n\t    if (this._backdrop) {\n\t      this._backdrop.removeEventListener(_transitionEndEvent2.default, this._backdropCloseTransitionendHandler);\n\t      _transitionEndEvent2.default && this._backdrop.addEventListener(_transitionEndEvent2.default, this._backdropCloseTransitionendHandler = function (event) {\n\t        return _this4._onBackdropCloseTransitionend(event);\n\t      });\n\t    }\n\t\n\t    if (this._resizeObserver) {\n\t      this._resizeObserver.resized.remove(this._resizedHandler);\n\t    }\n\t\n\t    this._body.classList.remove(CLASS_MODAL_IS_OPEN);\n\t  };\n\t\n\t  /**\n\t   * Reposition close button with dialog\n\t   */\n\t\n\t\n\t  ModalDefault.prototype._repositionCloseButton = function _repositionCloseButton() {\n\t    var rect = this._dialogBody.getBoundingClientRect();\n\t    var right = rect.right - rect.width;\n\t    // Only reposition if the window is positioned center, otherwise respect\n\t    // CSS styling:\n\t    if (right > 0) {\n\t      this._closeButton.style.right = right + 'px';\n\t    } else {\n\t      this._closeButton.style.right = '';\n\t    }\n\t  };\n\t\n\t  return ModalDefault;\n\t}(_modalDialog2.default);\n\t\n\texports.default = ModalDefault;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 19 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _transitionEndEvent = __webpack_require__(9);\n\t\n\tvar _transitionEndEvent2 = _interopRequireDefault(_transitionEndEvent);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar CLOSE_BUTTON_SIZE_SMALL = 45;\n\tvar CLOSE_BUTTON_SIZE_LARGE = 81;\n\tvar CLOSE_ICON_SIZE_SMALL = 17;\n\tvar CLOSE_ICON_SIZE_LARGE = 31;\n\tvar CLASS_BACKDROP = 'aui-modal-backdrop';\n\tvar CLASS_CLOSE = 'aui-modal-dialog__close';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\t\n\t/**\n\t * Class constructor for ModalDialog AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar ModalDialog = function (_Component) {\n\t  _inherits(ModalDialog, _Component);\n\t\n\t  function ModalDialog() {\n\t    _classCallCheck(this, ModalDialog);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  ModalDialog.prototype.init = function init() {\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._body = document.querySelector('body');\n\t\n\t    this._closeButton = this._element.querySelector('.' + CLASS_CLOSE);\n\t    if (this._closeButton) {\n\t      this._addCloseButton(this._closeButton);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Opens this modal.\n\t   */\n\t\n\t\n\t  ModalDialog.prototype.open = function open() {\n\t    if (this._element.parentNode !== this._body) {\n\t      this._body.appendChild(this._element);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Handle transition end event\n\t   * @param {Event} event which was fired.\n\t   */\n\t\n\t\n\t  ModalDialog.prototype._onBackdropCloseTransitionend = function _onBackdropCloseTransitionend(event) {\n\t    if (event.target === event.currentTarget) {\n\t      this._backdrop.removeEventListener(_transitionEndEvent2.default, this._backdropCloseTransitionendHandler);\n\t      this._element.classList.remove(CLASS_IS_ACTIVE);\n\t      this._removeBackdrop();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Adds a semi-transparent backdrop element behind the modal.\n\t   */\n\t\n\t\n\t  ModalDialog.prototype._addBackdrop = function _addBackdrop() {\n\t    if (!this._backdrop) {\n\t      this._backdrop = document.createElement('div');\n\t      this._backdrop.classList.add(CLASS_BACKDROP);\n\t      this._body.appendChild(this._backdrop);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Removes the backdrop element behind modal.\n\t   */\n\t\n\t\n\t  ModalDialog.prototype._removeBackdrop = function _removeBackdrop() {\n\t    if (this._backdrop) {\n\t      this._body.removeChild(this._backdrop);\n\t      this._backdrop = null;\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Adds close button\n\t   * @param {HTMLElement} container to append close icon to.\n\t   */\n\t\n\t\n\t  ModalDialog.prototype._addCloseButton = function _addCloseButton(container) {\n\t    var diagonalHalf = Math.sqrt(2) * CLOSE_ICON_SIZE_SMALL / 2;\n\t    var btnSize = CLOSE_BUTTON_SIZE_SMALL;\n\t\n\t    var small = this.createSvgNode('svg', {\n\t      class: 'aui-modal-close-icon-small',\n\t      viewBox: '0 0 ' + btnSize + ' ' + btnSize\n\t    });\n\t    var group = this.createSvgNode('g', {\n\t      transform: 'translate(' + btnSize / 2 + ', ' + btnSize / 2 + ')'\n\t    });\n\t    group.appendChild(this.createSvgNode('line', {\n\t      x1: '0',\n\t      y1: -diagonalHalf,\n\t      x2: '0',\n\t      y2: diagonalHalf,\n\t      stroke: 'currentColor',\n\t      transform: 'rotate(-45, 0, 0)'\n\t    }));\n\t    group.appendChild(this.createSvgNode('line', {\n\t      x1: '0',\n\t      y1: -diagonalHalf,\n\t      x2: '0',\n\t      y2: diagonalHalf,\n\t      stroke: 'currentColor',\n\t      transform: 'rotate(45, 0, 0)'\n\t    }));\n\t    small.appendChild(group);\n\t    container.appendChild(small);\n\t\n\t    diagonalHalf = Math.sqrt(2) * CLOSE_ICON_SIZE_LARGE / 2;\n\t    btnSize = CLOSE_BUTTON_SIZE_LARGE;\n\t    var large = this.createSvgNode('svg', {\n\t      'class': 'aui-modal-close-icon-large',\n\t      'viewBox': '0 0 ' + btnSize + ' ' + btnSize\n\t    });\n\t    group = this.createSvgNode('g', {\n\t      transform: 'translate(' + btnSize / 2 + ', ' + btnSize / 2 + ')'\n\t    });\n\t    group.appendChild(this.createSvgNode('line', {\n\t      x1: '0',\n\t      y1: -diagonalHalf,\n\t      x2: '0',\n\t      y2: diagonalHalf,\n\t      stroke: 'currentColor',\n\t      transform: 'rotate(-45, 0, 0)'\n\t    }));\n\t    group.appendChild(this.createSvgNode('line', {\n\t      x1: '0',\n\t      y1: -diagonalHalf,\n\t      x2: '0',\n\t      y2: diagonalHalf,\n\t      stroke: 'currentColor',\n\t      transform: 'rotate(45, 0, 0)'\n\t    }));\n\t    large.appendChild(group);\n\t    container.appendChild(large);\n\t  };\n\t\n\t  return ModalDialog;\n\t}(_component2.default);\n\t\n\texports.default = ModalDialog;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 20 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _modalDialog = __webpack_require__(19);\n\t\n\tvar _modalDialog2 = _interopRequireDefault(_modalDialog);\n\t\n\tvar _transitionEndEvent = __webpack_require__(9);\n\t\n\tvar _transitionEndEvent2 = _interopRequireDefault(_transitionEndEvent);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar CLASS_MODAL_IS_OPEN = 'aui-modal-open';\n\tvar CLASS_CONTENT = 'aui-modal-dialog__content';\n\tvar CLASS_MORPH_DIALOG = 'aui-modal-morph';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\tvar CLASS_IS_MORPHING = 'is-morphing';\n\t\n\t/**\n\t * Class constructor for ModalMorph AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar ModalMorph = function (_ModalDialog) {\n\t  _inherits(ModalMorph, _ModalDialog);\n\t\n\t  function ModalMorph() {\n\t    _classCallCheck(this, ModalMorph);\n\t\n\t    return _possibleConstructorReturn(this, _ModalDialog.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  ModalMorph.prototype.init = function init() {\n\t    _ModalDialog.prototype.init.call(this);\n\t\n\t    this._content = this._element.querySelector('.' + CLASS_CONTENT);\n\t  };\n\t\n\t  /**\n\t   * Open modal\n\t   * @param {HTMLElement} trigger The element which opens the modal.\n\t   */\n\t\n\t\n\t  ModalMorph.prototype.open = function open(trigger) {\n\t    var _this2 = this;\n\t\n\t    console.log('Open morphing modal');\n\t    _ModalDialog.prototype.open.call(this);\n\t    this._trigger = trigger;\n\t\n\t    // Make modal element visible\n\t    this._element.classList.add(CLASS_IS_ACTIVE);\n\t    this._element.scrollTop = 0;\n\t    this._addBackdrop();\n\t\n\t    window.requestAnimationFrame(function () {\n\t      return _this2._prepareOpenTransition();\n\t    });\n\t  };\n\t\n\t  ModalMorph.prototype._prepareOpenTransition = function _prepareOpenTransition() {\n\t    var _this3 = this;\n\t\n\t    var rect = this._trigger.getBoundingClientRect();\n\t\n\t    // Apply bounding rect to start with to morphing element\n\t    this._morph = this._getMorphElement(rect);\n\t\n\t    // Start opening animation\n\t    window.requestAnimationFrame(function () {\n\t      return _this3._startOpenTransition();\n\t    });\n\t  };\n\t\n\t  ModalMorph.prototype._startOpenTransition = function _startOpenTransition() {\n\t    var _this4 = this;\n\t\n\t    var rect = this._content.getBoundingClientRect();\n\t\n\t    // Apply bounding rect to end on to morphing element\n\t    this._applyBoundingRectToElement(this._morph, rect);\n\t    _transitionEndEvent2.default && this._element.addEventListener(_transitionEndEvent2.default, this._boundTransitionendElementIn = function (event) {\n\t      return _this4._onTransitionendElementIn(event);\n\t    });\n\t    this._morph.classList.add(CLASS_IS_MORPHING);\n\t    this._body.classList.add(CLASS_MODAL_IS_OPEN);\n\t  };\n\t\n\t  ModalMorph.prototype._onTransitionendElementIn = function _onTransitionendElementIn(event) {\n\t    this._element.removeEventListener(_transitionEndEvent2.default, this._boundTransitionendElementIn);\n\t    this._morph.classList.remove(CLASS_IS_MORPHING);\n\t  };\n\t\n\t  /**\n\t   * Close modal\n\t   */\n\t\n\t\n\t  ModalMorph.prototype.close = function close() {\n\t    var _this5 = this;\n\t\n\t    console.log('close');\n\t    if (this._backdrop) {\n\t      this._backdrop.removeEventListener(_transitionEndEvent2.default, this._backdropCloseTransitionendHandler);\n\t      _transitionEndEvent2.default && this._backdrop.addEventListener(_transitionEndEvent2.default, this._backdropCloseTransitionendHandler = function (event) {\n\t        return _this5._onBackdropCloseTransitionend(event);\n\t      });\n\t    }\n\t\n\t    this._element.removeEventListener(_transitionEndEvent2.default, this._boundTransitionendElementIn);\n\t\n\t    var rect = this._content.getBoundingClientRect();\n\t    this._applyBoundingRectToElement(this._morph, rect);\n\t    this._morph.classList.add(CLASS_IS_MORPHING);\n\t\n\t    _transitionEndEvent2.default && this._morph.addEventListener(_transitionEndEvent2.default, this._boundTransitionendMorphOut = function (event) {\n\t      return _this5._onTransitionendMorphOut(event);\n\t    });\n\t\n\t    window.requestAnimationFrame(function () {\n\t      return _this5._startCloseTransition();\n\t    });\n\t  };\n\t\n\t  ModalMorph.prototype._startCloseTransition = function _startCloseTransition() {\n\t    var rect = this._trigger.getBoundingClientRect();\n\t    this._applyBoundingRectToElement(this._morph, rect);\n\t\n\t    this._body.classList.remove(CLASS_MODAL_IS_OPEN);\n\t  };\n\t\n\t  ModalMorph.prototype._onTransitionendMorphOut = function _onTransitionendMorphOut(event) {\n\t    this._morph.removeEventListener(_transitionEndEvent2.default, this._boundTransitionendMorphOut);\n\t    this.removeChild(this._morph);\n\t    this._morph = null;\n\t  };\n\t\n\t  ModalMorph.prototype._onMorpBodyCloseTransitionend = function _onMorpBodyCloseTransitionend(event) {\n\t    if (event.target === event.currentTarget) {\n\t      this._morphBody.removeEventListener(_transitionEndEvent2.default, this._morpBodyCloseTransitionendHandler);\n\t      this._morphBody.removeAttribute('style');\n\t      this._content.classList.remove(CLASS_IS_MORPHING);\n\t    }\n\t  };\n\t\n\t  ModalMorph.prototype._applyBoundingRectToElement = function _applyBoundingRectToElement(element, rect) {\n\t    element.style.top = Math.round(rect.top) + 'px';\n\t    element.style.left = Math.round(rect.left) + 'px';\n\t    element.style.width = Math.round(rect.width) + 'px';\n\t    element.style.height = Math.round(rect.height) + 'px';\n\t  };\n\t\n\t  ModalMorph.prototype._getMorphElement = function _getMorphElement(rect) {\n\t    if (!this._morph) {\n\t      this._morph = this.createElement('div', [CLASS_MORPH_DIALOG]);\n\t      this._applyBoundingRectToElement(this._morph, rect);\n\t      this._body.append(this._morph);\n\t    }\n\t    return this._morph;\n\t  };\n\t\n\t  return ModalMorph;\n\t}(_modalDialog2.default);\n\t\n\texports.default = ModalMorph;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 21 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _navBar = __webpack_require__(22);\n\t\n\tvar _navBar2 = _interopRequireDefault(_navBar);\n\t\n\tvar _navDropdown = __webpack_require__(25);\n\t\n\tvar _navDropdown2 = _interopRequireDefault(_navDropdown);\n\t\n\tvar _navList = __webpack_require__(28);\n\t\n\tvar _navList2 = _interopRequireDefault(_navList);\n\t\n\tvar _resizeObserver = __webpack_require__(3);\n\t\n\tvar _resizeObserver2 = _interopRequireDefault(_resizeObserver);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-nav';\n\tvar CLASS_LIST = 'aui-nav--list';\n\tvar CLASS_BAR = 'aui-nav--bar';\n\tvar CLASS_TAB = 'aui-nav--tab';\n\tvar CLASS_DROPDOWN = 'aui-nav--dropdown';\n\t\n\t/**\n\t * Class constructor for Nav AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Nav = function (_Component) {\n\t  _inherits(Nav, _Component);\n\t\n\t  /**\n\t   * Upgrades all Nav AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Nav.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Nav(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  _createClass(Nav, null, [{\n\t    key: 'MODIFIER_LIST',\n\t\n\t\n\t    /**\n\t     * Returns modifier `list`\n\t     */\n\t    get: function get() {\n\t      return CLASS_LIST;\n\t    }\n\t\n\t    /**\n\t     * Returns modifier `bar`\n\t     */\n\t\n\t  }, {\n\t    key: 'MODIFIER_BAR',\n\t    get: function get() {\n\t      return CLASS_BAR;\n\t    }\n\t\n\t    /**\n\t     * Returns modifier `tab`\n\t     */\n\t\n\t  }, {\n\t    key: 'MODIFIER_TAB',\n\t    get: function get() {\n\t      return CLASS_TAB;\n\t    }\n\t\n\t    /**\n\t     * Returns modifier `dropdown`\n\t     */\n\t\n\t  }, {\n\t    key: 'MODIFIER_DROPDOWN',\n\t    get: function get() {\n\t      return CLASS_DROPDOWN;\n\t    }\n\t\n\t    /**\n\t     * Constructor\n\t     * @constructor\n\t     * @param {HTMLElement} element The element of the AUI component.\n\t     */\n\t\n\t  }]);\n\t\n\t  function Nav(element) {\n\t    _classCallCheck(this, Nav);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component.\n\t   */\n\t\n\t\n\t  Nav.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    // Initialize with appropriate decorator depending on modifier,\n\t    // represented by according CSS class:\n\t    if (this._element.classList.contains(CLASS_BAR)) {\n\t      this._originModifier = Nav.MODIFIER_BAR;\n\t    } else if (this._element.classList.contains(CLASS_TAB)) {\n\t      this._originModifier = Nav.MODIFIER_TAB;\n\t    } else if (this._element.classList.contains(CLASS_DROPDOWN)) {\n\t      this._originModifier = Nav.MODIFIER_DROPDOWN;\n\t    } else if (this._element.classList.contains(CLASS_LIST)) {\n\t      this._originModifier = Nav.MODIFIER_LIST;\n\t    }\n\t\n\t    this._layoutBreakpoint = parseInt(window.getComputedStyle(this._element, ':after').getPropertyValue('content').replace(/['\"]+/g, ''));\n\t\n\t    if (this._layoutBreakpoint > 0 && (this._originModifier === Nav.MODIFIER_BAR || this._originModifier === Nav.MODIFIER_TAB)) {\n\t      this._resizeObserver = new _resizeObserver2.default();\n\t      this._resizeObserver.resized.add(this._boundResize = function () {\n\t        return _this2._resized();\n\t      });\n\t      this._resized();\n\t    } else {\n\t      this.setModifier(this._originModifier);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Dispose component.\n\t   */\n\t\n\t\n\t  Nav.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    if (this._decorator) {\n\t      this._decorator.dispose();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Updates inidcator position and visibility of paddles.\n\t   */\n\t\n\t\n\t  Nav.prototype.update = function update() {\n\t    if (this._decorator) {\n\t      this._decorator.update();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Set modifier to switch style of Nav Component.\n\t   * @param {string} modifier name.\n\t   * @throws Will throw an error, if the given modifier is not supported.\n\t   */\n\t\n\t\n\t  Nav.prototype.setModifier = function setModifier(modifier) {\n\t    if (this._modifier === modifier) {\n\t      return;\n\t    }\n\t\n\t    if (this._decorator) {\n\t      this._decorator.dispose();\n\t    }\n\t\n\t    this._element.classList.remove(CLASS_LIST, CLASS_BAR, CLASS_TAB, CLASS_DROPDOWN);\n\t\n\t    switch (modifier) {\n\t      case Nav.MODIFIER_BAR:\n\t        this._element.classList.add(CLASS_BAR);\n\t        this._decorator = new _navBar2.default(this._element);\n\t        break;\n\t\n\t      case Nav.MODIFIER_TAB:\n\t        this._element.classList.add(CLASS_TAB);\n\t        this._decorator = new _navBar2.default(this._element);\n\t        break;\n\t\n\t      case Nav.MODIFIER_DROPDOWN:\n\t        this._element.classList.add(CLASS_DROPDOWN);\n\t        this._decorator = new _navDropdown2.default(this._element);\n\t        break;\n\t\n\t      case Nav.MODIFIER_LIST:\n\t        this._element.classList.add(CLASS_LIST);\n\t        this._decorator = new _navList2.default(this._element);\n\t        break;\n\t\n\t      default:\n\t        throw new Error('Modifier \\'' + modifier + '\\' for Nav component not supported.');\n\t    }\n\t\n\t    this._modifier = modifier;\n\t  };\n\t\n\t  /**\n\t   * Handle resize signal.\n\t   */\n\t\n\t\n\t  Nav.prototype._resized = function _resized() {\n\t    var viewportWidth = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n\t    if (this._originModifier === Nav.MODIFIER_BAR || this._originModifier === Nav.MODIFIER_TAB) {\n\t      if (viewportWidth >= this._layoutBreakpoint) {\n\t        this.setModifier(this._originModifier);\n\t      } else {\n\t        this.setModifier(Nav.MODIFIER_DROPDOWN);\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Returns index.\n\t   * @returns {number} the index of current active action element.\n\t   */\n\t\n\t\n\t  _createClass(Nav, [{\n\t    key: 'index',\n\t    get: function get() {\n\t      return this._decorator ? this._decorator.index : undefined;\n\t    }\n\t\n\t    /**\n\t     * Returns length.\n\t     * @returns {number} the number of action elements.\n\t     */\n\t\n\t  }, {\n\t    key: 'length',\n\t    get: function get() {\n\t      return this._decorator ? this._decorator.length : undefined;\n\t    }\n\t  }]);\n\t\n\t  return Nav;\n\t}(_component2.default);\n\t\n\texports.default = Nav;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 22 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _resizeObserver = __webpack_require__(3);\n\t\n\tvar _resizeObserver2 = _interopRequireDefault(_resizeObserver);\n\t\n\tvar _scrollObserverElement = __webpack_require__(23);\n\t\n\tvar _scrollObserverElement2 = _interopRequireDefault(_scrollObserverElement);\n\t\n\tvar _limit = __webpack_require__(24);\n\t\n\tvar _limit2 = _interopRequireDefault(_limit);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-nav';\n\tvar CLASS_PANEL = 'aui-nav__panel';\n\tvar CLASS_ACTION = 'aui-nav__action';\n\tvar CLASS_INDICATOR = 'aui-nav__indicator';\n\tvar CLASS_PADDLES = 'aui-nav__paddles';\n\tvar CLASS_PADDLE_LEFT = 'aui-nav__paddle-left';\n\tvar CLASS_PADDLE_RIGHT = 'aui-nav__paddle-right';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\tvar CLASS_IS_ANIMATED = 'is-animated';\n\tvar SHOW_INDICATOR_DELAY = 0.25; // in seconds; Delay after which, the indicator fades in.\n\tvar INDICATOR_HIDDEN_X = -20; // Position of indicator when it's hidden, e.g. on page load.\n\tvar INDICATOR_HIDDEN_WIDTH = 10; // Width of indicator when it's hidden, e.g. on page load.\n\tvar SCROLL_THRESHOLD = 20; // in px; How far to scroll, before paddles are visible.\n\tvar SCROLL_PADDING = 10; // in px;\n\tvar SCROLL_EASING = 0.2;\n\t\n\t/**\n\t * Class constructor for NavBar AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar NavBar = function (_Component) {\n\t  _inherits(NavBar, _Component);\n\t\n\t  /**\n\t   * Upgrades all NavBar AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  NavBar.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new NavBar(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function NavBar(element) {\n\t    _classCallCheck(this, NavBar);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component.\n\t   */\n\t\n\t\n\t  NavBar.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    // Refer elements\n\t    this._panel = this._element.querySelector('.' + CLASS_PANEL);\n\t    this._actionElements = Array.from(this._element.querySelectorAll('.' + CLASS_ACTION));\n\t\n\t    // Add indicator (line underneath action elements)\n\t    this._indicator = document.createElement('span');\n\t    this._indicator.classList.add(CLASS_INDICATOR);\n\t    this._panel.appendChild(this._indicator);\n\t\n\t    // Add paddles (gradient and buttons on the left/right, when scrolling is required)\n\t    this._paddles = document.createElement('div');\n\t    this._paddles.classList.add(CLASS_PADDLES);\n\t    this._element.appendChild(this._paddles);\n\t    this._paddleLeft = this._addPaddle(CLASS_PADDLE_LEFT);\n\t    this._paddleRight = this._addPaddle(CLASS_PADDLE_RIGHT);\n\t\n\t    // Watch window resizing\n\t    this._resizeObserver = new _resizeObserver2.default();\n\t    this._resizeObserver.resized.add(this._resizedHandler = function () {\n\t      return _this2.update();\n\t    });\n\t\n\t    // Watch scrolling of wrapper element\n\t    this._scrollObserver = new _scrollObserverElement2.default(this._panel);\n\t    this._scrollObserver.scrolled.add(this._scrollHandler = function () {\n\t      return _this2._onScrollElement();\n\t    });\n\t    this._onScrollElement();\n\t\n\t    // Add event handler\n\t    this._element.addEventListener('click', this._clickHandler = function (event) {\n\t      return _this2._onClick(event);\n\t    });\n\t\n\t    // Set initial action element active\n\t    this.setActive(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t\n\t    // Delay fade in of indicator\n\t    setTimeout(function () {\n\t      _this2._element.classList.add(CLASS_IS_ANIMATED);\n\t    }, SHOW_INDICATOR_DELAY * 1000);\n\t  };\n\t\n\t  /**\n\t   * Dispose component.\n\t   */\n\t\n\t\n\t  NavBar.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t    this._panel.scrollLeft = 0;\n\t    this._scrollActive = false;\n\t    this._resizeObserver.resized.remove(this._resizedHandler);\n\t    this._scrollObserver.scrolled.remove(this._scrollHandler);\n\t    this.removeChild(this._indicator);\n\t    this.removeChild(this._paddles);\n\t    this._element.removeEventListener('click', this._clickHandler);\n\t    this._element.classList.remove(CLASS_IS_ANIMATED);\n\t  };\n\t\n\t  /**\n\t   * Updates inidcator position and visibility of paddles.\n\t   */\n\t\n\t\n\t  NavBar.prototype.update = function update() {\n\t    this.setActive(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t    this._updatePaddleVisibility();\n\t  };\n\t\n\t  /**\n\t   * Set an action element at given index active.\n\t   * @param {index} index The index of action element to set active.\n\t   */\n\t\n\t\n\t  NavBar.prototype.setActiveByIndex = function setActiveByIndex(index) {\n\t    var i = (0, _limit2.default)(index, 0, this._actionElements.length);\n\t    this.setActive(this._actionElements[i]);\n\t  };\n\t\n\t  /**\n\t   * Set an action element active.\n\t   * @param {HTMLElement} activeTarget The action element to set active.\n\t   */\n\t\n\t\n\t  NavBar.prototype.setActive = function setActive(activeTarget) {\n\t    // TODO: Optimize like in nav-list\n\t    this._actionElements.forEach(function (item) {\n\t      item.classList.remove(CLASS_IS_ACTIVE);\n\t    });\n\t\n\t    var indicatorLeft = INDICATOR_HIDDEN_X;\n\t    var indicatorWidth = INDICATOR_HIDDEN_WIDTH;\n\t\n\t    if (activeTarget) {\n\t      activeTarget.classList.add(CLASS_IS_ACTIVE);\n\t      var containerBounds = this._element.getBoundingClientRect();\n\t      var rectTarget = activeTarget.getBoundingClientRect();\n\t      indicatorLeft = rectTarget.left - containerBounds.left + this._panel.scrollLeft;\n\t      indicatorWidth = activeTarget.offsetWidth;\n\t    }\n\t\n\t    this._indicator.style.left = indicatorLeft + 'px';\n\t    this._indicator.style.width = indicatorWidth + 'px';\n\t\n\t    this._index = null;\n\t    for (var i = 0; i < this._actionElements.length; i++) {\n\t      if (this._actionElements[i] === activeTarget) {\n\t        this._index = i;\n\t        break;\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Scroll to the next visible action element on the left.\n\t   */\n\t\n\t\n\t  NavBar.prototype.scrollLeft = function scrollLeft() {\n\t    this.scroll(-1);\n\t  };\n\t\n\t  /**\n\t   * Scroll to the next visible action element on the right.\n\t   */\n\t\n\t\n\t  NavBar.prototype.scrollRight = function scrollRight() {\n\t    this.scroll(1);\n\t  };\n\t\n\t  /**\n\t   * Scroll to the next visible action element on the left or right.\n\t   * @param {number} dir The direction to scroll to: -1=>left, 1=>right.\n\t   */\n\t\n\t\n\t  NavBar.prototype.scroll = function scroll(dir) {\n\t    var containerBounds = this._element.getBoundingClientRect();\n\t    var elementBounds = void 0;\n\t    var left = 0;\n\t    var right = this._panel.offsetWidth;\n\t    var scroll = 0;\n\t\n\t    if (dir < 0) {\n\t      // Scroll to previous element\n\t      for (var i = this._actionElements.length - 1; i > 0; i--) {\n\t        var element = this._actionElements[i];\n\t        elementBounds = element.getBoundingClientRect();\n\t        var elementLeft = elementBounds.left - containerBounds.left;\n\t        if (elementLeft < left) {\n\t          scroll = Math.ceil(elementLeft + this._panel.scrollLeft - SCROLL_PADDING);\n\t          break;\n\t        }\n\t      }\n\t    } else {\n\t      // Scroll to next element\n\t      for (var _i = 0; _i < this._actionElements.length; _i++) {\n\t        var _element = this._actionElements[_i];\n\t        elementBounds = _element.getBoundingClientRect();\n\t        var elementRight = elementBounds.left - containerBounds.left + _element.offsetWidth;\n\t        if (elementRight > right) {\n\t          scroll = Math.ceil(elementRight + this._panel.scrollLeft + SCROLL_PADDING - right);\n\t          break;\n\t        }\n\t      }\n\t    }\n\t\n\t    this._animateScroll(scroll);\n\t  };\n\t\n\t  /**\n\t   * Scroll to the next visible action element on the left or right.\n\t   * @param {number} scroll position to scroll to.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavBar.prototype._animateScroll = function _animateScroll(scroll) {\n\t    var _this3 = this;\n\t\n\t    this._scrollStart = this._panel.scrollLeft;\n\t    this._scrollDelta = scroll - this._scrollStart;\n\t    this._scrollRatio = 0;\n\t    this._scrollActive = true;\n\t    window.requestAnimationFrame(function () {\n\t      return _this3._animateScrollTick();\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Scroll animation tick.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavBar.prototype._animateScrollTick = function _animateScrollTick() {\n\t    var _this4 = this;\n\t\n\t    var ratio = 1 - this._scrollRatio;\n\t    ratio *= SCROLL_EASING;\n\t    this._scrollRatio += ratio;\n\t\n\t    if (ratio < 0.001) {\n\t      this._scrollRatio = 1;\n\t    }\n\t    this._panel.scrollLeft = this._scrollStart + this._scrollDelta * this._scrollRatio;\n\t\n\t    if (this._scrollActive && this._scrollRatio !== 1) {\n\t      window.requestAnimationFrame(function () {\n\t        return _this4._animateScrollTick();\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Adds a paddle element.\n\t   * @param {string} cssClass to add to element.\n\t   * @returns {HTMLElement} the created paddle element.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavBar.prototype._addPaddle = function _addPaddle(cssClass) {\n\t    var paddle = document.createElement('button');\n\t    paddle.setAttribute('type', 'button');\n\t    paddle.classList.add(cssClass);\n\t    this._paddles.appendChild(paddle);\n\t    return paddle;\n\t  };\n\t\n\t  /**\n\t   * Update visibility of paddles depending on scroll position.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavBar.prototype._updatePaddleVisibility = function _updatePaddleVisibility() {\n\t    if (this._scrollObserver.scrollLeft - SCROLL_THRESHOLD > 0) {\n\t      this._paddleLeft.disabled = false;\n\t    } else {\n\t      this._paddleLeft.disabled = true;\n\t    }\n\t\n\t    if (this._scrollObserver.scrollLeft + this._element.offsetWidth + SCROLL_THRESHOLD < this._panel.scrollWidth) {\n\t      this._paddleRight.disabled = false;\n\t    } else {\n\t      this._paddleRight.disabled = true;\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Handle scroll of element.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavBar.prototype._onScrollElement = function _onScrollElement() {\n\t    this._updatePaddleVisibility();\n\t  };\n\t\n\t  /**\n\t   * Handle click of element.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavBar.prototype._onClick = function _onClick(event) {\n\t    if (event.target === this._paddleLeft) {\n\t      event.preventDefault();\n\t      this.scrollLeft();\n\t    } else if (event.target === this._paddleRight) {\n\t      event.preventDefault();\n\t      this.scrollRight();\n\t    } else {\n\t      // Find closest action element\n\t      var currentElement = event.target;\n\t      while (currentElement !== event.currentTarget) {\n\t        if (currentElement.classList.contains(CLASS_ACTION)) {\n\t          if (!currentElement.disabled) {\n\t            this.setActive(currentElement);\n\t          }\n\t          break;\n\t        }\n\t        currentElement = currentElement.parentNode;\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Returns index.\n\t   * @returns {number} the index of current active action element.\n\t   */\n\t\n\t\n\t  _createClass(NavBar, [{\n\t    key: 'index',\n\t    get: function get() {\n\t      return this._index;\n\t    }\n\t\n\t    /**\n\t     * Returns length.\n\t     * @returns {number} the number of action elements.\n\t     */\n\t\n\t  }, {\n\t    key: 'length',\n\t    get: function get() {\n\t      return this._actionElements.length;\n\t    }\n\t  }]);\n\t\n\t  return NavBar;\n\t}(_component2.default);\n\t\n\texports.default = NavBar;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 23 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _signal = __webpack_require__(4);\n\t\n\tvar _signal2 = _interopRequireDefault(_signal);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tvar SCROLL_END_THRESHOLD = 100; // in ms\n\t\n\tvar ScrollObserverElement = function () {\n\t  function ScrollObserverElement(element) {\n\t    var _this = this;\n\t\n\t    _classCallCheck(this, ScrollObserverElement);\n\t\n\t    this._element = element;\n\t    this._scrollX = this._element.scrollLeft;\n\t    this._scrollY = this._element.scrollTop;\n\t    this._ticking = false;\n\t\n\t    this.scrolled = new _signal2.default();\n\t    this.scrollEnded = new _signal2.default();\n\t\n\t    this._element.addEventListener('scroll', this._scrollHandler = function (event) {\n\t      return _this._onScroll(event);\n\t    });\n\t  }\n\t\n\t  ScrollObserverElement.prototype._onScroll = function _onScroll(event) {\n\t    var _this2 = this;\n\t\n\t    this._scrollX = event.target.scrollLeft;\n\t    this._scrollY = event.target.scrollTop;\n\t\n\t    if (!this._ticking) {\n\t      window.requestAnimationFrame(function () {\n\t        _this2._ticking = false;\n\t        _this2.scrolled.dispatch(_this2._scrollX, _this2._scrollY);\n\t        clearTimeout(_this2._scrollEndTimeout);\n\t        _this2._scrollEndTimeout = setTimeout(function () {\n\t          _this2.scrollEnded.dispatch(_this2._scrollX, _this2._scrollY);\n\t        }, SCROLL_END_THRESHOLD);\n\t      });\n\t    }\n\t    this._ticking = true;\n\t  };\n\t\n\t  _createClass(ScrollObserverElement, [{\n\t    key: 'scrollLeft',\n\t    get: function get() {\n\t      return this._scrollX;\n\t    }\n\t  }, {\n\t    key: 'scrollTop',\n\t    get: function get() {\n\t      return this._scrollY;\n\t    }\n\t  }]);\n\t\n\t  return ScrollObserverElement;\n\t}();\n\t\n\texports.default = ScrollObserverElement;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 24 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.default = limit;\n\t/**\n\t * Limits a value to x >= min and x <= max.\n\t * @param {number} x The value to limit.\n\t * @param {number} min The value to limit.\n\t * @param {number} max The value to limit.\n\t * @returns {number} The limited value.\n\t */\n\tfunction limit(x, min, max) {\n\t  if (x > max) x = max;\n\t  if (x < min) x = min;\n\t  return x;\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 25 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _sticky = __webpack_require__(26);\n\t\n\tvar _sticky2 = _interopRequireDefault(_sticky);\n\t\n\tvar _limit = __webpack_require__(24);\n\t\n\tvar _limit2 = _interopRequireDefault(_limit);\n\t\n\tvar _isNone = __webpack_require__(27);\n\t\n\tvar _isNone2 = _interopRequireDefault(_isNone);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-nav';\n\tvar CLASS_PANEL = 'aui-nav__panel';\n\tvar CLASS_UNDERLINE = 'aui-nav__underline';\n\tvar CLASS_ITEM = 'aui-nav__item';\n\tvar CLASS_ACTION = 'aui-nav__action';\n\tvar CLASS_TOGGLE = 'aui-nav__toggle';\n\tvar CLASS_TOGGLE_LABEL = 'aui-nav__toggle-label';\n\tvar CLASS_STICKY = 'aui-nav--sticky';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\t\n\t/**\n\t * Class constructor for NavDropdown AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar NavDropdown = function (_Component) {\n\t  _inherits(NavDropdown, _Component);\n\t\n\t  /**\n\t   * Upgrades all NavDropdown AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  NavDropdown.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new NavDropdown(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function NavDropdown(element) {\n\t    _classCallCheck(this, NavDropdown);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component.\n\t   */\n\t\n\t\n\t  NavDropdown.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._index = 0;\n\t\n\t    // Refer elements\n\t    this._panel = this._element.querySelector('.' + CLASS_PANEL);\n\t    this._actions = Array.from(this._element.querySelectorAll('.' + CLASS_ACTION));\n\t\n\t    // Set transition delays for item elements\n\t    Array.from(this._element.querySelectorAll('.' + CLASS_ITEM)).forEach(function (element, index) {\n\t      element.style.transitionDelay = element.style.webkitTransitionDelay = 0.1 + 0.05 * index + 's';\n\t    });\n\t\n\t    // Add toggle element\n\t    this._toggle = this.createElement('button', [CLASS_TOGGLE], {\n\t      type: 'button'\n\t    });\n\t    this._element.appendChild(this._toggle);\n\t    this._toggleLabel = this.createElement('span', [CLASS_TOGGLE_LABEL]);\n\t    this._toggle.appendChild(this._toggleLabel);\n\t\n\t    // Add underline element\n\t    this._underline = this.createElement('div', [CLASS_UNDERLINE]);\n\t    this._element.appendChild(this._underline);\n\t\n\t    // Check if component is sticky\n\t    if (this._element.classList.contains(CLASS_STICKY)) {\n\t      this._stickyHandler = new _sticky2.default(this._element);\n\t    }\n\t\n\t    // Add event handler\n\t    this._element.addEventListener('click', this._clickHandler = function (event) {\n\t      return _this2._onClick(event);\n\t    });\n\t\n\t    // Set initial action element active\n\t    this.setActive(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t  };\n\t\n\t  /**\n\t   * Dispose component.\n\t   */\n\t\n\t\n\t  NavDropdown.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t    this._actions.forEach(function (element, index) {\n\t      element.style.transitionDelay = '';\n\t    });\n\t    this.removeChild(this._toggle);\n\t    this.removeChild(this._underline);\n\t    this._element.removeEventListener('click', this._clickHandler);\n\t  };\n\t\n\t  /**\n\t   * Updates inidcator position and visibility of paddles.\n\t   */\n\t\n\t\n\t  NavDropdown.prototype.update = function update() {\n\t    this.setActive(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t  };\n\t\n\t  /**\n\t   * Toggle active state.\n\t   * @param {boolean} force If is true, open panel, and if it is false, close it.\n\t   */\n\t\n\t\n\t  NavDropdown.prototype.toggle = function toggle(force) {\n\t    this._element.classList.toggle(CLASS_IS_ACTIVE, force);\n\t  };\n\t\n\t  /**\n\t   * Set an action element at given index active.\n\t   * @param {index} index The index of action element to set active.\n\t   */\n\t\n\t\n\t  NavDropdown.prototype.setActiveByIndex = function setActiveByIndex(index) {\n\t    var i = (0, _limit2.default)(index, 0, this._actions.length);\n\t    this.setActive(this._actions[i]);\n\t  };\n\t\n\t  /**\n\t   * Set an action element active.\n\t   * @param {HTMLElement} activeTarget The action element to set active.\n\t   */\n\t\n\t\n\t  NavDropdown.prototype.setActive = function setActive(activeTarget) {\n\t    // TODO: Optimize like in nav-list\n\t\n\t    // Remove active class from all action elements\n\t    this._actions.forEach(function (item) {\n\t      item.classList.remove(CLASS_IS_ACTIVE);\n\t    });\n\t\n\t    // If no action element is active, pick the first one\n\t    if ((0, _isNone2.default)(activeTarget)) {\n\t      activeTarget = this._actions[0];\n\t    }\n\t\n\t    // Apply active class to action element and mirror innerHTML to toggle\n\t    activeTarget.classList.add(CLASS_IS_ACTIVE);\n\t    this._toggleLabel.innerHTML = activeTarget.innerHTML;\n\t\n\t    // Update active index\n\t    this._index = null;\n\t    for (var i = 0; i < this._actions.length; i++) {\n\t      if (this._actions[i] === activeTarget) {\n\t        this._index = i;\n\t        break;\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Handle click of element.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavDropdown.prototype._onClick = function _onClick(event) {\n\t    if (event.target === this._toggle) {\n\t      this.toggle();\n\t    } else {\n\t      // Find closest action element\n\t      var currentElement = event.target;\n\t      while (currentElement !== event.currentTarget) {\n\t        if (currentElement.classList.contains(CLASS_ACTION)) {\n\t          this.setActive(currentElement);\n\t          this.toggle();\n\t          break;\n\t        }\n\t        currentElement = currentElement.parentNode;\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Returns index.\n\t   * @returns {number} the index of current active action element.\n\t   */\n\t\n\t\n\t  _createClass(NavDropdown, [{\n\t    key: 'index',\n\t    get: function get() {\n\t      return this._index;\n\t    }\n\t\n\t    /**\n\t     * Returns length.\n\t     * @returns {number} the number of action elements.\n\t     */\n\t\n\t  }, {\n\t    key: 'length',\n\t    get: function get() {\n\t      return this._actions.length;\n\t    }\n\t  }]);\n\t\n\t  return NavDropdown;\n\t}(_component2.default);\n\t\n\texports.default = NavDropdown;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 26 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _scrollObserver = __webpack_require__(16);\n\t\n\tvar _scrollObserver2 = _interopRequireDefault(_scrollObserver);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar CLASS_IS_STICKY = 'is-sticky';\n\t\n\t/**\n\t * Class constructor for Sticky AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Sticky = function (_Component) {\n\t  _inherits(Sticky, _Component);\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function Sticky(element) {\n\t    _classCallCheck(this, Sticky);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component.\n\t   */\n\t\n\t\n\t  Sticky.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    // If browser supports position:sticky, it will handle positioning and\n\t    // we can skip here.\n\t    if (window.getComputedStyle(this._element).position.indexOf('sticky') !== -1) {\n\t      return;\n\t    }\n\t\n\t    this._scrollObserver = new _scrollObserver2.default();\n\t    this._scrollObserver.scrolled.add(this._scrollHandler = function () {\n\t      return _this2.checkStickiness();\n\t    });\n\t\n\t    this._sticky = false;\n\t    this.checkStickiness();\n\t  };\n\t\n\t  /**\n\t  * Dispose component.\n\t  */\n\t\n\t\n\t  Sticky.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this.release();\n\t    this._scrollObserver.resized.remove(this._scrollHandler);\n\t    this._resizeObserver.resized.remove(this._resizedHandler);\n\t  };\n\t\n\t  /**\n\t   * Check if position.top is negative. If so stick otherwise release component.\n\t   */\n\t\n\t\n\t  Sticky.prototype.checkStickiness = function checkStickiness() {\n\t    if (this._element.getBoundingClientRect().top <= 0) {\n\t      if (!this._sticky) {\n\t        this.stick();\n\t      }\n\t    } else {\n\t      if (this._sticky) {\n\t        this.release();\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Stick component to top of viewport in adding sticky class.\n\t   */\n\t\n\t\n\t  Sticky.prototype.stick = function stick() {\n\t    if (!this._sticky) {\n\t      this._element.classList.add(CLASS_IS_STICKY);\n\t    }\n\t    this._sticky = true;\n\t  };\n\t\n\t  /**\n\t   * Release component and position not fixed in removing sticky class.\n\t   */\n\t\n\t\n\t  Sticky.prototype.release = function release() {\n\t    if (this._sticky) {\n\t      this._element.classList.remove(CLASS_IS_STICKY);\n\t    }\n\t    this._sticky = false;\n\t  };\n\t\n\t  return Sticky;\n\t}(_component2.default);\n\t\n\texports.default = Sticky;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 27 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.default = isNone;\n\t/**\n\t * Check if value is either `undefined` or `null`.\n\t * @param {*} value to check.\n\t * @returns {boolean} true if value is `undefined` or `null`.\n\t */\n\tfunction isNone(value) {\n\t  return value === undefined || value === null;\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 28 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _limit = __webpack_require__(24);\n\t\n\tvar _limit2 = _interopRequireDefault(_limit);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-nav';\n\tvar CLASS_ACTION = 'aui-nav__action';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\t\n\t/**\n\t * Class constructor for NavList AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar NavList = function (_Component) {\n\t  _inherits(NavList, _Component);\n\t\n\t  /**\n\t   * Upgrades all NavList AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  NavList.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new NavList(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function NavList(element) {\n\t    _classCallCheck(this, NavList);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component.\n\t   */\n\t\n\t\n\t  NavList.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    // Refer elements\n\t    this._actionElements = Array.from(this._element.querySelectorAll('.' + CLASS_ACTION));\n\t\n\t    // Add event handler\n\t    this._element.addEventListener('click', this._clickHandler = function (event) {\n\t      return _this2._onClick(event);\n\t    });\n\t\n\t    // Set initial action element active\n\t    this.setActive(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t  };\n\t\n\t  /**\n\t   * Dispose component.\n\t   */\n\t\n\t\n\t  NavList.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t    this._element.removeEventListener('click', this._clickHandler);\n\t  };\n\t\n\t  /**\n\t   * Updates inidcator position and visibility of paddles.\n\t   */\n\t\n\t\n\t  NavList.prototype.update = function update() {\n\t    this.setActive(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t  };\n\t\n\t  /**\n\t   * Set an action element at given index active.\n\t   * @param {index} index The index of action element to set active.\n\t   */\n\t\n\t\n\t  NavList.prototype.setActiveByIndex = function setActiveByIndex(index) {\n\t    var i = (0, _limit2.default)(index, 0, this._actionElements.length);\n\t    this.setActive(this._actionElements[i]);\n\t  };\n\t\n\t  /**\n\t   * Set an action element active.\n\t   * @param {HTMLElement} activeTarget The action element to set active.\n\t   */\n\t\n\t\n\t  NavList.prototype.setActive = function setActive(activeTarget) {\n\t    var _this3 = this;\n\t\n\t    this._actionElements.forEach(function (item, index) {\n\t      var active = item === activeTarget;\n\t      item.classList.toggle(CLASS_IS_ACTIVE, active);\n\t      if (active) {\n\t        _this3._index = index;\n\t      }\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Handle click of element.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  NavList.prototype._onClick = function _onClick(event) {\n\t    // Find closest action element\n\t    var currentElement = event.target;\n\t    while (currentElement !== event.currentTarget) {\n\t      if (currentElement.classList.contains(CLASS_ACTION)) {\n\t        if (!currentElement.disabled) {\n\t          this.setActive(currentElement);\n\t        }\n\t        break;\n\t      }\n\t      currentElement = currentElement.parentNode;\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Returns index.\n\t   * @returns {number} the index of current active action element.\n\t   */\n\t\n\t\n\t  _createClass(NavList, [{\n\t    key: 'index',\n\t    get: function get() {\n\t      return this._index;\n\t    }\n\t\n\t    /**\n\t     * Returns length.\n\t     * @returns {number} the number of action elements.\n\t     */\n\t\n\t  }, {\n\t    key: 'length',\n\t    get: function get() {\n\t      return this._actionElements.length;\n\t    }\n\t  }]);\n\t\n\t  return NavList;\n\t}(_component2.default);\n\t\n\texports.default = NavList;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 29 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-notification';\n\tvar CLASS_CONTENT = 'aui-notification__content';\n\tvar CLASS_CLOSE_BUTTON = 'aui-notification__close';\n\tvar CLASS_IS_CLOSED = 'is-closed';\n\tvar CLASS_IS_OPEN = 'is-open';\n\tvar ATTR_CLOSE = 'data-close';\n\t\n\t/**\n\t * Class constructor for Notification AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Notification = function (_Component) {\n\t  _inherits(Notification, _Component);\n\t\n\t  /**\n\t   * Upgrades all Notification AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Notification.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Notification(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Notification(element) {\n\t    _classCallCheck(this, Notification);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  Notification.prototype.init = function init() {\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._content = this._element.querySelector('.' + CLASS_CONTENT);\n\t    if (!this._content) {\n\t      this._content = document.createElement('div');\n\t      this._content.classList.add(CLASS_CONTENT);\n\t      this._element.appendChild(this._content);\n\t    }\n\t\n\t    // Add close button\n\t    this._closeButton = document.createElement('button');\n\t    this._closeButton.setAttribute('type', 'button');\n\t    this._closeButton.classList.add(CLASS_CLOSE_BUTTON);\n\t    this._element.appendChild(this._closeButton);\n\t\n\t    this.open();\n\t  };\n\t\n\t  Notification.prototype.open = function open() {\n\t    var _this2 = this;\n\t\n\t    this._element.addEventListener('click', this._clickHandler = function (event) {\n\t      return _this2._onClick(event);\n\t    });\n\t    this.checkOpeningPreparation();\n\t  };\n\t\n\t  Notification.prototype.checkOpeningPreparation = function checkOpeningPreparation() {\n\t    clearTimeout(this.openingTimeout);\n\t    this._element.classList.add(CLASS_IS_OPEN);\n\t    this._element.classList.remove(CLASS_IS_CLOSED);\n\t  };\n\t\n\t  Notification.prototype.close = function close() {\n\t    this._element.removeEventListener('click', this._clickHandler);\n\t    this._element.style.height = this._element.offsetHeight + 'px';\n\t    this._element.style.marginTop = '0px';\n\t    this._element.style.marginBottom = '0px';\n\t    this.checkClosingPreparation();\n\t  };\n\t\n\t  Notification.prototype.checkClosingPreparation = function checkClosingPreparation() {\n\t    var _this3 = this;\n\t\n\t    clearTimeout(this.openingTimeout);\n\t    if (window.getComputedStyle(this._element).height && this._element.style.height) {\n\t      this._element.classList.remove(CLASS_IS_OPEN);\n\t      this._element.classList.add(CLASS_IS_CLOSED);\n\t    } else {\n\t      window.requestAnimationFrame(function () {\n\t        return _this3.checkClosingPreparation();\n\t      });\n\t    }\n\t  };\n\t\n\t  Notification.prototype._onClick = function _onClick(event) {\n\t    if (event.target.classList.contains(CLASS_CLOSE_BUTTON) || event.target.hasAttribute(ATTR_CLOSE)) {\n\t      this.close();\n\t    }\n\t  };\n\t\n\t  return Notification;\n\t}(_component2.default);\n\t\n\texports.default = Notification;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 30 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _resizeObserver = __webpack_require__(3);\n\t\n\tvar _resizeObserver2 = _interopRequireDefault(_resizeObserver);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-pagination';\n\tvar CLASS_ITEM = 'aui-pagination__link';\n\tvar CLASS_INDICATOR = 'aui-pagination__indicator';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\tvar CLASS_IS_ANIMATED = 'is-animated';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\t\n\t/**\n\t * Class constructor for Pagination AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Pagination = function (_Component) {\n\t  _inherits(Pagination, _Component);\n\t\n\t  function Pagination() {\n\t    _classCallCheck(this, Pagination);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Pagination AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Pagination.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Pagination(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  Pagination.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._resizeObserver = new _resizeObserver2.default();\n\t    this._resizeObserver.resized.add(this._boundResized = function () {\n\t      return _this2.update();\n\t    });\n\t\n\t    this._items = Array.from(this._element.querySelectorAll('.' + CLASS_ITEM));\n\t\n\t    this._indicator = document.createElement('span');\n\t    this._indicator.classList.add(CLASS_INDICATOR);\n\t    this._element.appendChild(this._indicator);\n\t\n\t    this._element.addEventListener('click', this._boundClick = function (event) {\n\t      return _this2._onClick(event);\n\t    });\n\t\n\t    this._repositionIndicator(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t    setTimeout(function () {\n\t      _this2._element.classList.add(CLASS_IS_ANIMATED);\n\t    }, 250);\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Pagination.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._element.classList.remove(CLASS_IS_ANIMATED);\n\t\n\t    this._element.removeEventListener('click', this._boundClick);\n\t    this._resizeObserver.resized.remove(this._boundResized);\n\t\n\t    if (this._indicator) {\n\t      this.removeChild(this._indicator);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Update component.\n\t   */\n\t\n\t\n\t  Pagination.prototype.update = function update() {\n\t    this._repositionIndicator(this._element.querySelector('.' + CLASS_IS_ACTIVE));\n\t  };\n\t\n\t  /**\n\t   * Reposition indicator of `active` page.\n\t   * @param {HTMLElement} linkElement that is going to be `active`.\n\t   * @private\n\t   */\n\t\n\t\n\t  Pagination.prototype._repositionIndicator = function _repositionIndicator(linkElement) {\n\t    if (!linkElement) return;\n\t\n\t    this._items.forEach(function (item) {\n\t      item.classList.remove(CLASS_IS_ACTIVE);\n\t    });\n\t    linkElement.classList.add(CLASS_IS_ACTIVE);\n\t\n\t    // Indicator position\n\t    var rectContainer = this._element.getBoundingClientRect();\n\t    var rectTarget = linkElement.getBoundingClientRect();\n\t    var indicatorLeft = rectTarget.left - rectContainer.left + this._element.scrollLeft;\n\t    this._indicator.style.left = indicatorLeft + 'px';\n\t    this._indicator.style.width = linkElement.offsetWidth + 'px';\n\t  };\n\t\n\t  /**\n\t   * Handle click.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  Pagination.prototype._onClick = function _onClick(event) {\n\t    if (event.target.classList.contains(CLASS_ITEM) && !event.target.classList.contains(CLASS_IS_DISABLED)) {\n\t      this._repositionIndicator(event.target);\n\t    }\n\t  };\n\t\n\t  return Pagination;\n\t}(_component2.default);\n\t\n\texports.default = Pagination;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 31 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-player';\n\tvar SELECTOR_PROGRESS_CONTROL = '.aui-player__progress-control';\n\tvar SELECTOR_SEEK_HOLDER = '.aui-player__seek-holder';\n\tvar SELECTOR_PREVIEW = '.aui-player__preview';\n\tvar CLASS_SEEKING = 'is-seeking';\n\t\n\t/**\n\t * Class constructor for Player AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Player = function (_Component) {\n\t  _inherits(Player, _Component);\n\t\n\t  /**\n\t   * Upgrades all Player AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Player.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Player(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Player(element) {\n\t    _classCallCheck(this, Player);\n\t\n\t    var _this = _possibleConstructorReturn(this, _Component.call(this, element));\n\t\n\t    _this._progressControl = _this._element.querySelector(SELECTOR_PROGRESS_CONTROL);\n\t    if (_this._progressControl) {\n\t      _this._progressControl.addEventListener('mouseover', _this.progressControlOverListener = function (event) {\n\t        return _this.progressControlOverHandler(event);\n\t      });\n\t      _this._progressControl.addEventListener('mouseout', _this.progressControlOutListener = function (event) {\n\t        return _this.progressControlOutHandler(event);\n\t      });\n\t\n\t      _this._seekHolder = _this._progressControl.querySelector(SELECTOR_SEEK_HOLDER);\n\t    }\n\t\n\t    _this._preview = _this._element.querySelector(SELECTOR_PREVIEW);\n\t    return _this;\n\t  }\n\t\n\t  Player.prototype.progressControlOverHandler = function progressControlOverHandler(event) {\n\t    var _this2 = this;\n\t\n\t    this._progressControl.removeEventListener('mousemove', this.moveListener);\n\t    this._progressControl.addEventListener('mousemove', this.progressControlMoveListener = function (event) {\n\t      return _this2.progressControlMoveHandler(event);\n\t    });\n\t    this._element.classList.add(CLASS_SEEKING);\n\t    this.updateSeek(event.clientX);\n\t  };\n\t\n\t  Player.prototype.progressControlMoveHandler = function progressControlMoveHandler(event) {\n\t    this.updateSeek(event.clientX);\n\t  };\n\t\n\t  Player.prototype.progressControlOutHandler = function progressControlOutHandler(event) {\n\t    this._element.classList.remove(CLASS_SEEKING);\n\t  };\n\t\n\t  Player.prototype.updateSeek = function updateSeek() {\n\t    // Translate trigger position x to ratio of progress control width\n\t    var boundings = this._progressControl.getBoundingClientRect(),\n\t        offsetX = event.clientX - boundings.left,\n\t        ratio = offsetX / this._progressControl.offsetWidth,\n\t        ratioPercentStr = void 0;\n\t    ratio = Math.max(0, Math.min(ratio, 1));\n\t    ratioPercentStr = ratio * 100 + '%';\n\t    this._seekHolder.style.width = ratioPercentStr;\n\t  };\n\t\n\t  return Player;\n\t}(_component2.default);\n\t\n\texports.default = Player;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 32 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _limit = __webpack_require__(24);\n\t\n\tvar _limit2 = _interopRequireDefault(_limit);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-progress';\n\tvar CLASS_CONTINUOUS = 'aui-progress--continuous';\n\tvar CLASS_BAR = 'aui-progress__bar';\n\tvar CLASS_IS_PENDING = 'is-pending';\n\tvar CLASS_IS_LOADING = 'is-loading';\n\tvar CLASS_IS_COMPLETE = 'is-complete';\n\t\n\t/**\n\t * Class constructor for Progress AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Progress = function (_Component) {\n\t  _inherits(Progress, _Component);\n\t\n\t  /**\n\t   * Upgrades all Progress AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Progress.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Progress(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Progress(element) {\n\t    _classCallCheck(this, Progress);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  Progress.prototype.init = function init() {\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._continuous = this._element.classList.contains(CLASS_CONTINUOUS);\n\t\n\t    // Add bar elements:\n\t    this._bar = document.createElement('span');\n\t    this._bar.classList.add(CLASS_BAR);\n\t    this._element.appendChild(this._bar);\n\t\n\t    this.progress(0);\n\t  };\n\t\n\t  Progress.prototype.progress = function progress(ratio) {\n\t    ratio = (0, _limit2.default)(ratio, 0, 1);\n\t    this._progress = ratio;\n\t\n\t    if (!this._continuous) {\n\t      this._bar.style.width = this._progress * 100 + '%';\n\t    }\n\t\n\t    this.updateClasses();\n\t  };\n\t\n\t  Progress.prototype.updateClasses = function updateClasses() {\n\t    if (this._progress === 0) {\n\t      this._element.classList.add(CLASS_IS_PENDING);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_PENDING);\n\t    }\n\t\n\t    if (this._progress > 0 && this._progress < 1) {\n\t      this._element.classList.add(CLASS_IS_LOADING);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_LOADING);\n\t    }\n\t\n\t    if (this._progress === 1) {\n\t      this._element.classList.add(CLASS_IS_COMPLETE);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_COMPLETE);\n\t    }\n\t  };\n\t\n\t  return Progress;\n\t}(_component2.default);\n\t\n\texports.default = Progress;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 33 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-radio';\n\tvar CLASS_INPUT = 'aui-radio__input';\n\tvar CLASS_LABEL = 'aui-radio__label';\n\tvar CLASS_BOX = 'aui-radio__box';\n\tvar CLASS_TICK = 'aui-radio__tick';\n\tvar CLASS_IS_FOCUS = 'is-focused';\n\tvar CLASS_IS_CHECKED = 'is-checked';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\t\n\tvar _radios = void 0;\n\t\n\t/**\n\t * Class constructor for Radio AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Radio = function (_Component) {\n\t  _inherits(Radio, _Component);\n\t\n\t  function Radio() {\n\t    _classCallCheck(this, Radio);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Radio AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Radio.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Radio(element));\n\t      }\n\t    });\n\t    _radios = components;\n\t    return components;\n\t  };\n\t\n\t  Radio.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._input = this._element.querySelector('.' + CLASS_INPUT);\n\t    this._input.addEventListener('change', this._changeHandler = function (event) {\n\t      return _this2._onChange(event);\n\t    });\n\t    this._input.addEventListener('focus', this._focusHandler = function (event) {\n\t      return _this2._onFocus(event);\n\t    });\n\t    this._input.addEventListener('blur', this._blurHandler = function (event) {\n\t      return _this2._onBlur(event);\n\t    });\n\t\n\t    // Insert box with tick after label element:\n\t    this._label = this._element.querySelector('.' + CLASS_LABEL);\n\t    var box = document.createElement('span');\n\t    box.classList.add(CLASS_BOX);\n\t    this._label.parentNode.insertBefore(box, this._label.nextSibling);\n\t    var tick = document.createElement('span');\n\t    tick.classList.add(CLASS_TICK);\n\t    box.appendChild(tick);\n\t\n\t    this.groupName = this._input.getAttribute('name');\n\t\n\t    this.updateClasses();\n\t  };\n\t\n\t  Radio.prototype.updateClasses = function updateClasses() {\n\t    this.checkDisabled();\n\t    this.checkToggleState();\n\t    this.checkFocus();\n\t  };\n\t\n\t  /**\n\t   * Check the disabled state and update field accordingly.\n\t   */\n\t\n\t\n\t  Radio.prototype.checkDisabled = function checkDisabled() {\n\t    if (this._input.disabled) {\n\t      this._element.classList.add(CLASS_IS_DISABLED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DISABLED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the toggle state and update field accordingly.\n\t   */\n\t\n\t\n\t  Radio.prototype.checkToggleState = function checkToggleState() {\n\t    if (this._input.checked) {\n\t      this._element.classList.add(CLASS_IS_CHECKED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_CHECKED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the focus state and update field accordingly.\n\t   */\n\t\n\t\n\t  Radio.prototype.checkFocus = function checkFocus() {\n\t    if (Boolean(this._element.querySelector(':focus'))) {\n\t      this._element.classList.add(CLASS_IS_FOCUS);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_FOCUS);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Enable radio.\n\t   */\n\t\n\t\n\t  Radio.prototype.enable = function enable() {\n\t    this._input.disabled = false;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Disable radio.\n\t   */\n\t\n\t\n\t  Radio.prototype.disable = function disable() {\n\t    this._input.disabled = true;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Check radio.\n\t   */\n\t\n\t\n\t  Radio.prototype.check = function check() {\n\t    this._input.checked = true;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Uncheck radio.\n\t   */\n\t\n\t\n\t  Radio.prototype.uncheck = function uncheck() {\n\t    this._input.checked = false;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Radio.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._input.removeEventListener('change', this._changeHandler);\n\t    this._input.removeEventListener('focus', this._focusHandler);\n\t    this._input.removeEventListener('blur', this._blurHandler);\n\t\n\t    this._element.removeChild(this._element.querySelector('.' + CLASS_BOX));\n\t  };\n\t\n\t  /**\n\t   * Handle change event.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Radio.prototype._onChange = function _onChange(event) {\n\t    this.updateClasses();\n\t    // Since other radio buttons don't get change events, we need to look for\n\t    // them to update their classes.\n\t    for (var i = 0; i < _radios.length; i++) {\n\t      var button = _radios[i];\n\t      // Different name == different group, so no point updating those.\n\t      if (button._input.getAttribute('name') === this.groupName) {\n\t        button.updateClasses();\n\t      }\n\t    }\n\t  };\n\t\n\t  // TODO Find out why unfocus is triggered on mousedown\n\t\n\t\n\t  Radio.prototype._onFocus = function _onFocus(event) {\n\t    this._element.classList.add(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  Radio.prototype._onBlur = function _onBlur(event) {\n\t    this._element.classList.remove(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  /**\n\t   * Getter and Setter\n\t   */\n\t\n\t  _createClass(Radio, [{\n\t    key: 'input',\n\t    get: function get() {\n\t      return this._input;\n\t    }\n\t  }, {\n\t    key: 'checked',\n\t    get: function get() {\n\t      return this._input.checked = true;\n\t    },\n\t    set: function set(value) {\n\t      if (value) {\n\t        this.check();\n\t      } else {\n\t        this.uncheck();\n\t      }\n\t    }\n\t  }, {\n\t    key: 'disabled',\n\t    get: function get() {\n\t      return this._input.disabled = true;\n\t    },\n\t    set: function set(value) {\n\t      if (value) {\n\t        this.disable();\n\t      } else {\n\t        this.enable();\n\t      }\n\t    }\n\t  }]);\n\t\n\t  return Radio;\n\t}(_component2.default);\n\t\n\texports.default = Radio;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 34 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _animationEndEvent = __webpack_require__(35);\n\t\n\tvar _animationEndEvent2 = _interopRequireDefault(_animationEndEvent);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-response';\n\tvar CLASS_BUTTON_PRIMARY = 'aui-button--primary';\n\tvar CLASS_BUTTON_SECONDARY = 'aui-button--secondary';\n\tvar CLASS_BUTTON_ICON = 'aui-button--icon';\n\tvar CLASS_BUTTON_FLOATING = 'aui-button--floating';\n\tvar CLASS_RESPONSE = 'aui-response';\n\tvar CLASS_RESPONSE_MASKED = 'aui-response--masked';\n\tvar CLASS_EFFECT = 'aui-response__effect';\n\tvar CLASS_EFFECT_LARGE = 'aui-response__effect--large';\n\tvar CLASS_IS_ANIMATING = 'is-animating';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\t\n\t/**\n\t * Class constructor for Response AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Response = function (_Component) {\n\t  _inherits(Response, _Component);\n\t\n\t  /**\n\t   * Upgrades all Response AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Response.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Response(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Constructor\n\t   * @constructor\n\t   * @param {HTMLElement} element The element of the AUI component.\n\t   */\n\t  function Response(element) {\n\t    _classCallCheck(this, Response);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t\n\t\n\t  Response.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    var boxedButton = this._element.classList.contains(CLASS_BUTTON_PRIMARY) || this._element.classList.contains(CLASS_BUTTON_SECONDARY) || this._element.classList.contains(CLASS_BUTTON_FLOATING);\n\t\n\t    this._useTriggerX = boxedButton || !this._element.classList.contains(CLASS_BUTTON_ICON);\n\t    this._useTriggerY = boxedButton;\n\t    this._masked = boxedButton;\n\t    this._large = boxedButton;\n\t\n\t    this._responseContainer = document.createElement('span');\n\t    this._responseContainer.classList.add(CLASS_RESPONSE);\n\t    if (this._masked) {\n\t      this._responseContainer.classList.add(CLASS_RESPONSE_MASKED);\n\t    }\n\t    this._element.appendChild(this._responseContainer);\n\t\n\t    this._responseEffect = document.createElement('span');\n\t    this._responseEffect.classList.add(CLASS_EFFECT);\n\t    if (this._large) {\n\t      this._responseEffect.classList.add(CLASS_EFFECT_LARGE);\n\t    }\n\t    this._responseContainer.appendChild(this._responseEffect);\n\t\n\t    this._element.addEventListener('mousedown', this._mousedownHandler = function (event) {\n\t      return _this2._onMousedown(event);\n\t    });\n\t    _animationEndEvent2.default && this._responseEffect.addEventListener(_animationEndEvent2.default, this._animationendHandler = function (event) {\n\t      return _this2._onAnimationend(event);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Response.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._element.removeEventListener('mousedown', this._mousedownHandler);\n\t    if (_animationEndEvent2.default && this._responseEffect) {\n\t      this._responseEffect.removeEventListener(_animationEndEvent2.default, this._animationendHandler);\n\t    }\n\t    this._element.removeChild(this._responseContainer);\n\t  };\n\t\n\t  /**\n\t   * Handle mousedown of element.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  Response.prototype._onMousedown = function _onMousedown(event) {\n\t    // Get cross-browser offsetX, offsetY\n\t    var target = event.currentTarget || event.srcElement,\n\t        rect = target.getBoundingClientRect(),\n\t        offsetX = event.clientX - rect.left,\n\t        offsetY = event.clientY - rect.top;\n\t\n\t    if (!target.classList.contains(CLASS_IS_DISABLED)) {\n\t      this._responseEffect.style.left = this._useTriggerX ? offsetX + 'px' : '50%';\n\t      this._responseEffect.style.top = this._useTriggerY ? offsetY + 'px' : '50%';\n\t      this._responseContainer.classList.add(CLASS_IS_ANIMATING);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Handle animationend of element.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  Response.prototype._onAnimationend = function _onAnimationend(event) {\n\t    this._responseContainer.classList.remove(CLASS_IS_ANIMATING);\n\t  };\n\t\n\t  return Response;\n\t}(_component2.default);\n\t\n\texports.default = Response;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 35 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t// From Modernizr\n\tfunction whichAnimationEvent() {\n\t  var type = void 0;\n\t  var element = document.createElement('fakeelement');\n\t  var animations = {\n\t    'animation': 'animationend',\n\t    'OAnimation': 'oAnimationEnd',\n\t    'MozAnimation': 'animationend',\n\t    'WebkitAnimation': 'webkitAnimationEnd'\n\t  };\n\t\n\t  for (type in animations) {\n\t    if (element.style[type] !== undefined) {\n\t      return animations[type];\n\t    }\n\t  }\n\t}\n\t\n\tvar ANIMATION_EVENT = whichAnimationEvent();\n\t\n\texports.default = ANIMATION_EVENT;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 36 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-select';\n\tvar CLASS_INPUT = 'aui-select__input';\n\tvar CLASS_LABEL = 'aui-select__label';\n\tvar CLASS_FOCUS_LINE = 'aui-select__focus-line';\n\tvar CLASS_IS_FOCUS = 'is-focused';\n\tvar CLASS_IS_DIRTY = 'is-dirty';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\t\n\t/**\n\t * Class constructor for Select AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Select = function (_Component) {\n\t  _inherits(Select, _Component);\n\t\n\t  /**\n\t   * Upgrades all Select AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Select.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Select(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Select(element) {\n\t    _classCallCheck(this, Select);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  Select.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._label = this._element.querySelector('.' + CLASS_LABEL);\n\t\n\t    this._input = this._element.querySelector('.' + CLASS_INPUT);\n\t    this._input.addEventListener('change', this._changeHandler = function (event) {\n\t      return _this2._onChange(event);\n\t    });\n\t    this._input.addEventListener('focus', this._focusHandler = function (event) {\n\t      return _this2._onFocus(event);\n\t    });\n\t    this._input.addEventListener('blur', this._blurHandler = function (event) {\n\t      return _this2._onBlur(event);\n\t    });\n\t    this._input.addEventListener('reset', this._resetHandler = function (event) {\n\t      return _this2._onReset(event);\n\t    });\n\t\n\t    // Insert thick focus line after select element:\n\t    var focusLine = document.createElement('span');\n\t    focusLine.classList.add(CLASS_FOCUS_LINE);\n\t    this._label.parentNode.insertBefore(focusLine, this._label.nextSibling);\n\t\n\t    this.updateClasses();\n\t  };\n\t\n\t  Select.prototype.updateClasses = function updateClasses() {\n\t    this.checkDisabled();\n\t    this.checkDirty();\n\t    this.checkFocus();\n\t  };\n\t\n\t  /**\n\t   * Check the disabled state and update field accordingly.\n\t   */\n\t\n\t\n\t  Select.prototype.checkDisabled = function checkDisabled() {\n\t    if (this._input.disabled) {\n\t      this._element.classList.add(CLASS_IS_DISABLED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DISABLED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the dirty state and update field accordingly.\n\t   */\n\t\n\t\n\t  Select.prototype.checkDirty = function checkDirty() {\n\t    // console.log('value', this._input.value, typeof this._input.value);\n\t    // console.log('options', this._input.options[this._input.selectedIndex].disabled);\n\t    if (!this._input.options[this._input.selectedIndex].disabled) {\n\t      this._element.classList.add(CLASS_IS_DIRTY);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DIRTY);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the focus state and update field accordingly.\n\t   */\n\t\n\t\n\t  Select.prototype.checkFocus = function checkFocus() {\n\t    if (Boolean(this._element.querySelector(':focus'))) {\n\t      this._element.classList.add(CLASS_IS_FOCUS);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_FOCUS);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Disable text field.\n\t   */\n\t\n\t\n\t  Select.prototype.disable = function disable() {\n\t    this._input.disabled = true;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Event Handler\n\t   */\n\t\n\t  Select.prototype._onChange = function _onChange(event) {\n\t    this.updateClasses();\n\t  };\n\t\n\t  Select.prototype._onFocus = function _onFocus(event) {\n\t    this._element.classList.add(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  Select.prototype._onBlur = function _onBlur(event) {\n\t    this._element.classList.remove(CLASS_IS_FOCUS);\n\t  };\n\t\n\t  Select.prototype._onReset = function _onReset(event) {\n\t    this.updateClasses();\n\t  };\n\t\n\t  return Select;\n\t}(_component2.default);\n\t\n\texports.default = Select;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 37 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _limit = __webpack_require__(24);\n\t\n\tvar _limit2 = _interopRequireDefault(_limit);\n\t\n\tvar _mapLinear = __webpack_require__(38);\n\t\n\tvar _mapLinear2 = _interopRequireDefault(_mapLinear);\n\t\n\tvar _resizeObserver = __webpack_require__(3);\n\t\n\tvar _resizeObserver2 = _interopRequireDefault(_resizeObserver);\n\t\n\tvar _nouislider = __webpack_require__(39);\n\t\n\tvar _nouislider2 = _interopRequireDefault(_nouislider);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * NOTE Slider AUI components rely on the 3rd party library noUiSlider.\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @see https://github.com/leongersen/noUiSlider\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-slider';\n\tvar SELECTOR_HIDDEN_FIELD = '.aui-slider__hidden-field';\n\tvar SELECTOR_OUTPUT = '.aui-slider__output';\n\tvar CLASS_COMPONENT = 'aui-slider';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\tvar EVENT_NAMESPACE = CLASS_COMPONENT;\n\t\n\t/**\n\t * Class constructor for Slider AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Slider = function (_Component) {\n\t  _inherits(Slider, _Component);\n\t\n\t  function Slider() {\n\t    _classCallCheck(this, Slider);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Slider AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Slider.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Slider(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  Slider.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    // Save reference to component elements\n\t    this._hiddenField = this._element.querySelector(SELECTOR_HIDDEN_FIELD);\n\t    this._output = this._element.querySelector(SELECTOR_OUTPUT);\n\t\n\t    // Create slider container element\n\t    this._slider = document.createElement('div');\n\t    this._element.insertBefore(this._slider, this._element.firstChild);\n\t\n\t    // Parse and save start and range values:\n\t    this._value = this._parseData(this._hiddenField.value);\n\t    this._rangeMin = this._parseData(this._element.getAttribute('data-min'));\n\t    this._rangeMax = this._parseData(this._element.getAttribute('data-max'));\n\t\n\t    // Create noUiSlider instance\n\t    _nouislider2.default.create(this._slider, {\n\t      // Set the start value defined in the hidden field.\n\t      // https://refreshless.com/nouislider/slider-options/#section-start\n\t      start: this._value,\n\t\n\t      // Set the range as defined in the data attributes\n\t      // https://refreshless.com/nouislider/slider-values/#section-range\n\t      range: {\n\t        min: this._rangeMin,\n\t        max: this._rangeMax\n\t      },\n\t\n\t      // If there are two handles, set the bar between the handles, but not\n\t      // between the handles and the sliders edges. If there is only one handle,\n\t      // set the bar from the slider edge to the handle.\n\t      // https://refreshless.com/nouislider/slider-options/#section-Connect\n\t      connect: this._value.length > 1 ? true : [true, false],\n\t\n\t      // Define behaviour depending on number of handles\n\t      // https://refreshless.com/nouislider/behaviour-option/\n\t      behaviour: this._value.length > 1 ? 'tap-drag' : 'tap',\n\t\n\t      // Use AUI namespace for css classes\n\t      // https://refreshless.com/nouislider/more/#section-styling\n\t      cssPrefix: CLASS_COMPONENT + '__'\n\t    });\n\t    this._slider.noUiSlider.on('update.' + EVENT_NAMESPACE, function (values, handle, unencoded, tap, positions) {\n\t      return _this2._onUpdate(values, handle, unencoded, tap, positions);\n\t    });\n\t\n\t    if (this._output) {\n\t      this._resizeObserver = new _resizeObserver2.default();\n\t      this._resizeObserver.resized.add(this._resizedHandler = function () {\n\t        return _this2._centerOutput();\n\t      });\n\t    }\n\t\n\t    if (this._element.classList.contains(CLASS_IS_DISABLED)) {\n\t      this.disable();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Slider.prototype.dispose = function dispose() {\n\t    if (this._slider) {\n\t      this._slider.noUiSlider.off('.' + EVENT_NAMESPACE);\n\t    }\n\t    if (this._resizeObserver) {\n\t      this._resizeObserver.resized.remove(this._resizedHandler);\n\t      this._resizeObserver = null;\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Enable component\n\t   */\n\t\n\t\n\t  Slider.prototype.enable = function enable() {\n\t    this._element.classList.remove(CLASS_IS_DISABLED);\n\t    this._slider.removeAttribute('disabled');\n\t  };\n\t\n\t  /**\n\t   * Disable component\n\t   */\n\t\n\t\n\t  Slider.prototype.disable = function disable() {\n\t    this._element.classList.add(CLASS_IS_DISABLED);\n\t    this._slider.setAttribute('disabled', true);\n\t  };\n\t\n\t  /**\n\t   * Handle on update\n\t   * @param {Array} values Current slider values\n\t   * @param {Integer} handle Handle that caused the event 0 or 1\n\t   * @param {Array} unencoded Slider values without formatting\n\t   * @param {boolean} tap Event was caused by the user tapping the slider\n\t   * @param {Array} positions Left offset of the handles in relation to the slider\n\t   */\n\t\n\t\n\t  Slider.prototype._onUpdate = function _onUpdate(values, handle, unencoded, tap, positions) {\n\t    if (this._hiddenField) {\n\t      this._hiddenField.value = unencoded;\n\t    }\n\t\n\t    // Position output to center of slider handles\n\t    if (this._output) {\n\t      this._output.innerHTML = values.length > 1 ? values[0] + ' to ' + values[1] : '' + values[0];\n\t      this._centerOutput();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Center output bewteen handles.\n\t   */\n\t\n\t\n\t  Slider.prototype._centerOutput = function _centerOutput() {\n\t    var unencoded = this._slider.noUiSlider.get();\n\t    var sliderAverage = (typeof unencoded === 'undefined' ? 'undefined' : _typeof(unencoded)) === 'object' ? unencoded.reduce(function (previousValue, currentValue) {\n\t      return previousValue + parseFloat(currentValue);\n\t    }, 0) / unencoded.length : parseFloat(unencoded);\n\t    var maxRight = this._element.offsetWidth - this._output.offsetWidth;\n\t    var handleSize = this._slider.offsetHeight;\n\t    var position = (0, _mapLinear2.default)(sliderAverage, this._rangeMin, this._rangeMax, 0, 1) * this._slider.offsetWidth - this._output.offsetWidth / 2 + handleSize / 2;\n\t    this._output.style.left = (0, _limit2.default)(position, 0, maxRight) + 'px';\n\t  };\n\t\n\t  /**\n\t   * Parse data to use with noUiSlider\n\t   * Returns given value as array of floats\n\t   * \"0,100\" => [0,100]\n\t   * @param {string} value Current slider values\n\t   * @returns {Array} values as floats\n\t   */\n\t\n\t\n\t  Slider.prototype._parseData = function _parseData(value) {\n\t    return value && value.split(',').map(function (element) {\n\t      return parseFloat(element);\n\t    });\n\t  };\n\t\n\t  return Slider;\n\t}(_component2.default);\n\t\n\texports.default = Slider;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 38 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.default = mapLinear;\n\t/**\n\t * Linear mapping from range <a1, a2> to range <b1, b2>\n\t * @param {number} x The value to map\n\t * @param {number} a1 First endpoint of the range <a1, a2>\n\t * @param {number} a2 Final endpoint of the range <a1, a2>\n\t * @param {number} b1 First endpoint of the range <b1, b2>\n\t * @param {number} b2 Final endpoint of the range  <b1, b2>\n\t * @returns {number} The mapped value.\n\t */\n\tfunction mapLinear(x, a1, a2, b1, b2) {\n\t  return b1 + (x - a1) * (b2 - b1) / (a2 - a1);\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 39 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! nouislider - 9.2.0 - 2017-01-11 10:35:34 */\r\n\t\r\n\t(function (factory) {\r\n\t\r\n\t    if ( true ) {\r\n\t\r\n\t        // AMD. Register as an anonymous module.\r\n\t        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\r\n\t\r\n\t    } else if ( typeof exports === 'object' ) {\r\n\t\r\n\t        // Node/CommonJS\r\n\t        module.exports = factory();\r\n\t\r\n\t    } else {\r\n\t\r\n\t        // Browser globals\r\n\t        window.noUiSlider = factory();\r\n\t    }\r\n\t\r\n\t}(function( ){\r\n\t\r\n\t\t'use strict';\r\n\t\r\n\t\tvar VERSION = '9.2.0';\r\n\t\r\n\t\r\n\t\t// Creates a node, adds it to target, returns the new node.\r\n\t\tfunction addNodeTo ( target, className ) {\r\n\t\t\tvar div = document.createElement('div');\r\n\t\t\taddClass(div, className);\r\n\t\t\ttarget.appendChild(div);\r\n\t\t\treturn div;\r\n\t\t}\r\n\t\r\n\t\t// Removes duplicates from an array.\r\n\t\tfunction unique ( array ) {\r\n\t\t\treturn array.filter(function(a){\r\n\t\t\t\treturn !this[a] ? this[a] = true : false;\r\n\t\t\t}, {});\r\n\t\t}\r\n\t\r\n\t\t// Round a value to the closest 'to'.\r\n\t\tfunction closest ( value, to ) {\r\n\t\t\treturn Math.round(value / to) * to;\r\n\t\t}\r\n\t\r\n\t\t// Current position of an element relative to the document.\r\n\t\tfunction offset ( elem, orientation ) {\r\n\t\r\n\t\tvar rect = elem.getBoundingClientRect(),\r\n\t\t\tdoc = elem.ownerDocument,\r\n\t\t\tdocElem = doc.documentElement,\r\n\t\t\tpageOffset = getPageOffset();\r\n\t\r\n\t\t\t// getBoundingClientRect contains left scroll in Chrome on Android.\r\n\t\t\t// I haven't found a feature detection that proves this. Worst case\r\n\t\t\t// scenario on mis-match: the 'tap' feature on horizontal sliders breaks.\r\n\t\t\tif ( /webkit.*Chrome.*Mobile/i.test(navigator.userAgent) ) {\r\n\t\t\t\tpageOffset.x = 0;\r\n\t\t\t}\r\n\t\r\n\t\t\treturn orientation ? (rect.top + pageOffset.y - docElem.clientTop) : (rect.left + pageOffset.x - docElem.clientLeft);\r\n\t\t}\r\n\t\r\n\t\t// Checks whether a value is numerical.\r\n\t\tfunction isNumeric ( a ) {\r\n\t\t\treturn typeof a === 'number' && !isNaN( a ) && isFinite( a );\r\n\t\t}\r\n\t\r\n\t\t// Sets a class and removes it after [duration] ms.\r\n\t\tfunction addClassFor ( element, className, duration ) {\r\n\t\t\tif (duration > 0) {\r\n\t\t\taddClass(element, className);\r\n\t\t\t\tsetTimeout(function(){\r\n\t\t\t\t\tremoveClass(element, className);\r\n\t\t\t\t}, duration);\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// Limits a value to 0 - 100\r\n\t\tfunction limit ( a ) {\r\n\t\t\treturn Math.max(Math.min(a, 100), 0);\r\n\t\t}\r\n\t\r\n\t\t// Wraps a variable as an array, if it isn't one yet.\r\n\t\t// Note that an input array is returned by reference!\r\n\t\tfunction asArray ( a ) {\r\n\t\t\treturn Array.isArray(a) ? a : [a];\r\n\t\t}\r\n\t\r\n\t\t// Counts decimals\r\n\t\tfunction countDecimals ( numStr ) {\r\n\t\t\tnumStr = String(numStr);\r\n\t\t\tvar pieces = numStr.split(\".\");\r\n\t\t\treturn pieces.length > 1 ? pieces[1].length : 0;\r\n\t\t}\r\n\t\r\n\t\t// http://youmightnotneedjquery.com/#add_class\r\n\t\tfunction addClass ( el, className ) {\r\n\t\t\tif ( el.classList ) {\r\n\t\t\t\tel.classList.add(className);\r\n\t\t\t} else {\r\n\t\t\t\tel.className += ' ' + className;\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// http://youmightnotneedjquery.com/#remove_class\r\n\t\tfunction removeClass ( el, className ) {\r\n\t\t\tif ( el.classList ) {\r\n\t\t\t\tel.classList.remove(className);\r\n\t\t\t} else {\r\n\t\t\t\tel.className = el.className.replace(new RegExp('(^|\\\\b)' + className.split(' ').join('|') + '(\\\\b|$)', 'gi'), ' ');\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// https://plainjs.com/javascript/attributes/adding-removing-and-testing-for-classes-9/\r\n\t\tfunction hasClass ( el, className ) {\r\n\t\t\treturn el.classList ? el.classList.contains(className) : new RegExp('\\\\b' + className + '\\\\b').test(el.className);\r\n\t\t}\r\n\t\r\n\t\t// https://developer.mozilla.org/en-US/docs/Web/API/Window/scrollY#Notes\r\n\t\tfunction getPageOffset ( ) {\r\n\t\r\n\t\t\tvar supportPageOffset = window.pageXOffset !== undefined,\r\n\t\t\t\tisCSS1Compat = ((document.compatMode || \"\") === \"CSS1Compat\"),\r\n\t\t\t\tx = supportPageOffset ? window.pageXOffset : isCSS1Compat ? document.documentElement.scrollLeft : document.body.scrollLeft,\r\n\t\t\t\ty = supportPageOffset ? window.pageYOffset : isCSS1Compat ? document.documentElement.scrollTop : document.body.scrollTop;\r\n\t\r\n\t\t\treturn {\r\n\t\t\t\tx: x,\r\n\t\t\t\ty: y\r\n\t\t\t};\r\n\t\t}\r\n\t\r\n\t\t// we provide a function to compute constants instead\r\n\t\t// of accessing window.* as soon as the module needs it\r\n\t\t// so that we do not compute anything if not needed\r\n\t\tfunction getActions ( ) {\r\n\t\r\n\t\t\t// Determine the events to bind. IE11 implements pointerEvents without\r\n\t\t\t// a prefix, which breaks compatibility with the IE10 implementation.\r\n\t\t\treturn window.navigator.pointerEnabled ? {\r\n\t\t\t\tstart: 'pointerdown',\r\n\t\t\t\tmove: 'pointermove',\r\n\t\t\t\tend: 'pointerup'\r\n\t\t\t} : window.navigator.msPointerEnabled ? {\r\n\t\t\t\tstart: 'MSPointerDown',\r\n\t\t\t\tmove: 'MSPointerMove',\r\n\t\t\t\tend: 'MSPointerUp'\r\n\t\t\t} : {\r\n\t\t\t\tstart: 'mousedown touchstart',\r\n\t\t\t\tmove: 'mousemove touchmove',\r\n\t\t\t\tend: 'mouseup touchend'\r\n\t\t\t};\r\n\t\t}\r\n\t\r\n\t\r\n\t// Value calculation\r\n\t\r\n\t\t// Determine the size of a sub-range in relation to a full range.\r\n\t\tfunction subRangeRatio ( pa, pb ) {\r\n\t\t\treturn (100 / (pb - pa));\r\n\t\t}\r\n\t\r\n\t\t// (percentage) How many percent is this value of this range?\r\n\t\tfunction fromPercentage ( range, value ) {\r\n\t\t\treturn (value * 100) / ( range[1] - range[0] );\r\n\t\t}\r\n\t\r\n\t\t// (percentage) Where is this value on this range?\r\n\t\tfunction toPercentage ( range, value ) {\r\n\t\t\treturn fromPercentage( range, range[0] < 0 ?\r\n\t\t\t\tvalue + Math.abs(range[0]) :\r\n\t\t\t\t\tvalue - range[0] );\r\n\t\t}\r\n\t\r\n\t\t// (value) How much is this percentage on this range?\r\n\t\tfunction isPercentage ( range, value ) {\r\n\t\t\treturn ((value * ( range[1] - range[0] )) / 100) + range[0];\r\n\t\t}\r\n\t\r\n\t\r\n\t// Range conversion\r\n\t\r\n\t\tfunction getJ ( value, arr ) {\r\n\t\r\n\t\t\tvar j = 1;\r\n\t\r\n\t\t\twhile ( value >= arr[j] ){\r\n\t\t\t\tj += 1;\r\n\t\t\t}\r\n\t\r\n\t\t\treturn j;\r\n\t\t}\r\n\t\r\n\t\t// (percentage) Input a value, find where, on a scale of 0-100, it applies.\r\n\t\tfunction toStepping ( xVal, xPct, value ) {\r\n\t\r\n\t\t\tif ( value >= xVal.slice(-1)[0] ){\r\n\t\t\t\treturn 100;\r\n\t\t\t}\r\n\t\r\n\t\t\tvar j = getJ( value, xVal ), va, vb, pa, pb;\r\n\t\r\n\t\t\tva = xVal[j-1];\r\n\t\t\tvb = xVal[j];\r\n\t\t\tpa = xPct[j-1];\r\n\t\t\tpb = xPct[j];\r\n\t\r\n\t\t\treturn pa + (toPercentage([va, vb], value) / subRangeRatio (pa, pb));\r\n\t\t}\r\n\t\r\n\t\t// (value) Input a percentage, find where it is on the specified range.\r\n\t\tfunction fromStepping ( xVal, xPct, value ) {\r\n\t\r\n\t\t\t// There is no range group that fits 100\r\n\t\t\tif ( value >= 100 ){\r\n\t\t\t\treturn xVal.slice(-1)[0];\r\n\t\t\t}\r\n\t\r\n\t\t\tvar j = getJ( value, xPct ), va, vb, pa, pb;\r\n\t\r\n\t\t\tva = xVal[j-1];\r\n\t\t\tvb = xVal[j];\r\n\t\t\tpa = xPct[j-1];\r\n\t\t\tpb = xPct[j];\r\n\t\r\n\t\t\treturn isPercentage([va, vb], (value - pa) * subRangeRatio (pa, pb));\r\n\t\t}\r\n\t\r\n\t\t// (percentage) Get the step that applies at a certain value.\r\n\t\tfunction getStep ( xPct, xSteps, snap, value ) {\r\n\t\r\n\t\t\tif ( value === 100 ) {\r\n\t\t\t\treturn value;\r\n\t\t\t}\r\n\t\r\n\t\t\tvar j = getJ( value, xPct ), a, b;\r\n\t\r\n\t\t\t// If 'snap' is set, steps are used as fixed points on the slider.\r\n\t\t\tif ( snap ) {\r\n\t\r\n\t\t\t\ta = xPct[j-1];\r\n\t\t\t\tb = xPct[j];\r\n\t\r\n\t\t\t\t// Find the closest position, a or b.\r\n\t\t\t\tif ((value - a) > ((b-a)/2)){\r\n\t\t\t\t\treturn b;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\treturn a;\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( !xSteps[j-1] ){\r\n\t\t\t\treturn value;\r\n\t\t\t}\r\n\t\r\n\t\t\treturn xPct[j-1] + closest(\r\n\t\t\t\tvalue - xPct[j-1],\r\n\t\t\t\txSteps[j-1]\r\n\t\t\t);\r\n\t\t}\r\n\t\r\n\t\r\n\t// Entry parsing\r\n\t\r\n\t\tfunction handleEntryPoint ( index, value, that ) {\r\n\t\r\n\t\t\tvar percentage;\r\n\t\r\n\t\t\t// Wrap numerical input in an array.\r\n\t\t\tif ( typeof value === \"number\" ) {\r\n\t\t\t\tvalue = [value];\r\n\t\t\t}\r\n\t\r\n\t\t\t// Reject any invalid input, by testing whether value is an array.\r\n\t\t\tif ( Object.prototype.toString.call( value ) !== '[object Array]' ){\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' contains invalid value.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Covert min/max syntax to 0 and 100.\r\n\t\t\tif ( index === 'min' ) {\r\n\t\t\t\tpercentage = 0;\r\n\t\t\t} else if ( index === 'max' ) {\r\n\t\t\t\tpercentage = 100;\r\n\t\t\t} else {\r\n\t\t\t\tpercentage = parseFloat( index );\r\n\t\t\t}\r\n\t\r\n\t\t\t// Check for correct input.\r\n\t\t\tif ( !isNumeric( percentage ) || !isNumeric( value[0] ) ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' value isn't numeric.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Store values.\r\n\t\t\tthat.xPct.push( percentage );\r\n\t\t\tthat.xVal.push( value[0] );\r\n\t\r\n\t\t\t// NaN will evaluate to false too, but to keep\r\n\t\t\t// logging clear, set step explicitly. Make sure\r\n\t\t\t// not to override the 'step' setting with false.\r\n\t\t\tif ( !percentage ) {\r\n\t\t\t\tif ( !isNaN( value[1] ) ) {\r\n\t\t\t\t\tthat.xSteps[0] = value[1];\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tthat.xSteps.push( isNaN(value[1]) ? false : value[1] );\r\n\t\t\t}\r\n\t\r\n\t\t\tthat.xHighestCompleteStep.push(0);\r\n\t\t}\r\n\t\r\n\t\tfunction handleStepPoint ( i, n, that ) {\r\n\t\r\n\t\t\t// Ignore 'false' stepping.\r\n\t\t\tif ( !n ) {\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\t\r\n\t\t\t// Factor to range ratio\r\n\t\t\tthat.xSteps[i] = fromPercentage([\r\n\t\t\t\t that.xVal[i]\r\n\t\t\t\t,that.xVal[i+1]\r\n\t\t\t], n) / subRangeRatio (\r\n\t\t\t\tthat.xPct[i],\r\n\t\t\t\tthat.xPct[i+1] );\r\n\t\r\n\t\t\tvar totalSteps = (that.xVal[i+1] - that.xVal[i]) / that.xNumSteps[i];\r\n\t\t\tvar highestStep = Math.ceil(Number(totalSteps.toFixed(3)) - 1);\r\n\t\t\tvar step = that.xVal[i] + (that.xNumSteps[i] * highestStep);\r\n\t\r\n\t\t\tthat.xHighestCompleteStep[i] = step;\r\n\t\t}\r\n\t\r\n\t\r\n\t// Interface\r\n\t\r\n\t\t// The interface to Spectrum handles all direction-based\r\n\t\t// conversions, so the above values are unaware.\r\n\t\r\n\t\tfunction Spectrum ( entry, snap, direction, singleStep ) {\r\n\t\r\n\t\t\tthis.xPct = [];\r\n\t\t\tthis.xVal = [];\r\n\t\t\tthis.xSteps = [ singleStep || false ];\r\n\t\t\tthis.xNumSteps = [ false ];\r\n\t\t\tthis.xHighestCompleteStep = [];\r\n\t\r\n\t\t\tthis.snap = snap;\r\n\t\t\tthis.direction = direction;\r\n\t\r\n\t\t\tvar index, ordered = [ /* [0, 'min'], [1, '50%'], [2, 'max'] */ ];\r\n\t\r\n\t\t\t// Map the object keys to an array.\r\n\t\t\tfor ( index in entry ) {\r\n\t\t\t\tif ( entry.hasOwnProperty(index) ) {\r\n\t\t\t\t\tordered.push([entry[index], index]);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\r\n\t\t\t// Sort all entries by value (numeric sort).\r\n\t\t\tif ( ordered.length && typeof ordered[0][0] === \"object\" ) {\r\n\t\t\t\tordered.sort(function(a, b) { return a[0][0] - b[0][0]; });\r\n\t\t\t} else {\r\n\t\t\t\tordered.sort(function(a, b) { return a[0] - b[0]; });\r\n\t\t\t}\r\n\t\r\n\t\r\n\t\t\t// Convert all entries to subranges.\r\n\t\t\tfor ( index = 0; index < ordered.length; index++ ) {\r\n\t\t\t\thandleEntryPoint(ordered[index][1], ordered[index][0], this);\r\n\t\t\t}\r\n\t\r\n\t\t\t// Store the actual step values.\r\n\t\t\t// xSteps is sorted in the same order as xPct and xVal.\r\n\t\t\tthis.xNumSteps = this.xSteps.slice(0);\r\n\t\r\n\t\t\t// Convert all numeric steps to the percentage of the subrange they represent.\r\n\t\t\tfor ( index = 0; index < this.xNumSteps.length; index++ ) {\r\n\t\t\t\thandleStepPoint(index, this.xNumSteps[index], this);\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tSpectrum.prototype.getMargin = function ( value ) {\r\n\t\r\n\t\t\tvar step = this.xNumSteps[0];\r\n\t\r\n\t\t\tif ( step && ((value / step) % 1) !== 0 ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'limit', 'margin' and 'padding' must be divisible by step.\");\r\n\t\t\t}\r\n\t\r\n\t\t\treturn this.xPct.length === 2 ? fromPercentage(this.xVal, value) : false;\r\n\t\t};\r\n\t\r\n\t\tSpectrum.prototype.toStepping = function ( value ) {\r\n\t\r\n\t\t\tvalue = toStepping( this.xVal, this.xPct, value );\r\n\t\r\n\t\t\treturn value;\r\n\t\t};\r\n\t\r\n\t\tSpectrum.prototype.fromStepping = function ( value ) {\r\n\t\r\n\t\t\treturn fromStepping( this.xVal, this.xPct, value );\r\n\t\t};\r\n\t\r\n\t\tSpectrum.prototype.getStep = function ( value ) {\r\n\t\r\n\t\t\tvalue = getStep(this.xPct, this.xSteps, this.snap, value );\r\n\t\r\n\t\t\treturn value;\r\n\t\t};\r\n\t\r\n\t\tSpectrum.prototype.getNearbySteps = function ( value ) {\r\n\t\r\n\t\t\tvar j = getJ(value, this.xPct);\r\n\t\r\n\t\t\treturn {\r\n\t\t\t\tstepBefore: { startValue: this.xVal[j-2], step: this.xNumSteps[j-2], highestStep: this.xHighestCompleteStep[j-2] },\r\n\t\t\t\tthisStep: { startValue: this.xVal[j-1], step: this.xNumSteps[j-1], highestStep: this.xHighestCompleteStep[j-1] },\r\n\t\t\t\tstepAfter: { startValue: this.xVal[j-0], step: this.xNumSteps[j-0], highestStep: this.xHighestCompleteStep[j-0] }\r\n\t\t\t};\r\n\t\t};\r\n\t\r\n\t\tSpectrum.prototype.countStepDecimals = function () {\r\n\t\t\tvar stepDecimals = this.xNumSteps.map(countDecimals);\r\n\t\t\treturn Math.max.apply(null, stepDecimals);\r\n\t \t};\r\n\t\r\n\t\t// Outside testing\r\n\t\tSpectrum.prototype.convert = function ( value ) {\r\n\t\t\treturn this.getStep(this.toStepping(value));\r\n\t\t};\r\n\t\r\n\t/*\tEvery input option is tested and parsed. This'll prevent\r\n\t\tendless validation in internal methods. These tests are\r\n\t\tstructured with an item for every option available. An\r\n\t\toption can be marked as required by setting the 'r' flag.\r\n\t\tThe testing function is provided with three arguments:\r\n\t\t\t- The provided value for the option;\r\n\t\t\t- A reference to the options object;\r\n\t\t\t- The name for the option;\r\n\t\r\n\t\tThe testing function returns false when an error is detected,\r\n\t\tor true when everything is OK. It can also modify the option\r\n\t\tobject, to make sure all values can be correctly looped elsewhere. */\r\n\t\r\n\t\tvar defaultFormatter = { 'to': function( value ){\r\n\t\t\treturn value !== undefined && value.toFixed(2);\r\n\t\t}, 'from': Number };\r\n\t\r\n\t\tfunction testStep ( parsed, entry ) {\r\n\t\r\n\t\t\tif ( !isNumeric( entry ) ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'step' is not numeric.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// The step option can still be used to set stepping\r\n\t\t\t// for linear sliders. Overwritten if set in 'range'.\r\n\t\t\tparsed.singleStep = entry;\r\n\t\t}\r\n\t\r\n\t\tfunction testRange ( parsed, entry ) {\r\n\t\r\n\t\t\t// Filter incorrect input.\r\n\t\t\tif ( typeof entry !== 'object' || Array.isArray(entry) ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' is not an object.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Catch missing start or end.\r\n\t\t\tif ( entry.min === undefined || entry.max === undefined ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): Missing 'min' or 'max' in 'range'.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Catch equal start or end.\r\n\t\t\tif ( entry.min === entry.max ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' 'min' and 'max' cannot be equal.\");\r\n\t\t\t}\r\n\t\r\n\t\t\tparsed.spectrum = new Spectrum(entry, parsed.snap, parsed.dir, parsed.singleStep);\r\n\t\t}\r\n\t\r\n\t\tfunction testStart ( parsed, entry ) {\r\n\t\r\n\t\t\tentry = asArray(entry);\r\n\t\r\n\t\t\t// Validate input. Values aren't tested, as the public .val method\r\n\t\t\t// will always provide a valid location.\r\n\t\t\tif ( !Array.isArray( entry ) || !entry.length ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'start' option is incorrect.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Store the number of handles.\r\n\t\t\tparsed.handles = entry.length;\r\n\t\r\n\t\t\t// When the slider is initialized, the .val method will\r\n\t\t\t// be called with the start options.\r\n\t\t\tparsed.start = entry;\r\n\t\t}\r\n\t\r\n\t\tfunction testSnap ( parsed, entry ) {\r\n\t\r\n\t\t\t// Enforce 100% stepping within subranges.\r\n\t\t\tparsed.snap = entry;\r\n\t\r\n\t\t\tif ( typeof entry !== 'boolean' ){\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'snap' option must be a boolean.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testAnimate ( parsed, entry ) {\r\n\t\r\n\t\t\t// Enforce 100% stepping within subranges.\r\n\t\t\tparsed.animate = entry;\r\n\t\r\n\t\t\tif ( typeof entry !== 'boolean' ){\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'animate' option must be a boolean.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testAnimationDuration ( parsed, entry ) {\r\n\t\r\n\t\t\tparsed.animationDuration = entry;\r\n\t\r\n\t\t\tif ( typeof entry !== 'number' ){\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'animationDuration' option must be a number.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testConnect ( parsed, entry ) {\r\n\t\r\n\t\t\tvar connect = [false];\r\n\t\t\tvar i;\r\n\t\r\n\t\t\t// Map legacy options\r\n\t\t\tif ( entry === 'lower' ) {\r\n\t\t\t\tentry = [true, false];\r\n\t\t\t}\r\n\t\r\n\t\t\telse if ( entry === 'upper' ) {\r\n\t\t\t\tentry = [false, true];\r\n\t\t\t}\r\n\t\r\n\t\t\t// Handle boolean options\r\n\t\t\tif ( entry === true || entry === false ) {\r\n\t\r\n\t\t\t\tfor ( i = 1; i < parsed.handles; i++ ) {\r\n\t\t\t\t\tconnect.push(entry);\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tconnect.push(false);\r\n\t\t\t}\r\n\t\r\n\t\t\t// Reject invalid input\r\n\t\t\telse if ( !Array.isArray( entry ) || !entry.length || entry.length !== parsed.handles + 1 ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'connect' option doesn't match handle count.\");\r\n\t\t\t}\r\n\t\r\n\t\t\telse {\r\n\t\t\t\tconnect = entry;\r\n\t\t\t}\r\n\t\r\n\t\t\tparsed.connect = connect;\r\n\t\t}\r\n\t\r\n\t\tfunction testOrientation ( parsed, entry ) {\r\n\t\r\n\t\t\t// Set orientation to an a numerical value for easy\r\n\t\t\t// array selection.\r\n\t\t\tswitch ( entry ){\r\n\t\t\t  case 'horizontal':\r\n\t\t\t\tparsed.ort = 0;\r\n\t\t\t\tbreak;\r\n\t\t\t  case 'vertical':\r\n\t\t\t\tparsed.ort = 1;\r\n\t\t\t\tbreak;\r\n\t\t\t  default:\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'orientation' option is invalid.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testMargin ( parsed, entry ) {\r\n\t\r\n\t\t\tif ( !isNumeric(entry) ){\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'margin' option must be numeric.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Issue #582\r\n\t\t\tif ( entry === 0 ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\r\n\t\t\tparsed.margin = parsed.spectrum.getMargin(entry);\r\n\t\r\n\t\t\tif ( !parsed.margin ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'margin' option is only supported on linear sliders.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testLimit ( parsed, entry ) {\r\n\t\r\n\t\t\tif ( !isNumeric(entry) ){\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'limit' option must be numeric.\");\r\n\t\t\t}\r\n\t\r\n\t\t\tparsed.limit = parsed.spectrum.getMargin(entry);\r\n\t\r\n\t\t\tif ( !parsed.limit || parsed.handles < 2 ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'limit' option is only supported on linear sliders with 2 or more handles.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testPadding ( parsed, entry ) {\r\n\t\r\n\t\t\tif ( !isNumeric(entry) ){\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option must be numeric.\");\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( entry === 0 ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\r\n\t\t\tparsed.padding = parsed.spectrum.getMargin(entry);\r\n\t\r\n\t\t\tif ( !parsed.padding ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option is only supported on linear sliders.\");\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( parsed.padding < 0 ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option must be a positive number.\");\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( parsed.padding >= 50 ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option must be less than half the range.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testDirection ( parsed, entry ) {\r\n\t\r\n\t\t\t// Set direction as a numerical value for easy parsing.\r\n\t\t\t// Invert connection for RTL sliders, so that the proper\r\n\t\t\t// handles get the connect/background classes.\r\n\t\t\tswitch ( entry ) {\r\n\t\t\t  case 'ltr':\r\n\t\t\t\tparsed.dir = 0;\r\n\t\t\t\tbreak;\r\n\t\t\t  case 'rtl':\r\n\t\t\t\tparsed.dir = 1;\r\n\t\t\t\tbreak;\r\n\t\t\t  default:\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'direction' option was not recognized.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testBehaviour ( parsed, entry ) {\r\n\t\r\n\t\t\t// Make sure the input is a string.\r\n\t\t\tif ( typeof entry !== 'string' ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'behaviour' must be a string containing options.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Check if the string contains any keywords.\r\n\t\t\t// None are required.\r\n\t\t\tvar tap = entry.indexOf('tap') >= 0;\r\n\t\t\tvar drag = entry.indexOf('drag') >= 0;\r\n\t\t\tvar fixed = entry.indexOf('fixed') >= 0;\r\n\t\t\tvar snap = entry.indexOf('snap') >= 0;\r\n\t\t\tvar hover = entry.indexOf('hover') >= 0;\r\n\t\r\n\t\t\tif ( fixed ) {\r\n\t\r\n\t\t\t\tif ( parsed.handles !== 2 ) {\r\n\t\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'fixed' behaviour must be used with 2 handles\");\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Use margin to enforce fixed state\r\n\t\t\t\ttestMargin(parsed, parsed.start[1] - parsed.start[0]);\r\n\t\t\t}\r\n\t\r\n\t\t\tparsed.events = {\r\n\t\t\t\ttap: tap || snap,\r\n\t\t\t\tdrag: drag,\r\n\t\t\t\tfixed: fixed,\r\n\t\t\t\tsnap: snap,\r\n\t\t\t\thover: hover\r\n\t\t\t};\r\n\t\t}\r\n\t\r\n\t\tfunction testTooltips ( parsed, entry ) {\r\n\t\r\n\t\t\tif ( entry === false ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\r\n\t\t\telse if ( entry === true ) {\r\n\t\r\n\t\t\t\tparsed.tooltips = [];\r\n\t\r\n\t\t\t\tfor ( var i = 0; i < parsed.handles; i++ ) {\r\n\t\t\t\t\tparsed.tooltips.push(true);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\r\n\t\t\telse {\r\n\t\r\n\t\t\t\tparsed.tooltips = asArray(entry);\r\n\t\r\n\t\t\t\tif ( parsed.tooltips.length !== parsed.handles ) {\r\n\t\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): must pass a formatter for all handles.\");\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tparsed.tooltips.forEach(function(formatter){\r\n\t\t\t\t\tif ( typeof formatter !== 'boolean' && (typeof formatter !== 'object' || typeof formatter.to !== 'function') ) {\r\n\t\t\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'tooltips' must be passed a formatter or 'false'.\");\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testFormat ( parsed, entry ) {\r\n\t\r\n\t\t\tparsed.format = entry;\r\n\t\r\n\t\t\t// Any object with a to and from method is supported.\r\n\t\t\tif ( typeof entry.to === 'function' && typeof entry.from === 'function' ) {\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\t\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'format' requires 'to' and 'from' methods.\");\r\n\t\t}\r\n\t\r\n\t\tfunction testCssPrefix ( parsed, entry ) {\r\n\t\r\n\t\t\tif ( entry !== undefined && typeof entry !== 'string' && entry !== false ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'cssPrefix' must be a string or `false`.\");\r\n\t\t\t}\r\n\t\r\n\t\t\tparsed.cssPrefix = entry;\r\n\t\t}\r\n\t\r\n\t\tfunction testCssClasses ( parsed, entry ) {\r\n\t\r\n\t\t\tif ( entry !== undefined && typeof entry !== 'object' ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'cssClasses' must be an object.\");\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( typeof parsed.cssPrefix === 'string' ) {\r\n\t\t\t\tparsed.cssClasses = {};\r\n\t\r\n\t\t\t\tfor ( var key in entry ) {\r\n\t\t\t\t\tif ( !entry.hasOwnProperty(key) ) { continue; }\r\n\t\r\n\t\t\t\t\tparsed.cssClasses[key] = parsed.cssPrefix + entry[key];\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tparsed.cssClasses = entry;\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction testUseRaf ( parsed, entry ) {\r\n\t\t\tif ( entry === true || entry === false ) {\r\n\t\t\t\tparsed.useRequestAnimationFrame = entry;\r\n\t\t\t} else {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'useRequestAnimationFrame' option should be true (default) or false.\");\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// Test all developer settings and parse to assumption-safe values.\r\n\t\tfunction testOptions ( options ) {\r\n\t\r\n\t\t\t// To prove a fix for #537, freeze options here.\r\n\t\t\t// If the object is modified, an error will be thrown.\r\n\t\t\t// Object.freeze(options);\r\n\t\r\n\t\t\tvar parsed = {\r\n\t\t\t\tmargin: 0,\r\n\t\t\t\tlimit: 0,\r\n\t\t\t\tpadding: 0,\r\n\t\t\t\tanimate: true,\r\n\t\t\t\tanimationDuration: 300,\r\n\t\t\t\tformat: defaultFormatter\r\n\t\t\t};\r\n\t\r\n\t\t\t// Tests are executed in the order they are presented here.\r\n\t\t\tvar tests = {\r\n\t\t\t\t'step': { r: false, t: testStep },\r\n\t\t\t\t'start': { r: true, t: testStart },\r\n\t\t\t\t'connect': { r: true, t: testConnect },\r\n\t\t\t\t'direction': { r: true, t: testDirection },\r\n\t\t\t\t'snap': { r: false, t: testSnap },\r\n\t\t\t\t'animate': { r: false, t: testAnimate },\r\n\t\t\t\t'animationDuration': { r: false, t: testAnimationDuration },\r\n\t\t\t\t'range': { r: true, t: testRange },\r\n\t\t\t\t'orientation': { r: false, t: testOrientation },\r\n\t\t\t\t'margin': { r: false, t: testMargin },\r\n\t\t\t\t'limit': { r: false, t: testLimit },\r\n\t\t\t\t'padding': { r: false, t: testPadding },\r\n\t\t\t\t'behaviour': { r: true, t: testBehaviour },\r\n\t\t\t\t'format': { r: false, t: testFormat },\r\n\t\t\t\t'tooltips': { r: false, t: testTooltips },\r\n\t\t\t\t'cssPrefix': { r: false, t: testCssPrefix },\r\n\t\t\t\t'cssClasses': { r: false, t: testCssClasses },\r\n\t\t\t\t'useRequestAnimationFrame': { r: false, t: testUseRaf }\r\n\t\t\t};\r\n\t\r\n\t\t\tvar defaults = {\r\n\t\t\t\t'connect': false,\r\n\t\t\t\t'direction': 'ltr',\r\n\t\t\t\t'behaviour': 'tap',\r\n\t\t\t\t'orientation': 'horizontal',\r\n\t\t\t\t'cssPrefix' : 'noUi-',\r\n\t\t\t\t'cssClasses': {\r\n\t\t\t\t\ttarget: 'target',\r\n\t\t\t\t\tbase: 'base',\r\n\t\t\t\t\torigin: 'origin',\r\n\t\t\t\t\thandle: 'handle',\r\n\t\t\t\t\thandleLower: 'handle-lower',\r\n\t\t\t\t\thandleUpper: 'handle-upper',\r\n\t\t\t\t\thorizontal: 'horizontal',\r\n\t\t\t\t\tvertical: 'vertical',\r\n\t\t\t\t\tbackground: 'background',\r\n\t\t\t\t\tconnect: 'connect',\r\n\t\t\t\t\tltr: 'ltr',\r\n\t\t\t\t\trtl: 'rtl',\r\n\t\t\t\t\tdraggable: 'draggable',\r\n\t\t\t\t\tdrag: 'state-drag',\r\n\t\t\t\t\ttap: 'state-tap',\r\n\t\t\t\t\tactive: 'active',\r\n\t\t\t\t\ttooltip: 'tooltip',\r\n\t\t\t\t\tpips: 'pips',\r\n\t\t\t\t\tpipsHorizontal: 'pips-horizontal',\r\n\t\t\t\t\tpipsVertical: 'pips-vertical',\r\n\t\t\t\t\tmarker: 'marker',\r\n\t\t\t\t\tmarkerHorizontal: 'marker-horizontal',\r\n\t\t\t\t\tmarkerVertical: 'marker-vertical',\r\n\t\t\t\t\tmarkerNormal: 'marker-normal',\r\n\t\t\t\t\tmarkerLarge: 'marker-large',\r\n\t\t\t\t\tmarkerSub: 'marker-sub',\r\n\t\t\t\t\tvalue: 'value',\r\n\t\t\t\t\tvalueHorizontal: 'value-horizontal',\r\n\t\t\t\t\tvalueVertical: 'value-vertical',\r\n\t\t\t\t\tvalueNormal: 'value-normal',\r\n\t\t\t\t\tvalueLarge: 'value-large',\r\n\t\t\t\t\tvalueSub: 'value-sub'\r\n\t\t\t\t},\r\n\t\t\t\t'useRequestAnimationFrame': true\r\n\t\t\t};\r\n\t\r\n\t\t\t// Run all options through a testing mechanism to ensure correct\r\n\t\t\t// input. It should be noted that options might get modified to\r\n\t\t\t// be handled properly. E.g. wrapping integers in arrays.\r\n\t\t\tObject.keys(tests).forEach(function( name ){\r\n\t\r\n\t\t\t\t// If the option isn't set, but it is required, throw an error.\r\n\t\t\t\tif ( options[name] === undefined && defaults[name] === undefined ) {\r\n\t\r\n\t\t\t\t\tif ( tests[name].r ) {\r\n\t\t\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): '\" + name + \"' is required.\");\r\n\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\treturn true;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\ttests[name].t( parsed, options[name] === undefined ? defaults[name] : options[name] );\r\n\t\t\t});\r\n\t\r\n\t\t\t// Forward pips options\r\n\t\t\tparsed.pips = options.pips;\r\n\t\r\n\t\t\tvar styles = [['left', 'top'], ['right', 'bottom']];\r\n\t\r\n\t\t\t// Pre-define the styles.\r\n\t\t\tparsed.style = styles[parsed.dir][parsed.ort];\r\n\t\t\tparsed.styleOposite = styles[parsed.dir?0:1][parsed.ort];\r\n\t\r\n\t\t\treturn parsed;\r\n\t\t}\r\n\t\r\n\t\r\n\tfunction closure ( target, options, originalOptions ){\r\n\t\r\n\t\tvar actions = getActions( );\r\n\t\r\n\t\t// All variables local to 'closure' are prefixed with 'scope_'\r\n\t\tvar scope_Target = target;\r\n\t\tvar scope_Locations = [];\r\n\t\tvar scope_Base;\r\n\t\tvar scope_Handles;\r\n\t\tvar scope_HandleNumbers = [];\r\n\t\tvar scope_ActiveHandle = false;\r\n\t\tvar scope_Connects;\r\n\t\tvar scope_Spectrum = options.spectrum;\r\n\t\tvar scope_Values = [];\r\n\t\tvar scope_Events = {};\r\n\t\tvar scope_Self;\r\n\t\r\n\t\r\n\t\t// Append a origin to the base\r\n\t\tfunction addOrigin ( base, handleNumber ) {\r\n\t\r\n\t\t\tvar origin = addNodeTo(base, options.cssClasses.origin);\r\n\t\t\tvar handle = addNodeTo(origin, options.cssClasses.handle);\r\n\t\r\n\t\t\thandle.setAttribute('data-handle', handleNumber);\r\n\t\r\n\t\t\tif ( handleNumber === 0 ) {\r\n\t\t\t\taddClass(handle, options.cssClasses.handleLower);\r\n\t\t\t}\r\n\t\r\n\t\t\telse if ( handleNumber === options.handles - 1 ) {\r\n\t\t\t\taddClass(handle, options.cssClasses.handleUpper);\r\n\t\t\t}\r\n\t\r\n\t\t\treturn origin;\r\n\t\t}\r\n\t\r\n\t\t// Insert nodes for connect elements\r\n\t\tfunction addConnect ( base, add ) {\r\n\t\r\n\t\t\tif ( !add ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\r\n\t\t\treturn addNodeTo(base, options.cssClasses.connect);\r\n\t\t}\r\n\t\r\n\t\t// Add handles to the slider base.\r\n\t\tfunction addElements ( connectOptions, base ) {\r\n\t\r\n\t\t\tscope_Handles = [];\r\n\t\t\tscope_Connects = [];\r\n\t\r\n\t\t\tscope_Connects.push(addConnect(base, connectOptions[0]));\r\n\t\r\n\t\t\t// [::::O====O====O====]\r\n\t\t\t// connectOptions = [0, 1, 1, 1]\r\n\t\r\n\t\t\tfor ( var i = 0; i < options.handles; i++ ) {\r\n\t\t\t\t// Keep a list of all added handles.\r\n\t\t\t\tscope_Handles.push(addOrigin(base, i));\r\n\t\t\t\tscope_HandleNumbers[i] = i;\r\n\t\t\t\tscope_Connects.push(addConnect(base, connectOptions[i + 1]));\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// Initialize a single slider.\r\n\t\tfunction addSlider ( target ) {\r\n\t\r\n\t\t\t// Apply classes and data to the target.\r\n\t\t\taddClass(target, options.cssClasses.target);\r\n\t\r\n\t\t\tif ( options.dir === 0 ) {\r\n\t\t\t\taddClass(target, options.cssClasses.ltr);\r\n\t\t\t} else {\r\n\t\t\t\taddClass(target, options.cssClasses.rtl);\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( options.ort === 0 ) {\r\n\t\t\t\taddClass(target, options.cssClasses.horizontal);\r\n\t\t\t} else {\r\n\t\t\t\taddClass(target, options.cssClasses.vertical);\r\n\t\t\t}\r\n\t\r\n\t\t\tscope_Base = addNodeTo(target, options.cssClasses.base);\r\n\t\t}\r\n\t\r\n\t\r\n\t\tfunction addTooltip ( handle, handleNumber ) {\r\n\t\r\n\t\t\tif ( !options.tooltips[handleNumber] ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\r\n\t\t\treturn addNodeTo(handle.firstChild, options.cssClasses.tooltip);\r\n\t\t}\r\n\t\r\n\t\t// The tooltips option is a shorthand for using the 'update' event.\r\n\t\tfunction tooltips ( ) {\r\n\t\r\n\t\t\t// Tooltips are added with options.tooltips in original order.\r\n\t\t\tvar tips = scope_Handles.map(addTooltip);\r\n\t\r\n\t\t\tbindEvent('update', function(values, handleNumber, unencoded) {\r\n\t\r\n\t\t\t\tif ( !tips[handleNumber] ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tvar formattedValue = values[handleNumber];\r\n\t\r\n\t\t\t\tif ( options.tooltips[handleNumber] !== true ) {\r\n\t\t\t\t\tformattedValue = options.tooltips[handleNumber].to(unencoded[handleNumber]);\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\ttips[handleNumber].innerHTML = formattedValue;\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\r\n\t\tfunction getGroup ( mode, values, stepped ) {\r\n\t\r\n\t\t\t// Use the range.\r\n\t\t\tif ( mode === 'range' || mode === 'steps' ) {\r\n\t\t\t\treturn scope_Spectrum.xVal;\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( mode === 'count' ) {\r\n\t\r\n\t\t\t\tif ( !values ) {\r\n\t\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'values' required for mode 'count'.\");\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Divide 0 - 100 in 'count' parts.\r\n\t\t\t\tvar spread = ( 100 / (values - 1) );\r\n\t\t\t\tvar v;\r\n\t\t\t\tvar i = 0;\r\n\t\r\n\t\t\t\tvalues = [];\r\n\t\r\n\t\t\t\t// List these parts and have them handled as 'positions'.\r\n\t\t\t\twhile ( (v = i++ * spread) <= 100 ) {\r\n\t\t\t\t\tvalues.push(v);\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tmode = 'positions';\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( mode === 'positions' ) {\r\n\t\r\n\t\t\t\t// Map all percentages to on-range values.\r\n\t\t\t\treturn values.map(function( value ){\r\n\t\t\t\t\treturn scope_Spectrum.fromStepping( stepped ? scope_Spectrum.getStep( value ) : value );\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( mode === 'values' ) {\r\n\t\r\n\t\t\t\t// If the value must be stepped, it needs to be converted to a percentage first.\r\n\t\t\t\tif ( stepped ) {\r\n\t\r\n\t\t\t\t\treturn values.map(function( value ){\r\n\t\r\n\t\t\t\t\t\t// Convert to percentage, apply step, return to value.\r\n\t\t\t\t\t\treturn scope_Spectrum.fromStepping( scope_Spectrum.getStep( scope_Spectrum.toStepping( value ) ) );\r\n\t\t\t\t\t});\r\n\t\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Otherwise, we can simply use the values.\r\n\t\t\t\treturn values;\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction generateSpread ( density, mode, group ) {\r\n\t\r\n\t\t\tfunction safeIncrement(value, increment) {\r\n\t\t\t\t// Avoid floating point variance by dropping the smallest decimal places.\r\n\t\t\t\treturn (value + increment).toFixed(7) / 1;\r\n\t\t\t}\r\n\t\r\n\t\t\tvar indexes = {};\r\n\t\t\tvar firstInRange = scope_Spectrum.xVal[0];\r\n\t\t\tvar lastInRange = scope_Spectrum.xVal[scope_Spectrum.xVal.length-1];\r\n\t\t\tvar ignoreFirst = false;\r\n\t\t\tvar ignoreLast = false;\r\n\t\t\tvar prevPct = 0;\r\n\t\r\n\t\t\t// Create a copy of the group, sort it and filter away all duplicates.\r\n\t\t\tgroup = unique(group.slice().sort(function(a, b){ return a - b; }));\r\n\t\r\n\t\t\t// Make sure the range starts with the first element.\r\n\t\t\tif ( group[0] !== firstInRange ) {\r\n\t\t\t\tgroup.unshift(firstInRange);\r\n\t\t\t\tignoreFirst = true;\r\n\t\t\t}\r\n\t\r\n\t\t\t// Likewise for the last one.\r\n\t\t\tif ( group[group.length - 1] !== lastInRange ) {\r\n\t\t\t\tgroup.push(lastInRange);\r\n\t\t\t\tignoreLast = true;\r\n\t\t\t}\r\n\t\r\n\t\t\tgroup.forEach(function ( current, index ) {\r\n\t\r\n\t\t\t\t// Get the current step and the lower + upper positions.\r\n\t\t\t\tvar step;\r\n\t\t\t\tvar i;\r\n\t\t\t\tvar q;\r\n\t\t\t\tvar low = current;\r\n\t\t\t\tvar high = group[index+1];\r\n\t\t\t\tvar newPct;\r\n\t\t\t\tvar pctDifference;\r\n\t\t\t\tvar pctPos;\r\n\t\t\t\tvar type;\r\n\t\t\t\tvar steps;\r\n\t\t\t\tvar realSteps;\r\n\t\t\t\tvar stepsize;\r\n\t\r\n\t\t\t\t// When using 'steps' mode, use the provided steps.\r\n\t\t\t\t// Otherwise, we'll step on to the next subrange.\r\n\t\t\t\tif ( mode === 'steps' ) {\r\n\t\t\t\t\tstep = scope_Spectrum.xNumSteps[ index ];\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Default to a 'full' step.\r\n\t\t\t\tif ( !step ) {\r\n\t\t\t\t\tstep = high-low;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Low can be 0, so test for false. If high is undefined,\r\n\t\t\t\t// we are at the last subrange. Index 0 is already handled.\r\n\t\t\t\tif ( low === false || high === undefined ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Make sure step isn't 0, which would cause an infinite loop (#654)\r\n\t\t\t\tstep = Math.max(step, 0.0000001);\r\n\t\r\n\t\t\t\t// Find all steps in the subrange.\r\n\t\t\t\tfor ( i = low; i <= high; i = safeIncrement(i, step) ) {\r\n\t\r\n\t\t\t\t\t// Get the percentage value for the current step,\r\n\t\t\t\t\t// calculate the size for the subrange.\r\n\t\t\t\t\tnewPct = scope_Spectrum.toStepping( i );\r\n\t\t\t\t\tpctDifference = newPct - prevPct;\r\n\t\r\n\t\t\t\t\tsteps = pctDifference / density;\r\n\t\t\t\t\trealSteps = Math.round(steps);\r\n\t\r\n\t\t\t\t\t// This ratio represents the ammount of percentage-space a point indicates.\r\n\t\t\t\t\t// For a density 1 the points/percentage = 1. For density 2, that percentage needs to be re-devided.\r\n\t\t\t\t\t// Round the percentage offset to an even number, then divide by two\r\n\t\t\t\t\t// to spread the offset on both sides of the range.\r\n\t\t\t\t\tstepsize = pctDifference/realSteps;\r\n\t\r\n\t\t\t\t\t// Divide all points evenly, adding the correct number to this subrange.\r\n\t\t\t\t\t// Run up to <= so that 100% gets a point, event if ignoreLast is set.\r\n\t\t\t\t\tfor ( q = 1; q <= realSteps; q += 1 ) {\r\n\t\r\n\t\t\t\t\t\t// The ratio between the rounded value and the actual size might be ~1% off.\r\n\t\t\t\t\t\t// Correct the percentage offset by the number of points\r\n\t\t\t\t\t\t// per subrange. density = 1 will result in 100 points on the\r\n\t\t\t\t\t\t// full range, 2 for 50, 4 for 25, etc.\r\n\t\t\t\t\t\tpctPos = prevPct + ( q * stepsize );\r\n\t\t\t\t\t\tindexes[pctPos.toFixed(5)] = ['x', 0];\r\n\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\t// Determine the point type.\r\n\t\t\t\t\ttype = (group.indexOf(i) > -1) ? 1 : ( mode === 'steps' ? 2 : 0 );\r\n\t\r\n\t\t\t\t\t// Enforce the 'ignoreFirst' option by overwriting the type for 0.\r\n\t\t\t\t\tif ( !index && ignoreFirst ) {\r\n\t\t\t\t\t\ttype = 0;\r\n\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\tif ( !(i === high && ignoreLast)) {\r\n\t\t\t\t\t\t// Mark the 'type' of this point. 0 = plain, 1 = real value, 2 = step value.\r\n\t\t\t\t\t\tindexes[newPct.toFixed(5)] = [i, type];\r\n\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\t// Update the percentage count.\r\n\t\t\t\t\tprevPct = newPct;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\r\n\t\t\treturn indexes;\r\n\t\t}\r\n\t\r\n\t\tfunction addMarking ( spread, filterFunc, formatter ) {\r\n\t\r\n\t\t\tvar element = document.createElement('div');\r\n\t\t\tvar out = '';\r\n\t\t\tvar valueSizeClasses = [\r\n\t\t\t\toptions.cssClasses.valueNormal,\r\n\t\t\t\toptions.cssClasses.valueLarge,\r\n\t\t\t\toptions.cssClasses.valueSub\r\n\t\t\t];\r\n\t\t\tvar markerSizeClasses = [\r\n\t\t\t\toptions.cssClasses.markerNormal,\r\n\t\t\t\toptions.cssClasses.markerLarge,\r\n\t\t\t\toptions.cssClasses.markerSub\r\n\t\t\t];\r\n\t\t\tvar valueOrientationClasses = [\r\n\t\t\t\toptions.cssClasses.valueHorizontal,\r\n\t\t\t\toptions.cssClasses.valueVertical\r\n\t\t\t];\r\n\t\t\tvar markerOrientationClasses = [\r\n\t\t\t\toptions.cssClasses.markerHorizontal,\r\n\t\t\t\toptions.cssClasses.markerVertical\r\n\t\t\t];\r\n\t\r\n\t\t\taddClass(element, options.cssClasses.pips);\r\n\t\t\taddClass(element, options.ort === 0 ? options.cssClasses.pipsHorizontal : options.cssClasses.pipsVertical);\r\n\t\r\n\t\t\tfunction getClasses( type, source ){\r\n\t\t\t\tvar a = source === options.cssClasses.value;\r\n\t\t\t\tvar orientationClasses = a ? valueOrientationClasses : markerOrientationClasses;\r\n\t\t\t\tvar sizeClasses = a ? valueSizeClasses : markerSizeClasses;\r\n\t\r\n\t\t\t\treturn source + ' ' + orientationClasses[options.ort] + ' ' + sizeClasses[type];\r\n\t\t\t}\r\n\t\r\n\t\t\tfunction getTags( offset, source, values ) {\r\n\t\t\t\treturn 'class=\"' + getClasses(values[1], source) + '\" style=\"' + options.style + ': ' + offset + '%\"';\r\n\t\t\t}\r\n\t\r\n\t\t\tfunction addSpread ( offset, values ){\r\n\t\r\n\t\t\t\t// Apply the filter function, if it is set.\r\n\t\t\t\tvalues[1] = (values[1] && filterFunc) ? filterFunc(values[0], values[1]) : values[1];\r\n\t\r\n\t\t\t\t// Add a marker for every point\r\n\t\t\t\tout += '<div ' + getTags(offset, options.cssClasses.marker, values) + '></div>';\r\n\t\r\n\t\t\t\t// Values are only appended for points marked '1' or '2'.\r\n\t\t\t\tif ( values[1] ) {\r\n\t\t\t\t\tout += '<div ' + getTags(offset, options.cssClasses.value, values) + '>' + formatter.to(values[0]) + '</div>';\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\r\n\t\t\t// Append all points.\r\n\t\t\tObject.keys(spread).forEach(function(a){\r\n\t\t\t\taddSpread(a, spread[a]);\r\n\t\t\t});\r\n\t\r\n\t\t\telement.innerHTML = out;\r\n\t\r\n\t\t\treturn element;\r\n\t\t}\r\n\t\r\n\t\tfunction pips ( grid ) {\r\n\t\r\n\t\t\tvar mode = grid.mode;\r\n\t\t\tvar density = grid.density || 1;\r\n\t\t\tvar filter = grid.filter || false;\r\n\t\t\tvar values = grid.values || false;\r\n\t\t\tvar stepped = grid.stepped || false;\r\n\t\t\tvar group = getGroup( mode, values, stepped );\r\n\t\t\tvar spread = generateSpread( density, mode, group );\r\n\t\t\tvar format = grid.format || {\r\n\t\t\t\tto: Math.round\r\n\t\t\t};\r\n\t\r\n\t\t\treturn scope_Target.appendChild(addMarking(\r\n\t\t\t\tspread,\r\n\t\t\t\tfilter,\r\n\t\t\t\tformat\r\n\t\t\t));\r\n\t\t}\r\n\t\r\n\t\r\n\t\t// Shorthand for base dimensions.\r\n\t\tfunction baseSize ( ) {\r\n\t\t\tvar rect = scope_Base.getBoundingClientRect(), alt = 'offset' + ['Width', 'Height'][options.ort];\r\n\t\t\treturn options.ort === 0 ? (rect.width||scope_Base[alt]) : (rect.height||scope_Base[alt]);\r\n\t\t}\r\n\t\r\n\t\t// Handler for attaching events trough a proxy.\r\n\t\tfunction attachEvent ( events, element, callback, data ) {\r\n\t\r\n\t\t\t// This function can be used to 'filter' events to the slider.\r\n\t\t\t// element is a node, not a nodeList\r\n\t\r\n\t\t\tvar method = function ( e ){\r\n\t\r\n\t\t\t\tif ( scope_Target.hasAttribute('disabled') ) {\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Stop if an active 'tap' transition is taking place.\r\n\t\t\t\tif ( hasClass(scope_Target, options.cssClasses.tap) ) {\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\te = fixEvent(e, data.pageOffset);\r\n\t\r\n\t\t\t\t// Handle reject of multitouch\r\n\t\t\t\tif ( !e ) {\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Ignore right or middle clicks on start #454\r\n\t\t\t\tif ( events === actions.start && e.buttons !== undefined && e.buttons > 1 ) {\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Ignore right or middle clicks on start #454\r\n\t\t\t\tif ( data.hover && e.buttons ) {\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\te.calcPoint = e.points[ options.ort ];\r\n\t\r\n\t\t\t\t// Call the event handler with the event [ and additional data ].\r\n\t\t\t\tcallback ( e, data );\r\n\t\t\t};\r\n\t\r\n\t\t\tvar methods = [];\r\n\t\r\n\t\t\t// Bind a closure on the target for every event type.\r\n\t\t\tevents.split(' ').forEach(function( eventName ){\r\n\t\t\t\telement.addEventListener(eventName, method, false);\r\n\t\t\t\tmethods.push([eventName, method]);\r\n\t\t\t});\r\n\t\r\n\t\t\treturn methods;\r\n\t\t}\r\n\t\r\n\t\t// Provide a clean event with standardized offset values.\r\n\t\tfunction fixEvent ( e, pageOffset ) {\r\n\t\r\n\t\t\t// Prevent scrolling and panning on touch events, while\r\n\t\t\t// attempting to slide. The tap event also depends on this.\r\n\t\t\te.preventDefault();\r\n\t\r\n\t\t\t// Filter the event to register the type, which can be\r\n\t\t\t// touch, mouse or pointer. Offset changes need to be\r\n\t\t\t// made on an event specific basis.\r\n\t\t\tvar touch = e.type.indexOf('touch') === 0;\r\n\t\t\tvar mouse = e.type.indexOf('mouse') === 0;\r\n\t\t\tvar pointer = e.type.indexOf('pointer') === 0;\r\n\t\t\tvar x;\r\n\t\t\tvar y;\r\n\t\r\n\t\t\t// IE10 implemented pointer events with a prefix;\r\n\t\t\tif ( e.type.indexOf('MSPointer') === 0 ) {\r\n\t\t\t\tpointer = true;\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( touch ) {\r\n\t\r\n\t\t\t\t// Fix bug when user touches with two or more fingers on mobile devices.\r\n\t\t\t\t// It's useful when you have two or more sliders on one page,\r\n\t\t\t\t// that can be touched simultaneously.\r\n\t\t\t\t// #649, #663, #668\r\n\t\t\t\tif ( e.touches.length > 1 ) {\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// noUiSlider supports one movement at a time,\r\n\t\t\t\t// so we can select the first 'changedTouch'.\r\n\t\t\t\tx = e.changedTouches[0].pageX;\r\n\t\t\t\ty = e.changedTouches[0].pageY;\r\n\t\t\t}\r\n\t\r\n\t\t\tpageOffset = pageOffset || getPageOffset();\r\n\t\r\n\t\t\tif ( mouse || pointer ) {\r\n\t\t\t\tx = e.clientX + pageOffset.x;\r\n\t\t\t\ty = e.clientY + pageOffset.y;\r\n\t\t\t}\r\n\t\r\n\t\t\te.pageOffset = pageOffset;\r\n\t\t\te.points = [x, y];\r\n\t\t\te.cursor = mouse || pointer; // Fix #435\r\n\t\r\n\t\t\treturn e;\r\n\t\t}\r\n\t\r\n\t\t// Translate a coordinate in the document to a percentage on the slider\r\n\t\tfunction calcPointToPercentage ( calcPoint ) {\r\n\t\t\tvar location = calcPoint - offset(scope_Base, options.ort);\r\n\t\t\tvar proposal = ( location * 100 ) / baseSize();\r\n\t\t\treturn options.dir ? 100 - proposal : proposal;\r\n\t\t}\r\n\t\r\n\t\t// Find handle closest to a certain percentage on the slider\r\n\t\tfunction getClosestHandle ( proposal ) {\r\n\t\r\n\t\t\tvar closest = 100;\r\n\t\t\tvar handleNumber = false;\r\n\t\r\n\t\t\tscope_Handles.forEach(function(handle, index){\r\n\t\r\n\t\t\t\t// Disabled handles are ignored\r\n\t\t\t\tif ( handle.hasAttribute('disabled') ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tvar pos = Math.abs(scope_Locations[index] - proposal);\r\n\t\r\n\t\t\t\tif ( pos < closest ) {\r\n\t\t\t\t\thandleNumber = index;\r\n\t\t\t\t\tclosest = pos;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\r\n\t\t\treturn handleNumber;\r\n\t\t}\r\n\t\r\n\t\t// Moves handle(s) by a percentage\r\n\t\t// (bool, % to move, [% where handle started, ...], [index in scope_Handles, ...])\r\n\t\tfunction moveHandles ( upward, proposal, locations, handleNumbers ) {\r\n\t\r\n\t\t\tvar proposals = locations.slice();\r\n\t\r\n\t\t\tvar b = [!upward, upward];\r\n\t\t\tvar f = [upward, !upward];\r\n\t\r\n\t\t\t// Copy handleNumbers so we don't change the dataset\r\n\t\t\thandleNumbers = handleNumbers.slice();\r\n\t\r\n\t\t\t// Check to see which handle is 'leading'.\r\n\t\t\t// If that one can't move the second can't either.\r\n\t\t\tif ( upward ) {\r\n\t\t\t\thandleNumbers.reverse();\r\n\t\t\t}\r\n\t\r\n\t\t\t// Step 1: get the maximum percentage that any of the handles can move\r\n\t\t\tif ( handleNumbers.length > 1 ) {\r\n\t\r\n\t\t\t\thandleNumbers.forEach(function(handleNumber, o) {\r\n\t\r\n\t\t\t\t\tvar to = checkHandlePosition(proposals, handleNumber, proposals[handleNumber] + proposal, b[o], f[o]);\r\n\t\r\n\t\t\t\t\t// Stop if one of the handles can't move.\r\n\t\t\t\t\tif ( to === false ) {\r\n\t\t\t\t\t\tproposal = 0;\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tproposal = to - proposals[handleNumber];\r\n\t\t\t\t\t\tproposals[handleNumber] = to;\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\r\n\t\t\t// If using one handle, check backward AND forward\r\n\t\t\telse {\r\n\t\t\t\tb = f = [true];\r\n\t\t\t}\r\n\t\r\n\t\t\tvar state = false;\r\n\t\r\n\t\t\t// Step 2: Try to set the handles with the found percentage\r\n\t\t\thandleNumbers.forEach(function(handleNumber, o) {\r\n\t\t\t\tstate = setHandle(handleNumber, locations[handleNumber] + proposal, b[o], f[o]) || state;\r\n\t\t\t});\r\n\t\r\n\t\t\t// Step 3: If a handle moved, fire events\r\n\t\t\tif ( state ) {\r\n\t\t\t\thandleNumbers.forEach(function(handleNumber){\r\n\t\t\t\t\tfireEvent('update', handleNumber);\r\n\t\t\t\t\tfireEvent('slide', handleNumber);\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// External event handling\r\n\t\tfunction fireEvent ( eventName, handleNumber, tap ) {\r\n\t\r\n\t\t\tObject.keys(scope_Events).forEach(function( targetEvent ) {\r\n\t\r\n\t\t\t\tvar eventType = targetEvent.split('.')[0];\r\n\t\r\n\t\t\t\tif ( eventName === eventType ) {\r\n\t\t\t\t\tscope_Events[targetEvent].forEach(function( callback ) {\r\n\t\r\n\t\t\t\t\t\tcallback.call(\r\n\t\t\t\t\t\t\t// Use the slider public API as the scope ('this')\r\n\t\t\t\t\t\t\tscope_Self,\r\n\t\t\t\t\t\t\t// Return values as array, so arg_1[arg_2] is always valid.\r\n\t\t\t\t\t\t\tscope_Values.map(options.format.to),\r\n\t\t\t\t\t\t\t// Handle index, 0 or 1\r\n\t\t\t\t\t\t\thandleNumber,\r\n\t\t\t\t\t\t\t// Unformatted slider values\r\n\t\t\t\t\t\t\tscope_Values.slice(),\r\n\t\t\t\t\t\t\t// Event is fired by tap, true or false\r\n\t\t\t\t\t\t\ttap || false,\r\n\t\t\t\t\t\t\t// Left offset of the handle, in relation to the slider\r\n\t\t\t\t\t\t\tscope_Locations.slice()\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\r\n\t\t// Fire 'end' when a mouse or pen leaves the document.\r\n\t\tfunction documentLeave ( event, data ) {\r\n\t\t\tif ( event.type === \"mouseout\" && event.target.nodeName === \"HTML\" && event.relatedTarget === null ){\r\n\t\t\t\teventEnd (event, data);\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// Handle movement on document for handle and range drag.\r\n\t\tfunction eventMove ( event, data ) {\r\n\t\r\n\t\t\t// Fix #498\r\n\t\t\t// Check value of .buttons in 'start' to work around a bug in IE10 mobile (data.buttonsProperty).\r\n\t\t\t// https://connect.microsoft.com/IE/feedback/details/927005/mobile-ie10-windows-phone-buttons-property-of-pointermove-event-always-zero\r\n\t\t\t// IE9 has .buttons and .which zero on mousemove.\r\n\t\t\t// Firefox breaks the spec MDN defines.\r\n\t\t\tif ( navigator.appVersion.indexOf(\"MSIE 9\") === -1 && event.buttons === 0 && data.buttonsProperty !== 0 ) {\r\n\t\t\t\treturn eventEnd(event, data);\r\n\t\t\t}\r\n\t\r\n\t\t\t// Check if we are moving up or down\r\n\t\t\tvar movement = (options.dir ? -1 : 1) * (event.calcPoint - data.startCalcPoint);\r\n\t\r\n\t\t\t// Convert the movement into a percentage of the slider width/height\r\n\t\t\tvar proposal = (movement * 100) / data.baseSize;\r\n\t\r\n\t\t\tmoveHandles(movement > 0, proposal, data.locations, data.handleNumbers);\r\n\t\t}\r\n\t\r\n\t\t// Unbind move events on document, call callbacks.\r\n\t\tfunction eventEnd ( event, data ) {\r\n\t\r\n\t\t\t// The handle is no longer active, so remove the class.\r\n\t\t\tif ( scope_ActiveHandle ) {\r\n\t\t\t\tremoveClass(scope_ActiveHandle, options.cssClasses.active);\r\n\t\t\t\tscope_ActiveHandle = false;\r\n\t\t\t}\r\n\t\r\n\t\t\t// Remove cursor styles and text-selection events bound to the body.\r\n\t\t\tif ( event.cursor ) {\r\n\t\t\t\tdocument.body.style.cursor = '';\r\n\t\t\t\tdocument.body.removeEventListener('selectstart', document.body.noUiListener);\r\n\t\t\t}\r\n\t\r\n\t\t\t// Unbind the move and end events, which are added on 'start'.\r\n\t\t\tdocument.documentElement.noUiListeners.forEach(function( c ) {\r\n\t\t\t\tdocument.documentElement.removeEventListener(c[0], c[1]);\r\n\t\t\t});\r\n\t\r\n\t\t\t// Remove dragging class.\r\n\t\t\tremoveClass(scope_Target, options.cssClasses.drag);\r\n\t\r\n\t\t\tsetZindex();\r\n\t\r\n\t\t\tdata.handleNumbers.forEach(function(handleNumber){\r\n\t\t\t\tfireEvent('set', handleNumber);\r\n\t\t\t\tfireEvent('change', handleNumber);\r\n\t\t\t\tfireEvent('end', handleNumber);\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\t// Bind move events on document.\r\n\t\tfunction eventStart ( event, data ) {\r\n\t\r\n\t\t\tif ( data.handleNumbers.length === 1 ) {\r\n\t\r\n\t\t\t\tvar handle = scope_Handles[data.handleNumbers[0]];\r\n\t\r\n\t\t\t\t// Ignore 'disabled' handles\r\n\t\t\t\tif ( handle.hasAttribute('disabled') ) {\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// Mark the handle as 'active' so it can be styled.\r\n\t\t\t\tscope_ActiveHandle = handle.children[0];\r\n\t\t\t\taddClass(scope_ActiveHandle, options.cssClasses.active);\r\n\t\t\t}\r\n\t\r\n\t\t\t// Fix #551, where a handle gets selected instead of dragged.\r\n\t\t\tevent.preventDefault();\r\n\t\r\n\t\t\t// A drag should never propagate up to the 'tap' event.\r\n\t\t\tevent.stopPropagation();\r\n\t\r\n\t\t\t// Attach the move and end events.\r\n\t\t\tvar moveEvent = attachEvent(actions.move, document.documentElement, eventMove, {\r\n\t\t\t\tstartCalcPoint: event.calcPoint,\r\n\t\t\t\tbaseSize: baseSize(),\r\n\t\t\t\tpageOffset: event.pageOffset,\r\n\t\t\t\thandleNumbers: data.handleNumbers,\r\n\t\t\t\tbuttonsProperty: event.buttons,\r\n\t\t\t\tlocations: scope_Locations.slice()\r\n\t\t\t});\r\n\t\r\n\t\t\tvar endEvent = attachEvent(actions.end, document.documentElement, eventEnd, {\r\n\t\t\t\thandleNumbers: data.handleNumbers\r\n\t\t\t});\r\n\t\r\n\t\t\tvar outEvent = attachEvent(\"mouseout\", document.documentElement, documentLeave, {\r\n\t\t\t\thandleNumbers: data.handleNumbers\r\n\t\t\t});\r\n\t\r\n\t\t\tdocument.documentElement.noUiListeners = moveEvent.concat(endEvent, outEvent);\r\n\t\r\n\t\t\t// Text selection isn't an issue on touch devices,\r\n\t\t\t// so adding cursor styles can be skipped.\r\n\t\t\tif ( event.cursor ) {\r\n\t\r\n\t\t\t\t// Prevent the 'I' cursor and extend the range-drag cursor.\r\n\t\t\t\tdocument.body.style.cursor = getComputedStyle(event.target).cursor;\r\n\t\r\n\t\t\t\t// Mark the target with a dragging state.\r\n\t\t\t\tif ( scope_Handles.length > 1 ) {\r\n\t\t\t\t\taddClass(scope_Target, options.cssClasses.drag);\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tvar f = function(){\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t};\r\n\t\r\n\t\t\t\tdocument.body.noUiListener = f;\r\n\t\r\n\t\t\t\t// Prevent text selection when dragging the handles.\r\n\t\t\t\tdocument.body.addEventListener('selectstart', f, false);\r\n\t\t\t}\r\n\t\r\n\t\t\tdata.handleNumbers.forEach(function(handleNumber){\r\n\t\t\t\tfireEvent('start', handleNumber);\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\t// Move closest handle to tapped location.\r\n\t\tfunction eventTap ( event ) {\r\n\t\r\n\t\t\t// The tap event shouldn't propagate up\r\n\t\t\tevent.stopPropagation();\r\n\t\r\n\t\t\tvar proposal = calcPointToPercentage(event.calcPoint);\r\n\t\t\tvar handleNumber = getClosestHandle(proposal);\r\n\t\r\n\t\t\t// Tackle the case that all handles are 'disabled'.\r\n\t\t\tif ( handleNumber === false ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\r\n\t\t\t// Flag the slider as it is now in a transitional state.\r\n\t\t\t// Transition takes a configurable amount of ms (default 300). Re-enable the slider after that.\r\n\t\t\tif ( !options.events.snap ) {\r\n\t\t\t\taddClassFor(scope_Target, options.cssClasses.tap, options.animationDuration);\r\n\t\t\t}\r\n\t\r\n\t\t\tsetHandle(handleNumber, proposal, true, true);\r\n\t\r\n\t\t\tsetZindex();\r\n\t\r\n\t\t\tfireEvent('slide', handleNumber, true);\r\n\t\t\tfireEvent('set', handleNumber, true);\r\n\t\t\tfireEvent('change', handleNumber, true);\r\n\t\t\tfireEvent('update', handleNumber, true);\r\n\t\r\n\t\t\tif ( options.events.snap ) {\r\n\t\t\t\teventStart(event, { handleNumbers: [handleNumber] });\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// Fires a 'hover' event for a hovered mouse/pen position.\r\n\t\tfunction eventHover ( event ) {\r\n\t\r\n\t\t\tvar proposal = calcPointToPercentage(event.calcPoint);\r\n\t\r\n\t\t\tvar to = scope_Spectrum.getStep(proposal);\r\n\t\t\tvar value = scope_Spectrum.fromStepping(to);\r\n\t\r\n\t\t\tObject.keys(scope_Events).forEach(function( targetEvent ) {\r\n\t\t\t\tif ( 'hover' === targetEvent.split('.')[0] ) {\r\n\t\t\t\t\tscope_Events[targetEvent].forEach(function( callback ) {\r\n\t\t\t\t\t\tcallback.call( scope_Self, value );\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\t// Attach events to several slider parts.\r\n\t\tfunction bindSliderEvents ( behaviour ) {\r\n\t\r\n\t\t\t// Attach the standard drag event to the handles.\r\n\t\t\tif ( !behaviour.fixed ) {\r\n\t\r\n\t\t\t\tscope_Handles.forEach(function( handle, index ){\r\n\t\r\n\t\t\t\t\t// These events are only bound to the visual handle\r\n\t\t\t\t\t// element, not the 'real' origin element.\r\n\t\t\t\t\tattachEvent ( actions.start, handle.children[0], eventStart, {\r\n\t\t\t\t\t\thandleNumbers: [index]\r\n\t\t\t\t\t});\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\r\n\t\t\t// Attach the tap event to the slider base.\r\n\t\t\tif ( behaviour.tap ) {\r\n\t\t\t\tattachEvent (actions.start, scope_Base, eventTap, {});\r\n\t\t\t}\r\n\t\r\n\t\t\t// Fire hover events\r\n\t\t\tif ( behaviour.hover ) {\r\n\t\t\t\tattachEvent (actions.move, scope_Base, eventHover, { hover: true });\r\n\t\t\t}\r\n\t\r\n\t\t\t// Make the range draggable.\r\n\t\t\tif ( behaviour.drag ){\r\n\t\r\n\t\t\t\tscope_Connects.forEach(function( connect, index ){\r\n\t\r\n\t\t\t\t\tif ( connect === false || index === 0 || index === scope_Connects.length - 1 ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\tvar handleBefore = scope_Handles[index - 1];\r\n\t\t\t\t\tvar handleAfter = scope_Handles[index];\r\n\t\t\t\t\tvar eventHolders = [connect];\r\n\t\r\n\t\t\t\t\taddClass(connect, options.cssClasses.draggable);\r\n\t\r\n\t\t\t\t\t// When the range is fixed, the entire range can\r\n\t\t\t\t\t// be dragged by the handles. The handle in the first\r\n\t\t\t\t\t// origin will propagate the start event upward,\r\n\t\t\t\t\t// but it needs to be bound manually on the other.\r\n\t\t\t\t\tif ( behaviour.fixed ) {\r\n\t\t\t\t\t\teventHolders.push(handleBefore.children[0]);\r\n\t\t\t\t\t\teventHolders.push(handleAfter.children[0]);\r\n\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\teventHolders.forEach(function( eventHolder ) {\r\n\t\t\t\t\t\tattachEvent ( actions.start, eventHolder, eventStart, {\r\n\t\t\t\t\t\t\thandles: [handleBefore, handleAfter],\r\n\t\t\t\t\t\t\thandleNumbers: [index - 1, index]\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t});\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\r\n\t\t// Split out the handle positioning logic so the Move event can use it, too\r\n\t\tfunction checkHandlePosition ( reference, handleNumber, to, lookBackward, lookForward ) {\r\n\t\r\n\t\t\t// For sliders with multiple handles, limit movement to the other handle.\r\n\t\t\t// Apply the margin option by adding it to the handle positions.\r\n\t\t\tif ( scope_Handles.length > 1 ) {\r\n\t\r\n\t\t\t\tif ( lookBackward && handleNumber > 0 ) {\r\n\t\t\t\t\tto = Math.max(to, reference[handleNumber - 1] + options.margin);\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tif ( lookForward && handleNumber < scope_Handles.length - 1 ) {\r\n\t\t\t\t\tto = Math.min(to, reference[handleNumber + 1] - options.margin);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\r\n\t\t\t// The limit option has the opposite effect, limiting handles to a\r\n\t\t\t// maximum distance from another. Limit must be > 0, as otherwise\r\n\t\t\t// handles would be unmoveable.\r\n\t\t\tif ( scope_Handles.length > 1 && options.limit ) {\r\n\t\r\n\t\t\t\tif ( lookBackward && handleNumber > 0 ) {\r\n\t\t\t\t\tto = Math.min(to, reference[handleNumber - 1] + options.limit);\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tif ( lookForward && handleNumber < scope_Handles.length - 1 ) {\r\n\t\t\t\t\tto = Math.max(to, reference[handleNumber + 1] - options.limit);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\r\n\t\t\t// The padding option keeps the handles a certain distance from the\r\n\t\t\t// edges of the slider. Padding must be > 0.\r\n\t\t\tif ( options.padding ) {\r\n\t\r\n\t\t\t\tif ( handleNumber === 0 ) {\r\n\t\t\t\t\tto = Math.max(to, options.padding);\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tif ( handleNumber === scope_Handles.length - 1 ) {\r\n\t\t\t\t\tto = Math.min(to, 100 - options.padding);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\r\n\t\t\tto = scope_Spectrum.getStep(to);\r\n\t\r\n\t\t\t// Limit percentage to the 0 - 100 range\r\n\t\t\tto = limit(to);\r\n\t\r\n\t\t\t// Return false if handle can't move\r\n\t\t\tif ( to === reference[handleNumber] ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\r\n\t\t\treturn to;\r\n\t\t}\r\n\t\r\n\t\tfunction toPct ( pct ) {\r\n\t\t\treturn pct + '%';\r\n\t\t}\r\n\t\r\n\t\t// Updates scope_Locations and scope_Values, updates visual state\r\n\t\tfunction updateHandlePosition ( handleNumber, to ) {\r\n\t\r\n\t\t\t// Update locations.\r\n\t\t\tscope_Locations[handleNumber] = to;\r\n\t\r\n\t\t\t// Convert the value to the slider stepping/range.\r\n\t\t\tscope_Values[handleNumber] = scope_Spectrum.fromStepping(to);\r\n\t\r\n\t\t\t// Called synchronously or on the next animationFrame\r\n\t\t\tvar stateUpdate = function() {\r\n\t\t\t\tscope_Handles[handleNumber].style[options.style] = toPct(to);\r\n\t\t\t\tupdateConnect(handleNumber);\r\n\t\t\t\tupdateConnect(handleNumber + 1);\r\n\t\t\t};\r\n\t\r\n\t\t\t// Set the handle to the new position.\r\n\t\t\t// Use requestAnimationFrame for efficient painting.\r\n\t\t\t// No significant effect in Chrome, Edge sees dramatic performace improvements.\r\n\t\t\t// Option to disable is useful for unit tests, and single-step debugging.\r\n\t\t\tif ( window.requestAnimationFrame && options.useRequestAnimationFrame ) {\r\n\t\t\t\twindow.requestAnimationFrame(stateUpdate);\r\n\t\t\t} else {\r\n\t\t\t\tstateUpdate();\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\tfunction setZindex ( ) {\r\n\t\r\n\t\t\tscope_HandleNumbers.forEach(function(handleNumber){\r\n\t\t\t\t// Handles before the slider middle are stacked later = higher,\r\n\t\t\t\t// Handles after the middle later is lower\r\n\t\t\t\t// [[7] [8] .......... | .......... [5] [4]\r\n\t\t\t\tvar dir = (scope_Locations[handleNumber] > 50 ? -1 : 1);\r\n\t\t\t\tvar zIndex = 3 + (scope_Handles.length + (dir * handleNumber));\r\n\t\t\t\tscope_Handles[handleNumber].childNodes[0].style.zIndex = zIndex;\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\t// Test suggested values and apply margin, step.\r\n\t\tfunction setHandle ( handleNumber, to, lookBackward, lookForward ) {\r\n\t\r\n\t\t\tto = checkHandlePosition(scope_Locations, handleNumber, to, lookBackward, lookForward);\r\n\t\r\n\t\t\tif ( to === false ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\r\n\t\t\tupdateHandlePosition(handleNumber, to);\r\n\t\r\n\t\t\treturn true;\r\n\t\t}\r\n\t\r\n\t\t// Updates style attribute for connect nodes\r\n\t\tfunction updateConnect ( index ) {\r\n\t\r\n\t\t\t// Skip connects set to false\r\n\t\t\tif ( !scope_Connects[index] ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\r\n\t\t\tvar l = 0;\r\n\t\t\tvar h = 100;\r\n\t\r\n\t\t\tif ( index !== 0 ) {\r\n\t\t\t\tl = scope_Locations[index - 1];\r\n\t\t\t}\r\n\t\r\n\t\t\tif ( index !== scope_Connects.length - 1 ) {\r\n\t\t\t\th = scope_Locations[index];\r\n\t\t\t}\r\n\t\r\n\t\t\tscope_Connects[index].style[options.style] = toPct(l);\r\n\t\t\tscope_Connects[index].style[options.styleOposite] = toPct(100 - h);\r\n\t\t}\r\n\t\r\n\t\t// ...\r\n\t\tfunction setValue ( to, handleNumber ) {\r\n\t\r\n\t\t\t// Setting with null indicates an 'ignore'.\r\n\t\t\t// Inputting 'false' is invalid.\r\n\t\t\tif ( to === null || to === false ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\r\n\t\t\t// If a formatted number was passed, attemt to decode it.\r\n\t\t\tif ( typeof to === 'number' ) {\r\n\t\t\t\tto = String(to);\r\n\t\t\t}\r\n\t\r\n\t\t\tto = options.format.from(to);\r\n\t\r\n\t\t\t// Request an update for all links if the value was invalid.\r\n\t\t\t// Do so too if setting the handle fails.\r\n\t\t\tif ( to !== false && !isNaN(to) ) {\r\n\t\t\t\tsetHandle(handleNumber, scope_Spectrum.toStepping(to), false, false);\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// Set the slider value.\r\n\t\tfunction valueSet ( input, fireSetEvent ) {\r\n\t\r\n\t\t\tvar values = asArray(input);\r\n\t\t\tvar isInit = scope_Locations[0] === undefined;\r\n\t\r\n\t\t\t// Event fires by default\r\n\t\t\tfireSetEvent = (fireSetEvent === undefined ? true : !!fireSetEvent);\r\n\t\r\n\t\t\tvalues.forEach(setValue);\r\n\t\r\n\t\t\t// Animation is optional.\r\n\t\t\t// Make sure the initial values were set before using animated placement.\r\n\t\t\tif ( options.animate && !isInit ) {\r\n\t\t\t\taddClassFor(scope_Target, options.cssClasses.tap, options.animationDuration);\r\n\t\t\t}\r\n\t\r\n\t\t\t// Now that all base values are set, apply constraints\r\n\t\t\tscope_HandleNumbers.forEach(function(handleNumber){\r\n\t\t\t\tsetHandle(handleNumber, scope_Locations[handleNumber], true, false);\r\n\t\t\t});\r\n\t\r\n\t\t\tsetZindex();\r\n\t\r\n\t\t\tscope_HandleNumbers.forEach(function(handleNumber){\r\n\t\r\n\t\t\t\tfireEvent('update', handleNumber);\r\n\t\r\n\t\t\t\t// Fire the event only for handles that received a new value, as per #579\r\n\t\t\t\tif ( values[handleNumber] !== null && fireSetEvent ) {\r\n\t\t\t\t\tfireEvent('set', handleNumber);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\t// Reset slider to initial values\r\n\t\tfunction valueReset ( fireSetEvent ) {\r\n\t\t\tvalueSet(options.start, fireSetEvent);\r\n\t\t}\r\n\t\r\n\t\t// Get the slider value.\r\n\t\tfunction valueGet ( ) {\r\n\t\r\n\t\t\tvar values = scope_Values.map(options.format.to);\r\n\t\r\n\t\t\t// If only one handle is used, return a single value.\r\n\t\t\tif ( values.length === 1 ){\r\n\t\t\t\treturn values[0];\r\n\t\t\t}\r\n\t\r\n\t\t\treturn values;\r\n\t\t}\r\n\t\r\n\t\t// Removes classes from the root and empties it.\r\n\t\tfunction destroy ( ) {\r\n\t\r\n\t\t\tfor ( var key in options.cssClasses ) {\r\n\t\t\t\tif ( !options.cssClasses.hasOwnProperty(key) ) { continue; }\r\n\t\t\t\tremoveClass(scope_Target, options.cssClasses[key]);\r\n\t\t\t}\r\n\t\r\n\t\t\twhile (scope_Target.firstChild) {\r\n\t\t\t\tscope_Target.removeChild(scope_Target.firstChild);\r\n\t\t\t}\r\n\t\r\n\t\t\tdelete scope_Target.noUiSlider;\r\n\t\t}\r\n\t\r\n\t\t// Get the current step size for the slider.\r\n\t\tfunction getCurrentStep ( ) {\r\n\t\r\n\t\t\t// Check all locations, map them to their stepping point.\r\n\t\t\t// Get the step point, then find it in the input list.\r\n\t\t\treturn scope_Locations.map(function( location, index ){\r\n\t\r\n\t\t\t\tvar nearbySteps = scope_Spectrum.getNearbySteps( location );\r\n\t\t\t\tvar value = scope_Values[index];\r\n\t\t\t\tvar increment = nearbySteps.thisStep.step;\r\n\t\t\t\tvar decrement = null;\r\n\t\r\n\t\t\t\t// If the next value in this step moves into the next step,\r\n\t\t\t\t// the increment is the start of the next step - the current value\r\n\t\t\t\tif ( increment !== false ) {\r\n\t\t\t\t\tif ( value + increment > nearbySteps.stepAfter.startValue ) {\r\n\t\t\t\t\t\tincrement = nearbySteps.stepAfter.startValue - value;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\r\n\t\r\n\t\t\t\t// If the value is beyond the starting point\r\n\t\t\t\tif ( value > nearbySteps.thisStep.startValue ) {\r\n\t\t\t\t\tdecrement = nearbySteps.thisStep.step;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\telse if ( nearbySteps.stepBefore.step === false ) {\r\n\t\t\t\t\tdecrement = false;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// If a handle is at the start of a step, it always steps back into the previous step first\r\n\t\t\t\telse {\r\n\t\t\t\t\tdecrement = value - nearbySteps.stepBefore.highestStep;\r\n\t\t\t\t}\r\n\t\r\n\t\r\n\t\t\t\t// Now, if at the slider edges, there is not in/decrement\r\n\t\t\t\tif ( location === 100 ) {\r\n\t\t\t\t\tincrement = null;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\telse if ( location === 0 ) {\r\n\t\t\t\t\tdecrement = null;\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\t// As per #391, the comparison for the decrement step can have some rounding issues.\r\n\t\t\t\tvar stepDecimals = scope_Spectrum.countStepDecimals();\r\n\t\r\n\t\t\t\t// Round per #391\r\n\t\t\t\tif ( increment !== null && increment !== false ) {\r\n\t\t\t\t\tincrement = Number(increment.toFixed(stepDecimals));\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\tif ( decrement !== null && decrement !== false ) {\r\n\t\t\t\t\tdecrement = Number(decrement.toFixed(stepDecimals));\r\n\t\t\t\t}\r\n\t\r\n\t\t\t\treturn [decrement, increment];\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\t// Attach an event to this slider, possibly including a namespace\r\n\t\tfunction bindEvent ( namespacedEvent, callback ) {\r\n\t\t\tscope_Events[namespacedEvent] = scope_Events[namespacedEvent] || [];\r\n\t\t\tscope_Events[namespacedEvent].push(callback);\r\n\t\r\n\t\t\t// If the event bound is 'update,' fire it immediately for all handles.\r\n\t\t\tif ( namespacedEvent.split('.')[0] === 'update' ) {\r\n\t\t\t\tscope_Handles.forEach(function(a, index){\r\n\t\t\t\t\tfireEvent('update', index);\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t\r\n\t\t// Undo attachment of event\r\n\t\tfunction removeEvent ( namespacedEvent ) {\r\n\t\r\n\t\t\tvar event = namespacedEvent && namespacedEvent.split('.')[0];\r\n\t\t\tvar namespace = event && namespacedEvent.substring(event.length);\r\n\t\r\n\t\t\tObject.keys(scope_Events).forEach(function( bind ){\r\n\t\r\n\t\t\t\tvar tEvent = bind.split('.')[0],\r\n\t\t\t\t\ttNamespace = bind.substring(tEvent.length);\r\n\t\r\n\t\t\t\tif ( (!event || event === tEvent) && (!namespace || namespace === tNamespace) ) {\r\n\t\t\t\t\tdelete scope_Events[bind];\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t\r\n\t\t// Updateable: margin, limit, padding, step, range, animate, snap\r\n\t\tfunction updateOptions ( optionsToUpdate, fireSetEvent ) {\r\n\t\r\n\t\t\t// Spectrum is created using the range, snap, direction and step options.\r\n\t\t\t// 'snap' and 'step' can be updated, 'direction' cannot, due to event binding.\r\n\t\t\t// If 'snap' and 'step' are not passed, they should remain unchanged.\r\n\t\t\tvar v = valueGet();\r\n\t\r\n\t\t\tvar updateAble = ['margin', 'limit', 'padding', 'range', 'animate', 'snap', 'step', 'format'];\r\n\t\r\n\t\t\t// Only change options that we're actually passed to update.\r\n\t\t\tupdateAble.forEach(function(name){\r\n\t\t\t\tif ( optionsToUpdate[name] !== undefined ) {\r\n\t\t\t\t\toriginalOptions[name] = optionsToUpdate[name];\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\r\n\t\t\tvar newOptions = testOptions(originalOptions);\r\n\t\r\n\t\t\t// Load new options into the slider state\r\n\t\t\tupdateAble.forEach(function(name){\r\n\t\t\t\tif ( optionsToUpdate[name] !== undefined ) {\r\n\t\t\t\t\toptions[name] = newOptions[name];\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\r\n\t\t\t// Save current spectrum direction as testOptions in testRange call\r\n\t\t\t// doesn't rely on current direction\r\n\t\t\tnewOptions.spectrum.direction = scope_Spectrum.direction;\r\n\t\t\tscope_Spectrum = newOptions.spectrum;\r\n\t\r\n\t\t\t// Limit, margin and padding depend on the spectrum but are stored outside of it. (#677)\r\n\t\t\toptions.margin = newOptions.margin;\r\n\t\t\toptions.limit = newOptions.limit;\r\n\t\t\toptions.padding = newOptions.padding;\r\n\t\r\n\t\t\t// Invalidate the current positioning so valueSet forces an update.\r\n\t\t\tscope_Locations = [];\r\n\t\t\tvalueSet(optionsToUpdate.start || v, fireSetEvent);\r\n\t\t}\r\n\t\r\n\t\t// Throw an error if the slider was already initialized.\r\n\t\tif ( scope_Target.noUiSlider ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): Slider was already initialized.\");\r\n\t\t}\r\n\t\r\n\t\t// Create the base element, initialise HTML and set classes.\r\n\t\t// Add handles and connect elements.\r\n\t\taddSlider(scope_Target);\r\n\t\taddElements(options.connect, scope_Base);\r\n\t\r\n\t\tscope_Self = {\r\n\t\t\tdestroy: destroy,\r\n\t\t\tsteps: getCurrentStep,\r\n\t\t\ton: bindEvent,\r\n\t\t\toff: removeEvent,\r\n\t\t\tget: valueGet,\r\n\t\t\tset: valueSet,\r\n\t\t\treset: valueReset,\r\n\t\t\t// Exposed for unit testing, don't use this in your application.\r\n\t\t\t__moveHandles: function(a, b, c) { moveHandles(a, b, scope_Locations, c); },\r\n\t\t\toptions: originalOptions, // Issue #600, #678\r\n\t\t\tupdateOptions: updateOptions,\r\n\t\t\ttarget: scope_Target, // Issue #597\r\n\t\t\tpips: pips // Issue #594\r\n\t\t};\r\n\t\r\n\t\t// Attach user events.\r\n\t\tbindSliderEvents(options.events);\r\n\t\r\n\t\t// Use the public value method to set the start values.\r\n\t\tvalueSet(options.start);\r\n\t\r\n\t\tif ( options.pips ) {\r\n\t\t\tpips(options.pips);\r\n\t\t}\r\n\t\r\n\t\tif ( options.tooltips ) {\r\n\t\t\ttooltips();\r\n\t\t}\r\n\t\r\n\t\treturn scope_Self;\r\n\t\r\n\t}\r\n\t\r\n\t\r\n\t\t// Run the standard initializer\r\n\t\tfunction initialize ( target, originalOptions ) {\r\n\t\r\n\t\t\tif ( !target.nodeName ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): create requires a single element.\");\r\n\t\t\t}\r\n\t\r\n\t\t\t// Test the options and create the slider environment;\r\n\t\t\tvar options = testOptions( originalOptions, target );\r\n\t\t\tvar api = closure( target, options, originalOptions );\r\n\t\r\n\t\t\ttarget.noUiSlider = api;\r\n\t\r\n\t\t\treturn api;\r\n\t\t}\r\n\t\r\n\t\t// Use an object instead of a function for future expansibility;\r\n\t\treturn {\r\n\t\t\tversion: VERSION,\r\n\t\t\tcreate: initialize\r\n\t\t};\r\n\t\r\n\t}));\n\n/***/ },\n/* 40 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _clamp = __webpack_require__(41);\n\t\n\tvar _clamp2 = _interopRequireDefault(_clamp);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-indicator';\n\tvar CLASS_ITEM = 'aui-indicator__item';\n\tvar CLASS_ACTION = 'aui-indicator__action';\n\tvar CLASS_INDICATOR = 'aui-indicator__indicator';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\t\n\t/**\n\t * Class constructor for Indicator AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Indicator = function (_Component) {\n\t  _inherits(Indicator, _Component);\n\t\n\t  /**\n\t   * Upgrades all Indicator AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Indicator.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Indicator(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Indicator(element) {\n\t    _classCallCheck(this, Indicator);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  Indicator.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._actions = Array.from(this._element.querySelectorAll('.' + CLASS_ACTION));\n\t    this._listItems = Array.from(this._element.querySelectorAll('.' + CLASS_ITEM));\n\t\n\t    this._indicator = document.createElement('span');\n\t    this._indicator.classList.add(CLASS_INDICATOR);\n\t    this._element.appendChild(this._indicator);\n\t\n\t    this._element.addEventListener('click', this.clickHandler = function (event) {\n\t      return _this2._onClick(event);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Handle click.\n\t   * @param {Event} event The event that fired.\n\t   * @private\n\t   */\n\t\n\t\n\t  Indicator.prototype._onClick = function _onClick(event) {\n\t    if (!event.target.classList.contains(CLASS_ACTION)) {\n\t      return;\n\t    }\n\t    event.preventDefault();\n\t\n\t    this.selectAction(event.target);\n\t  };\n\t\n\t  /**\n\t   * Select item with given action element.\n\t   * @param {HTMLElement} actionElement Action child element of the list item to select.\n\t   * @private\n\t   */\n\t\n\t\n\t  Indicator.prototype.selectAction = function selectAction(actionElement) {\n\t    if (actionElement) {\n\t      // Find index\n\t      var listItem = actionElement.parentNode;\n\t      var index = this._listItems.indexOf(listItem);\n\t      this.select(index);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Select item.\n\t   * @param {Integer} index Zero-based index of the list item to select.\n\t   * @private\n\t   */\n\t\n\t\n\t  Indicator.prototype.select = function select() {\n\t    var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\t\n\t    index = (0, _clamp2.default)(index, 0, this._actions.length - 1);\n\t    var activeItem = this._actions[index];\n\t\n\t    // Update actions\n\t    this._actions.forEach(function (item) {\n\t      item.classList.remove(CLASS_IS_ACTIVE);\n\t    });\n\t    activeItem.classList.add(CLASS_IS_ACTIVE);\n\t\n\t    // Update indicator position\n\t    var rectContainer = this._element.getBoundingClientRect();\n\t    var rectTarget = activeItem.getBoundingClientRect();\n\t    var indicatorLeft = rectTarget.left - rectContainer.left;\n\t    this._indicator.style.left = indicatorLeft + 'px';\n\t  };\n\t\n\t  return Indicator;\n\t}(_component2.default);\n\t\n\texports.default = Indicator;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 41 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.default = clamp;\n\t/**\n\t * Clamps `number` within the inclusive `lower` and `upper` bounds.\n\t *\n\t * @since 4.0.0\n\t * @category Number\n\t * @param {number} number The number to clamp.\n\t * @param {number} lower The lower bound.\n\t * @param {number} upper The upper bound.\n\t * @returns {number} Returns the clamped number.\n\t * @example\n\t *\n\t * clamp(-10, -5, 5)\n\t * // => -5\n\t *\n\t * clamp(10, -5, 5)\n\t * // => 5\n\t */\n\tfunction clamp(number, lower, upper) {\n\t  number = +number;\n\t  lower = +lower;\n\t  upper = +upper;\n\t  lower = lower === lower ? lower : 0;\n\t  upper = upper === upper ? upper : 0;\n\t  if (number === number) {\n\t    number = number <= upper ? number : upper;\n\t    number = number >= lower ? number : lower;\n\t  }\n\t  return number;\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 42 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tvar _objectResize = __webpack_require__(43);\n\t\n\tvar _objectResize2 = _interopRequireDefault(_objectResize);\n\t\n\tvar _limit = __webpack_require__(24);\n\t\n\tvar _limit2 = _interopRequireDefault(_limit);\n\t\n\tvar _bezierEasing = __webpack_require__(44);\n\t\n\tvar _bezierEasing2 = _interopRequireDefault(_bezierEasing);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-spinner';\n\tvar CLASS_CONTINUOUS = 'aui-spinner--continuous';\n\tvar CLASS_SHAPE = 'aui-spinner__svg';\n\tvar CLASS_PATH = 'aui-spinner__path';\n\tvar CLASS_PATH_PROGRESS = 'aui-spinner__path--progress';\n\tvar CLASS_GROUP = 'aui-spinner__group';\n\tvar CLASS_GROUP_BASE_PATH = 'aui-spinner__group-base';\n\tvar CLASS_GROUP_PROGRESS_PATH = 'aui-spinner__group-progress';\n\tvar CLASS_VALUE = 'aui-spinner__value';\n\tvar CLASS_IS_PENDING = 'is-pending';\n\tvar CLASS_IS_LOADING = 'is-loading';\n\tvar CLASS_IS_COMPLETE = 'is-complete';\n\tvar SIZE = 48;\n\tvar RADIUS = 22;\n\tvar STROKE_WIDTH = 3;\n\tvar LOOP_ANIMATION_DURATION = 1.5;\n\tvar LOOP_ANIMATION = [{\n\t  dashLength: 0,\n\t  dashOffset: 0,\n\t  rotate: 0\n\t}, {\n\t  dashLength: 0.65,\n\t  dashOffset: -1,\n\t  rotate: 360\n\t}];\n\t\n\t/**\n\t * Class constructor for Spinner AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Spinner = function (_Component) {\n\t  _inherits(Spinner, _Component);\n\t\n\t  /**\n\t   * Upgrades all Spinner AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Spinner.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Spinner(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Spinner(element) {\n\t    _classCallCheck(this, Spinner);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  Spinner.prototype.init = function init() {\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._objectResize = new _objectResize2.default(this._element, this.resize, this);\n\t\n\t    this._continuous = this._element.classList.contains(CLASS_CONTINUOUS);\n\t\n\t    // Add value element, if required:\n\t    if (!this._continuous) {\n\t      this._value = document.createElement('span');\n\t      this._value.classList.add(CLASS_VALUE);\n\t      this._element.appendChild(this._value);\n\t    }\n\t\n\t    // Add SVG graphic:\n\t    // <svg class=\"aui-spinner__shape\" viewBox=\"0 0 200 200\">\n\t    //   <g class=\"aui-spinner__group\">\n\t    //     <circle class=\"aui-spinner__path\" cx=\"0\" cy=\"0\" r=\"100\" />\n\t    //     <circle class=\"aui-spinner__path aui-spinner__path--progress\" cx=\"0\" cy=\"0\" r=\"100\" />\n\t    //   </g>\n\t    // </svg>\n\t    var shape = this.createSvgNode('svg', {\n\t      class: CLASS_SHAPE,\n\t      viewBox: '0 0 ' + SIZE + ' ' + SIZE\n\t    });\n\t    var group = this.createSvgNode('g', { class: CLASS_GROUP });\n\t    var groupCircle1 = this.createSvgNode('g', { class: CLASS_GROUP_BASE_PATH });\n\t    var groupCircle2 = this.createSvgNode('g', { class: CLASS_GROUP_PROGRESS_PATH });\n\t    var circle1 = this.createSvgNode('circle', {\n\t      class: CLASS_PATH,\n\t      cx: 0,\n\t      cy: 0,\n\t      r: RADIUS\n\t    });\n\t    var circle2 = this.createSvgNode('circle', {\n\t      class: CLASS_PATH + ' ' + CLASS_PATH_PROGRESS,\n\t      cx: 0,\n\t      cy: 0,\n\t      r: RADIUS,\n\t      transform: 'rotate(-90)'\n\t    });\n\t    groupCircle1.appendChild(circle1);\n\t    groupCircle2.appendChild(circle2);\n\t    group.appendChild(groupCircle1);\n\t    group.appendChild(groupCircle2);\n\t    shape.appendChild(group);\n\t    this._element.appendChild(shape);\n\t    this._shape = shape;\n\t    this._group = group;\n\t    this._progressPath = circle2;\n\t    this._basePath = circle1;\n\t    this._groupProgress = groupCircle2;\n\t\n\t    this._easing = (0, _bezierEasing2.default)(0.75, 0.02, 0.5, 1);\n\t    this._easingDasharray = (0, _bezierEasing2.default)(0.4, 0, 0, 1);\n\t    this._progressPath.style.strokeOpacity = 0;\n\t\n\t    this.resize();\n\t    this.progress(0);\n\t  };\n\t\n\t  Spinner.prototype.progress = function progress(ratio) {\n\t    ratio = (0, _limit2.default)(ratio, 0, 1);\n\t    this._progress = ratio;\n\t    var pathLength = this._getCircleLength(this._progressPath);\n\t\n\t    if (!this._continuous) {\n\t      this._progressPath.style.strokeDasharray = this._progress === 1 ? 'none' : this._progress * pathLength + ', ' + pathLength;\n\t      this._progressPath.style.strokeOpacity = this._progress === 0 ? 0 : 1;\n\t    }\n\t\n\t    if (this._value) {\n\t      this._value.innerHTML = '' + Math.round(this._progress * 100);\n\t    }\n\t\n\t    this._updateClasses();\n\t  };\n\t\n\t  Spinner.prototype.loop = function loop() {\n\t    var _this2 = this;\n\t\n\t    if (this._continuous) {\n\t      this._progressPath.style.strokeOpacity = 1;\n\t      window.requestAnimationFrame(function (timestamp) {\n\t        return _this2._animateLoop(timestamp);\n\t      });\n\t    }\n\t  };\n\t\n\t  Spinner.prototype.stop = function stop() {};\n\t\n\t  Spinner.prototype.resize = function resize() {\n\t    var size = this._element.offsetWidth;\n\t    var radius = (size - STROKE_WIDTH) / 2;\n\t    this._shape.setAttributeNS(null, 'viewBox', size / -2 + ' ' + size / -2 + ' ' + size + ' ' + size);\n\t    this._basePath.setAttributeNS(null, 'r', '' + radius);\n\t    this._progressPath.setAttributeNS(null, 'r', '' + radius);\n\t  };\n\t\n\t  // TODO Optimize calculations; wording.\n\t\n\t\n\t  Spinner.prototype._animateLoop = function _animateLoop(timestamp) {\n\t    var _this3 = this;\n\t\n\t    if (!this._loopStart) {\n\t      this._loopStart = timestamp;\n\t    }\n\t\n\t    // The progress in seconds 0 <= progress <= LOOP_ANIMATION_DURATION\n\t    var progress = (timestamp - this._loopStart) / 1000;\n\t    // The progress ratio between 0 <= progressRatio <= 1\n\t    var progressRatio = progress / LOOP_ANIMATION_DURATION;\n\t    if (progressRatio > 1 || progressRatio === 0) {\n\t      this._animationEndSet = false;\n\t      progress = 0;\n\t      progressRatio = 0;\n\t      this._loopStart = timestamp;\n\t      this._dashLengthStart = LOOP_ANIMATION[0].dashLength;\n\t      this._dashOffsetStart = LOOP_ANIMATION[0].dashOffset;\n\t      this._dashLengthEnd = LOOP_ANIMATION[1].dashLength;\n\t      this._dashOffsetEnd = LOOP_ANIMATION[1].dashOffset;\n\t    }\n\t    var ease = this._easing(progressRatio);\n\t    var pathLength = this._getCircleLength(this._progressPath);\n\t    this._dashLengthRatio = this._dashLengthStart + (this._dashLengthEnd - this._dashLengthStart) * this._easingDasharray(progressRatio);\n\t    this._dashOffsetRatio = this._dashOffsetStart + (this._dashOffsetEnd - this._dashOffsetStart) * ease;\n\t    this._rotate = LOOP_ANIMATION[1].rotate * ease;\n\t\n\t    var dashLength = pathLength * this._dashLengthRatio;\n\t    var dashOffset = pathLength * this._dashOffsetRatio;\n\t\n\t    this._progressPath.style.strokeDasharray = dashLength + ', ' + pathLength;\n\t    this._progressPath.style.strokeDashoffset = '' + dashOffset;\n\t    // this._group.setAttributeNS(null, 'transform', `rotate(${this._rotate})`);\n\t    this._groupProgress.setAttributeNS(null, 'transform', 'rotate(' + this._rotate + ')');\n\t\n\t    window.requestAnimationFrame(function (timestamp) {\n\t      return _this3._animateLoop(timestamp);\n\t    });\n\t  };\n\t\n\t  Spinner.prototype._updateClasses = function _updateClasses() {\n\t    if (this._progress === 0) {\n\t      this._element.classList.add(CLASS_IS_PENDING);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_PENDING);\n\t    }\n\t\n\t    if (this._progress > 0 && this._progress < 1) {\n\t      this._element.classList.add(CLASS_IS_LOADING);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_LOADING);\n\t    }\n\t\n\t    if (this._progress === 1) {\n\t      this._element.classList.add(CLASS_IS_COMPLETE);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_COMPLETE);\n\t    }\n\t  };\n\t\n\t  Spinner.prototype._getCircleLength = function _getCircleLength(circle) {\n\t    var r = circle.getAttribute('r');\n\t    return 2 * Math.PI * r;\n\t  };\n\t\n\t  return Spinner;\n\t}(_component2.default);\n\t\n\texports.default = Spinner;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 43 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tvar ObjectResize = function () {\n\t  function ObjectResize(parent, callback, callbackScope) {\n\t    var _this = this;\n\t\n\t    _classCallCheck(this, ObjectResize);\n\t\n\t    var isIE = navigator.userAgent.match(/Trident/);\n\t\n\t    // NOTE\n\t    // this._parent.style.position != 'static'\n\t    // this._parent.style.display = 'block'\n\t\n\t    this._parent = parent;\n\t    this._helperElement = document.createElement('object');\n\t    this._helperElement.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; pointer-events: none; z-index: -1; border: 0px; opacity: 0;');\n\t    this._helperElement.setAttribute('border', '0');\n\t    this._helperElement.onload = function () {\n\t      return _this._onLoad();\n\t    };\n\t    this._helperElement.type = 'text/html';\n\t    if (isIE) {\n\t      this._parent.appendChild(this._helperElement);\n\t    }\n\t    this._helperElement.data = 'about:blank';\n\t    if (!isIE) {\n\t      this._parent.appendChild(this._helperElement);\n\t    }\n\t\n\t    this._callback = callback;\n\t    this._callbackScope = callbackScope;\n\t\n\t    this._ticking = false;\n\t  }\n\t\n\t  ObjectResize.prototype._onLoad = function _onLoad(event) {\n\t    var _this2 = this;\n\t\n\t    this._helperElement.contentDocument.defaultView.addEventListener('resize', this._resizeHandler = function (event) {\n\t      return _this2._onResize(event);\n\t    });\n\t  };\n\t\n\t  ObjectResize.prototype._onResize = function _onResize(event) {\n\t    var _this3 = this;\n\t\n\t    if (!this._ticking) {\n\t      window.requestAnimationFrame(function () {\n\t        _this3._ticking = false;\n\t        _this3._callback.call(_this3._callbackScope);\n\t      });\n\t    }\n\t    this._ticking = true;\n\t  };\n\t\n\t  ObjectResize.prototype.dispose = function dispose() {\n\t    this._helperElement.contentDocument.defaultView.removeEventListener('resize', this._resizeHandler);\n\t    this._parent.removeChild(this._helperElement);\n\t  };\n\t\n\t  return ObjectResize;\n\t}();\n\t\n\t// (function() {\n\t//   var attachEvent = document.attachEvent;\n\t//   var isIE = navigator.userAgent.match(/Trident/);\n\t//   var requestFrame = (function() {\n\t//     var raf = window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame ||\n\t//       function(fn) {\n\t//         return window.setTimeout(fn, 20);\n\t//       };\n\t//     return function(fn) {\n\t//       return raf(fn);\n\t//     };\n\t//   })();\n\t//\n\t//   var cancelFrame = (function() {\n\t//     var cancel = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.webkitCancelAnimationFrame ||\n\t//       window.clearTimeout;\n\t//     return function(id) {\n\t//       return cancel(id);\n\t//     };\n\t//   })();\n\t//\n\t//   function resizeListener(e) {\n\t//     var win = e.target || e.srcElement;\n\t//     if (win.__resizeRAF__) cancelFrame(win.__resizeRAF__);\n\t//     win.__resizeRAF__ = requestFrame(function() {\n\t//       var trigger = win.__resizeTrigger__;\n\t//       trigger.__resizeListeners__.forEach(function(fn) {\n\t//         fn.call(trigger, e);\n\t//       });\n\t//     });\n\t//   }\n\t//\n\t//   function objectLoad(e) {\n\t//     this.contentDocument.defaultView.__resizeTrigger__ = this.__resizeElement__;\n\t//     this.contentDocument.defaultView.addEventListener('resize', resizeListener);\n\t//   }\n\t//\n\t//   window.addResizeListener = function(element, fn) {\n\t//     if (!element.__resizeListeners__) {\n\t//       element.__resizeListeners__ = [];\n\t//       if (attachEvent) {\n\t//         element.__resizeTrigger__ = element;\n\t//         element.attachEvent('onresize', resizeListener);\n\t//       } else {\n\t//         if (getComputedStyle(element).position === 'static') element.style.position = 'relative';\n\t//         var obj = element.__resizeTrigger__ = document.createElement('object');\n\t//         obj.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; pointer-events: none; z-index: -1;');\n\t//         obj.__resizeElement__ = element;\n\t//         obj.onload = objectLoad;\n\t//         obj.type = 'text/html';\n\t//         if (isIE) element.appendChild(obj);\n\t//         obj.data = 'about:blank';\n\t//         if (!isIE) element.appendChild(obj);\n\t//       }\n\t//     }\n\t//     element.__resizeListeners__.push(fn);\n\t//   };\n\t//\n\t//   window.removeResizeListener = function(element, fn) {\n\t//     element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);\n\t//     if (!element.__resizeListeners__.length) {\n\t//       if (attachEvent) element.detachEvent('onresize', resizeListener);\n\t//       else {\n\t//         element.__resizeTrigger__.contentDocument.defaultView.removeEventListener('resize', resizeListener);\n\t//         element.__resizeTrigger__ = !element.removeChild(element.__resizeTrigger__);\n\t//       }\n\t//     }\n\t//   }\n\t// })();\n\t\n\t\n\texports.default = ObjectResize;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 44 */\n/***/ function(module, exports) {\n\n\t/**\n\t * https://github.com/gre/bezier-easing\n\t * BezierEasing - use bezier curve for transition easing function\n\t * by Gaëtan Renaudeau 2014 - 2015 – MIT License\n\t */\n\t\n\t// These values are established by empiricism with tests (tradeoff: performance VS precision)\n\tvar NEWTON_ITERATIONS = 4;\n\tvar NEWTON_MIN_SLOPE = 0.001;\n\tvar SUBDIVISION_PRECISION = 0.0000001;\n\tvar SUBDIVISION_MAX_ITERATIONS = 10;\n\t\n\tvar kSplineTableSize = 11;\n\tvar kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\n\t\n\tvar float32ArraySupported = typeof Float32Array === 'function';\n\t\n\tfunction A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }\n\tfunction B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }\n\tfunction C (aA1)      { return 3.0 * aA1; }\n\t\n\t// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\n\tfunction calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }\n\t\n\t// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.\n\tfunction getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }\n\t\n\tfunction binarySubdivide (aX, aA, aB, mX1, mX2) {\n\t  var currentX, currentT, i = 0;\n\t  do {\n\t    currentT = aA + (aB - aA) / 2.0;\n\t    currentX = calcBezier(currentT, mX1, mX2) - aX;\n\t    if (currentX > 0.0) {\n\t      aB = currentT;\n\t    } else {\n\t      aA = currentT;\n\t    }\n\t  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n\t  return currentT;\n\t}\n\t\n\tfunction newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {\n\t for (var i = 0; i < NEWTON_ITERATIONS; ++i) {\n\t   var currentSlope = getSlope(aGuessT, mX1, mX2);\n\t   if (currentSlope === 0.0) {\n\t     return aGuessT;\n\t   }\n\t   var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n\t   aGuessT -= currentX / currentSlope;\n\t }\n\t return aGuessT;\n\t}\n\t\n\tfunction LinearEasing (x) {\n\t  return x;\n\t}\n\t\n\tmodule.exports = function bezier (mX1, mY1, mX2, mY2) {\n\t  if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {\n\t    throw new Error('bezier x values must be in [0, 1] range');\n\t  }\n\t\n\t  if (mX1 === mY1 && mX2 === mY2) {\n\t    return LinearEasing;\n\t  }\n\t\n\t  // Precompute samples table\n\t  var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);\n\t  for (var i = 0; i < kSplineTableSize; ++i) {\n\t    sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n\t  }\n\t\n\t  function getTForX (aX) {\n\t    var intervalStart = 0.0;\n\t    var currentSample = 1;\n\t    var lastSample = kSplineTableSize - 1;\n\t\n\t    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n\t      intervalStart += kSampleStepSize;\n\t    }\n\t    --currentSample;\n\t\n\t    // Interpolate to provide an initial guess for t\n\t    var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n\t    var guessForT = intervalStart + dist * kSampleStepSize;\n\t\n\t    var initialSlope = getSlope(guessForT, mX1, mX2);\n\t    if (initialSlope >= NEWTON_MIN_SLOPE) {\n\t      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n\t    } else if (initialSlope === 0.0) {\n\t      return guessForT;\n\t    } else {\n\t      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n\t    }\n\t  }\n\t\n\t  return function BezierEasing (x) {\n\t    // Because JavaScript number are imprecise, we should guarantee the extremes are right.\n\t    if (x === 0) {\n\t      return 0;\n\t    }\n\t    if (x === 1) {\n\t      return 1;\n\t    }\n\t    return calcBezier(getTForX(x), mY1, mY2);\n\t  };\n\t};\n\n\n/***/ },\n/* 45 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-textfield';\n\tvar CLASS_FIELD = 'aui-textfield__field';\n\tvar CLASS_INPUT = 'aui-textfield__input';\n\tvar CLASS_LABEL = 'aui-textfield__label';\n\tvar CLASS_FOCUS_LINE = 'aui-textfield__focus-line';\n\tvar CLASS_COUNTER = 'aui-textfield__counter';\n\tvar CLASS_COUNTER_VALUE = 'aui-textfield__counter-value';\n\tvar CLASS_IS_FOCUS = 'is-focused';\n\tvar CLASS_IS_DIRTY = 'is-dirty';\n\tvar CLASS_IS_INVALID = 'is-invalid';\n\tvar CLASS_IS_DISABLED = 'is-disabled';\n\tvar CLASS_IS_EQUAL_MAX_CHARS = 'is-equal-max-length';\n\tvar CLASS_IS_GREATER_MAX_CHARS = 'is-greater-max-length';\n\tvar ATTR_AUTOSIZE = 'data-autosize';\n\t\n\t/**\n\t * Class constructor for Textfield AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Textfield = function (_Component) {\n\t  _inherits(Textfield, _Component);\n\t\n\t  /**\n\t   * Upgrades all Textfield AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Textfield.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Textfield(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  function Textfield(element) {\n\t    _classCallCheck(this, Textfield);\n\t\n\t    return _possibleConstructorReturn(this, _Component.call(this, element));\n\t  }\n\t\n\t  Textfield.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    this._input = this._element.querySelector('.' + CLASS_INPUT);\n\t    this._input.addEventListener('input', this._inputHandler = function (event) {\n\t      return _this2._onInput(event);\n\t    });\n\t    this._input.addEventListener('focus', this._focusHandler = function (event) {\n\t      return _this2._onFocus(event);\n\t    });\n\t    this._input.addEventListener('blur', this._blurHandler = function (event) {\n\t      return _this2._onBlur(event);\n\t    });\n\t    this._input.addEventListener('change', this._changeHandler = function (event) {\n\t      return _this2._onChange(event);\n\t    });\n\t    this._input.addEventListener('reset', this._resetHandler = function (event) {\n\t      return _this2._onReset(event);\n\t    });\n\t\n\t    // Insert counter if data attribute 'count' is present:\n\t    if (this._element.getAttribute('data-count')) {\n\t      this._maxChars = parseInt(this._element.getAttribute('data-count')) || 0;\n\t      this._label = this._element.querySelector('.' + CLASS_FIELD);\n\t      this._counter = document.createElement('span');\n\t      this._counter.classList.add(CLASS_COUNTER);\n\t      this._label.parentNode.insertBefore(this._counter, this._label.nextSibling);\n\t      this._counterValue = document.createElement('span');\n\t      this._counterValue.classList.add(CLASS_COUNTER_VALUE);\n\t      this._counterValue.innerHTML = this._maxChars;\n\t      this._counter.appendChild(this._counterValue);\n\t      this._hasCounter = true;\n\t    }\n\t\n\t    // Insert thick focus line after label element:\n\t    this._label = this._element.querySelector('.' + CLASS_LABEL);\n\t    var focusLine = document.createElement('span');\n\t    focusLine.classList.add(CLASS_FOCUS_LINE);\n\t    this._label.parentNode.insertBefore(focusLine, this._label.nextSibling);\n\t\n\t    // If textarea should adjust height to content\n\t    if (this._element.hasAttribute(ATTR_AUTOSIZE) && this._element.getAttribute(ATTR_AUTOSIZE) !== 'false') {\n\t      var style = window.getComputedStyle(this._input);\n\t      this._inputPadding = parseInt(style.paddingTop) + parseInt(style.paddingBottom) || 0;\n\t      this._inputBorder = parseInt(style.borderTop) + parseInt(style.borderBottom) || 0;\n\t      this._input.addEventListener('keyup', this._keyupHandler = function (event) {\n\t        return _this2._onKeyup(event);\n\t      });\n\t      this._autosize = true;\n\t    }\n\t\n\t    this.updateClasses();\n\t  };\n\t\n\t  Textfield.prototype.update = function update() {\n\t    this.updateClasses();\n\t    this.updateCounter();\n\t    if (this._autosize) {\n\t      this.adjustHeightToContent();\n\t    }\n\t  };\n\t\n\t  Textfield.prototype.updateClasses = function updateClasses() {\n\t    this.checkDisabled();\n\t    this.checkDirty();\n\t    this.checkFocus();\n\t  };\n\t\n\t  Textfield.prototype.updateCounter = function updateCounter() {\n\t    if (this._counterValue) {\n\t      var numChars = this._input.value.length;\n\t      var remainingChars = this._maxChars - numChars;\n\t      this._counterValue.innerHTML = remainingChars;\n\t\n\t      if (remainingChars === 0) {\n\t        this._element.classList.add(CLASS_IS_EQUAL_MAX_CHARS);\n\t      } else {\n\t        this._element.classList.remove(CLASS_IS_EQUAL_MAX_CHARS);\n\t      }\n\t\n\t      if (remainingChars < 0) {\n\t        this._element.classList.add(CLASS_IS_GREATER_MAX_CHARS);\n\t        this._element.classList.add(CLASS_IS_INVALID);\n\t      } else {\n\t        this._element.classList.remove(CLASS_IS_GREATER_MAX_CHARS);\n\t        this._element.classList.remove(CLASS_IS_INVALID);\n\t      }\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the disabled state and update field accordingly.\n\t   */\n\t\n\t\n\t  Textfield.prototype.checkDisabled = function checkDisabled() {\n\t    if (this._input.disabled) {\n\t      this._element.classList.add(CLASS_IS_DISABLED);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DISABLED);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the dirty state and update field accordingly.\n\t   */\n\t\n\t\n\t  Textfield.prototype.checkDirty = function checkDirty() {\n\t    if (this._input.value && this._input.value.length > 0) {\n\t      this._element.classList.add(CLASS_IS_DIRTY);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_DIRTY);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Check the focus state and update field accordingly.\n\t   */\n\t\n\t\n\t  Textfield.prototype.checkFocus = function checkFocus() {\n\t    if (Boolean(this._element.querySelector(':focus'))) {\n\t      this._element.classList.add(CLASS_IS_FOCUS);\n\t    } else {\n\t      this._element.classList.remove(CLASS_IS_FOCUS);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Resize textarea\n\t   */\n\t\n\t\n\t  Textfield.prototype.adjustHeightToContent = function adjustHeightToContent() {\n\t    var htmlTop = window.pageYOffset;\n\t    var bodyTop = document.body.scrollTop;\n\t    var originalHeight = this._input.style.height;\n\t\n\t    this._input.style.height = 'auto';\n\t    if (this._input.scrollHeight === 0) {\n\t      // If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.\n\t      this._input.style.height = originalHeight;\n\t      return;\n\t    }\n\t    this._input.style.height = this._input.scrollHeight + this._inputBorder + 'px';\n\t\n\t    // prevents scroll position jump\n\t    document.documentElement.scrollTop = htmlTop;\n\t    document.body.scrollTop = bodyTop;\n\t  };\n\t\n\t  /**\n\t   * Disable text field.\n\t   */\n\t\n\t\n\t  Textfield.prototype.disable = function disable() {\n\t    this._input.disabled = true;\n\t    this.updateClasses();\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Textfield.prototype.dispose = function dispose() {\n\t    _Component.prototype.dispose.call(this);\n\t\n\t    this._input.removeEventListener('input', this._inputHandler);\n\t    this._input.removeEventListener('focus', this._focusHandler);\n\t    this._input.removeEventListener('blur', this._blurHandler);\n\t    this._input.removeEventListener('change', this._changeHandler);\n\t    this._input.removeEventListener('reset', this._resetHandler);\n\t\n\t    _Component.prototype.removeChild.call(this, this._element.querySelector('.' + CLASS_FOCUS_LINE));\n\t    _Component.prototype.removeChild.call(this, this._element.querySelector('.' + CLASS_COUNTER));\n\t  };\n\t\n\t  /**\n\t   * Event Handler\n\t   */\n\t\n\t  Textfield.prototype._onInput = function _onInput(event) {\n\t    this.update();\n\t  };\n\t\n\t  Textfield.prototype._onFocus = function _onFocus(event) {\n\t    this.update();\n\t  };\n\t\n\t  Textfield.prototype._onBlur = function _onBlur(event) {\n\t    this.update();\n\t  };\n\t\n\t  Textfield.prototype._onChange = function _onChange(event) {\n\t    this.update();\n\t  };\n\t\n\t  Textfield.prototype._onReset = function _onReset(event) {\n\t    this.update();\n\t  };\n\t\n\t  Textfield.prototype._onKeyup = function _onKeyup(event) {\n\t    this.updateCounter();\n\t    if (this._autosize) {\n\t      this.adjustHeightToContent();\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Getter and Setter\n\t   */\n\t\n\t  _createClass(Textfield, [{\n\t    key: 'input',\n\t    get: function get() {\n\t      return this._input;\n\t    }\n\t  }, {\n\t    key: 'autoSize',\n\t    get: function get() {\n\t      return this._autosize;\n\t    },\n\t    set: function set(value) {\n\t      return this._autosize = Boolean(value);\n\t    }\n\t  }]);\n\t\n\t  return Textfield;\n\t}(_component2.default);\n\t\n\texports.default = Textfield;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 46 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _component = __webpack_require__(2);\n\t\n\tvar _component2 = _interopRequireDefault(_component);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar SELECTOR_COMPONENT = '.aui-js-tooltip';\n\tvar CLASS_TRIANGLE = 'aui-tooltip__triangle';\n\tvar CLASS_IS_UPGRADED = 'is-upgraded';\n\tvar CLASS_IS_ACTIVE = 'is-active';\n\tvar CLASS_IS_TOP = 'is-top';\n\tvar OFFSET_VIEWPORT_X = 10;\n\tvar OFFSET_TARGET_TOP = 12;\n\tvar OFFSET_TARGET_BOTTOM = 12;\n\tvar OPEN_DELAY = 400;\n\t\n\t/**\n\t * Class constructor for Tooltip AUI component.\n\t * Implements AUI component design pattern defined at:\n\t * https://github.com/...\n\t *\n\t * @param {HTMLElement} element The element that will be upgraded.\n\t */\n\t\n\tvar Tooltip = function (_Component) {\n\t  _inherits(Tooltip, _Component);\n\t\n\t  function Tooltip() {\n\t    _classCallCheck(this, Tooltip);\n\t\n\t    return _possibleConstructorReturn(this, _Component.apply(this, arguments));\n\t  }\n\t\n\t  /**\n\t   * Upgrades all Tooltip AUI components.\n\t   * @returns {Array} Returns an array of all newly upgraded components.\n\t   */\n\t  Tooltip.upgradeElements = function upgradeElements() {\n\t    var components = [];\n\t    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(function (element) {\n\t      if (!_component2.default.isElementUpgraded(element)) {\n\t        components.push(new Tooltip(element));\n\t      }\n\t    });\n\t    return components;\n\t  };\n\t\n\t  /**\n\t   * Initialize component\n\t   */\n\t  Tooltip.prototype.init = function init() {\n\t    var _this2 = this;\n\t\n\t    _Component.prototype.init.call(this);\n\t\n\t    var forId = this._element.getAttribute('for');\n\t\n\t    if (forId) {\n\t      this._trigger = document.getElementById(forId);\n\t    }\n\t\n\t    if (this._trigger) {\n\t      // Add triangle shape\n\t      this._triangle = document.createElement('span');\n\t      this._triangle.classList.add(CLASS_TRIANGLE);\n\t      this._element.appendChild(this._triangle);\n\t\n\t      // Prevent accidental text selection on Android\n\t      if (!this._trigger.hasAttribute('tabindex')) {\n\t        this._trigger.setAttribute('tabindex', '0');\n\t      }\n\t\n\t      this._trigger.addEventListener('mouseenter', this._boundMouseenter = function (event) {\n\t        return _this2._onTriggerEnter(event);\n\t      });\n\t      this._trigger.addEventListener('mouseleave', this._boundMouseleave = function (event) {\n\t        return _this2._onTriggerLeave(event);\n\t      });\n\t      this._trigger.addEventListener('focusin', this._boundfocusin = function (event) {\n\t        return _this2._onTriggerEnter(event);\n\t      });\n\t      this._trigger.addEventListener('focusout', this._boundfocusout = function (event) {\n\t        return _this2._onTriggerLeave(event);\n\t      });\n\t      this._trigger.addEventListener('touchstart', this._boundTouchstart = function (event) {\n\t        return _this2._onTriggerEnter(event);\n\t      });\n\t      window.addEventListener('touchend', this._boundTouchendWindow = function (event) {\n\t        return _this2._onTriggerLeaveOutside(event);\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * Dispose component\n\t   */\n\t\n\t\n\t  Tooltip.prototype.dispose = function dispose() {\n\t    this._trigger.removeEventListener('mouseenter', this._boundMouseenter);\n\t    this._trigger.removeEventListener('mouseleave', this._boundMouseleave);\n\t    this._trigger.removeEventListener('mousemove', this._boundMouseMove);\n\t    this._trigger.removeEventListener('focusin', this._boundfocusin);\n\t    this._trigger.removeEventListener('focusout', this._boundfocusout);\n\t    this._trigger.removeEventListener('touchstart', this._boundTouchstart);\n\t    window.removeEventListener('touchend', this._boundTouchendWindow);\n\t    window.removeEventListener('scroll', this._boundScrollWindow);\n\t\n\t    this._element.classList.remove(CLASS_IS_TOP, CLASS_IS_ACTIVE, CLASS_IS_UPGRADED);\n\t    this._element.removeAttribute('style');\n\t    this._element.removeChild(this._triangle);\n\t  };\n\t\n\t  /**\n\t   * Open tooltip\n\t   * @param {HTMLElement} trigger element that opens the tooltip.\n\t   * @param {number} clientX the x-coordinate of trigger (mouse/touch).\n\t   */\n\t\n\t\n\t  Tooltip.prototype.open = function open(trigger, clientX) {\n\t    var _this3 = this;\n\t\n\t    if (!trigger) {\n\t      return;\n\t    }\n\t\n\t    var rect = trigger.getBoundingClientRect();\n\t    this._element.style.left = '0px';\n\t    this._element.style.top = '0px';\n\t    clientX = clientX || rect.left + rect.width / 2;\n\t    var triggerX = clientX - rect.left;\n\t    var yTop = rect.top - this._element.offsetHeight - OFFSET_TARGET_TOP;\n\t    var yBottom = rect.bottom + OFFSET_TARGET_BOTTOM + 2;\n\t    var x = rect.left + rect.width / 2 - this._element.offsetWidth / 2;\n\t    var y = yBottom;\n\t    var triangleX = 0;\n\t\n\t    this._element.classList.remove(CLASS_IS_TOP);\n\t\n\t    x = rect.left + triggerX - this._element.offsetWidth / 2;\n\t\n\t    if (x < OFFSET_VIEWPORT_X) {\n\t      x = OFFSET_VIEWPORT_X;\n\t    }\n\t\n\t    // If tooltip would be out of viewport on the right\n\t    if (x + this._element.offsetWidth > window.innerWidth - OFFSET_VIEWPORT_X) {\n\t      x = window.innerWidth - OFFSET_VIEWPORT_X - this._element.offsetWidth;\n\t    }\n\t\n\t    // If viewport height isn't large enough, place tooltip on top if possible\n\t    if (yBottom + this._element.offsetHeight > window.innerHeight - OFFSET_VIEWPORT_X) {\n\t      y = yTop;\n\t      this._element.classList.add(CLASS_IS_TOP);\n\t    }\n\t\n\t    triangleX = triggerX + rect.left - x;\n\t\n\t    this._element.classList.add(CLASS_IS_ACTIVE);\n\t    this._element.style.left = x + 'px';\n\t    this._element.style.top = y + 'px';\n\t\n\t    this._triangle.style.left = triangleX + 'px';\n\t\n\t    this._scrolled = false;\n\t    window.addEventListener('scroll', this._boundScrollWindow = function (event) {\n\t      return _this3._onScrollWindow(event);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Close tooltip.\n\t   */\n\t\n\t\n\t  Tooltip.prototype.close = function close() {\n\t    clearTimeout(this.openTimeout);\n\t    window.removeEventListener('scroll', this._boundScrollWindow);\n\t    this._element.classList.remove(CLASS_IS_ACTIVE);\n\t  };\n\t\n\t  /**\n\t   * Handle enter event.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Tooltip.prototype._onTriggerEnter = function _onTriggerEnter(event) {\n\t    var _this4 = this;\n\t\n\t    // this.open(event.target, event.clientX);\n\t    this.openPositionX = event.clientX;\n\t    this._trigger.addEventListener('mousemove', this._boundMouseMove = function (event) {\n\t      return _this4._onTriggerMove(event);\n\t    });\n\t\n\t    clearTimeout(this.openTimeout);\n\t    this.openTimeout = setTimeout(function () {\n\t      _this4._trigger.removeEventListener('mousemove', _this4._boundMouseMove);\n\t      _this4.open(event.target, _this4.openPositionX);\n\t    }, OPEN_DELAY);\n\t  };\n\t\n\t  /**\n\t   * Handle mousemove event.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Tooltip.prototype._onTriggerMove = function _onTriggerMove(event) {\n\t    this.openPositionX = event.clientX;\n\t  };\n\t\n\t  /**\n\t   * Handle leave event.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Tooltip.prototype._onTriggerLeave = function _onTriggerLeave(event) {\n\t    this.close();\n\t  };\n\t\n\t  /**\n\t   * Handle leave outside event.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Tooltip.prototype._onTriggerLeaveOutside = function _onTriggerLeaveOutside(event) {\n\t    console.log('leaveoutside', event);\n\t    if (!this._element.contains(event.target) && !this._trigger.contains(event.target)) {\n\t      console.log('-> close');\n\t      this.close();\n\t    };\n\t  };\n\t\n\t  /**\n\t   * Handle scroll event.\n\t   * @param {Event} event that fired.\n\t   */\n\t\n\t\n\t  Tooltip.prototype._onScrollWindow = function _onScrollWindow(event) {\n\t    window.removeEventListener('scroll', this._boundScrollWindow);\n\t    if (!this._scrolled) {\n\t      this.close();\n\t      this._scrolled = true;\n\t    }\n\t  };\n\t\n\t  return Tooltip;\n\t}(_component2.default);\n\t\n\texports.default = Tooltip;\n\tmodule.exports = exports['default'];\n\n/***/ }\n/******/ ])\n});\n;\n\n\n/** WEBPACK FOOTER **\n ** audi-ui.min.js\n **/"," \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\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\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.loaded = 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// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 9f4e75109a8376f38dab\n **/","// TODO Add ComponentHandler.upgradeAllRegistered components e.g. to update them when all fonts are loaded.\n// TODO Perform a `Cutting the mustard` test once. audiui-head.js\n// TODO Outsource dependencies Tether, nouislider, bezier-easing\n\n/**\n * Import all AUI components.\n */\nimport Alert from './alert/alert';\nimport Audioplayer from './audioplayer/audioplayer';\nimport Breadcrumb from './breadcrumb/breadcrumb';\nimport Checkbox from './checkbox/checkbox';\nimport Dropdown from './dropdown/dropdown';\nimport Flyout from './flyout/flyout';\nimport Header from './header/header';\nimport Modal from './modal/modal';\nimport Nav from './nav/nav';\nimport Notification from './notification/notification';\nimport Pagination from './pagination/pagination';\nimport Player from './player/player';\nimport Popover from './popover/popover';\nimport Progress from './progress/progress';\nimport Radio from './radio/radio';\nimport Response from './response/response';\nimport Select from './select/select';\nimport Slider from './slider/slider';\nimport Indicator from './indicator/indicator';\nimport Spinner from './spinner/spinner';\nimport Textfield from './textfield/textfield';\nimport Tooltip from './tooltip/tooltip';\n\n/**\n * Export all AUI components to make them accessible through npm.\n * @example\n * import {Alert} from 'audi-ui';\n * Alert.upgradeElements();\n */\nexport {\n  Alert,\n  Audioplayer,\n  Breadcrumb,\n  Checkbox,\n  Dropdown,\n  Flyout,\n  Header,\n  Modal,\n  Nav,\n  Notification,\n  Pagination,\n  Player,\n  Popover,\n  Progress,\n  Radio,\n  Response,\n  Select,\n  Slider,\n  Indicator,\n  Spinner,\n  Textfield,\n  Tooltip\n}\n\n/**\n * Export Component Handler as default to have access to all components.\n * @example\n * import auiHandler from 'audi-ui';\n * auiHandler.upgradeAllElements();\n */\nclass ComponentHandler {\n\n  constructor() {\n\n    /**\n     * Performs a \"Cutting the mustard\" test. If the browser supports the features\n     * tested, adds a aui-js class to the <html> element.\n     */\n    if ('classList' in document.createElement('div') && 'querySelector' in document && 'addEventListener' in window && Array.prototype.forEach) {\n      document.documentElement.classList.add('aui-js');\n    }\n\n    this.upgradeAllElements();\n  }\n\n  upgradeAllElements() {\n    Alert.upgradeElements();\n    Audioplayer.upgradeElements();\n    Breadcrumb.upgradeElements();\n    Checkbox.upgradeElements();\n    Dropdown.upgradeElements();\n    Flyout.upgradeElements();\n    Header.upgradeElements();\n    // Modal.upgradeElements();\n    Nav.upgradeElements();\n    Notification.upgradeElements();\n    Pagination.upgradeElements();\n    Player.upgradeElements();\n    Popover.upgradeElements();\n    // Progress.upgradeElements();\n    Radio.upgradeElements();\n    Response.upgradeElements();\n    Select.upgradeElements();\n    Slider.upgradeElements();\n    Indicator.upgradeElements();\n    // Spinner.upgradeElements();\n    Textfield.upgradeElements();\n    Tooltip.upgradeElements();\n  }\n\n}\n\nconst componentHandler = new ComponentHandler();\n\nexport default componentHandler;\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/index.js\n **/","import Component from '../component/component';\nimport ResizeObserver from '../util/resize-observer';\n\nconst SELECTOR_COMPONENT = '.aui-js-alert';\nconst CLASS_CONTENT = 'aui-alert__content';\nconst CLASS_CLOSE_BUTTON = 'aui-alert__close';\nconst CLASS_IS_CLOSED = 'is-closed';\nconst CLASS_IS_OPEN = 'is-open';\nconst ATTR_CLOSE = 'data-close';\nconst ATTR_OPENDELAY = 'data-opendelay';\n\n/**\n * Class constructor for Alert AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Alert extends Component {\n\n  /**\n   * Upgrades all Alert AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Alert(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    this._content = this._element.querySelector(`.${CLASS_CONTENT}`);\n\n    // Add close button\n    this._closeButton = document.createElement('button');\n    this._closeButton.setAttribute('type', 'button');\n    this._closeButton.classList.add(CLASS_CLOSE_BUTTON);\n    if (this._content) {\n      this._content.appendChild(this._closeButton);\n    }\n\n    if (this._element.hasAttribute(ATTR_OPENDELAY)) {\n      let delay = parseInt(this._element.getAttribute(ATTR_OPENDELAY));\n      this._element.classList.add(CLASS_IS_CLOSED);\n      this.openingTimeout = setTimeout(() => this.open(true), delay);\n    } else {\n      this.open();\n    }\n\n    this._resizeObserver = new ResizeObserver();\n    this._resizeObserver.resized.add(this._resizedHandler = () => this.update());\n\n    this.update();\n  }\n\n  /**\n   * Open an Alert\n   * @param {boolean} animate True, if the opening should be animated. Default: false\n   */\n  open(animate) {\n    animate = animate || false;\n    this._element.addEventListener('click', this._clickHandler = (event) => this._onClick(event));\n    if (animate) {\n      this._animateOpen();\n    } else {\n      this._element.classList.add(CLASS_IS_OPEN);\n      this._element.classList.remove(CLASS_IS_CLOSED);\n    }\n  }\n\n  /**\n   * Animate opening of Alert\n   */\n  _animateOpen() {\n    clearTimeout(this.openingTimeout);\n    // Loop until start height is set and correctly rendered\n    if (window.getComputedStyle(this._element).height && this._element.style.height) {\n      this._element.classList.add(CLASS_IS_OPEN);\n      this._element.classList.remove(CLASS_IS_CLOSED);\n    } else {\n      window.requestAnimationFrame(() => this._animateOpen());\n    }\n  }\n\n  /**\n   * Close this Alert\n   */\n  close() {\n    this._element.removeEventListener('click', this._clickHandler);\n    this._element.style.height = `${this._content.offsetHeight}px`;\n    this._animateClose();\n  }\n\n  /**\n   * Animate closing of Alert\n   */\n  _animateClose() {\n    clearTimeout(this.openingTimeout);\n    // Loop until start height is set and correctly rendered\n    if (window.getComputedStyle(this._element).height && this._element.style.height) {\n      this._element.classList.remove(CLASS_IS_OPEN);\n      this._element.classList.add(CLASS_IS_CLOSED);\n    } else {\n      window.requestAnimationFrame(() => this._animateClose());\n    }\n  }\n\n  /**\n   * Update Alert.\n   * Equalize element height with containing content.\n   */\n  update() {\n    this._element.style.height = `${this._content.offsetHeight}px`;\n  }\n\n  /**\n   * Handle click of element.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onClick(event) {\n    if (event.target.classList.contains(CLASS_CLOSE_BUTTON) || event.target.hasAttribute(ATTR_CLOSE)) {\n      this.close();\n    }\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n    clearTimeout(this.openingTimeout);\n    this._element.classList.remove(CLASS_IS_CLOSED);\n    this._element.classList.remove(CLASS_IS_OPEN);\n    this._element.removeEventListener('click', this._clickHandler);\n    this._element.style.height = '';\n    this.removeChild(this._closeButton);\n    this.resizeObserver.resized.remove(this._resizedHandler);\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/alert/alert.js\n **/","const CLASS_IS_UPGRADED = 'is-upgraded';\n\nconst SVG_NS = 'http://www.w3.org/2000/svg';\n\n/**\n * Class constructor for abstract AUI Component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Component {\n\n  /**\n   * Check if an element is upgraded.\n   * @param {HTMLElement} element The element to test if its already be upgraded.\n   * @returns {boolean} Returns true if element is already upgraded\n   */\n  static isElementUpgraded(element) {\n    return element.classList.contains(CLASS_IS_UPGRADED);\n  }\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   * @param {String} namespace The namespace of the AUI component, like `auiComponent`.\n   */\n  constructor(element, namespace) {\n    this._element = element;\n\n    if (this._element) {\n      if (namespace) {\n        this._element[namespace] = this;\n      }\n      this.init();\n    }\n  }\n\n  /**\n   * Initialize component\n   */\n  init() {\n    this._element.classList.add(CLASS_IS_UPGRADED);\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    this._element.classList.remove(CLASS_IS_UPGRADED);\n  }\n\n  /**\n   * Remove a child element from its parent.\n   * @param {HTMLElement} childNode The element to remove.\n   */\n  removeChild(childNode) {\n    if (childNode && childNode.parentNode) {\n      if (this.isIE()) {\n        childNode.removeNode(true);\n      } else {\n        childNode.remove();\n      }\n    }\n  }\n\n  /**\n   * Creates an HTML element and sets the given CSS classes and attributes.\n   * @param {string} tagName is a string that specifies the type of element to be created.\n   * @param {Array} classes is an array of class names to set, e.g. ['aui-class-1', 'aui-class-2'].\n   * @param {Object} attributes is an object with attributes to set, e.g. {width: 100}.\n   * @returns {HTMLElement} The created element.\n   */\n  createElement(tagName, classes, attributes) {\n    let element = document.createElement(tagName);\n    if (classes && classes.length) {\n      element.classList.add.apply(element.classList, classes);\n    }\n    for (var attr in attributes) {\n      element.setAttribute(attr, attributes[attr]);\n    }\n    return element;\n  }\n\n  /**\n   * Creates an SVG element and sets the given attributes.\n   * @param {string} qualifiedName is a string that specifies the type of element to be created.\n   * @param {Object} attributes is an object with attributes to set, e.g. {width: 100}.\n   * @returns {SVGElement} The created element.\n   */\n  createSvgNode(qualifiedName, attributes) {\n    let element = document.createElementNS(SVG_NS, qualifiedName);\n    for (var attr in attributes) {\n      element.setAttributeNS(\n        null,\n        // Replaces viewBox with view-box\n        // attr.replace(/[A-Z]/g, function(match) {\n        //   return '-' + match.toLowerCase();\n        // }),\n        attr,\n        attributes[attr]\n      );\n    }\n    return element;\n  }\n\n  /**\n   * Returns the HTMLElement of component.\n   */\n  get element() {\n    return this._element;\n  }\n\n  /**\n   * Returns boolean if browser is Internet Explorer. Other browser (also Edge) return false.\n   */\n  isIE() {\n  var ua = window.navigator.userAgent;\n    var msie = ua.indexOf('MSIE ');\n    if (msie > 0) {\n      // IE 10 or older\n      return true;\n    }\n\n    var trident = ua.indexOf('Trident/');\n    if (trident > 0) {\n      // IE 11\n      var rv = ua.indexOf('rv:');\n      return true;\n    }\n\n    var edge = ua.indexOf('Edge/');\n    if (edge > 0) {\n      // Edge (IE 12+)\n      return false;\n    }\n\n    // other browser\n    return false;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/component/component.js\n **/","import Signal from '../util/signal';\n\nlet instance = null;\n\nexport default class ResizeObserver {\n\n  constructor() {\n    if (!instance) {\n      instance = this;\n      this.init();\n    }\n\n    return instance;\n  }\n\n  init() {\n    this._ticking = false;\n\n    this.resized = new Signal();\n\n    window.addEventListener('resize', this._resizeHandler = (event) => this._onResize(event));\n  }\n\n  _onResize(event) {\n    if (!this._ticking) {\n      window.requestAnimationFrame(() => {\n        this._ticking = false;\n        this.resized.dispatch();\n      });\n    }\n    this._ticking = true;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/resize-observer.js\n **/","// TODO Fork https://github.com/thomaseckhardt/js-signals translate to ES6\n\nclass SignalBinding {\n\n  constructor(signal, listener, isOnce, priority) {\n    // Handler function bound to the signal.\n    this._listener = listener;\n\n    // If binding should be executed just once.\n    this._isOnce = isOnce;\n\n    // Reference to Signal object that listener is currently bound to.\n    this._signal = signal;\n\n    // Listener priority\n    this._priority = priority || 0;\n\n    // If binding is active and should be executed.\n    this._active = true;\n  }\n\n  _isBound() {\n    return (!!this._signal && !!this._listener);\n  }\n\n  /**\n   * Call listener passing arbitrary parameters.\n   * If binding was added using `Signal.addOnce()` it will be automatically\n   * removed from signal dispatch queue, this method is used internally for\n   * the signal dispatch.\n   * @param {Array} Array of parameters that should be passed to the listener\n   * @return {*} Value returned by the listener.\n   */\n  execute(params) {\n    let handlerReturn;\n    if (this._active && !!this._listener) {\n      handlerReturn = this._listener.apply(this._context, params);\n      if (this._isOnce) {\n        this.detach();\n      }\n    }\n    return handlerReturn;\n  }\n\n  /**\n   * Detach binding from signal.\n   * - alias to: mySignal.remove(myBinding.getListener());\n   * @return {Function|null} Handler function bound to the signal or `null` if binding was previously detached.\n   */\n  detach() {\n    return this._isBound() ? this._signal.remove(this._listener) : null;\n  }\n\n  get isOnce() {\n    return this._isOnce;\n  }\n\n  get listener() {\n    return this._listener;\n  }\n\n  get signal() {\n    return this._signal;\n  }\n\n  get priority() {\n    return this._priority;\n  }\n\n  dispose() {\n    delete this._signal;\n    delete this._listener;\n  }\n\n  toString() {\n    return '[SignalBinding isOnce:' + this._isOnce + ', isBound:' + this.isBound() + ', active:' + this._active + ']';\n  }\n}\n\n\nclass Signal {\n\n  constructor() {\n    this._bindings = [];\n    this._prevParams = null;\n    this._active = true;\n  }\n\n  /**\n   * Add a listener to the signal.\n   * @param {Function} listener Signal handler function.\n   * @param {Object} [listenerContext] Context on which listener will be executed (object that should represent the `this` variable inside listener function).\n   * @param {Number} [priority] The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added. (default = 0)\n   * @return {SignalBinding} An Object representing the binding between the Signal and listener.\n   */\n  add(listener, priority) {\n    this._validateListener(listener, 'add');\n    return this._registerListener(listener, false, priority);\n  }\n\n  addOnce(listener, priority) {\n    this._validateListener(listener, 'addOnce');\n    return this._registerListener(listener, true, priority);\n  }\n\n  remove(listener) {\n    this._validateListener(listener, 'remove');\n\n    var i = this._indexOfListener(listener);\n    if (i !== -1) {\n      this._bindings[i].dispose(); //no reason to a SignalBinding exist if it isn't attached to a signal\n      this._bindings.splice(i, 1);\n    }\n    return listener;\n  }\n\n  removeAll() {\n    let n = this._bindings.length;\n    while (n--) {\n      this._bindings[n].dispose();\n    }\n    this._bindings.length = 0;\n  }\n\n  has(listener) {\n    return this._indexOfListener(listener) !== -1;\n  }\n\n  dispatch() {\n    if (!this._active) {\n      return;\n    }\n\n    let n = this._bindings.length;\n    if (!n) {\n      return;\n    }\n\n    let params = Array.prototype.slice.call(arguments);\n    let bindings;\n\n    bindings = this._bindings.slice(); //clone array in case add/remove items during dispatch\n\n    //execute all callbacks until end of the list or until a callback returns `false` or stops propagation\n    //reverse loop since listeners with higher priority will be added at the end of the list\n    do {\n      n--;\n    } while (bindings[n] && bindings[n].execute(params) !== false);\n  }\n\n  dispose() {\n    this.removeAll();\n    delete this._bindings;\n    delete this._prevParams;\n  }\n\n  _registerListener(listener, isOnce, priority) {\n    let prevIndex = this._indexOfListener(listener);\n    let binding;\n\n    if (prevIndex !== -1) {\n      binding = this._bindings[prevIndex];\n      if (binding.isOnce() !== isOnce) {\n        throw new Error(`You cannot add${isOnce ? '' : 'Once'}() then add${!isOnce ? '' : 'Once'}() the same listener without removing the relationship first.`);\n      }\n    } else {\n      binding = new SignalBinding(this, listener, isOnce, priority);\n      this._addBinding(binding);\n    }\n\n    if (this.memorize && this._prevParams) {\n      binding.execute(this._prevParams);\n    }\n\n    return binding;\n  }\n\n  _validateListener(listener, fnName) {\n    if (typeof listener !== 'function') {\n      throw new Error(`listener is a required param of ${fnName}() and should be a Function.`);\n    }\n  }\n\n  _indexOfListener(listener) {\n    let n = this._bindings.length;\n    let current;\n    while (n--) {\n      current = this._bindings[n];\n      if (current.listener === listener) {\n        return n;\n      }\n    }\n    return -1;\n  }\n\n  _addBinding(binding) {\n    var n = this._bindings.length;\n    do {\n      --n;\n    } while (this._bindings[n] && binding.priority <= this._bindings[n].priority);\n    this._bindings.splice(n + 1, 0, binding);\n  }\n}\n\nexport default Signal;\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/signal.js\n **/","import Component from '../component/component';\nimport Popover from './../popover/popover';\n\nconst SELECTOR_COMPONENT = '.aui-audioplayer';\n\nexport default class Audioplayer extends Component {\n\n  /**\n   * Upgrades all Audioplayer components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Audioplayer(element));\n      }\n    });\n    return components;\n  };\n\n  formatCurrentTime(currentTime) {\n    return `${('0' + Math.floor(currentTime % 3600 / 60)).slice(-2)}:${('0' + Math.floor(currentTime % 3600 % 60)).slice(-2)}`;\n  }\n\n  init() {\n    super.init();\n    this.currentTrack = 0;\n    this.scrobble = false;\n    this.embed = this.element.querySelector('.aui-audioplayer__embed');\n    this.embed.preload = true;\n    this.tracks = JSON.parse(this.element.querySelector('.aui-audioplayer__tracks').value);\n    this.embed.addEventListener('ended', (event) => {\n      this.cancelProgress();\n      if (this.tracks.length > 1) {\n        this.next();\n      } else {\n        this.pause();\n        this.element.classList.add('has-ended');\n      }\n      this.updateProgress();\n    });\n    this.embed.addEventListener('canplay', (event) => {\n      this.element.querySelector('.aui-audioplayer__time').innerHTML = this.formatCurrentTime(this.embed.duration);\n    });\n    this.embed.addEventListener('timeupdate', (event) => {\n      this.element.querySelector('.aui-audioplayer__time').innerHTML = this.formatCurrentTime(this.embed.currentTime);\n    });\n    let play = this.element.querySelector('.aui-audioplayer__play');\n    if (play) {\n      play.addEventListener('click', (event) => {\n        if (this.isPlaying()) {\n          this.pause();\n        } else {\n          this.play();\n        }\n      });\n    }\n    let mute = this.element.querySelector('.aui-audioplayer__mute');\n    if (mute) {\n      mute.addEventListener('click', (event) => {\n        if (this.isMuted()) {\n          this.unmute();\n        } else {\n          this.mute();\n        }\n      });\n    }\n    let next = this.element.querySelector('.aui-audioplayer__next');\n    if (next) {\n      next.addEventListener('click', (event) => {\n        this.next();\n      });\n    }\n    let previous = this.element.querySelector('.aui-audioplayer__previous');\n    if (previous) {\n      previous.addEventListener('click', (event) => {\n        this.previous();\n      });\n    }\n    window.setTimeout(() => {\n      this.slider = this.element.querySelector('.aui-slider__target').noUiSlider;\n      this.slider.on('start', () => {\n        this.scrobble = true;\n      });\n      this.slider.on('end', () => {\n        this.scrobble = false;\n      });\n      this.slider.on('change', (value) => {\n        this.embed.currentTime = ((Math.abs(value) * this.embed.duration) / 100);\n      });\n    }, 400);\n  }\n\n  isMuted() {\n    return this.embed.muted;\n  }\n\n  isPlaying() {\n    return !this.embed.paused;\n  }\n\n  mute() {\n    this.element.classList.add('is-mute');\n    this.embed.muted = true;\n  }\n\n  next() {\n    if (this.tracks.length > 1) {\n      let restartPlayback = this.isPlaying();\n      this.pause();\n\n      if (this.currentTrack >= this.tracks.length - 1) {\n        this.currentTrack = 0;\n      } else {\n        this.currentTrack = this.currentTrack + 1;\n      }\n      this.embed.src = this.tracks[this.currentTrack].src;\n      this.embed.load();\n      this.slider.set(0);\n      this.element.querySelector('.aui-audioplayer__time').innerHTML = this.formatCurrentTime(this.embed.duration);\n      if (restartPlayback) this.play();\n\n      this.element.querySelector('.aui-audioplayer__time').innerHTML = '00:00';\n      this.element.querySelector('.aui-audioplayer__title').innerHTML = this.tracks[this.currentTrack].title;\n      let cover = this.element.querySelector('.aui-audioplayer__cover');\n      if (cover) {\n        cover.querySelector('.aui-audioplayer__cover-image').setAttribute('src', this.tracks[this.currentTrack].cover);\n      }\n    }\n  }\n\n  pause() {\n    this.cancelProgress();\n    this.element.classList.remove('is-playing');\n    this.embed.pause();\n  }\n\n  play() {\n    this.updateProgress();\n    this.element.classList.add('is-playing');\n    this.element.classList.remove('has-ended');\n    this.embed.play();\n  }\n\n  previous() {\n    if (this.tracks.length > 1) {\n      let restartPlayback = this.isPlaying();\n      this.pause();\n\n      if (this.currentTrack === 0) {\n        this.currentTrack = this.tracks.length - 1;\n      } else {\n        this.currentTrack = this.currentTrack - 1;\n      }\n      this.embed.src = this.tracks[this.currentTrack].src;\n      this.embed.load();\n      this.slider.set(0);\n      this.element.querySelector('.aui-audioplayer__time').innerHTML = this.formatCurrentTime(this.embed.duration);\n      if (restartPlayback) this.play();\n\n      this.element.querySelector('.aui-audioplayer__time').innerHTML = '00:00';\n      this.element.querySelector('.aui-audioplayer__title').innerHTML = this.tracks[this.currentTrack].title;\n      let cover = this.element.querySelector('.aui-audioplayer__cover');\n      if (cover) {\n        cover.querySelector('.aui-audioplayer__cover-image').setAttribute('src', this.tracks[this.currentTrack].cover);\n      }\n    }\n  }\n\n  unmute() {\n    this.element.classList.remove('is-mute');\n    this.embed.muted = false;\n  }\n\n  cancelProgress() {\n    if (this.tick) {\n      window.cancelAnimationFrame(this.tick);\n      this.tick = undefined;\n    }\n  }\n\n  updateProgress() {\n    this.tick = window.requestAnimationFrame(() => {\n      if(!this.scrobble) this.slider.set(Math.abs((this.embed.currentTime * 100) / this.embed.duration));\n      this.updateProgress();\n    });\n  }\n\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/audioplayer/audioplayer.js\n **/","import Component from '../component/component';\nimport reflow from '../util/reflow';\nimport closest from '../util/closest';\nimport transitionend from '../util/transition-end-event';\nimport Tether from 'tether';\n\nconst SELECTOR_COMPONENT = '.aui-js-popover';\nconst SELECTOR_DISMISS = '[data-dismiss=\"popover\"]';\nconst CLASS_ARROW = 'aui-popover__arrow';\nconst CLASS_ARROW_SHAPE = 'aui-popover__arrow-shape';\nconst CLASS_ACTIVE = 'is-active';\nconst CLASS_SHOWN = 'is-shown';\nconst CLASS_POPOVER_IS_OPEN = 'aui-popover-is-open';\nconst ARROW_SIZE = 20;\n\nconst AttachmentMap = {\n  top: 'bottom center',\n  right: 'middle left',\n  bottom: 'top center',\n  left: 'middle right'\n}\n\n/**\n * Class constructor for Popover AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Popover extends Component {\n\n  /**\n   * Upgrades all Popover AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Popover(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    this._body = document.querySelector('body');\n\n    this._id = this._element.getAttribute('id');\n    this._trigger = document.getElementById(this._element.getAttribute('for'));\n    this._tether = null;\n    const placement = this._element.hasAttribute('data-placement') ? this._element.getAttribute('data-placement') : 'top';\n    this._attachement = AttachmentMap[placement.toLowerCase()];\n\n    const content = this._element.querySelector('.aui-popover__content');\n    const arrowColor = this._element.hasAttribute('data-arrow-color') ? this._element.getAttribute('data-arrow-color') : window.getComputedStyle(content).backgroundColor;\n    this._arrow = this._addArrow(content, arrowColor);\n\n    if (this._trigger) {\n      this._trigger.addEventListener('click', this._boundClickHandler = (event) => this.toggle(event));\n    }\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n\n    this.hide();\n    this.removeChild(this._arrow);\n\n    if (this._trigger) {\n      this._trigger.removeEventListener('click', this._boundClickHandler);\n    }\n  }\n\n  /**\n   * Toggle show/hide Popover\n   * @param {Event} event Click event of trigger element (optional)\n   */\n  toggle(event) {\n    const performToggle = () => {\n      if (!this._element.classList.contains(CLASS_ACTIVE) && this._tether) {\n        this.show();\n      } else {\n        this.hide();\n      }\n    };\n\n    if (event) {\n      event.preventDefault();\n\n      if (this._tether === null) {\n        this._tether = new Tether({\n          element: this._element,\n          target: event.currentTarget,\n          attachment: this._attachement,\n          classPrefix: 'aui-tether',\n          // NOTE We set an offset in CSS, because this offset wouln't be\n          // flipped as it should:\n          // https://github.com/HubSpot/tether/issues/106\n          offset: '0 0',\n          constraints: [{\n            to: 'window',\n            pin: ['left', 'right'],\n            attachment: 'together'\n          }],\n          optimizations: {\n            gpu: false\n          }\n        });\n        reflow(this._element); // REVIEW Do we need this anymore?\n        this._tether.position();\n      }\n      performToggle();\n\n    } else {\n      performToggle();\n    }\n  }\n\n  /**\n   * Show Popover\n   */\n  show() {\n    this._body.classList.add(CLASS_POPOVER_IS_OPEN);\n    this._element.classList.add(CLASS_ACTIVE);\n    this._element.classList.add(CLASS_SHOWN);\n    setTimeout(() => {\n      window.addEventListener('click', this._boundWindowClickHandler = (event) => this._onClickOutside(event));\n    })\n  }\n\n  /**\n   * Hide Popover\n   */\n  hide() {\n    this._element.classList.remove(CLASS_SHOWN);\n    this._element.addEventListener(transitionend, this._boundAnimationendHandler = (event) => this._onHideComplete(event));\n    window.removeEventListener('click', this._boundWindowClickHandler);\n  }\n\n  /**\n   * Clean up Tether instance\n   * @private\n   */\n  _cleanupTether() {\n    if (this._tether) {\n      this._tether.destroy();\n      this._tether = null;\n    }\n    this._element.removeAttribute('style');\n  }\n\n  /**\n   * Handle click of window.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onClickOutside(event) {\n    // Hide if target dismisses Popover\n    if (closest(event.target, SELECTOR_DISMISS, this._element)) {\n      this.hide();\n\n      // Hide if target is not inside Popover and is not a trigger element\n    } else if (!this._element.contains(event.target) && event.target !== this._trigger) {\n      this.hide();\n    }\n  }\n\n  /**\n   * Handle hide transition complete.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onHideComplete(event) {\n    this._body.classList.remove(CLASS_POPOVER_IS_OPEN);\n    this._element.classList.remove(CLASS_ACTIVE);\n    this._element.removeEventListener(transitionend, this._boundAnimationendHandler);\n    this._cleanupTether();\n  }\n\n  /**\n   * Adds an arrow SVG element\n   * <span class=\"…\"><svg … ><path … /></svg></span>\n   *\n   * @param {HTMLElement} parent element to append arrow to.\n   * @param {string} color used as value of fill property.\n   * @returns {HTMLElement} the added arrow element.\n   */\n  _addArrow(parent, color) {\n    const element = document.createElement('span');\n    element.classList.add(CLASS_ARROW);\n    const svg = this.createSvgNode('svg', {\n      class: CLASS_ARROW_SHAPE,\n      width: ARROW_SIZE,\n      height: ARROW_SIZE,\n      viewBox: `0 0 ${ARROW_SIZE} ${ARROW_SIZE}`\n    });\n    // Draw a diamond square ◆\n    const path = this.createSvgNode('path', {\n      d: `M${ARROW_SIZE / 2} 0 L ${ARROW_SIZE} ${ARROW_SIZE / 2} L ${ARROW_SIZE / 2} ${ARROW_SIZE} L 0 ${ARROW_SIZE / 2} Z`,\n      fill: color\n    });\n    svg.appendChild(path);\n    element.appendChild(svg);\n    parent.appendChild(element);\n    return element;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/popover/popover.js\n **/","/**\n * Trigger a reflow\n * @param {HTMLElement} element to trigger a reflow.\n */\nexport default function reflow(element) {\n  new Function('bs', 'return bs')(element.offsetHeight);\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/reflow.js\n **/","/**\n * Get the first element that matches the selector by testing the element itself\n * and traversing up through its ancestors in the DOM tree.\n * @param {HTMLElement} element to search wherefrom\n * @param {string} selector A string containing a selector expression to match elements against.\n * @param {HTMLElement} context A DOM element within which a matching element may be found.\n * @returns {HTMLElement} found element or null\n */\nexport default function closest(element, selector, context) {\n  let matchesFn;\n\n  ['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'].some(function(fn) {\n    if (typeof document.body[fn] === 'function') {\n      matchesFn = fn;\n      return true;\n    }\n    return false;\n  });\n\n  let parent;\n\n  // traverse parents\n  parent = element;\n  while (parent) {\n    if (parent && parent[matchesFn](selector)) {\n      return parent;\n    }\n    if (parent === context) {\n      return null;\n    }\n    parent = parent.parentElement;\n  }\n\n  return null;\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/closest.js\n **/","// From Modernizr\nfunction whichTransitionEvent() {\n  var t;\n  var el = document.createElement('fakeelement');\n  var transitions = {\n    'transition': 'transitionend',\n    'OTransition': 'oTransitionEnd',\n    'MozTransition': 'transitionend',\n    'WebkitTransition': 'webkitTransitionEnd'\n  }\n\n  for (t in transitions) {\n    if (el.style[t] !== undefined) {\n      return transitions[t];\n    }\n  }\n}\n\nconst TRANSITION_EVENT = whichTransitionEvent();\n\nexport default TRANSITION_EVENT;\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/transition-end-event.js\n **/","/*! tether 1.4.4 */\n\n(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define([], factory);\n  } else if (typeof exports === 'object') {\n    module.exports = factory();\n  } else {\n    root.Tether = factory();\n  }\n}(this, function() {\n\n'use strict';\n\nvar _createClass = (function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar TetherBase = undefined;\nif (typeof TetherBase === 'undefined') {\n  TetherBase = { modules: [] };\n}\n\nvar zeroElement = null;\n\n// Same as native getBoundingClientRect, except it takes into account parent <frame> offsets\n// if the element lies within a nested document (<frame> or <iframe>-like).\nfunction getActualBoundingClientRect(node) {\n  var boundingRect = node.getBoundingClientRect();\n\n  // The original object returned by getBoundingClientRect is immutable, so we clone it\n  // We can't use extend because the properties are not considered part of the object by hasOwnProperty in IE9\n  var rect = {};\n  for (var k in boundingRect) {\n    rect[k] = boundingRect[k];\n  }\n\n  if (node.ownerDocument !== document) {\n    var _frameElement = node.ownerDocument.defaultView.frameElement;\n    if (_frameElement) {\n      var frameRect = getActualBoundingClientRect(_frameElement);\n      rect.top += frameRect.top;\n      rect.bottom += frameRect.top;\n      rect.left += frameRect.left;\n      rect.right += frameRect.left;\n    }\n  }\n\n  return rect;\n}\n\nfunction getScrollParents(el) {\n  // In firefox if the el is inside an iframe with display: none; window.getComputedStyle() will return null;\n  // https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n  var computedStyle = getComputedStyle(el) || {};\n  var position = computedStyle.position;\n  var parents = [];\n\n  if (position === 'fixed') {\n    return [el];\n  }\n\n  var parent = el;\n  while ((parent = parent.parentNode) && parent && parent.nodeType === 1) {\n    var style = undefined;\n    try {\n      style = getComputedStyle(parent);\n    } catch (err) {}\n\n    if (typeof style === 'undefined' || style === null) {\n      parents.push(parent);\n      return parents;\n    }\n\n    var _style = style;\n    var overflow = _style.overflow;\n    var overflowX = _style.overflowX;\n    var overflowY = _style.overflowY;\n\n    if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {\n      if (position !== 'absolute' || ['relative', 'absolute', 'fixed'].indexOf(style.position) >= 0) {\n        parents.push(parent);\n      }\n    }\n  }\n\n  parents.push(el.ownerDocument.body);\n\n  // If the node is within a frame, account for the parent window scroll\n  if (el.ownerDocument !== document) {\n    parents.push(el.ownerDocument.defaultView);\n  }\n\n  return parents;\n}\n\nvar uniqueId = (function () {\n  var id = 0;\n  return function () {\n    return ++id;\n  };\n})();\n\nvar zeroPosCache = {};\nvar getOrigin = function getOrigin() {\n  // getBoundingClientRect is unfortunately too accurate.  It introduces a pixel or two of\n  // jitter as the user scrolls that messes with our ability to detect if two positions\n  // are equivilant or not.  We place an element at the top left of the page that will\n  // get the same jitter, so we can cancel the two out.\n  var node = zeroElement;\n  if (!node || !document.body.contains(node)) {\n    node = document.createElement('div');\n    node.setAttribute('data-tether-id', uniqueId());\n    extend(node.style, {\n      top: 0,\n      left: 0,\n      position: 'absolute'\n    });\n\n    document.body.appendChild(node);\n\n    zeroElement = node;\n  }\n\n  var id = node.getAttribute('data-tether-id');\n  if (typeof zeroPosCache[id] === 'undefined') {\n    zeroPosCache[id] = getActualBoundingClientRect(node);\n\n    // Clear the cache when this position call is done\n    defer(function () {\n      delete zeroPosCache[id];\n    });\n  }\n\n  return zeroPosCache[id];\n};\n\nfunction removeUtilElements() {\n  if (zeroElement) {\n    document.body.removeChild(zeroElement);\n  }\n  zeroElement = null;\n};\n\nfunction getBounds(el) {\n  var doc = undefined;\n  if (el === document) {\n    doc = document;\n    el = document.documentElement;\n  } else {\n    doc = el.ownerDocument;\n  }\n\n  var docEl = doc.documentElement;\n\n  var box = getActualBoundingClientRect(el);\n\n  var origin = getOrigin();\n\n  box.top -= origin.top;\n  box.left -= origin.left;\n\n  if (typeof box.width === 'undefined') {\n    box.width = document.body.scrollWidth - box.left - box.right;\n  }\n  if (typeof box.height === 'undefined') {\n    box.height = document.body.scrollHeight - box.top - box.bottom;\n  }\n\n  box.top = box.top - docEl.clientTop;\n  box.left = box.left - docEl.clientLeft;\n  box.right = doc.body.clientWidth - box.width - box.left;\n  box.bottom = doc.body.clientHeight - box.height - box.top;\n\n  return box;\n}\n\nfunction getOffsetParent(el) {\n  return el.offsetParent || document.documentElement;\n}\n\nvar _scrollBarSize = null;\nfunction getScrollBarSize() {\n  if (_scrollBarSize) {\n    return _scrollBarSize;\n  }\n  var inner = document.createElement('div');\n  inner.style.width = '100%';\n  inner.style.height = '200px';\n\n  var outer = document.createElement('div');\n  extend(outer.style, {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    pointerEvents: 'none',\n    visibility: 'hidden',\n    width: '200px',\n    height: '150px',\n    overflow: 'hidden'\n  });\n\n  outer.appendChild(inner);\n\n  document.body.appendChild(outer);\n\n  var widthContained = inner.offsetWidth;\n  outer.style.overflow = 'scroll';\n  var widthScroll = inner.offsetWidth;\n\n  if (widthContained === widthScroll) {\n    widthScroll = outer.clientWidth;\n  }\n\n  document.body.removeChild(outer);\n\n  var width = widthContained - widthScroll;\n\n  _scrollBarSize = { width: width, height: width };\n  return _scrollBarSize;\n}\n\nfunction extend() {\n  var out = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n  var args = [];\n\n  Array.prototype.push.apply(args, arguments);\n\n  args.slice(1).forEach(function (obj) {\n    if (obj) {\n      for (var key in obj) {\n        if (({}).hasOwnProperty.call(obj, key)) {\n          out[key] = obj[key];\n        }\n      }\n    }\n  });\n\n  return out;\n}\n\nfunction removeClass(el, name) {\n  if (typeof el.classList !== 'undefined') {\n    name.split(' ').forEach(function (cls) {\n      if (cls.trim()) {\n        el.classList.remove(cls);\n      }\n    });\n  } else {\n    var regex = new RegExp('(^| )' + name.split(' ').join('|') + '( |$)', 'gi');\n    var className = getClassName(el).replace(regex, ' ');\n    setClassName(el, className);\n  }\n}\n\nfunction addClass(el, name) {\n  if (typeof el.classList !== 'undefined') {\n    name.split(' ').forEach(function (cls) {\n      if (cls.trim()) {\n        el.classList.add(cls);\n      }\n    });\n  } else {\n    removeClass(el, name);\n    var cls = getClassName(el) + (' ' + name);\n    setClassName(el, cls);\n  }\n}\n\nfunction hasClass(el, name) {\n  if (typeof el.classList !== 'undefined') {\n    return el.classList.contains(name);\n  }\n  var className = getClassName(el);\n  return new RegExp('(^| )' + name + '( |$)', 'gi').test(className);\n}\n\nfunction getClassName(el) {\n  // Can't use just SVGAnimatedString here since nodes within a Frame in IE have\n  // completely separately SVGAnimatedString base classes\n  if (el.className instanceof el.ownerDocument.defaultView.SVGAnimatedString) {\n    return el.className.baseVal;\n  }\n  return el.className;\n}\n\nfunction setClassName(el, className) {\n  el.setAttribute('class', className);\n}\n\nfunction updateClasses(el, add, all) {\n  // Of the set of 'all' classes, we need the 'add' classes, and only the\n  // 'add' classes to be set.\n  all.forEach(function (cls) {\n    if (add.indexOf(cls) === -1 && hasClass(el, cls)) {\n      removeClass(el, cls);\n    }\n  });\n\n  add.forEach(function (cls) {\n    if (!hasClass(el, cls)) {\n      addClass(el, cls);\n    }\n  });\n}\n\nvar deferred = [];\n\nvar defer = function defer(fn) {\n  deferred.push(fn);\n};\n\nvar flush = function flush() {\n  var fn = undefined;\n  while (fn = deferred.pop()) {\n    fn();\n  }\n};\n\nvar Evented = (function () {\n  function Evented() {\n    _classCallCheck(this, Evented);\n  }\n\n  _createClass(Evented, [{\n    key: 'on',\n    value: function on(event, handler, ctx) {\n      var once = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];\n\n      if (typeof this.bindings === 'undefined') {\n        this.bindings = {};\n      }\n      if (typeof this.bindings[event] === 'undefined') {\n        this.bindings[event] = [];\n      }\n      this.bindings[event].push({ handler: handler, ctx: ctx, once: once });\n    }\n  }, {\n    key: 'once',\n    value: function once(event, handler, ctx) {\n      this.on(event, handler, ctx, true);\n    }\n  }, {\n    key: 'off',\n    value: function off(event, handler) {\n      if (typeof this.bindings === 'undefined' || typeof this.bindings[event] === 'undefined') {\n        return;\n      }\n\n      if (typeof handler === 'undefined') {\n        delete this.bindings[event];\n      } else {\n        var i = 0;\n        while (i < this.bindings[event].length) {\n          if (this.bindings[event][i].handler === handler) {\n            this.bindings[event].splice(i, 1);\n          } else {\n            ++i;\n          }\n        }\n      }\n    }\n  }, {\n    key: 'trigger',\n    value: function trigger(event) {\n      if (typeof this.bindings !== 'undefined' && this.bindings[event]) {\n        var i = 0;\n\n        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n          args[_key - 1] = arguments[_key];\n        }\n\n        while (i < this.bindings[event].length) {\n          var _bindings$event$i = this.bindings[event][i];\n          var handler = _bindings$event$i.handler;\n          var ctx = _bindings$event$i.ctx;\n          var once = _bindings$event$i.once;\n\n          var context = ctx;\n          if (typeof context === 'undefined') {\n            context = this;\n          }\n\n          handler.apply(context, args);\n\n          if (once) {\n            this.bindings[event].splice(i, 1);\n          } else {\n            ++i;\n          }\n        }\n      }\n    }\n  }]);\n\n  return Evented;\n})();\n\nTetherBase.Utils = {\n  getActualBoundingClientRect: getActualBoundingClientRect,\n  getScrollParents: getScrollParents,\n  getBounds: getBounds,\n  getOffsetParent: getOffsetParent,\n  extend: extend,\n  addClass: addClass,\n  removeClass: removeClass,\n  hasClass: hasClass,\n  updateClasses: updateClasses,\n  defer: defer,\n  flush: flush,\n  uniqueId: uniqueId,\n  Evented: Evented,\n  getScrollBarSize: getScrollBarSize,\n  removeUtilElements: removeUtilElements\n};\n/* globals TetherBase, performance */\n\n'use strict';\n\nvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\nvar _createClass = (function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nvar _get = function get(_x6, _x7, _x8) { var _again = true; _function: while (_again) { var object = _x6, property = _x7, receiver = _x8; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x6 = parent; _x7 = property; _x8 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nif (typeof TetherBase === 'undefined') {\n  throw new Error('You must include the utils.js file before tether.js');\n}\n\nvar _TetherBase$Utils = TetherBase.Utils;\nvar getScrollParents = _TetherBase$Utils.getScrollParents;\nvar getBounds = _TetherBase$Utils.getBounds;\nvar getOffsetParent = _TetherBase$Utils.getOffsetParent;\nvar extend = _TetherBase$Utils.extend;\nvar addClass = _TetherBase$Utils.addClass;\nvar removeClass = _TetherBase$Utils.removeClass;\nvar updateClasses = _TetherBase$Utils.updateClasses;\nvar defer = _TetherBase$Utils.defer;\nvar flush = _TetherBase$Utils.flush;\nvar getScrollBarSize = _TetherBase$Utils.getScrollBarSize;\nvar removeUtilElements = _TetherBase$Utils.removeUtilElements;\n\nfunction within(a, b) {\n  var diff = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];\n\n  return a + diff >= b && b >= a - diff;\n}\n\nvar transformKey = (function () {\n  if (typeof document === 'undefined') {\n    return '';\n  }\n  var el = document.createElement('div');\n\n  var transforms = ['transform', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform'];\n  for (var i = 0; i < transforms.length; ++i) {\n    var key = transforms[i];\n    if (el.style[key] !== undefined) {\n      return key;\n    }\n  }\n})();\n\nvar tethers = [];\n\nvar position = function position() {\n  tethers.forEach(function (tether) {\n    tether.position(false);\n  });\n  flush();\n};\n\nfunction now() {\n  if (typeof performance === 'object' && typeof performance.now === 'function') {\n    return performance.now();\n  }\n  return +new Date();\n}\n\n(function () {\n  var lastCall = null;\n  var lastDuration = null;\n  var pendingTimeout = null;\n\n  var tick = function tick() {\n    if (typeof lastDuration !== 'undefined' && lastDuration > 16) {\n      // We voluntarily throttle ourselves if we can't manage 60fps\n      lastDuration = Math.min(lastDuration - 16, 250);\n\n      // Just in case this is the last event, remember to position just once more\n      pendingTimeout = setTimeout(tick, 250);\n      return;\n    }\n\n    if (typeof lastCall !== 'undefined' && now() - lastCall < 10) {\n      // Some browsers call events a little too frequently, refuse to run more than is reasonable\n      return;\n    }\n\n    if (pendingTimeout != null) {\n      clearTimeout(pendingTimeout);\n      pendingTimeout = null;\n    }\n\n    lastCall = now();\n    position();\n    lastDuration = now() - lastCall;\n  };\n\n  if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {\n    ['resize', 'scroll', 'touchmove'].forEach(function (event) {\n      window.addEventListener(event, tick);\n    });\n  }\n})();\n\nvar MIRROR_LR = {\n  center: 'center',\n  left: 'right',\n  right: 'left'\n};\n\nvar MIRROR_TB = {\n  middle: 'middle',\n  top: 'bottom',\n  bottom: 'top'\n};\n\nvar OFFSET_MAP = {\n  top: 0,\n  left: 0,\n  middle: '50%',\n  center: '50%',\n  bottom: '100%',\n  right: '100%'\n};\n\nvar autoToFixedAttachment = function autoToFixedAttachment(attachment, relativeToAttachment) {\n  var left = attachment.left;\n  var top = attachment.top;\n\n  if (left === 'auto') {\n    left = MIRROR_LR[relativeToAttachment.left];\n  }\n\n  if (top === 'auto') {\n    top = MIRROR_TB[relativeToAttachment.top];\n  }\n\n  return { left: left, top: top };\n};\n\nvar attachmentToOffset = function attachmentToOffset(attachment) {\n  var left = attachment.left;\n  var top = attachment.top;\n\n  if (typeof OFFSET_MAP[attachment.left] !== 'undefined') {\n    left = OFFSET_MAP[attachment.left];\n  }\n\n  if (typeof OFFSET_MAP[attachment.top] !== 'undefined') {\n    top = OFFSET_MAP[attachment.top];\n  }\n\n  return { left: left, top: top };\n};\n\nfunction addOffset() {\n  var out = { top: 0, left: 0 };\n\n  for (var _len = arguments.length, offsets = Array(_len), _key = 0; _key < _len; _key++) {\n    offsets[_key] = arguments[_key];\n  }\n\n  offsets.forEach(function (_ref) {\n    var top = _ref.top;\n    var left = _ref.left;\n\n    if (typeof top === 'string') {\n      top = parseFloat(top, 10);\n    }\n    if (typeof left === 'string') {\n      left = parseFloat(left, 10);\n    }\n\n    out.top += top;\n    out.left += left;\n  });\n\n  return out;\n}\n\nfunction offsetToPx(offset, size) {\n  if (typeof offset.left === 'string' && offset.left.indexOf('%') !== -1) {\n    offset.left = parseFloat(offset.left, 10) / 100 * size.width;\n  }\n  if (typeof offset.top === 'string' && offset.top.indexOf('%') !== -1) {\n    offset.top = parseFloat(offset.top, 10) / 100 * size.height;\n  }\n\n  return offset;\n}\n\nvar parseOffset = function parseOffset(value) {\n  var _value$split = value.split(' ');\n\n  var _value$split2 = _slicedToArray(_value$split, 2);\n\n  var top = _value$split2[0];\n  var left = _value$split2[1];\n\n  return { top: top, left: left };\n};\nvar parseAttachment = parseOffset;\n\nvar TetherClass = (function (_Evented) {\n  _inherits(TetherClass, _Evented);\n\n  function TetherClass(options) {\n    var _this = this;\n\n    _classCallCheck(this, TetherClass);\n\n    _get(Object.getPrototypeOf(TetherClass.prototype), 'constructor', this).call(this);\n    this.position = this.position.bind(this);\n\n    tethers.push(this);\n\n    this.history = [];\n\n    this.setOptions(options, false);\n\n    TetherBase.modules.forEach(function (module) {\n      if (typeof module.initialize !== 'undefined') {\n        module.initialize.call(_this);\n      }\n    });\n\n    this.position();\n  }\n\n  _createClass(TetherClass, [{\n    key: 'getClass',\n    value: function getClass() {\n      var key = arguments.length <= 0 || arguments[0] === undefined ? '' : arguments[0];\n      var classes = this.options.classes;\n\n      if (typeof classes !== 'undefined' && classes[key]) {\n        return this.options.classes[key];\n      } else if (this.options.classPrefix) {\n        return this.options.classPrefix + '-' + key;\n      } else {\n        return key;\n      }\n    }\n  }, {\n    key: 'setOptions',\n    value: function setOptions(options) {\n      var _this2 = this;\n\n      var pos = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];\n\n      var defaults = {\n        offset: '0 0',\n        targetOffset: '0 0',\n        targetAttachment: 'auto auto',\n        classPrefix: 'tether'\n      };\n\n      this.options = extend(defaults, options);\n\n      var _options = this.options;\n      var element = _options.element;\n      var target = _options.target;\n      var targetModifier = _options.targetModifier;\n\n      this.element = element;\n      this.target = target;\n      this.targetModifier = targetModifier;\n\n      if (this.target === 'viewport') {\n        this.target = document.body;\n        this.targetModifier = 'visible';\n      } else if (this.target === 'scroll-handle') {\n        this.target = document.body;\n        this.targetModifier = 'scroll-handle';\n      }\n\n      ['element', 'target'].forEach(function (key) {\n        if (typeof _this2[key] === 'undefined') {\n          throw new Error('Tether Error: Both element and target must be defined');\n        }\n\n        if (typeof _this2[key].jquery !== 'undefined') {\n          _this2[key] = _this2[key][0];\n        } else if (typeof _this2[key] === 'string') {\n          _this2[key] = document.querySelector(_this2[key]);\n        }\n      });\n\n      addClass(this.element, this.getClass('element'));\n      if (!(this.options.addTargetClasses === false)) {\n        addClass(this.target, this.getClass('target'));\n      }\n\n      if (!this.options.attachment) {\n        throw new Error('Tether Error: You must provide an attachment');\n      }\n\n      this.targetAttachment = parseAttachment(this.options.targetAttachment);\n      this.attachment = parseAttachment(this.options.attachment);\n      this.offset = parseOffset(this.options.offset);\n      this.targetOffset = parseOffset(this.options.targetOffset);\n\n      if (typeof this.scrollParents !== 'undefined') {\n        this.disable();\n      }\n\n      if (this.targetModifier === 'scroll-handle') {\n        this.scrollParents = [this.target];\n      } else {\n        this.scrollParents = getScrollParents(this.target);\n      }\n\n      if (!(this.options.enabled === false)) {\n        this.enable(pos);\n      }\n    }\n  }, {\n    key: 'getTargetBounds',\n    value: function getTargetBounds() {\n      if (typeof this.targetModifier !== 'undefined') {\n        if (this.targetModifier === 'visible') {\n          if (this.target === document.body) {\n            return { top: pageYOffset, left: pageXOffset, height: innerHeight, width: innerWidth };\n          } else {\n            var bounds = getBounds(this.target);\n\n            var out = {\n              height: bounds.height,\n              width: bounds.width,\n              top: bounds.top,\n              left: bounds.left\n            };\n\n            out.height = Math.min(out.height, bounds.height - (pageYOffset - bounds.top));\n            out.height = Math.min(out.height, bounds.height - (bounds.top + bounds.height - (pageYOffset + innerHeight)));\n            out.height = Math.min(innerHeight, out.height);\n            out.height -= 2;\n\n            out.width = Math.min(out.width, bounds.width - (pageXOffset - bounds.left));\n            out.width = Math.min(out.width, bounds.width - (bounds.left + bounds.width - (pageXOffset + innerWidth)));\n            out.width = Math.min(innerWidth, out.width);\n            out.width -= 2;\n\n            if (out.top < pageYOffset) {\n              out.top = pageYOffset;\n            }\n            if (out.left < pageXOffset) {\n              out.left = pageXOffset;\n            }\n\n            return out;\n          }\n        } else if (this.targetModifier === 'scroll-handle') {\n          var bounds = undefined;\n          var target = this.target;\n          if (target === document.body) {\n            target = document.documentElement;\n\n            bounds = {\n              left: pageXOffset,\n              top: pageYOffset,\n              height: innerHeight,\n              width: innerWidth\n            };\n          } else {\n            bounds = getBounds(target);\n          }\n\n          var style = getComputedStyle(target);\n\n          var hasBottomScroll = target.scrollWidth > target.clientWidth || [style.overflow, style.overflowX].indexOf('scroll') >= 0 || this.target !== document.body;\n\n          var scrollBottom = 0;\n          if (hasBottomScroll) {\n            scrollBottom = 15;\n          }\n\n          var height = bounds.height - parseFloat(style.borderTopWidth) - parseFloat(style.borderBottomWidth) - scrollBottom;\n\n          var out = {\n            width: 15,\n            height: height * 0.975 * (height / target.scrollHeight),\n            left: bounds.left + bounds.width - parseFloat(style.borderLeftWidth) - 15\n          };\n\n          var fitAdj = 0;\n          if (height < 408 && this.target === document.body) {\n            fitAdj = -0.00011 * Math.pow(height, 2) - 0.00727 * height + 22.58;\n          }\n\n          if (this.target !== document.body) {\n            out.height = Math.max(out.height, 24);\n          }\n\n          var scrollPercentage = this.target.scrollTop / (target.scrollHeight - height);\n          out.top = scrollPercentage * (height - out.height - fitAdj) + bounds.top + parseFloat(style.borderTopWidth);\n\n          if (this.target === document.body) {\n            out.height = Math.max(out.height, 24);\n          }\n\n          return out;\n        }\n      } else {\n        return getBounds(this.target);\n      }\n    }\n  }, {\n    key: 'clearCache',\n    value: function clearCache() {\n      this._cache = {};\n    }\n  }, {\n    key: 'cache',\n    value: function cache(k, getter) {\n      // More than one module will often need the same DOM info, so\n      // we keep a cache which is cleared on each position call\n      if (typeof this._cache === 'undefined') {\n        this._cache = {};\n      }\n\n      if (typeof this._cache[k] === 'undefined') {\n        this._cache[k] = getter.call(this);\n      }\n\n      return this._cache[k];\n    }\n  }, {\n    key: 'enable',\n    value: function enable() {\n      var _this3 = this;\n\n      var pos = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];\n\n      if (!(this.options.addTargetClasses === false)) {\n        addClass(this.target, this.getClass('enabled'));\n      }\n      addClass(this.element, this.getClass('enabled'));\n      this.enabled = true;\n\n      this.scrollParents.forEach(function (parent) {\n        if (parent !== _this3.target.ownerDocument) {\n          parent.addEventListener('scroll', _this3.position);\n        }\n      });\n\n      if (pos) {\n        this.position();\n      }\n    }\n  }, {\n    key: 'disable',\n    value: function disable() {\n      var _this4 = this;\n\n      removeClass(this.target, this.getClass('enabled'));\n      removeClass(this.element, this.getClass('enabled'));\n      this.enabled = false;\n\n      if (typeof this.scrollParents !== 'undefined') {\n        this.scrollParents.forEach(function (parent) {\n          parent.removeEventListener('scroll', _this4.position);\n        });\n      }\n    }\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      var _this5 = this;\n\n      this.disable();\n\n      tethers.forEach(function (tether, i) {\n        if (tether === _this5) {\n          tethers.splice(i, 1);\n        }\n      });\n\n      // Remove any elements we were using for convenience from the DOM\n      if (tethers.length === 0) {\n        removeUtilElements();\n      }\n    }\n  }, {\n    key: 'updateAttachClasses',\n    value: function updateAttachClasses(elementAttach, targetAttach) {\n      var _this6 = this;\n\n      elementAttach = elementAttach || this.attachment;\n      targetAttach = targetAttach || this.targetAttachment;\n      var sides = ['left', 'top', 'bottom', 'right', 'middle', 'center'];\n\n      if (typeof this._addAttachClasses !== 'undefined' && this._addAttachClasses.length) {\n        // updateAttachClasses can be called more than once in a position call, so\n        // we need to clean up after ourselves such that when the last defer gets\n        // ran it doesn't add any extra classes from previous calls.\n        this._addAttachClasses.splice(0, this._addAttachClasses.length);\n      }\n\n      if (typeof this._addAttachClasses === 'undefined') {\n        this._addAttachClasses = [];\n      }\n      var add = this._addAttachClasses;\n\n      if (elementAttach.top) {\n        add.push(this.getClass('element-attached') + '-' + elementAttach.top);\n      }\n      if (elementAttach.left) {\n        add.push(this.getClass('element-attached') + '-' + elementAttach.left);\n      }\n      if (targetAttach.top) {\n        add.push(this.getClass('target-attached') + '-' + targetAttach.top);\n      }\n      if (targetAttach.left) {\n        add.push(this.getClass('target-attached') + '-' + targetAttach.left);\n      }\n\n      var all = [];\n      sides.forEach(function (side) {\n        all.push(_this6.getClass('element-attached') + '-' + side);\n        all.push(_this6.getClass('target-attached') + '-' + side);\n      });\n\n      defer(function () {\n        if (!(typeof _this6._addAttachClasses !== 'undefined')) {\n          return;\n        }\n\n        updateClasses(_this6.element, _this6._addAttachClasses, all);\n        if (!(_this6.options.addTargetClasses === false)) {\n          updateClasses(_this6.target, _this6._addAttachClasses, all);\n        }\n\n        delete _this6._addAttachClasses;\n      });\n    }\n  }, {\n    key: 'position',\n    value: function position() {\n      var _this7 = this;\n\n      var flushChanges = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];\n\n      // flushChanges commits the changes immediately, leave true unless you are positioning multiple\n      // tethers (in which case call Tether.Utils.flush yourself when you're done)\n\n      if (!this.enabled) {\n        return;\n      }\n\n      this.clearCache();\n\n      // Turn 'auto' attachments into the appropriate corner or edge\n      var targetAttachment = autoToFixedAttachment(this.targetAttachment, this.attachment);\n\n      this.updateAttachClasses(this.attachment, targetAttachment);\n\n      var elementPos = this.cache('element-bounds', function () {\n        return getBounds(_this7.element);\n      });\n\n      var width = elementPos.width;\n      var height = elementPos.height;\n\n      if (width === 0 && height === 0 && typeof this.lastSize !== 'undefined') {\n        var _lastSize = this.lastSize;\n\n        // We cache the height and width to make it possible to position elements that are\n        // getting hidden.\n        width = _lastSize.width;\n        height = _lastSize.height;\n      } else {\n        this.lastSize = { width: width, height: height };\n      }\n\n      var targetPos = this.cache('target-bounds', function () {\n        return _this7.getTargetBounds();\n      });\n      var targetSize = targetPos;\n\n      // Get an actual px offset from the attachment\n      var offset = offsetToPx(attachmentToOffset(this.attachment), { width: width, height: height });\n      var targetOffset = offsetToPx(attachmentToOffset(targetAttachment), targetSize);\n\n      var manualOffset = offsetToPx(this.offset, { width: width, height: height });\n      var manualTargetOffset = offsetToPx(this.targetOffset, targetSize);\n\n      // Add the manually provided offset\n      offset = addOffset(offset, manualOffset);\n      targetOffset = addOffset(targetOffset, manualTargetOffset);\n\n      // It's now our goal to make (element position + offset) == (target position + target offset)\n      var left = targetPos.left + targetOffset.left - offset.left;\n      var top = targetPos.top + targetOffset.top - offset.top;\n\n      for (var i = 0; i < TetherBase.modules.length; ++i) {\n        var _module2 = TetherBase.modules[i];\n        var ret = _module2.position.call(this, {\n          left: left,\n          top: top,\n          targetAttachment: targetAttachment,\n          targetPos: targetPos,\n          elementPos: elementPos,\n          offset: offset,\n          targetOffset: targetOffset,\n          manualOffset: manualOffset,\n          manualTargetOffset: manualTargetOffset,\n          scrollbarSize: scrollbarSize,\n          attachment: this.attachment\n        });\n\n        if (ret === false) {\n          return false;\n        } else if (typeof ret === 'undefined' || typeof ret !== 'object') {\n          continue;\n        } else {\n          top = ret.top;\n          left = ret.left;\n        }\n      }\n\n      // We describe the position three different ways to give the optimizer\n      // a chance to decide the best possible way to position the element\n      // with the fewest repaints.\n      var next = {\n        // It's position relative to the page (absolute positioning when\n        // the element is a child of the body)\n        page: {\n          top: top,\n          left: left\n        },\n\n        // It's position relative to the viewport (fixed positioning)\n        viewport: {\n          top: top - pageYOffset,\n          bottom: pageYOffset - top - height + innerHeight,\n          left: left - pageXOffset,\n          right: pageXOffset - left - width + innerWidth\n        }\n      };\n\n      var doc = this.target.ownerDocument;\n      var win = doc.defaultView;\n\n      var scrollbarSize = undefined;\n      if (win.innerHeight > doc.documentElement.clientHeight) {\n        scrollbarSize = this.cache('scrollbar-size', getScrollBarSize);\n        next.viewport.bottom -= scrollbarSize.height;\n      }\n\n      if (win.innerWidth > doc.documentElement.clientWidth) {\n        scrollbarSize = this.cache('scrollbar-size', getScrollBarSize);\n        next.viewport.right -= scrollbarSize.width;\n      }\n\n      if (['', 'static'].indexOf(doc.body.style.position) === -1 || ['', 'static'].indexOf(doc.body.parentElement.style.position) === -1) {\n        // Absolute positioning in the body will be relative to the page, not the 'initial containing block'\n        next.page.bottom = doc.body.scrollHeight - top - height;\n        next.page.right = doc.body.scrollWidth - left - width;\n      }\n\n      if (typeof this.options.optimizations !== 'undefined' && this.options.optimizations.moveElement !== false && !(typeof this.targetModifier !== 'undefined')) {\n        (function () {\n          var offsetParent = _this7.cache('target-offsetparent', function () {\n            return getOffsetParent(_this7.target);\n          });\n          var offsetPosition = _this7.cache('target-offsetparent-bounds', function () {\n            return getBounds(offsetParent);\n          });\n          var offsetParentStyle = getComputedStyle(offsetParent);\n          var offsetParentSize = offsetPosition;\n\n          var offsetBorder = {};\n          ['Top', 'Left', 'Bottom', 'Right'].forEach(function (side) {\n            offsetBorder[side.toLowerCase()] = parseFloat(offsetParentStyle['border' + side + 'Width']);\n          });\n\n          offsetPosition.right = doc.body.scrollWidth - offsetPosition.left - offsetParentSize.width + offsetBorder.right;\n          offsetPosition.bottom = doc.body.scrollHeight - offsetPosition.top - offsetParentSize.height + offsetBorder.bottom;\n\n          if (next.page.top >= offsetPosition.top + offsetBorder.top && next.page.bottom >= offsetPosition.bottom) {\n            if (next.page.left >= offsetPosition.left + offsetBorder.left && next.page.right >= offsetPosition.right) {\n              // We're within the visible part of the target's scroll parent\n              var scrollTop = offsetParent.scrollTop;\n              var scrollLeft = offsetParent.scrollLeft;\n\n              // It's position relative to the target's offset parent (absolute positioning when\n              // the element is moved to be a child of the target's offset parent).\n              next.offset = {\n                top: next.page.top - offsetPosition.top + scrollTop - offsetBorder.top,\n                left: next.page.left - offsetPosition.left + scrollLeft - offsetBorder.left\n              };\n            }\n          }\n        })();\n      }\n\n      // We could also travel up the DOM and try each containing context, rather than only\n      // looking at the body, but we're gonna get diminishing returns.\n\n      this.move(next);\n\n      this.history.unshift(next);\n\n      if (this.history.length > 3) {\n        this.history.pop();\n      }\n\n      if (flushChanges) {\n        flush();\n      }\n\n      return true;\n    }\n\n    // THE ISSUE\n  }, {\n    key: 'move',\n    value: function move(pos) {\n      var _this8 = this;\n\n      if (!(typeof this.element.parentNode !== 'undefined')) {\n        return;\n      }\n\n      var same = {};\n\n      for (var type in pos) {\n        same[type] = {};\n\n        for (var key in pos[type]) {\n          var found = false;\n\n          for (var i = 0; i < this.history.length; ++i) {\n            var point = this.history[i];\n            if (typeof point[type] !== 'undefined' && !within(point[type][key], pos[type][key])) {\n              found = true;\n              break;\n            }\n          }\n\n          if (!found) {\n            same[type][key] = true;\n          }\n        }\n      }\n\n      var css = { top: '', left: '', right: '', bottom: '' };\n\n      var transcribe = function transcribe(_same, _pos) {\n        var hasOptimizations = typeof _this8.options.optimizations !== 'undefined';\n        var gpu = hasOptimizations ? _this8.options.optimizations.gpu : null;\n        if (gpu !== false) {\n          var yPos = undefined,\n              xPos = undefined;\n          if (_same.top) {\n            css.top = 0;\n            yPos = _pos.top;\n          } else {\n            css.bottom = 0;\n            yPos = -_pos.bottom;\n          }\n\n          if (_same.left) {\n            css.left = 0;\n            xPos = _pos.left;\n          } else {\n            css.right = 0;\n            xPos = -_pos.right;\n          }\n\n          if (window.matchMedia) {\n            // HubSpot/tether#207\n            var retina = window.matchMedia('only screen and (min-resolution: 1.3dppx)').matches || window.matchMedia('only screen and (-webkit-min-device-pixel-ratio: 1.3)').matches;\n            if (!retina) {\n              xPos = Math.round(xPos);\n              yPos = Math.round(yPos);\n            }\n          }\n\n          css[transformKey] = 'translateX(' + xPos + 'px) translateY(' + yPos + 'px)';\n\n          if (transformKey !== 'msTransform') {\n            // The Z transform will keep this in the GPU (faster, and prevents artifacts),\n            // but IE9 doesn't support 3d transforms and will choke.\n            css[transformKey] += \" translateZ(0)\";\n          }\n        } else {\n          if (_same.top) {\n            css.top = _pos.top + 'px';\n          } else {\n            css.bottom = _pos.bottom + 'px';\n          }\n\n          if (_same.left) {\n            css.left = _pos.left + 'px';\n          } else {\n            css.right = _pos.right + 'px';\n          }\n        }\n      };\n\n      var moved = false;\n      if ((same.page.top || same.page.bottom) && (same.page.left || same.page.right)) {\n        css.position = 'absolute';\n        transcribe(same.page, pos.page);\n      } else if ((same.viewport.top || same.viewport.bottom) && (same.viewport.left || same.viewport.right)) {\n        css.position = 'fixed';\n        transcribe(same.viewport, pos.viewport);\n      } else if (typeof same.offset !== 'undefined' && same.offset.top && same.offset.left) {\n        (function () {\n          css.position = 'absolute';\n          var offsetParent = _this8.cache('target-offsetparent', function () {\n            return getOffsetParent(_this8.target);\n          });\n\n          if (getOffsetParent(_this8.element) !== offsetParent) {\n            defer(function () {\n              _this8.element.parentNode.removeChild(_this8.element);\n              offsetParent.appendChild(_this8.element);\n            });\n          }\n\n          transcribe(same.offset, pos.offset);\n          moved = true;\n        })();\n      } else {\n        css.position = 'absolute';\n        transcribe({ top: true, left: true }, pos.page);\n      }\n\n      if (!moved) {\n        if (this.options.bodyElement) {\n          if (this.element.parentNode !== this.options.bodyElement) {\n            this.options.bodyElement.appendChild(this.element);\n          }\n        } else {\n          var offsetParentIsBody = true;\n          var currentNode = this.element.parentNode;\n          while (currentNode && currentNode.nodeType === 1 && currentNode.tagName !== 'BODY') {\n            if (getComputedStyle(currentNode).position !== 'static') {\n              offsetParentIsBody = false;\n              break;\n            }\n\n            currentNode = currentNode.parentNode;\n          }\n\n          if (!offsetParentIsBody) {\n            this.element.parentNode.removeChild(this.element);\n            this.element.ownerDocument.body.appendChild(this.element);\n          }\n        }\n      }\n\n      // Any css change will trigger a repaint, so let's avoid one if nothing changed\n      var writeCSS = {};\n      var write = false;\n      for (var key in css) {\n        var val = css[key];\n        var elVal = this.element.style[key];\n\n        if (elVal !== val) {\n          write = true;\n          writeCSS[key] = val;\n        }\n      }\n\n      if (write) {\n        defer(function () {\n          extend(_this8.element.style, writeCSS);\n          _this8.trigger('repositioned');\n        });\n      }\n    }\n  }]);\n\n  return TetherClass;\n})(Evented);\n\nTetherClass.modules = [];\n\nTetherBase.position = position;\n\nvar Tether = extend(TetherClass, TetherBase);\n/* globals TetherBase */\n\n'use strict';\n\nvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\nvar _TetherBase$Utils = TetherBase.Utils;\nvar getBounds = _TetherBase$Utils.getBounds;\nvar extend = _TetherBase$Utils.extend;\nvar updateClasses = _TetherBase$Utils.updateClasses;\nvar defer = _TetherBase$Utils.defer;\n\nvar BOUNDS_FORMAT = ['left', 'top', 'right', 'bottom'];\n\nfunction getBoundingRect(tether, to) {\n  if (to === 'scrollParent') {\n    to = tether.scrollParents[0];\n  } else if (to === 'window') {\n    to = [pageXOffset, pageYOffset, innerWidth + pageXOffset, innerHeight + pageYOffset];\n  }\n\n  if (to === document) {\n    to = to.documentElement;\n  }\n\n  if (typeof to.nodeType !== 'undefined') {\n    (function () {\n      var node = to;\n      var size = getBounds(to);\n      var pos = size;\n      var style = getComputedStyle(to);\n\n      to = [pos.left, pos.top, size.width + pos.left, size.height + pos.top];\n\n      // Account any parent Frames scroll offset\n      if (node.ownerDocument !== document) {\n        var win = node.ownerDocument.defaultView;\n        to[0] += win.pageXOffset;\n        to[1] += win.pageYOffset;\n        to[2] += win.pageXOffset;\n        to[3] += win.pageYOffset;\n      }\n\n      BOUNDS_FORMAT.forEach(function (side, i) {\n        side = side[0].toUpperCase() + side.substr(1);\n        if (side === 'Top' || side === 'Left') {\n          to[i] += parseFloat(style['border' + side + 'Width']);\n        } else {\n          to[i] -= parseFloat(style['border' + side + 'Width']);\n        }\n      });\n    })();\n  }\n\n  return to;\n}\n\nTetherBase.modules.push({\n  position: function position(_ref) {\n    var _this = this;\n\n    var top = _ref.top;\n    var left = _ref.left;\n    var targetAttachment = _ref.targetAttachment;\n\n    if (!this.options.constraints) {\n      return true;\n    }\n\n    var _cache = this.cache('element-bounds', function () {\n      return getBounds(_this.element);\n    });\n\n    var height = _cache.height;\n    var width = _cache.width;\n\n    if (width === 0 && height === 0 && typeof this.lastSize !== 'undefined') {\n      var _lastSize = this.lastSize;\n\n      // Handle the item getting hidden as a result of our positioning without glitching\n      // the classes in and out\n      width = _lastSize.width;\n      height = _lastSize.height;\n    }\n\n    var targetSize = this.cache('target-bounds', function () {\n      return _this.getTargetBounds();\n    });\n\n    var targetHeight = targetSize.height;\n    var targetWidth = targetSize.width;\n\n    var allClasses = [this.getClass('pinned'), this.getClass('out-of-bounds')];\n\n    this.options.constraints.forEach(function (constraint) {\n      var outOfBoundsClass = constraint.outOfBoundsClass;\n      var pinnedClass = constraint.pinnedClass;\n\n      if (outOfBoundsClass) {\n        allClasses.push(outOfBoundsClass);\n      }\n      if (pinnedClass) {\n        allClasses.push(pinnedClass);\n      }\n    });\n\n    allClasses.forEach(function (cls) {\n      ['left', 'top', 'right', 'bottom'].forEach(function (side) {\n        allClasses.push(cls + '-' + side);\n      });\n    });\n\n    var addClasses = [];\n\n    var tAttachment = extend({}, targetAttachment);\n    var eAttachment = extend({}, this.attachment);\n\n    this.options.constraints.forEach(function (constraint) {\n      var to = constraint.to;\n      var attachment = constraint.attachment;\n      var pin = constraint.pin;\n\n      if (typeof attachment === 'undefined') {\n        attachment = '';\n      }\n\n      var changeAttachX = undefined,\n          changeAttachY = undefined;\n      if (attachment.indexOf(' ') >= 0) {\n        var _attachment$split = attachment.split(' ');\n\n        var _attachment$split2 = _slicedToArray(_attachment$split, 2);\n\n        changeAttachY = _attachment$split2[0];\n        changeAttachX = _attachment$split2[1];\n      } else {\n        changeAttachX = changeAttachY = attachment;\n      }\n\n      var bounds = getBoundingRect(_this, to);\n\n      if (changeAttachY === 'target' || changeAttachY === 'both') {\n        if (top < bounds[1] && tAttachment.top === 'top') {\n          top += targetHeight;\n          tAttachment.top = 'bottom';\n        }\n\n        if (top + height > bounds[3] && tAttachment.top === 'bottom') {\n          top -= targetHeight;\n          tAttachment.top = 'top';\n        }\n      }\n\n      if (changeAttachY === 'together') {\n        if (tAttachment.top === 'top') {\n          if (eAttachment.top === 'bottom' && top < bounds[1]) {\n            top += targetHeight;\n            tAttachment.top = 'bottom';\n\n            top += height;\n            eAttachment.top = 'top';\n          } else if (eAttachment.top === 'top' && top + height > bounds[3] && top - (height - targetHeight) >= bounds[1]) {\n            top -= height - targetHeight;\n            tAttachment.top = 'bottom';\n\n            eAttachment.top = 'bottom';\n          }\n        }\n\n        if (tAttachment.top === 'bottom') {\n          if (eAttachment.top === 'top' && top + height > bounds[3]) {\n            top -= targetHeight;\n            tAttachment.top = 'top';\n\n            top -= height;\n            eAttachment.top = 'bottom';\n          } else if (eAttachment.top === 'bottom' && top < bounds[1] && top + (height * 2 - targetHeight) <= bounds[3]) {\n            top += height - targetHeight;\n            tAttachment.top = 'top';\n\n            eAttachment.top = 'top';\n          }\n        }\n\n        if (tAttachment.top === 'middle') {\n          if (top + height > bounds[3] && eAttachment.top === 'top') {\n            top -= height;\n            eAttachment.top = 'bottom';\n          } else if (top < bounds[1] && eAttachment.top === 'bottom') {\n            top += height;\n            eAttachment.top = 'top';\n          }\n        }\n      }\n\n      if (changeAttachX === 'target' || changeAttachX === 'both') {\n        if (left < bounds[0] && tAttachment.left === 'left') {\n          left += targetWidth;\n          tAttachment.left = 'right';\n        }\n\n        if (left + width > bounds[2] && tAttachment.left === 'right') {\n          left -= targetWidth;\n          tAttachment.left = 'left';\n        }\n      }\n\n      if (changeAttachX === 'together') {\n        if (left < bounds[0] && tAttachment.left === 'left') {\n          if (eAttachment.left === 'right') {\n            left += targetWidth;\n            tAttachment.left = 'right';\n\n            left += width;\n            eAttachment.left = 'left';\n          } else if (eAttachment.left === 'left') {\n            left += targetWidth;\n            tAttachment.left = 'right';\n\n            left -= width;\n            eAttachment.left = 'right';\n          }\n        } else if (left + width > bounds[2] && tAttachment.left === 'right') {\n          if (eAttachment.left === 'left') {\n            left -= targetWidth;\n            tAttachment.left = 'left';\n\n            left -= width;\n            eAttachment.left = 'right';\n          } else if (eAttachment.left === 'right') {\n            left -= targetWidth;\n            tAttachment.left = 'left';\n\n            left += width;\n            eAttachment.left = 'left';\n          }\n        } else if (tAttachment.left === 'center') {\n          if (left + width > bounds[2] && eAttachment.left === 'left') {\n            left -= width;\n            eAttachment.left = 'right';\n          } else if (left < bounds[0] && eAttachment.left === 'right') {\n            left += width;\n            eAttachment.left = 'left';\n          }\n        }\n      }\n\n      if (changeAttachY === 'element' || changeAttachY === 'both') {\n        if (top < bounds[1] && eAttachment.top === 'bottom') {\n          top += height;\n          eAttachment.top = 'top';\n        }\n\n        if (top + height > bounds[3] && eAttachment.top === 'top') {\n          top -= height;\n          eAttachment.top = 'bottom';\n        }\n      }\n\n      if (changeAttachX === 'element' || changeAttachX === 'both') {\n        if (left < bounds[0]) {\n          if (eAttachment.left === 'right') {\n            left += width;\n            eAttachment.left = 'left';\n          } else if (eAttachment.left === 'center') {\n            left += width / 2;\n            eAttachment.left = 'left';\n          }\n        }\n\n        if (left + width > bounds[2]) {\n          if (eAttachment.left === 'left') {\n            left -= width;\n            eAttachment.left = 'right';\n          } else if (eAttachment.left === 'center') {\n            left -= width / 2;\n            eAttachment.left = 'right';\n          }\n        }\n      }\n\n      if (typeof pin === 'string') {\n        pin = pin.split(',').map(function (p) {\n          return p.trim();\n        });\n      } else if (pin === true) {\n        pin = ['top', 'left', 'right', 'bottom'];\n      }\n\n      pin = pin || [];\n\n      var pinned = [];\n      var oob = [];\n\n      if (top < bounds[1]) {\n        if (pin.indexOf('top') >= 0) {\n          top = bounds[1];\n          pinned.push('top');\n        } else {\n          oob.push('top');\n        }\n      }\n\n      if (top + height > bounds[3]) {\n        if (pin.indexOf('bottom') >= 0) {\n          top = bounds[3] - height;\n          pinned.push('bottom');\n        } else {\n          oob.push('bottom');\n        }\n      }\n\n      if (left < bounds[0]) {\n        if (pin.indexOf('left') >= 0) {\n          left = bounds[0];\n          pinned.push('left');\n        } else {\n          oob.push('left');\n        }\n      }\n\n      if (left + width > bounds[2]) {\n        if (pin.indexOf('right') >= 0) {\n          left = bounds[2] - width;\n          pinned.push('right');\n        } else {\n          oob.push('right');\n        }\n      }\n\n      if (pinned.length) {\n        (function () {\n          var pinnedClass = undefined;\n          if (typeof _this.options.pinnedClass !== 'undefined') {\n            pinnedClass = _this.options.pinnedClass;\n          } else {\n            pinnedClass = _this.getClass('pinned');\n          }\n\n          addClasses.push(pinnedClass);\n          pinned.forEach(function (side) {\n            addClasses.push(pinnedClass + '-' + side);\n          });\n        })();\n      }\n\n      if (oob.length) {\n        (function () {\n          var oobClass = undefined;\n          if (typeof _this.options.outOfBoundsClass !== 'undefined') {\n            oobClass = _this.options.outOfBoundsClass;\n          } else {\n            oobClass = _this.getClass('out-of-bounds');\n          }\n\n          addClasses.push(oobClass);\n          oob.forEach(function (side) {\n            addClasses.push(oobClass + '-' + side);\n          });\n        })();\n      }\n\n      if (pinned.indexOf('left') >= 0 || pinned.indexOf('right') >= 0) {\n        eAttachment.left = tAttachment.left = false;\n      }\n      if (pinned.indexOf('top') >= 0 || pinned.indexOf('bottom') >= 0) {\n        eAttachment.top = tAttachment.top = false;\n      }\n\n      if (tAttachment.top !== targetAttachment.top || tAttachment.left !== targetAttachment.left || eAttachment.top !== _this.attachment.top || eAttachment.left !== _this.attachment.left) {\n        _this.updateAttachClasses(eAttachment, tAttachment);\n        _this.trigger('update', {\n          attachment: eAttachment,\n          targetAttachment: tAttachment\n        });\n      }\n    });\n\n    defer(function () {\n      if (!(_this.options.addTargetClasses === false)) {\n        updateClasses(_this.target, addClasses, allClasses);\n      }\n      updateClasses(_this.element, addClasses, allClasses);\n    });\n\n    return { top: top, left: left };\n  }\n});\n/* globals TetherBase */\n\n'use strict';\n\nvar _TetherBase$Utils = TetherBase.Utils;\nvar getBounds = _TetherBase$Utils.getBounds;\nvar updateClasses = _TetherBase$Utils.updateClasses;\nvar defer = _TetherBase$Utils.defer;\n\nTetherBase.modules.push({\n  position: function position(_ref) {\n    var _this = this;\n\n    var top = _ref.top;\n    var left = _ref.left;\n\n    var _cache = this.cache('element-bounds', function () {\n      return getBounds(_this.element);\n    });\n\n    var height = _cache.height;\n    var width = _cache.width;\n\n    var targetPos = this.getTargetBounds();\n\n    var bottom = top + height;\n    var right = left + width;\n\n    var abutted = [];\n    if (top <= targetPos.bottom && bottom >= targetPos.top) {\n      ['left', 'right'].forEach(function (side) {\n        var targetPosSide = targetPos[side];\n        if (targetPosSide === left || targetPosSide === right) {\n          abutted.push(side);\n        }\n      });\n    }\n\n    if (left <= targetPos.right && right >= targetPos.left) {\n      ['top', 'bottom'].forEach(function (side) {\n        var targetPosSide = targetPos[side];\n        if (targetPosSide === top || targetPosSide === bottom) {\n          abutted.push(side);\n        }\n      });\n    }\n\n    var allClasses = [];\n    var addClasses = [];\n\n    var sides = ['left', 'top', 'right', 'bottom'];\n    allClasses.push(this.getClass('abutted'));\n    sides.forEach(function (side) {\n      allClasses.push(_this.getClass('abutted') + '-' + side);\n    });\n\n    if (abutted.length) {\n      addClasses.push(this.getClass('abutted'));\n    }\n\n    abutted.forEach(function (side) {\n      addClasses.push(_this.getClass('abutted') + '-' + side);\n    });\n\n    defer(function () {\n      if (!(_this.options.addTargetClasses === false)) {\n        updateClasses(_this.target, addClasses, allClasses);\n      }\n      updateClasses(_this.element, addClasses, allClasses);\n    });\n\n    return true;\n  }\n});\n/* globals TetherBase */\n\n'use strict';\n\nvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\nTetherBase.modules.push({\n  position: function position(_ref) {\n    var top = _ref.top;\n    var left = _ref.left;\n\n    if (!this.options.shift) {\n      return;\n    }\n\n    var shift = this.options.shift;\n    if (typeof this.options.shift === 'function') {\n      shift = this.options.shift.call(this, { top: top, left: left });\n    }\n\n    var shiftTop = undefined,\n        shiftLeft = undefined;\n    if (typeof shift === 'string') {\n      shift = shift.split(' ');\n      shift[1] = shift[1] || shift[0];\n\n      var _shift = shift;\n\n      var _shift2 = _slicedToArray(_shift, 2);\n\n      shiftTop = _shift2[0];\n      shiftLeft = _shift2[1];\n\n      shiftTop = parseFloat(shiftTop, 10);\n      shiftLeft = parseFloat(shiftLeft, 10);\n    } else {\n      shiftTop = shift.top;\n      shiftLeft = shift.left;\n    }\n\n    top += shiftTop;\n    left += shiftLeft;\n\n    return { top: top, left: left };\n  }\n});\nreturn Tether;\n\n}));\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/tether/dist/js/tether.js\n ** module id = 10\n ** module chunks = 0\n **/","import Component from '../component/component';\nimport ResizeObserver from '../util/resize-observer';\n\nconst SELECTOR_COMPONENT = '.aui-js-breadcrumb';\nconst CLASS_ITEMS = 'aui-breadcrumb__items';\nconst CLASS_IS_OVERSIZED = 'is-oversized';\n\n/**\n * Class constructor for Breadcrumb AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Breadcrumb extends Component {\n\n  /**\n   * Upgrades all Breadcrumb AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Breadcrumb(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n  }\n\n  init() {\n    super.init();\n\n    this._items = this._element.querySelector(`.${CLASS_ITEMS}`);\n\n    this._resizeObserver = new ResizeObserver();\n    this._resizeObserver.resized.add(this._resizedHandler = () => this.update());\n\n    this.update();\n  }\n\n  update() {\n    this._checkSize();\n  }\n\n  dispose() {\n    super.dispose();\n\n    this._resizeObserver.resized.remove(this._resizedHandler);\n  }\n\n  _checkSize() {\n    if (this._items.scrollWidth > this._items.offsetWidth) {\n      this._items.scrollLeft = 9999;\n      this._element.classList.add(CLASS_IS_OVERSIZED);\n    } else {\n      this._element.classList.remove(CLASS_IS_OVERSIZED);\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/breadcrumb/breadcrumb.js\n **/","import Component from '../component/component';\n\nconst NAMESPACE = 'auiCheckbox';\nconst SELECTOR_COMPONENT = '.aui-js-checkbox';\nconst CLASS_INPUT = 'aui-checkbox__input';\nconst CLASS_LABEL = 'aui-checkbox__label';\nconst CLASS_BOX = 'aui-checkbox__box';\nconst CLASS_TICK = 'aui-checkbox__tick';\nconst CLASS_IS_FOCUS = 'is-focused';\nconst CLASS_IS_CHECKED = 'is-checked';\nconst CLASS_IS_DISABLED = 'is-disabled';\n\n/**\n * Class constructor for Checkbox AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Checkbox extends Component {\n\n  /**\n   * Upgrades all Checkbox AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Checkbox(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Returns all AUI component instances within the given container\n   * @param {HTMLElement} container The container element to search for components\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static get(container = document) {\n    let components = [];\n    if (container) {\n      Array.from(container.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n        components.push(element.auiCheckbox);\n      });\n    }\n    return components;\n  }\n\n  constructor(element) {\n    super(element, NAMESPACE);\n  }\n\n  init() {\n    super.init();\n\n    this._input = this._element.querySelector(`.${CLASS_INPUT}`);\n    this._input.addEventListener('change', this._changeHandler = (event) => this._onChange(event));\n    this._input.addEventListener('focus', this._focusHandler = (event) => this._onFocus(event));\n    this._input.addEventListener('blur', this._blurHandler = (event) => this._onBlur(event));\n\n    // Insert box with tick after label element:\n    this._label = this._element.querySelector(`.${CLASS_LABEL}`);\n    let box = document.createElement('span');\n    box.classList.add(CLASS_BOX);\n    this._label.parentNode.insertBefore(box, this._label.nextSibling);\n    let tick = document.createElement('span');\n    tick.classList.add(CLASS_TICK);\n    box.appendChild(tick);\n\n    this.updateClasses();\n  }\n\n  updateClasses() {\n    this.checkDisabled();\n    this.checkToggleState();\n    this.checkFocus();\n  }\n\n  /**\n   * Check the disabled state and update field accordingly.\n   */\n  checkDisabled() {\n    if (this._input.disabled) {\n      this._element.classList.add(CLASS_IS_DISABLED);\n    } else {\n      this._element.classList.remove(CLASS_IS_DISABLED);\n    }\n  }\n\n  /**\n   * Check the toggle state and update field accordingly.\n   */\n  checkToggleState() {\n    if (this._input.checked) {\n      this._element.classList.add(CLASS_IS_CHECKED);\n    } else {\n      this._element.classList.remove(CLASS_IS_CHECKED);\n    }\n  }\n\n  /**\n   * Check the focus state and update field accordingly.\n   */\n  checkFocus() {\n    if (Boolean(this._element.querySelector(':focus'))) {\n      this._element.classList.add(CLASS_IS_FOCUS);\n    } else {\n      this._element.classList.remove(CLASS_IS_FOCUS);\n    }\n  }\n\n  /**\n   * Enable checkbox\n   */\n  enable() {\n    this._input.disabled = false;\n    this.updateClasses();\n  }\n\n  /**\n   * Disable checkbox\n   */\n  disable() {\n    this._input.disabled = true;\n    this.updateClasses();\n  }\n\n  /**\n   * Check checkbox\n   */\n  check() {\n    this._input.checked = true;\n    this.updateClasses();\n  }\n\n  /**\n   * Uncheck checkbox\n   */\n  uncheck() {\n    this._input.checked = false;\n    this.updateClasses();\n  }\n\n  /**\n   * Uncheck checkbox\n   */\n  toggle() {\n    if (this._input.checked) {\n      this.uncheck();\n    } else {\n      this.check();\n    }\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n\n    this._input.removeEventListener('change', this._changeHandler);\n    this._input.removeEventListener('focus', this._focusHandler);\n    this._input.removeEventListener('blur', this._blurHandler);\n\n    this._element.removeChild(this._element.querySelector(`.${CLASS_BOX}`));\n  }\n\n  /**\n   * Event Handler\n   */\n\n  _onChange(event) {\n    this.updateClasses();\n  }\n\n  // TODO Find out why unfocus is triggered on mousedown\n  _onFocus(event) {\n    this._element.classList.add(CLASS_IS_FOCUS);\n  }\n\n  _onBlur(event) {\n    this._element.classList.remove(CLASS_IS_FOCUS);\n  }\n\n  /**\n   * Getter and Setter\n   */\n\n  get input() {\n    return this._input;\n  }\n\n  get checked() {\n    return this._input.checked = true;\n  }\n\n  set checked(value) {\n    if (value) {\n      this.check();\n    } else {\n      this.uncheck();\n    }\n  }\n\n  get disabled() {\n    return this._input.disabled = true;\n  }\n\n  set disabled(value) {\n    if (value) {\n      this.disable();\n    } else {\n      this.enable();\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/checkbox/checkbox.js\n **/","import Component from '../component/component';\nimport Checkbox from '../checkbox/checkbox';\n\nconst SELECTOR_COMPONENT = '.aui-js-dropdown';\nconst SELECTOR_OPTION_INPUT = 'input';\nconst CLASS_ANIMATED_LIST_ITEMS = 'aui-dropdown__list-item--animate';\nconst CLASS_LABEL = 'aui-dropdown__label';\nconst CLASS_INPUT = 'aui-dropdown__input';\nconst CLASS_VALUE = 'aui-dropdown__value';\nconst CLASS_FOCUS_LINE = 'aui-dropdown__focus-line';\nconst CLASS_OPTION = 'aui-dropdown__option';\nconst CLASS_MULTIPLE = 'aui-dropdown--multiple';\nconst CLASS_IS_FOCUS = 'is-focused';\nconst CLASS_IS_DIRTY = 'is-dirty';\nconst CLASS_IS_DISABLED = 'is-disabled';\nconst CLASS_IS_ACTIVE = 'is-active';\n\n/**\n * Class constructor for Dropdown AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Dropdown extends Component {\n\n  /**\n   * Upgrades all Dropdown AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Dropdown(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n\n    this._element.addEventListener('click', this._clickHandler = event => this._onClick(event));\n\n    this.multiple = this._element.classList.contains(CLASS_MULTIPLE);\n    this._isActive = false;\n\n    this._valueField = this._element.querySelector(`.${CLASS_VALUE}`);\n\n    this._input = this._element.querySelector(`.${CLASS_INPUT}`);\n    this._input.addEventListener('input', this._inputHandler = event => this._onInput(event));\n    this._input.addEventListener('focus', this._focusHandler = event => this._onFocus(event));\n    this._input.addEventListener('blur', this._blurHandler = event => this._onBlur(event));\n    this._input.addEventListener('reset', this._resetHandler = event => this._onReset(event));\n\n    let itemsAnimated = this._element.querySelectorAll(`.${CLASS_ANIMATED_LIST_ITEMS}`);\n    for (var i = 0; i < itemsAnimated.length; i++) {\n      itemsAnimated[i].style.transitionDelay = itemsAnimated[i].style.webkitTransitionDelay = `${.05 * i}s`;\n    }\n\n    // Insert thick focus line after label element:\n    this._label = this._element.querySelector(`.${CLASS_LABEL}`);\n    let focusLine = document.createElement('span');\n    focusLine.classList.add(CLASS_FOCUS_LINE);\n    this._label.parentNode.insertBefore(focusLine, this._label.nextSibling);\n\n    this.updateClasses();\n  }\n\n  optionClicked(option) {\n    if (this._valueField) {\n      this._valueField.value = this._getOptionValue(option);\n    }\n\n    this.updateInput(option);\n\n    if (!this.multiple) {\n      this.close();\n    }\n  }\n\n  updateInput(option) {\n    let value = '';\n    if (this.multiple) {\n      let values = [];\n      Array.from(this._element.querySelectorAll(`.${CLASS_OPTION}`)).forEach(element => {\n        const input = element.querySelector(SELECTOR_OPTION_INPUT);\n        if (input && input.checked) {\n          values.push(this._getOptionTitle(element));\n        }\n      });\n      value = values.length > 0 ? `(${values.length}) ${values.join(', ')}` : '';\n    } else {\n      value = this._getOptionTitle(option);\n    }\n    this._input.value = value;\n    this.updateClasses();\n  }\n\n  _getOptionTitle(option) {\n    let title = '';\n    if (option) {\n      title = option.hasAttribute('data-title') ? option.getAttribute('data-title') : '';\n    }\n    return title;\n  }\n\n  _getOptionValue(option) {\n    let value = '';\n    if (option) {\n      value = option.hasAttribute('data-value') ? option.getAttribute('data-value') : '';\n    }\n    return value;\n  }\n\n  open() {\n    if (!this._element.classList.contains(CLASS_IS_DISABLED)) {\n      this._isActive = true;\n      this._element.classList.add(CLASS_IS_ACTIVE);\n      window.addEventListener('click', this._clickHandlerWindow = (event) => this._onClickOutside(event));\n    }\n  }\n\n  close() {\n    this._isActive = false;\n    this._element.classList.remove(CLASS_IS_ACTIVE);\n    window.removeEventListener('click', this.close);\n  }\n\n  toggleOpen() {\n    if (this._isActive) {\n      this.close();\n    } else {\n      this.open();\n    }\n  }\n\n  updateClasses() {\n    this.checkDisabled();\n    this.checkDirty();\n    this.checkFocus();\n  }\n\n  /**\n   * Check the disabled state and update field accordingly.\n   */\n  checkDisabled() {\n    if (this._input.disabled) {\n      this._element.classList.add(CLASS_IS_DISABLED);\n    } else {\n      this._element.classList.remove(CLASS_IS_DISABLED);\n    }\n  }\n\n  /**\n   * Check the dirty state and update field accordingly.\n   */\n  checkDirty() {\n    if (this._input.value && this._input.value.length > 0) {\n      this._element.classList.add(CLASS_IS_DIRTY);\n    } else {\n      this._element.classList.remove(CLASS_IS_DIRTY);\n    }\n  }\n\n  /**\n   * Check the focus state and update field accordingly.\n   */\n  checkFocus() {\n    if (Boolean(this._element.querySelector(':focus'))) {\n      this._element.classList.add(CLASS_IS_FOCUS);\n    } else {\n      this._element.classList.remove(CLASS_IS_FOCUS);\n    }\n  }\n\n  /**\n   * Disable text field.\n   */\n  disable() {\n    this._input.disabled = true;\n    this.updateClasses();\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n\n    this._input.removeEventListener('input', this._inputHandler);\n    this._input.removeEventListener('focus', this._focusHandler);\n    this._input.removeEventListener('blur', this._blurHandler);\n    this._input.removeEventListener('reset', this._resetHandler);\n\n    window.removeEventListener('click', this.close);\n  }\n\n  /**\n   * Event Handler\n   */\n\n  _onClick(event) {\n    let isOption = false;\n\n    // Find closest action element\n    let currentElement = event.target;\n    while (currentElement !== event.currentTarget) {\n      if (currentElement.classList.contains(CLASS_OPTION)) {\n        isOption = true;\n        break;\n      }\n      currentElement = currentElement.parentNode;\n    }\n\n    if (!isOption) {\n      this.toggleOpen();\n    } else {\n      // Toggle the Checkbox contained\n      Checkbox.get(currentElement).forEach(checkbox => {\n        checkbox.toggle();\n        this.optionClicked(currentElement);\n      });\n    }\n  }\n\n  _onClickOutside(event) {\n    if (!this._element.contains(event.target)) {\n      this.close();\n      this.updateClasses();\n    }\n  }\n\n  _onInput(event) {\n    this.updateClasses();\n  }\n\n  _onFocus(event) {\n    this._element.classList.add(CLASS_IS_FOCUS);\n  }\n\n  _onBlur(event) {\n    this._element.classList.remove(CLASS_IS_FOCUS);\n  }\n\n  _onReset(event) {\n    this.updateClasses();\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/dropdown/dropdown.js\n **/","import Component from '../component/component';\n\nconst SELECTOR_COMPONENT = '.aui-js-flyout';\nconst CLASS_TOGGLE = 'aui-flyout__toggle';\nconst CLASS_TRIANGLE = 'aui-flyout__triangle';\nconst CLASS_HEADER = 'aui-flyout__header';\nconst CLASS_CLOSE_BUTTON = 'aui-flyout__close';\nconst CLASS_PANEL = 'aui-flyout__panel';\nconst CLASS_IS_UPGRADED = 'is-upgraded';\nconst CLASS_IS_ACTIVE = 'is-active';\nconst CLASS_FLYOUT_IS_OPEN = 'aui-flyout-is-open';\nconst TOGGLE_THRESHOLD = 250; // in ms\n\n/**\n * Class constructor for Flyout AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Flyout extends Component {\n\n  /**\n   * Upgrades all Flyout AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Flyout(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    this._activationTime = 0;\n\n    this._body = document.querySelector('body');\n    this._toggle = this._element.querySelector(`.${CLASS_TOGGLE}`);\n    this._panel = this._element.querySelector(`.${CLASS_PANEL}`);\n\n    // Add triangle shape\n    this._triangle = document.createElement('span');\n    this._triangle.classList.add(CLASS_TRIANGLE);\n    this._panel.appendChild(this._triangle);\n\n    // Add panel header with close button\n    this._header = document.createElement('div');\n    this._header.classList.add(CLASS_HEADER);\n    this._header.innerHTML = `<button class=\"${CLASS_CLOSE_BUTTON}\" type=\"button\"></button>`;\n    this._panel.appendChild(this._header);\n\n    this._closeBtn = this._header.querySelector(`.${CLASS_CLOSE_BUTTON}`);\n    this._closeBtn.addEventListener('click', this._boundClickClose = (event) => this._onClickClose(event));\n    this._toggle.addEventListener('click', this._boundClickToggle = (event) => this._onClickToggle(event));\n\n    if (this._element.classList.contains(CLASS_IS_ACTIVE)) {\n      this.open();\n    }\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    this._toggle.removeEventListener('click', this._boundClickToggle);\n    this._closeBtn.removeEventListener('click', this._boundClickClose);\n    window.removeEventListener('click', this._boundClickWindow);\n    window.removeEventListener('touchend', this._boundTouchendWindow);\n\n    this._panel.removeChild(this._triangle);\n\n    this._element.classList.remove(CLASS_IS_ACTIVE, CLASS_IS_UPGRADED);\n    this._element.removeAttribute('style');\n  }\n\n  /**\n   * Open Flyout\n   */\n  open() {\n    this._body.classList.add(CLASS_FLYOUT_IS_OPEN);\n    this._activationTime = Date.now();\n    this._isActive = true;\n    this._element.classList.add(CLASS_IS_ACTIVE);\n    window.addEventListener('click', this._boundClickWindow = (event) => this._onTouchOutside(event), true);\n    window.addEventListener('touchend', this._boundTouchendWindow = (event) => this._onTouchOutside(event), true);\n  }\n\n  /**\n   * Close Flyout\n   */\n  close() {\n    this._body.classList.remove(CLASS_FLYOUT_IS_OPEN);\n    this._isActive = false;\n    this._element.classList.remove(CLASS_IS_ACTIVE);\n    window.removeEventListener('click', this._boundClickWindow, true);\n    window.removeEventListener('touchend', this._boundTouchendWindow, true);\n  }\n\n  /**\n   * Toggle open/close Flyout\n   */\n  toggle() {\n    let elapsed = Date.now() - this._activationTime;\n    if (elapsed < TOGGLE_THRESHOLD) {\n      return;\n    }\n\n    if (this._isActive) {\n      this.close();\n    } else {\n      this.open();\n    }\n  }\n\n  /**\n   * Handle click of close button.\n   * @param {Event} event that fired.\n   */\n  _onClickClose(event) {\n    this.close();\n  }\n\n  /**\n   * Handle click of toggle.\n   * @param {Event} event that fired.\n   */\n  _onClickToggle(event) {\n    this.toggle();\n  }\n\n  /**\n   * Handle mouseneter.\n   * @param {Event} event that fired.\n   */\n  _onMouseEnter(event) {\n    this.open(event.target, event.clientX);\n  }\n\n  /**\n   * Handle mouseleave.\n   * @param {Event} event that fired.\n   */\n  _onMouseLeave(event) {\n    this.close();\n  }\n\n  /**\n   * Handle touch.\n   * @param {Event} event that fired.\n   */\n  _onTouch(event) {\n    event.stopPropagation();\n    this.open();\n  }\n\n  /**\n   * Handle touch outside.\n   * @param {Event} event that fired.\n   */\n  _onTouchOutside(event) {\n    if (!this._element.contains(event.target)) {\n      this.close();\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/flyout/flyout.js\n **/","import Component from '../component/component';\nimport ScrollObserver from '../util/scroll-observer';\n\nconst SELECTOR_COMPONENT = '.aui-js-header';\nconst CLASS_STICKYABLE = 'aui-header--sticky';\nconst CLASS_IS_STICKY = 'is-sticky';\n\n/**\n * Class constructor for Header AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Header extends Component {\n\n  /**\n   * Upgrades all Header AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Header(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component.\n   */\n  init() {\n    super.init();\n\n    // If Header ist not sticky, there is nothing todo.\n    if (!this._element.classList.contains(CLASS_STICKYABLE)) {\n      return;\n    }\n\n    // REVIEW position:sticky currently not working. See also SCSS.\n    // If browser supports position:sticky, it will handle positioning and\n    // we can skip here.\n    // if (window.getComputedStyle(this._element).position.indexOf('sticky') !== -1) {\n    //   return;\n    // }\n\n    this._scrollObserver = new ScrollObserver();\n    this._scrollObserver.scrolled.add(this._scrollHandler = () => this.checkStickiness());\n\n    this._sticky = false;\n    this.checkStickiness();\n  }\n\n  /**\n  * Dispose component.\n  */\n  dispose() {\n    super.dispose();\n\n    this._scrollObserver.resized.remove(this._scrollHandler);\n    this._resizeObserver.resized.remove(this._resizedHandler);\n  }\n\n  /**\n   * Check if position.top is negative. If so stick otherwise release component.\n   */\n  checkStickiness() {\n    if (this._element.getBoundingClientRect().top <= 0) {\n      if (!this._sticky) {\n        this.stick();\n      }\n    } else {\n      if (this._sticky) {\n        this.release();\n      }\n    }\n  }\n\n  /**\n   * Stick component to top of viewport in adding sticky class.\n   */\n  stick() {\n    if (!this._sticky) {\n      this._element.classList.add(CLASS_IS_STICKY);\n    }\n    this._sticky = true;\n  }\n\n  /**\n   * Release component and position not fixed in removing sticky class.\n   */\n  release() {\n    if (this._sticky) {\n      this._element.classList.remove(CLASS_IS_STICKY);\n    }\n    this._sticky = false;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/header/header.js\n **/","import Signal from '../util/signal';\n\nlet instance = null;\n\nconst SCROLL_END_THRESHOLD = 100; // in ms\n\nexport default class ScrollObserver {\n\n  constructor() {\n    if (!instance) {\n      instance = this;\n      this.init();\n    }\n\n    return instance;\n  }\n\n  init() {\n    this._scrollX = 0;\n    this._scrollY = 0;\n    this._ticking = false;\n\n    this.scrolled = new Signal();\n    this.scrollEnded = new Signal();\n\n    window.addEventListener('scroll', this.scrollHandler = (event) => this.onScroll(event));\n  }\n\n  onScroll(event) {\n    this._scrollX = window.scrollX;\n    this._scrollY = window.scrollY;\n\n    if (!this._ticking) {\n      window.requestAnimationFrame(() => {\n        this._ticking = false;\n        this.scrolled.dispatch(this._scrollX, this._scrollY);\n        clearTimeout(this._scrollEndTimeout);\n        this._scrollEndTimeout = setTimeout(() => {\n          this.scrollEnded.dispatch(this._scrollX, this._scrollY);\n        }, SCROLL_END_THRESHOLD);\n      });\n    }\n    this._ticking = true;\n  }\n\n  get scrollX() {\n    return this._scrollX;\n  }\n\n  get scrollY() {\n    return this._scrollY;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/scroll-observer.js\n **/","import Component from '../component/component';\nimport ModalDefault from '../modal/modal-default';\nimport ModalMorph from '../modal/modal-morph';\n\nconst SELECTOR_COMPONENT = '.aui-js-modal';\nconst CLASS_MORPH = 'aui-modal--morph';\n\nlet modalComponents;\nlet currentModal;\n\n/**\n * Class constructor for Modal AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Modal extends Component {\n\n  /**\n   * Upgrades all Modal AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Modal(element));\n      }\n    });\n    modalComponents = components;\n    return components;\n  };\n\n  /**\n   * Get a modal component by element ID.\n   * @param {string} id The id attribute of the components HTML element.\n   * @returns {Modal} Returns a modal with the given ID.\n   */\n  static getModalById(id) {\n    for (var i = 0; i < modalComponents.length; i++) {\n      if (modalComponents[i].id === id) {\n        return modalComponents[i];\n      }\n    }\n  }\n\n  /**\n   * Close current modal.\n   */\n  static closeCurrentModal() {\n    if (currentModal) {\n      currentModal.close();\n      currentModal = null;\n    }\n  }\n\n  /**\n   * Returns modifier `morph`\n   */\n  static get MODIFIER_MORPH() {\n    return CLASS_MORPH;\n  }\n\n  /**\n   * Returns modifier `default`\n   */\n  static get MODIFIER_DEFAULT() {\n    return '';\n  }\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    this._id = this._element.getAttribute('id');\n\n    // Initialize with appropriate decorator depending on modifier,\n    // represented by according CSS class:\n    if (this._element.classList.contains(CLASS_MORPH)) {\n      this._decorator = new ModalMorph(this._element);\n    } else {\n      this._decorator = new ModalDefault(this._element);\n    }\n  }\n\n  /**\n   * Opens this modal.\n   * @param {HTMLElement} trigger The element which opens the modal.\n   */\n  open(trigger) {\n    currentModal = this;\n    this._decorator.open(trigger);\n  }\n\n  /**\n   * Closes this modal.\n   */\n  close() {\n    currentModal = null;\n    this._decorator.close();\n  }\n\n  /**\n   * @returns {string} Returns the ID of the modal\n   */\n  get id() {\n    return this._id;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/modal/modal.js\n **/","import ModalDialog from '../modal/modal-dialog';\nimport ResizeObserver from '../util/resize-observer';\nimport transitionendEvent from '../util/transition-end-event';\n\nconst CLASS_MODAL_IS_OPEN = 'aui-modal-open';\nconst CLASS_WINDOW = 'aui-modal-dialog--window';\nconst CLASS_DIALOG_BODY = 'aui-modal-dialog__body';\nconst CLASS_IS_ACTIVE = 'is-active';\n\n/**\n * Class constructor for ModalDefault AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class ModalDefault extends ModalDialog {\n\n  /**\n   * Opens this modal.\n   * @param {HTMLElement} trigger The element which opens the modal.\n   */\n  open(trigger) {\n    super.open();\n    this._trigger = trigger;\n\n    // Make modal element visible\n    this._element.classList.add(CLASS_IS_ACTIVE);\n    this._element.scrollTop = 0;\n    this._addBackdrop();\n\n    // If dialog acts as window, we have to reposition the close button to\n    // stick with the dialog.\n    if (this._element.querySelector(`.${CLASS_WINDOW}`) && this._closeButton) {\n      if (this._resizeObserver === undefined) {\n        this._resizeObserver = new ResizeObserver();\n        this._dialogBody = this._element.querySelector(`.${CLASS_DIALOG_BODY}`);\n      }\n      this._resizeObserver.resized.add(this._resizedHandler = () => this._repositionCloseButton());\n      this._repositionCloseButton();\n    }\n\n    window.requestAnimationFrame(() => this._prepareOpenTransition());\n  }\n\n  /**\n   * Prepare the open transition.\n   */\n  _prepareOpenTransition() {\n    // Loops until modal is really visible.\n    // That's required to make transitions work as aspected.\n    if (this._element.offsetWidth > 0) {\n\n      // Start opening animation\n      this._body.classList.add(CLASS_MODAL_IS_OPEN);\n\n    } else {\n      window.requestAnimationFrame(() => this._prepareOpenTransition());\n    }\n  }\n\n  /**\n   * Closes this modal.\n   */\n  close() {\n    if (this._backdrop) {\n      this._backdrop.removeEventListener(transitionendEvent, this._backdropCloseTransitionendHandler);\n      transitionendEvent && this._backdrop.addEventListener(transitionendEvent, this._backdropCloseTransitionendHandler = (event) => this._onBackdropCloseTransitionend(event));\n    }\n\n    if (this._resizeObserver) {\n      this._resizeObserver.resized.remove(this._resizedHandler);\n    }\n\n    this._body.classList.remove(CLASS_MODAL_IS_OPEN);\n  }\n\n  /**\n   * Reposition close button with dialog\n   */\n  _repositionCloseButton() {\n    const rect = this._dialogBody.getBoundingClientRect();\n    const right = rect.right - rect.width;\n    // Only reposition if the window is positioned center, otherwise respect\n    // CSS styling:\n    if (right > 0) {\n      this._closeButton.style.right = `${right}px`;\n    } else {\n      this._closeButton.style.right = '';\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/modal/modal-default.js\n **/","import Component from '../component/component';\nimport transitionendEvent from '../util/transition-end-event';\n\nconst CLOSE_BUTTON_SIZE_SMALL = 45;\nconst CLOSE_BUTTON_SIZE_LARGE = 81;\nconst CLOSE_ICON_SIZE_SMALL = 17;\nconst CLOSE_ICON_SIZE_LARGE = 31;\nconst CLASS_BACKDROP = 'aui-modal-backdrop';\nconst CLASS_CLOSE = 'aui-modal-dialog__close';\nconst CLASS_IS_ACTIVE = 'is-active';\n\n/**\n * Class constructor for ModalDialog AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class ModalDialog extends Component {\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    this._body = document.querySelector('body');\n\n    this._closeButton = this._element.querySelector(`.${CLASS_CLOSE}`);\n    if (this._closeButton) {\n      this._addCloseButton(this._closeButton);\n    }\n  }\n\n  /**\n   * Opens this modal.\n   */\n  open() {\n    if (this._element.parentNode !== this._body) {\n      this._body.appendChild(this._element);\n    }\n  }\n\n  /**\n   * Handle transition end event\n   * @param {Event} event which was fired.\n   */\n  _onBackdropCloseTransitionend(event) {\n    if (event.target === event.currentTarget) {\n      this._backdrop.removeEventListener(transitionendEvent, this._backdropCloseTransitionendHandler);\n      this._element.classList.remove(CLASS_IS_ACTIVE);\n      this._removeBackdrop();\n    }\n  }\n\n  /**\n   * Adds a semi-transparent backdrop element behind the modal.\n   */\n  _addBackdrop() {\n    if (!this._backdrop) {\n      this._backdrop = document.createElement('div');\n      this._backdrop.classList.add(CLASS_BACKDROP);\n      this._body.appendChild(this._backdrop);\n    }\n  }\n\n  /**\n   * Removes the backdrop element behind modal.\n   */\n  _removeBackdrop() {\n    if (this._backdrop) {\n      this._body.removeChild(this._backdrop);\n      this._backdrop = null;\n    }\n  }\n\n  /**\n   * Adds close button\n   * @param {HTMLElement} container to append close icon to.\n   */\n  _addCloseButton(container) {\n    let diagonalHalf = (Math.sqrt(2) * CLOSE_ICON_SIZE_SMALL) / 2;\n    let btnSize = CLOSE_BUTTON_SIZE_SMALL;\n\n    const small = this.createSvgNode(\n      'svg', {\n        class: 'aui-modal-close-icon-small',\n        viewBox: `0 0 ${btnSize} ${btnSize}`\n      });\n    let group = this.createSvgNode(\n      'g', {\n        transform: `translate(${btnSize / 2}, ${btnSize / 2})`\n      });\n    group.appendChild(this.createSvgNode('line', {\n      x1: '0',\n      y1: -diagonalHalf,\n      x2: '0',\n      y2: diagonalHalf,\n      stroke: 'currentColor',\n      transform: 'rotate(-45, 0, 0)'\n    }));\n    group.appendChild(this.createSvgNode('line', {\n      x1: '0',\n      y1: -diagonalHalf,\n      x2: '0',\n      y2: diagonalHalf,\n      stroke: 'currentColor',\n      transform: 'rotate(45, 0, 0)'\n    }));\n    small.appendChild(group);\n    container.appendChild(small);\n\n    diagonalHalf = (Math.sqrt(2) * CLOSE_ICON_SIZE_LARGE) / 2;\n    btnSize = CLOSE_BUTTON_SIZE_LARGE;\n    const large = this.createSvgNode(\n      'svg', {\n        'class': 'aui-modal-close-icon-large',\n        'viewBox': `0 0 ${btnSize} ${btnSize}`\n      });\n    group = this.createSvgNode(\n      'g', {\n        transform: `translate(${btnSize / 2}, ${btnSize / 2})`\n      });\n    group.appendChild(this.createSvgNode('line', {\n      x1: '0',\n      y1: -diagonalHalf,\n      x2: '0',\n      y2: diagonalHalf,\n      stroke: 'currentColor',\n      transform: 'rotate(-45, 0, 0)'\n    }));\n    group.appendChild(this.createSvgNode('line', {\n      x1: '0',\n      y1: -diagonalHalf,\n      x2: '0',\n      y2: diagonalHalf,\n      stroke: 'currentColor',\n      transform: 'rotate(45, 0, 0)'\n    }));\n    large.appendChild(group);\n    container.appendChild(large);\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/modal/modal-dialog.js\n **/","import ModalDialog from '../modal/modal-dialog';\nimport transitionendEvent from '../util/transition-end-event';\n\nconst CLASS_MODAL_IS_OPEN = 'aui-modal-open';\nconst CLASS_CONTENT = 'aui-modal-dialog__content';\nconst CLASS_MORPH_DIALOG = 'aui-modal-morph';\nconst CLASS_IS_ACTIVE = 'is-active';\nconst CLASS_IS_MORPHING = 'is-morphing';\n\n/**\n * Class constructor for ModalMorph AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class ModalMorph extends ModalDialog {\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    this._content = this._element.querySelector(`.${CLASS_CONTENT}`);\n  }\n\n  /**\n   * Open modal\n   * @param {HTMLElement} trigger The element which opens the modal.\n   */\n  open(trigger) {\n    console.log('Open morphing modal');\n    super.open();\n    this._trigger = trigger;\n\n    // Make modal element visible\n    this._element.classList.add(CLASS_IS_ACTIVE);\n    this._element.scrollTop = 0;\n    this._addBackdrop();\n\n    window.requestAnimationFrame(() => this._prepareOpenTransition());\n  }\n\n  _prepareOpenTransition() {\n    const rect = this._trigger.getBoundingClientRect();\n\n    // Apply bounding rect to start with to morphing element\n    this._morph = this._getMorphElement(rect);\n\n    // Start opening animation\n    window.requestAnimationFrame(() => this._startOpenTransition());\n  }\n\n  _startOpenTransition() {\n    const rect = this._content.getBoundingClientRect();\n\n    // Apply bounding rect to end on to morphing element\n    this._applyBoundingRectToElement(this._morph, rect);\n    transitionendEvent && this._element.addEventListener(transitionendEvent, this._boundTransitionendElementIn = (event) => this._onTransitionendElementIn(event));\n    this._morph.classList.add(CLASS_IS_MORPHING);\n    this._body.classList.add(CLASS_MODAL_IS_OPEN);\n  }\n\n  _onTransitionendElementIn(event) {\n    this._element.removeEventListener(transitionendEvent, this._boundTransitionendElementIn);\n    this._morph.classList.remove(CLASS_IS_MORPHING);\n  }\n\n  /**\n   * Close modal\n   */\n  close() {\n    console.log('close');\n    if (this._backdrop) {\n      this._backdrop.removeEventListener(transitionendEvent, this._backdropCloseTransitionendHandler);\n      transitionendEvent && this._backdrop.addEventListener(transitionendEvent, this._backdropCloseTransitionendHandler = (event) => this._onBackdropCloseTransitionend(event));\n    }\n\n    this._element.removeEventListener(transitionendEvent, this._boundTransitionendElementIn);\n\n    const rect = this._content.getBoundingClientRect();\n    this._applyBoundingRectToElement(this._morph, rect);\n    this._morph.classList.add(CLASS_IS_MORPHING);\n\n    transitionendEvent && this._morph.addEventListener(transitionendEvent, this._boundTransitionendMorphOut = (event) => this._onTransitionendMorphOut(event));\n\n    window.requestAnimationFrame(() => this._startCloseTransition());\n  }\n\n  _startCloseTransition() {\n    const rect = this._trigger.getBoundingClientRect();\n    this._applyBoundingRectToElement(this._morph, rect);\n\n    this._body.classList.remove(CLASS_MODAL_IS_OPEN);\n  }\n\n  _onTransitionendMorphOut(event) {\n    this._morph.removeEventListener(transitionendEvent, this._boundTransitionendMorphOut);\n    this.removeChild(this._morph);\n    this._morph = null;\n  }\n\n  _onMorpBodyCloseTransitionend(event) {\n    if (event.target === event.currentTarget) {\n      this._morphBody.removeEventListener(transitionendEvent, this._morpBodyCloseTransitionendHandler);\n      this._morphBody.removeAttribute('style');\n      this._content.classList.remove(CLASS_IS_MORPHING);\n    }\n  }\n\n  _applyBoundingRectToElement(element, rect) {\n    element.style.top = `${Math.round(rect.top)}px`;\n    element.style.left = `${Math.round(rect.left)}px`;\n    element.style.width = `${Math.round(rect.width)}px`;\n    element.style.height = `${Math.round(rect.height)}px`;\n  }\n\n  _getMorphElement(rect) {\n    if (!this._morph) {\n      this._morph = this.createElement('div', [CLASS_MORPH_DIALOG]);\n      this._applyBoundingRectToElement(this._morph, rect);\n      this._body.append(this._morph);\n    }\n    return this._morph;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/modal/modal-morph.js\n **/","import Component from '../component/component';\nimport NavBar from '../nav/nav-bar';\nimport NavDropdown from '../nav/nav-dropdown';\nimport NavList from '../nav/nav-list';\nimport ResizeObserver from '../util/resize-observer';\n\nconst SELECTOR_COMPONENT = '.aui-js-nav';\nconst CLASS_LIST = 'aui-nav--list';\nconst CLASS_BAR = 'aui-nav--bar';\nconst CLASS_TAB = 'aui-nav--tab';\nconst CLASS_DROPDOWN = 'aui-nav--dropdown';\n\n/**\n * Class constructor for Nav AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Nav extends Component {\n\n  /**\n   * Upgrades all Nav AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Nav(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Returns modifier `list`\n   */\n  static get MODIFIER_LIST() {\n    return CLASS_LIST;\n  }\n\n  /**\n   * Returns modifier `bar`\n   */\n  static get MODIFIER_BAR() {\n    return CLASS_BAR;\n  }\n\n  /**\n   * Returns modifier `tab`\n   */\n  static get MODIFIER_TAB() {\n    return CLASS_TAB;\n  }\n\n  /**\n   * Returns modifier `dropdown`\n   */\n  static get MODIFIER_DROPDOWN() {\n    return CLASS_DROPDOWN;\n  }\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component.\n   */\n  init() {\n    super.init();\n\n    // Initialize with appropriate decorator depending on modifier,\n    // represented by according CSS class:\n    if (this._element.classList.contains(CLASS_BAR)) {\n      this._originModifier = Nav.MODIFIER_BAR;\n\n    } else if (this._element.classList.contains(CLASS_TAB)) {\n      this._originModifier = Nav.MODIFIER_TAB;\n\n    } else if (this._element.classList.contains(CLASS_DROPDOWN)) {\n      this._originModifier = Nav.MODIFIER_DROPDOWN;\n\n    } else if (this._element.classList.contains(CLASS_LIST)) {\n      this._originModifier = Nav.MODIFIER_LIST;\n    }\n\n    this._layoutBreakpoint = parseInt(window.getComputedStyle(this._element, ':after').getPropertyValue('content').replace(/['\"]+/g, ''));\n\n    if (this._layoutBreakpoint > 0 && (this._originModifier === Nav.MODIFIER_BAR || this._originModifier === Nav.MODIFIER_TAB)) {\n      this._resizeObserver = new ResizeObserver();\n      this._resizeObserver.resized.add(this._boundResize = () => this._resized());\n      this._resized();\n    } else {\n      this.setModifier(this._originModifier);\n    }\n  }\n\n  /**\n   * Dispose component.\n   */\n  dispose() {\n    super.dispose();\n\n    if (this._decorator) {\n      this._decorator.dispose();\n    }\n  }\n\n  /**\n   * Updates inidcator position and visibility of paddles.\n   */\n  update() {\n    if (this._decorator) {\n      this._decorator.update();\n    }\n  }\n\n  /**\n   * Set modifier to switch style of Nav Component.\n   * @param {string} modifier name.\n   * @throws Will throw an error, if the given modifier is not supported.\n   */\n  setModifier(modifier) {\n    if (this._modifier === modifier) {\n      return;\n    }\n\n    if (this._decorator) {\n      this._decorator.dispose();\n    }\n\n    this._element.classList.remove(CLASS_LIST, CLASS_BAR, CLASS_TAB, CLASS_DROPDOWN);\n\n    switch (modifier) {\n      case Nav.MODIFIER_BAR:\n        this._element.classList.add(CLASS_BAR);\n        this._decorator = new NavBar(this._element);\n        break;\n\n      case Nav.MODIFIER_TAB:\n        this._element.classList.add(CLASS_TAB);\n        this._decorator = new NavBar(this._element);\n        break;\n\n      case Nav.MODIFIER_DROPDOWN:\n        this._element.classList.add(CLASS_DROPDOWN);\n        this._decorator = new NavDropdown(this._element);\n        break;\n\n      case Nav.MODIFIER_LIST:\n        this._element.classList.add(CLASS_LIST);\n        this._decorator = new NavList(this._element);\n        break;\n\n      default:\n        throw new Error(`Modifier '${modifier}' for Nav component not supported.`);\n    }\n\n    this._modifier = modifier;\n  }\n\n  /**\n   * Handle resize signal.\n   */\n  _resized() {\n    const viewportWidth = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n    if (this._originModifier === Nav.MODIFIER_BAR || this._originModifier === Nav.MODIFIER_TAB) {\n      if (viewportWidth >= this._layoutBreakpoint) {\n        this.setModifier(this._originModifier);\n      } else {\n        this.setModifier(Nav.MODIFIER_DROPDOWN);\n      }\n    }\n  }\n\n  /**\n   * Returns index.\n   * @returns {number} the index of current active action element.\n   */\n  get index() {\n    return this._decorator\n      ? this._decorator.index\n      : undefined;\n  }\n\n  /**\n   * Returns length.\n   * @returns {number} the number of action elements.\n   */\n  get length() {\n    return this._decorator\n      ? this._decorator.length\n      : undefined;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/nav/nav.js\n **/","import Component from '../component/component';\nimport ResizeObserver from '../util/resize-observer';\nimport ScrollObserverElement from '../util/scroll-observer-element';\nimport limit from '../util/limit';\n\nconst SELECTOR_COMPONENT = '.aui-js-nav';\nconst CLASS_PANEL = 'aui-nav__panel';\nconst CLASS_ACTION = 'aui-nav__action';\nconst CLASS_INDICATOR = 'aui-nav__indicator';\nconst CLASS_PADDLES = 'aui-nav__paddles';\nconst CLASS_PADDLE_LEFT = 'aui-nav__paddle-left';\nconst CLASS_PADDLE_RIGHT = 'aui-nav__paddle-right';\nconst CLASS_IS_ACTIVE = 'is-active';\nconst CLASS_IS_ANIMATED = 'is-animated';\nconst SHOW_INDICATOR_DELAY = 0.25; // in seconds; Delay after which, the indicator fades in.\nconst INDICATOR_HIDDEN_X = -20; // Position of indicator when it's hidden, e.g. on page load.\nconst INDICATOR_HIDDEN_WIDTH = 10; // Width of indicator when it's hidden, e.g. on page load.\nconst SCROLL_THRESHOLD = 20; // in px; How far to scroll, before paddles are visible.\nconst SCROLL_PADDING = 10; // in px;\nconst SCROLL_EASING = 0.2;\n\n/**\n * Class constructor for NavBar AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class NavBar extends Component {\n\n  /**\n   * Upgrades all NavBar AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new NavBar(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component.\n   */\n  init() {\n    super.init();\n\n    // Refer elements\n    this._panel = this._element.querySelector(`.${CLASS_PANEL}`);\n    this._actionElements = Array.from(this._element.querySelectorAll(`.${CLASS_ACTION}`));\n\n    // Add indicator (line underneath action elements)\n    this._indicator = document.createElement('span');\n    this._indicator.classList.add(CLASS_INDICATOR);\n    this._panel.appendChild(this._indicator);\n\n    // Add paddles (gradient and buttons on the left/right, when scrolling is required)\n    this._paddles = document.createElement('div');\n    this._paddles.classList.add(CLASS_PADDLES);\n    this._element.appendChild(this._paddles);\n    this._paddleLeft = this._addPaddle(CLASS_PADDLE_LEFT);\n    this._paddleRight = this._addPaddle(CLASS_PADDLE_RIGHT);\n\n    // Watch window resizing\n    this._resizeObserver = new ResizeObserver();\n    this._resizeObserver.resized.add(this._resizedHandler = () => this.update());\n\n    // Watch scrolling of wrapper element\n    this._scrollObserver = new ScrollObserverElement(this._panel);\n    this._scrollObserver.scrolled.add(this._scrollHandler = () => this._onScrollElement());\n    this._onScrollElement();\n\n    // Add event handler\n    this._element.addEventListener('click', this._clickHandler = (event) => this._onClick(event));\n\n    // Set initial action element active\n    this.setActive(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n\n    // Delay fade in of indicator\n    setTimeout(() => {\n      this._element.classList.add(CLASS_IS_ANIMATED);\n    }, SHOW_INDICATOR_DELAY * 1000);\n  }\n\n  /**\n   * Dispose component.\n   */\n  dispose() {\n    super.dispose();\n    this._panel.scrollLeft = 0;\n    this._scrollActive = false;\n    this._resizeObserver.resized.remove(this._resizedHandler);\n    this._scrollObserver.scrolled.remove(this._scrollHandler);\n    this.removeChild(this._indicator);\n    this.removeChild(this._paddles);\n    this._element.removeEventListener('click', this._clickHandler);\n    this._element.classList.remove(CLASS_IS_ANIMATED);\n  }\n\n  /**\n   * Updates inidcator position and visibility of paddles.\n   */\n  update() {\n    this.setActive(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n    this._updatePaddleVisibility();\n  }\n\n  /**\n   * Set an action element at given index active.\n   * @param {index} index The index of action element to set active.\n   */\n  setActiveByIndex(index) {\n    let i = limit(index, 0, this._actionElements.length);\n    this.setActive(this._actionElements[i]);\n  }\n\n  /**\n   * Set an action element active.\n   * @param {HTMLElement} activeTarget The action element to set active.\n   */\n  setActive(activeTarget) {\n    // TODO: Optimize like in nav-list\n    this._actionElements.forEach(item => {\n      item.classList.remove(CLASS_IS_ACTIVE);\n    });\n\n    let indicatorLeft = INDICATOR_HIDDEN_X;\n    let indicatorWidth = INDICATOR_HIDDEN_WIDTH;\n\n    if (activeTarget) {\n      activeTarget.classList.add(CLASS_IS_ACTIVE);\n      let containerBounds = this._element.getBoundingClientRect();\n      let rectTarget = activeTarget.getBoundingClientRect();\n      indicatorLeft = rectTarget.left - containerBounds.left + this._panel.scrollLeft;\n      indicatorWidth = activeTarget.offsetWidth;\n    }\n\n    this._indicator.style.left = `${indicatorLeft}px`;\n    this._indicator.style.width = `${indicatorWidth}px`;\n\n    this._index = null;\n    for (var i = 0; i < this._actionElements.length; i++) {\n      if (this._actionElements[i] === activeTarget) {\n        this._index = i;\n        break;\n      }\n    }\n  }\n\n  /**\n   * Scroll to the next visible action element on the left.\n   */\n  scrollLeft() {\n    this.scroll(-1);\n  }\n\n  /**\n   * Scroll to the next visible action element on the right.\n   */\n  scrollRight() {\n    this.scroll(1);\n  }\n\n  /**\n   * Scroll to the next visible action element on the left or right.\n   * @param {number} dir The direction to scroll to: -1=>left, 1=>right.\n   */\n  scroll(dir) {\n    let containerBounds = this._element.getBoundingClientRect();\n    let elementBounds;\n    let left = 0;\n    let right = this._panel.offsetWidth;\n    let scroll = 0;\n\n    if (dir < 0) {\n      // Scroll to previous element\n      for (let i = this._actionElements.length - 1; i > 0; i--) {\n        let element = this._actionElements[i];\n        elementBounds = element.getBoundingClientRect();\n        let elementLeft = elementBounds.left - containerBounds.left;\n        if (elementLeft < left) {\n          scroll = Math.ceil(elementLeft + this._panel.scrollLeft - SCROLL_PADDING);\n          break;\n        }\n      }\n\n    } else {\n      // Scroll to next element\n      for (let i = 0; i < this._actionElements.length; i++) {\n        let element = this._actionElements[i];\n        elementBounds = element.getBoundingClientRect();\n        let elementRight = elementBounds.left - containerBounds.left + element.offsetWidth;\n        if (elementRight > right) {\n          scroll = Math.ceil(elementRight + this._panel.scrollLeft + SCROLL_PADDING - right);\n          break;\n        }\n      }\n    }\n\n    this._animateScroll(scroll);\n  }\n\n  /**\n   * Scroll to the next visible action element on the left or right.\n   * @param {number} scroll position to scroll to.\n   * @private\n   */\n  _animateScroll(scroll) {\n    this._scrollStart = this._panel.scrollLeft;\n    this._scrollDelta = scroll - this._scrollStart;\n    this._scrollRatio = 0;\n    this._scrollActive = true;\n    window.requestAnimationFrame(() => this._animateScrollTick());\n  }\n\n  /**\n   * Scroll animation tick.\n   * @private\n   */\n  _animateScrollTick() {\n    let ratio = 1 - this._scrollRatio;\n    ratio *= SCROLL_EASING;\n    this._scrollRatio += ratio;\n\n    if (ratio < 0.001) {\n      this._scrollRatio = 1;\n    }\n    this._panel.scrollLeft = this._scrollStart + this._scrollDelta * this._scrollRatio;\n\n    if (this._scrollActive && this._scrollRatio !== 1) {\n      window.requestAnimationFrame(() => this._animateScrollTick());\n    }\n  }\n\n  /**\n   * Adds a paddle element.\n   * @param {string} cssClass to add to element.\n   * @returns {HTMLElement} the created paddle element.\n   * @private\n   */\n  _addPaddle(cssClass) {\n    let paddle = document.createElement('button');\n    paddle.setAttribute('type', 'button');\n    paddle.classList.add(cssClass);\n    this._paddles.appendChild(paddle);\n    return paddle;\n  }\n\n  /**\n   * Update visibility of paddles depending on scroll position.\n   * @private\n   */\n  _updatePaddleVisibility() {\n    if (this._scrollObserver.scrollLeft - SCROLL_THRESHOLD > 0) {\n      this._paddleLeft.disabled = false;\n    } else {\n      this._paddleLeft.disabled = true;\n    }\n\n    if (this._scrollObserver.scrollLeft + this._element.offsetWidth + SCROLL_THRESHOLD < this._panel.scrollWidth) {\n      this._paddleRight.disabled = false;\n    } else {\n      this._paddleRight.disabled = true;\n    }\n  }\n\n  /**\n   * Handle scroll of element.\n   * @private\n   */\n  _onScrollElement() {\n    this._updatePaddleVisibility();\n  }\n\n  /**\n   * Handle click of element.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onClick(event) {\n    if (event.target === this._paddleLeft) {\n      event.preventDefault();\n      this.scrollLeft();\n\n    } else if (event.target === this._paddleRight) {\n      event.preventDefault();\n      this.scrollRight();\n\n    } else {\n      // Find closest action element\n      let currentElement = event.target;\n      while (currentElement !== event.currentTarget) {\n        if (currentElement.classList.contains(CLASS_ACTION)) {\n          if (!currentElement.disabled) {\n            this.setActive(currentElement);\n          }\n          break;\n        }\n        currentElement = currentElement.parentNode;\n      }\n    }\n  }\n\n  /**\n   * Returns index.\n   * @returns {number} the index of current active action element.\n   */\n  get index() {\n    return this._index;\n  }\n\n  /**\n   * Returns length.\n   * @returns {number} the number of action elements.\n   */\n  get length() {\n    return this._actionElements.length;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/nav/nav-bar.js\n **/","import Signal from '../util/signal';\n\nconst SCROLL_END_THRESHOLD = 100; // in ms\n\nexport default class ScrollObserverElement {\n\n  constructor(element) {\n    this._element = element;\n    this._scrollX = this._element.scrollLeft;\n    this._scrollY = this._element.scrollTop;\n    this._ticking = false;\n\n    this.scrolled = new Signal();\n    this.scrollEnded = new Signal();\n\n    this._element.addEventListener('scroll', this._scrollHandler = (event) => this._onScroll(event));\n  }\n\n  _onScroll(event) {\n    this._scrollX = event.target.scrollLeft;\n    this._scrollY = event.target.scrollTop;\n\n    if (!this._ticking) {\n      window.requestAnimationFrame(() => {\n        this._ticking = false;\n        this.scrolled.dispatch(this._scrollX, this._scrollY);\n        clearTimeout(this._scrollEndTimeout);\n        this._scrollEndTimeout = setTimeout(() => {\n          this.scrollEnded.dispatch(this._scrollX, this._scrollY);\n        }, SCROLL_END_THRESHOLD);\n      });\n    }\n    this._ticking = true;\n  }\n\n  get scrollLeft() {\n    return this._scrollX;\n  }\n\n  get scrollTop() {\n    return this._scrollY;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/scroll-observer-element.js\n **/","/**\n * Limits a value to x >= min and x <= max.\n * @param {number} x The value to limit.\n * @param {number} min The value to limit.\n * @param {number} max The value to limit.\n * @returns {number} The limited value.\n */\nexport default function limit(x, min, max) {\n  if (x > max) x = max;\n  if (x < min) x = min;\n  return x;\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/limit.js\n **/","import Component from '../component/component';\nimport Sticky from '../sticky/sticky';\nimport limit from '../util/limit';\nimport isNone from '../util/is-none';\n\nconst SELECTOR_COMPONENT = '.aui-js-nav';\nconst CLASS_PANEL = 'aui-nav__panel';\nconst CLASS_UNDERLINE = 'aui-nav__underline';\nconst CLASS_ITEM = 'aui-nav__item';\nconst CLASS_ACTION = 'aui-nav__action';\nconst CLASS_TOGGLE = 'aui-nav__toggle';\nconst CLASS_TOGGLE_LABEL = 'aui-nav__toggle-label';\nconst CLASS_STICKY = 'aui-nav--sticky';\nconst CLASS_IS_ACTIVE = 'is-active';\n\n/**\n * Class constructor for NavDropdown AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class NavDropdown extends Component {\n\n  /**\n   * Upgrades all NavDropdown AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new NavDropdown(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component.\n   */\n  init() {\n    super.init();\n\n    this._index = 0;\n\n    // Refer elements\n    this._panel = this._element.querySelector(`.${CLASS_PANEL}`);\n    this._actions = Array.from(this._element.querySelectorAll(`.${CLASS_ACTION}`));\n\n    // Set transition delays for item elements\n    Array.from(this._element.querySelectorAll(`.${CLASS_ITEM}`)).forEach((element, index) => {\n      element.style.transitionDelay = element.style.webkitTransitionDelay = `${0.1 + 0.05 * index}s`;\n    });\n\n    // Add toggle element\n    this._toggle = this.createElement('button', [CLASS_TOGGLE], {\n      type: 'button'\n    });\n    this._element.appendChild(this._toggle);\n    this._toggleLabel = this.createElement('span', [CLASS_TOGGLE_LABEL]);\n    this._toggle.appendChild(this._toggleLabel);\n\n    // Add underline element\n    this._underline = this.createElement('div', [CLASS_UNDERLINE]);\n    this._element.appendChild(this._underline);\n\n    // Check if component is sticky\n    if (this._element.classList.contains(CLASS_STICKY)) {\n      this._stickyHandler = new Sticky(this._element);\n    }\n\n    // Add event handler\n    this._element.addEventListener('click', this._clickHandler = (event) => this._onClick(event));\n\n    // Set initial action element active\n    this.setActive(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n  }\n\n  /**\n   * Dispose component.\n   */\n  dispose() {\n    super.dispose();\n    this._actions.forEach((element, index) => {\n      element.style.transitionDelay = '';\n    });\n    this.removeChild(this._toggle);\n    this.removeChild(this._underline);\n    this._element.removeEventListener('click', this._clickHandler);\n  }\n\n  /**\n   * Updates inidcator position and visibility of paddles.\n   */\n  update() {\n    this.setActive(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n  }\n\n  /**\n   * Toggle active state.\n   * @param {boolean} force If is true, open panel, and if it is false, close it.\n   */\n  toggle(force) {\n    this._element.classList.toggle(CLASS_IS_ACTIVE, force);\n  }\n\n  /**\n   * Set an action element at given index active.\n   * @param {index} index The index of action element to set active.\n   */\n  setActiveByIndex(index) {\n    let i = limit(index, 0, this._actions.length);\n    this.setActive(this._actions[i]);\n  }\n\n  /**\n   * Set an action element active.\n   * @param {HTMLElement} activeTarget The action element to set active.\n   */\n  setActive(activeTarget) {\n    // TODO: Optimize like in nav-list\n\n    // Remove active class from all action elements\n    this._actions.forEach(item => {\n      item.classList.remove(CLASS_IS_ACTIVE);\n    });\n\n    // If no action element is active, pick the first one\n    if (isNone(activeTarget)) {\n      activeTarget = this._actions[0];\n    }\n\n    // Apply active class to action element and mirror innerHTML to toggle\n    activeTarget.classList.add(CLASS_IS_ACTIVE);\n    this._toggleLabel.innerHTML = activeTarget.innerHTML;\n\n    // Update active index\n    this._index = null;\n    for (var i = 0; i < this._actions.length; i++) {\n      if (this._actions[i] === activeTarget) {\n        this._index = i;\n        break;\n      }\n    }\n  }\n\n  /**\n   * Handle click of element.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onClick(event) {\n    if (event.target === this._toggle) {\n      this.toggle();\n    } else {\n      // Find closest action element\n      let currentElement = event.target;\n      while (currentElement !== event.currentTarget) {\n        if (currentElement.classList.contains(CLASS_ACTION)) {\n          this.setActive(currentElement);\n          this.toggle();\n          break;\n        }\n        currentElement = currentElement.parentNode;\n      }\n    }\n  }\n\n  /**\n   * Returns index.\n   * @returns {number} the index of current active action element.\n   */\n  get index() {\n    return this._index;\n  }\n\n  /**\n   * Returns length.\n   * @returns {number} the number of action elements.\n   */\n  get length() {\n    return this._actions.length;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/nav/nav-dropdown.js\n **/","import Component from '../component/component';\nimport ScrollObserver from '../util/scroll-observer';\n\nconst CLASS_IS_STICKY = 'is-sticky';\n\n/**\n * Class constructor for Sticky AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Sticky extends Component {\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component.\n   */\n  init() {\n    super.init();\n\n    // If browser supports position:sticky, it will handle positioning and\n    // we can skip here.\n    if (window.getComputedStyle(this._element).position.indexOf('sticky') !== -1) {\n      return;\n    }\n\n    this._scrollObserver = new ScrollObserver();\n    this._scrollObserver.scrolled.add(this._scrollHandler = () => this.checkStickiness());\n\n    this._sticky = false;\n    this.checkStickiness();\n  }\n\n  /**\n  * Dispose component.\n  */\n  dispose() {\n    super.dispose();\n\n    this.release();\n    this._scrollObserver.resized.remove(this._scrollHandler);\n    this._resizeObserver.resized.remove(this._resizedHandler);\n  }\n\n  /**\n   * Check if position.top is negative. If so stick otherwise release component.\n   */\n  checkStickiness() {\n    if (this._element.getBoundingClientRect().top <= 0) {\n      if (!this._sticky) {\n        this.stick();\n      }\n    } else {\n      if (this._sticky) {\n        this.release();\n      }\n    }\n  }\n\n  /**\n   * Stick component to top of viewport in adding sticky class.\n   */\n  stick() {\n    if (!this._sticky) {\n      this._element.classList.add(CLASS_IS_STICKY);\n    }\n    this._sticky = true;\n  }\n\n  /**\n   * Release component and position not fixed in removing sticky class.\n   */\n  release() {\n    if (this._sticky) {\n      this._element.classList.remove(CLASS_IS_STICKY);\n    }\n    this._sticky = false;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/sticky/sticky.js\n **/","/**\n * Check if value is either `undefined` or `null`.\n * @param {*} value to check.\n * @returns {boolean} true if value is `undefined` or `null`.\n */\nexport default function isNone(value) {\n  return (value === undefined || value === null);\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/is-none.js\n **/","import Component from '../component/component';\nimport limit from '../util/limit';\n\nconst SELECTOR_COMPONENT = '.aui-js-nav';\nconst CLASS_ACTION = 'aui-nav__action';\nconst CLASS_IS_ACTIVE = 'is-active';\n\n/**\n * Class constructor for NavList AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class NavList extends Component {\n\n  /**\n   * Upgrades all NavList AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new NavList(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component.\n   */\n  init() {\n    super.init();\n\n    // Refer elements\n    this._actionElements = Array.from(this._element.querySelectorAll(`.${CLASS_ACTION}`));\n\n    // Add event handler\n    this._element.addEventListener('click', this._clickHandler = (event) => this._onClick(event));\n\n    // Set initial action element active\n    this.setActive(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n  }\n\n  /**\n   * Dispose component.\n   */\n  dispose() {\n    super.dispose();\n    this._element.removeEventListener('click', this._clickHandler);\n  }\n\n  /**\n   * Updates inidcator position and visibility of paddles.\n   */\n  update() {\n    this.setActive(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n  }\n\n  /**\n   * Set an action element at given index active.\n   * @param {index} index The index of action element to set active.\n   */\n  setActiveByIndex(index) {\n    const i = limit(index, 0, this._actionElements.length);\n    this.setActive(this._actionElements[i]);\n  }\n\n  /**\n   * Set an action element active.\n   * @param {HTMLElement} activeTarget The action element to set active.\n   */\n  setActive(activeTarget) {\n    this._actionElements.forEach((item, index) => {\n      const active = (item === activeTarget);\n      item.classList.toggle(CLASS_IS_ACTIVE, active);\n      if (active) {\n        this._index = index;\n      }\n    });\n  }\n\n\n  /**\n   * Handle click of element.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onClick(event) {\n    // Find closest action element\n    let currentElement = event.target;\n    while (currentElement !== event.currentTarget) {\n      if (currentElement.classList.contains(CLASS_ACTION)) {\n        if (!currentElement.disabled) {\n          this.setActive(currentElement);\n        }\n        break;\n      }\n      currentElement = currentElement.parentNode;\n    }\n  }\n\n  /**\n   * Returns index.\n   * @returns {number} the index of current active action element.\n   */\n  get index() {\n    return this._index;\n  }\n\n  /**\n   * Returns length.\n   * @returns {number} the number of action elements.\n   */\n  get length() {\n    return this._actionElements.length;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/nav/nav-list.js\n **/","import Component from '../component/component';\n\nconst SELECTOR_COMPONENT = '.aui-js-notification';\nconst CLASS_CONTENT = 'aui-notification__content';\nconst CLASS_CLOSE_BUTTON = 'aui-notification__close';\nconst CLASS_IS_CLOSED = 'is-closed';\nconst CLASS_IS_OPEN = 'is-open';\nconst ATTR_CLOSE = 'data-close';\n\n/**\n * Class constructor for Notification AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Notification extends Component {\n\n  /**\n   * Upgrades all Notification AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Notification(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n  }\n\n  init() {\n    super.init();\n\n    this._content = this._element.querySelector(`.${CLASS_CONTENT}`);\n    if (!this._content) {\n      this._content = document.createElement('div');\n      this._content.classList.add(CLASS_CONTENT);\n      this._element.appendChild(this._content);\n    }\n\n    // Add close button\n    this._closeButton = document.createElement('button');\n    this._closeButton.setAttribute('type', 'button');\n    this._closeButton.classList.add(CLASS_CLOSE_BUTTON);\n    this._element.appendChild(this._closeButton);\n\n    this.open();\n  }\n\n  open() {\n    this._element.addEventListener('click', this._clickHandler = (event) => this._onClick(event));\n    this.checkOpeningPreparation();\n  }\n\n  checkOpeningPreparation() {\n    clearTimeout(this.openingTimeout);\n    this._element.classList.add(CLASS_IS_OPEN);\n    this._element.classList.remove(CLASS_IS_CLOSED);\n  }\n\n  close() {\n    this._element.removeEventListener('click', this._clickHandler);\n    this._element.style.height = `${this._element.offsetHeight}px`;\n    this._element.style.marginTop = '0px';\n    this._element.style.marginBottom = '0px';\n    this.checkClosingPreparation();\n  }\n\n  checkClosingPreparation() {\n    clearTimeout(this.openingTimeout);\n    if (window.getComputedStyle(this._element).height && this._element.style.height) {\n      this._element.classList.remove(CLASS_IS_OPEN);\n      this._element.classList.add(CLASS_IS_CLOSED);\n    } else {\n      window.requestAnimationFrame(() => this.checkClosingPreparation());\n    }\n  }\n\n  _onClick(event) {\n    if (event.target.classList.contains(CLASS_CLOSE_BUTTON) || event.target.hasAttribute(ATTR_CLOSE)) {\n      this.close();\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/notification/notification.js\n **/","import Component from '../component/component';\nimport ResizeObserver from '../util/resize-observer';\n\nconst SELECTOR_COMPONENT = '.aui-js-pagination';\nconst CLASS_ITEM = 'aui-pagination__link';\nconst CLASS_INDICATOR = 'aui-pagination__indicator';\nconst CLASS_IS_ACTIVE = 'is-active';\nconst CLASS_IS_ANIMATED = 'is-animated';\nconst CLASS_IS_DISABLED = 'is-disabled';\n\n/**\n * Class constructor for Pagination AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Pagination extends Component {\n\n  /**\n   * Upgrades all Pagination AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Pagination(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    this._resizeObserver = new ResizeObserver();\n    this._resizeObserver.resized.add(this._boundResized = () => this.update());\n\n    this._items = Array.from(this._element.querySelectorAll(`.${CLASS_ITEM}`));\n\n    this._indicator = document.createElement('span');\n    this._indicator.classList.add(CLASS_INDICATOR);\n    this._element.appendChild(this._indicator);\n\n    this._element.addEventListener('click', this._boundClick = (event) => this._onClick(event));\n\n    this._repositionIndicator(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n    setTimeout(() => {\n      this._element.classList.add(CLASS_IS_ANIMATED);\n    }, 250);\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n\n    this._element.classList.remove(CLASS_IS_ANIMATED);\n\n    this._element.removeEventListener('click', this._boundClick);\n    this._resizeObserver.resized.remove(this._boundResized);\n\n    if (this._indicator) {\n      this.removeChild(this._indicator);\n    }\n  }\n\n  /**\n   * Update component.\n   */\n  update() {\n    this._repositionIndicator(this._element.querySelector(`.${CLASS_IS_ACTIVE}`));\n  }\n\n  /**\n   * Reposition indicator of `active` page.\n   * @param {HTMLElement} linkElement that is going to be `active`.\n   * @private\n   */\n  _repositionIndicator(linkElement) {\n    if (!linkElement)\n      return;\n\n    this._items.forEach(item => {\n      item.classList.remove(CLASS_IS_ACTIVE);\n    });\n    linkElement.classList.add(CLASS_IS_ACTIVE);\n\n    // Indicator position\n    const rectContainer = this._element.getBoundingClientRect();\n    const rectTarget = linkElement.getBoundingClientRect();\n    const indicatorLeft = rectTarget.left - rectContainer.left + this._element.scrollLeft;\n    this._indicator.style.left = `${indicatorLeft}px`;\n    this._indicator.style.width = `${linkElement.offsetWidth}px`;\n  }\n\n  /**\n   * Handle click.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onClick(event) {\n    if (event.target.classList.contains(CLASS_ITEM) && !event.target.classList.contains(CLASS_IS_DISABLED)) {\n      this._repositionIndicator(event.target);\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/pagination/pagination.js\n **/","import Component from '../component/component';\n\nconst SELECTOR_COMPONENT = '.aui-js-player';\nconst SELECTOR_PROGRESS_CONTROL = '.aui-player__progress-control';\nconst SELECTOR_SEEK_HOLDER = '.aui-player__seek-holder';\nconst SELECTOR_PREVIEW = '.aui-player__preview';\nconst CLASS_SEEKING = 'is-seeking';\n\n/**\n * Class constructor for Player AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Player extends Component {\n\n  /**\n   * Upgrades all Player AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Player(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n\n    this._progressControl = this._element.querySelector(SELECTOR_PROGRESS_CONTROL);\n    if (this._progressControl) {\n      this._progressControl.addEventListener('mouseover', this.progressControlOverListener = event => this.progressControlOverHandler(event));\n      this._progressControl.addEventListener('mouseout', this.progressControlOutListener = event => this.progressControlOutHandler(event));\n\n      this._seekHolder = this._progressControl.querySelector(SELECTOR_SEEK_HOLDER);\n    }\n\n    this._preview = this._element.querySelector(SELECTOR_PREVIEW);\n  }\n\n  progressControlOverHandler(event) {\n    this._progressControl.removeEventListener('mousemove', this.moveListener);\n    this._progressControl.addEventListener('mousemove', this.progressControlMoveListener = event => this.progressControlMoveHandler(event));\n    this._element.classList.add(CLASS_SEEKING);\n    this.updateSeek(event.clientX);\n  }\n\n  progressControlMoveHandler(event) {\n    this.updateSeek(event.clientX);\n  }\n\n  progressControlOutHandler(event) {\n    this._element.classList.remove(CLASS_SEEKING);\n  }\n\n  updateSeek() {\n    // Translate trigger position x to ratio of progress control width\n    let boundings = this._progressControl.getBoundingClientRect(),\n      offsetX = event.clientX - boundings.left,\n      ratio = offsetX / this._progressControl.offsetWidth,\n      ratioPercentStr;\n    ratio = Math.max(0, Math.min(ratio, 1));\n    ratioPercentStr = `${ratio * 100}%`\n    this._seekHolder.style.width = ratioPercentStr;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/player/player.js\n **/","import Component from '../component/component';\nimport limit from '../util/limit';\n\nconst SELECTOR_COMPONENT = '.aui-js-progress';\nconst CLASS_CONTINUOUS = 'aui-progress--continuous';\nconst CLASS_BAR = 'aui-progress__bar';\nconst CLASS_IS_PENDING = 'is-pending';\nconst CLASS_IS_LOADING = 'is-loading';\nconst CLASS_IS_COMPLETE = 'is-complete';\n\n/**\n * Class constructor for Progress AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Progress extends Component {\n\n  /**\n   * Upgrades all Progress AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Progress(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n  }\n\n  init() {\n    super.init();\n\n    this._continuous = this._element.classList.contains(CLASS_CONTINUOUS);\n\n    // Add bar elements:\n    this._bar = document.createElement('span');\n    this._bar.classList.add(CLASS_BAR);\n    this._element.appendChild(this._bar);\n\n    this.progress(0);\n  }\n\n  progress(ratio) {\n    ratio = limit(ratio, 0, 1);\n    this._progress = ratio;\n\n    if (!this._continuous) {\n      this._bar.style.width = `${this._progress * 100}%`;\n    }\n\n    this.updateClasses();\n  }\n\n  updateClasses() {\n    if (this._progress === 0) {\n      this._element.classList.add(CLASS_IS_PENDING);\n    } else {\n      this._element.classList.remove(CLASS_IS_PENDING);\n    }\n\n    if (this._progress > 0 && this._progress < 1) {\n      this._element.classList.add(CLASS_IS_LOADING);\n    } else {\n      this._element.classList.remove(CLASS_IS_LOADING);\n    }\n\n    if (this._progress === 1) {\n      this._element.classList.add(CLASS_IS_COMPLETE);\n    } else {\n      this._element.classList.remove(CLASS_IS_COMPLETE);\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/progress/progress.js\n **/","import Component from '../component/component';\n\nconst SELECTOR_COMPONENT = '.aui-js-radio';\nconst CLASS_INPUT = 'aui-radio__input';\nconst CLASS_LABEL = 'aui-radio__label';\nconst CLASS_BOX = 'aui-radio__box';\nconst CLASS_TICK = 'aui-radio__tick';\nconst CLASS_IS_FOCUS = 'is-focused';\nconst CLASS_IS_CHECKED = 'is-checked';\nconst CLASS_IS_DISABLED = 'is-disabled';\n\nlet _radios;\n\n/**\n * Class constructor for Radio AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Radio extends Component {\n\n  /**\n   * Upgrades all Radio AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Radio(element));\n      }\n    });\n    _radios = components;\n    return components;\n  };\n\n  init() {\n    super.init();\n\n    this._input = this._element.querySelector(`.${CLASS_INPUT}`);\n    this._input.addEventListener('change', this._changeHandler = (event) => this._onChange(event));\n    this._input.addEventListener('focus', this._focusHandler = (event) => this._onFocus(event));\n    this._input.addEventListener('blur', this._blurHandler = (event) => this._onBlur(event));\n\n    // Insert box with tick after label element:\n    this._label = this._element.querySelector(`.${CLASS_LABEL}`);\n    let box = document.createElement('span');\n    box.classList.add(CLASS_BOX);\n    this._label.parentNode.insertBefore(box, this._label.nextSibling);\n    let tick = document.createElement('span');\n    tick.classList.add(CLASS_TICK);\n    box.appendChild(tick);\n\n    this.groupName = this._input.getAttribute('name');\n\n    this.updateClasses();\n  }\n\n  updateClasses() {\n    this.checkDisabled();\n    this.checkToggleState();\n    this.checkFocus();\n  }\n\n  /**\n   * Check the disabled state and update field accordingly.\n   */\n  checkDisabled() {\n    if (this._input.disabled) {\n      this._element.classList.add(CLASS_IS_DISABLED);\n    } else {\n      this._element.classList.remove(CLASS_IS_DISABLED);\n    }\n  }\n\n  /**\n   * Check the toggle state and update field accordingly.\n   */\n  checkToggleState() {\n    if (this._input.checked) {\n      this._element.classList.add(CLASS_IS_CHECKED);\n    } else {\n      this._element.classList.remove(CLASS_IS_CHECKED);\n    }\n  }\n\n  /**\n   * Check the focus state and update field accordingly.\n   */\n  checkFocus() {\n    if (Boolean(this._element.querySelector(':focus'))) {\n      this._element.classList.add(CLASS_IS_FOCUS);\n    } else {\n      this._element.classList.remove(CLASS_IS_FOCUS);\n    }\n  }\n\n  /**\n   * Enable radio.\n   */\n  enable() {\n    this._input.disabled = false;\n    this.updateClasses();\n  }\n\n  /**\n   * Disable radio.\n   */\n  disable() {\n    this._input.disabled = true;\n    this.updateClasses();\n  }\n\n  /**\n   * Check radio.\n   */\n  check() {\n    this._input.checked = true;\n    this.updateClasses();\n  }\n\n  /**\n   * Uncheck radio.\n   */\n  uncheck() {\n    this._input.checked = false;\n    this.updateClasses();\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n\n    this._input.removeEventListener('change', this._changeHandler);\n    this._input.removeEventListener('focus', this._focusHandler);\n    this._input.removeEventListener('blur', this._blurHandler);\n\n    this._element.removeChild(this._element.querySelector(`.${CLASS_BOX}`));\n  }\n\n  /**\n   * Handle change event.\n   * @param {Event} event that fired.\n   */\n  _onChange(event) {\n    this.updateClasses();\n    // Since other radio buttons don't get change events, we need to look for\n    // them to update their classes.\n    for (var i = 0; i < _radios.length; i++) {\n      var button = _radios[i];\n      // Different name == different group, so no point updating those.\n      if (button._input.getAttribute('name') === this.groupName) {\n        button.updateClasses();\n      }\n    }\n  }\n\n  // TODO Find out why unfocus is triggered on mousedown\n  _onFocus(event) {\n    this._element.classList.add(CLASS_IS_FOCUS);\n  }\n\n  _onBlur(event) {\n    this._element.classList.remove(CLASS_IS_FOCUS);\n  }\n\n  /**\n   * Getter and Setter\n   */\n\n  get input() {\n    return this._input;\n  }\n\n  get checked() {\n    return this._input.checked = true;\n  }\n\n  set checked(value) {\n    if (value) {\n      this.check();\n    } else {\n      this.uncheck();\n    }\n  }\n\n  get disabled() {\n    return this._input.disabled = true;\n  }\n\n  set disabled(value) {\n    if (value) {\n      this.disable();\n    } else {\n      this.enable();\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/radio/radio.js\n **/","import Component from '../component/component';\nimport animationEndEvent from '../util/animation-end-event';\n\nconst SELECTOR_COMPONENT = '.aui-js-response';\nconst CLASS_BUTTON_PRIMARY = 'aui-button--primary';\nconst CLASS_BUTTON_SECONDARY = 'aui-button--secondary';\nconst CLASS_BUTTON_ICON = 'aui-button--icon';\nconst CLASS_BUTTON_FLOATING = 'aui-button--floating';\nconst CLASS_RESPONSE = 'aui-response';\nconst CLASS_RESPONSE_MASKED = 'aui-response--masked';\nconst CLASS_EFFECT = 'aui-response__effect';\nconst CLASS_EFFECT_LARGE = 'aui-response__effect--large';\nconst CLASS_IS_ANIMATING = 'is-animating';\nconst CLASS_IS_DISABLED = 'is-disabled';\n\n/**\n * Class constructor for Response AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Response extends Component {\n\n  /**\n   * Upgrades all Response AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Response(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Constructor\n   * @constructor\n   * @param {HTMLElement} element The element of the AUI component.\n   */\n  constructor(element) {\n    super(element);\n  }\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    let boxedButton = this._element.classList.contains(CLASS_BUTTON_PRIMARY) || this._element.classList.contains(CLASS_BUTTON_SECONDARY) || this._element.classList.contains(CLASS_BUTTON_FLOATING);\n\n    this._useTriggerX = boxedButton || !this._element.classList.contains(CLASS_BUTTON_ICON);\n    this._useTriggerY = boxedButton;\n    this._masked = boxedButton;\n    this._large = boxedButton;\n\n    this._responseContainer = document.createElement('span');\n    this._responseContainer.classList.add(CLASS_RESPONSE);\n    if (this._masked) {\n      this._responseContainer.classList.add(CLASS_RESPONSE_MASKED);\n    }\n    this._element.appendChild(this._responseContainer);\n\n    this._responseEffect = document.createElement('span');\n    this._responseEffect.classList.add(CLASS_EFFECT);\n    if (this._large) {\n      this._responseEffect.classList.add(CLASS_EFFECT_LARGE);\n    }\n    this._responseContainer.appendChild(this._responseEffect);\n\n    this._element.addEventListener('mousedown', this._mousedownHandler = (event) => this._onMousedown(event));\n    animationEndEvent && this._responseEffect.addEventListener(animationEndEvent, this._animationendHandler = (event) => this._onAnimationend(event));\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n\n    this._element.removeEventListener('mousedown', this._mousedownHandler);\n    if (animationEndEvent && this._responseEffect) {\n      this._responseEffect.removeEventListener(animationEndEvent, this._animationendHandler);\n    }\n    this._element.removeChild(this._responseContainer);\n  }\n\n  /**\n   * Handle mousedown of element.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onMousedown(event) {\n    // Get cross-browser offsetX, offsetY\n    let target = event.currentTarget || event.srcElement,\n      rect = target.getBoundingClientRect(),\n      offsetX = event.clientX - rect.left,\n      offsetY = event.clientY - rect.top;\n\n    if (!target.classList.contains(CLASS_IS_DISABLED)) {\n      this._responseEffect.style.left = this._useTriggerX ? `${offsetX}px` : '50%';\n      this._responseEffect.style.top = this._useTriggerY ? `${offsetY}px` : '50%';\n      this._responseContainer.classList.add(CLASS_IS_ANIMATING);\n    }\n  }\n\n  /**\n   * Handle animationend of element.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onAnimationend(event) {\n    this._responseContainer.classList.remove(CLASS_IS_ANIMATING);\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/response/response.js\n **/","// From Modernizr\nfunction whichAnimationEvent() {\n  let type;\n  let element = document.createElement('fakeelement');\n  let animations = {\n    'animation': 'animationend',\n    'OAnimation': 'oAnimationEnd',\n    'MozAnimation': 'animationend',\n    'WebkitAnimation': 'webkitAnimationEnd'\n  }\n\n  for (type in animations) {\n    if (element.style[type] !== undefined) {\n      return animations[type];\n    }\n  }\n}\n\nconst ANIMATION_EVENT = whichAnimationEvent();\n\nexport default ANIMATION_EVENT;\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/animation-end-event.js\n **/","import Component from '../component/component';\n\nconst SELECTOR_COMPONENT = '.aui-js-select';\nconst CLASS_INPUT = 'aui-select__input';\nconst CLASS_LABEL = 'aui-select__label';\nconst CLASS_FOCUS_LINE = 'aui-select__focus-line';\nconst CLASS_IS_FOCUS = 'is-focused';\nconst CLASS_IS_DIRTY = 'is-dirty';\nconst CLASS_IS_DISABLED = 'is-disabled';\n\n/**\n * Class constructor for Select AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Select extends Component {\n\n  /**\n   * Upgrades all Select AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Select(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n  }\n\n  init() {\n    super.init();\n\n    this._label = this._element.querySelector(`.${CLASS_LABEL}`);\n\n    this._input = this._element.querySelector(`.${CLASS_INPUT}`);\n    this._input.addEventListener('change', this._changeHandler = (event) => this._onChange(event));\n    this._input.addEventListener('focus', this._focusHandler = (event) => this._onFocus(event));\n    this._input.addEventListener('blur', this._blurHandler = (event) => this._onBlur(event));\n    this._input.addEventListener('reset', this._resetHandler = (event) => this._onReset(event));\n\n    // Insert thick focus line after select element:\n    let focusLine = document.createElement('span');\n    focusLine.classList.add(CLASS_FOCUS_LINE);\n    this._label.parentNode.insertBefore(focusLine, this._label.nextSibling);\n\n    this.updateClasses();\n  }\n\n  updateClasses() {\n    this.checkDisabled();\n    this.checkDirty();\n    this.checkFocus();\n  }\n\n  /**\n   * Check the disabled state and update field accordingly.\n   */\n  checkDisabled() {\n    if (this._input.disabled) {\n      this._element.classList.add(CLASS_IS_DISABLED);\n    } else {\n      this._element.classList.remove(CLASS_IS_DISABLED);\n    }\n  }\n\n  /**\n   * Check the dirty state and update field accordingly.\n   */\n  checkDirty() {\n    // console.log('value', this._input.value, typeof this._input.value);\n    // console.log('options', this._input.options[this._input.selectedIndex].disabled);\n    if (!this._input.options[this._input.selectedIndex].disabled) {\n      this._element.classList.add(CLASS_IS_DIRTY);\n    } else {\n      this._element.classList.remove(CLASS_IS_DIRTY);\n    }\n  }\n\n  /**\n   * Check the focus state and update field accordingly.\n   */\n  checkFocus() {\n    if (Boolean(this._element.querySelector(':focus'))) {\n      this._element.classList.add(CLASS_IS_FOCUS);\n    } else {\n      this._element.classList.remove(CLASS_IS_FOCUS);\n    }\n  }\n\n  /**\n   * Disable text field.\n   */\n  disable() {\n    this._input.disabled = true;\n    this.updateClasses();\n  }\n\n  /**\n   * Event Handler\n   */\n\n  _onChange(event) {\n    this.updateClasses();\n  }\n\n  _onFocus(event) {\n    this._element.classList.add(CLASS_IS_FOCUS);\n  }\n\n  _onBlur(event) {\n    this._element.classList.remove(CLASS_IS_FOCUS);\n  }\n\n  _onReset(event) {\n    this.updateClasses();\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/select/select.js\n **/","/**\n * NOTE Slider AUI components rely on the 3rd party library noUiSlider.\n * @see https://github.com/leongersen/noUiSlider\n */\n\nimport Component from '../component/component';\nimport limit from '../util/limit';\nimport mapLinear from '../util/map-linear';\nimport ResizeObserver from '../util/resize-observer';\nimport noUiSlider from 'nouislider';\n\nconst SELECTOR_COMPONENT = '.aui-js-slider';\nconst SELECTOR_HIDDEN_FIELD = '.aui-slider__hidden-field';\nconst SELECTOR_OUTPUT = '.aui-slider__output';\nconst CLASS_COMPONENT = 'aui-slider';\nconst CLASS_IS_DISABLED = 'is-disabled';\nconst EVENT_NAMESPACE = CLASS_COMPONENT;\n\n/**\n * Class constructor for Slider AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Slider extends Component {\n\n  /**\n   * Upgrades all Slider AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Slider(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    // Save reference to component elements\n    this._hiddenField = this._element.querySelector(SELECTOR_HIDDEN_FIELD);\n    this._output = this._element.querySelector(SELECTOR_OUTPUT);\n\n    // Create slider container element\n    this._slider = document.createElement('div');\n    this._element.insertBefore(this._slider, this._element.firstChild);\n\n    // Parse and save start and range values:\n    this._value = this._parseData(this._hiddenField.value);\n    this._rangeMin = this._parseData(this._element.getAttribute('data-min'));\n    this._rangeMax = this._parseData(this._element.getAttribute('data-max'));\n\n    // Create noUiSlider instance\n    noUiSlider.create(this._slider, {\n      // Set the start value defined in the hidden field.\n      // https://refreshless.com/nouislider/slider-options/#section-start\n      start: this._value,\n\n      // Set the range as defined in the data attributes\n      // https://refreshless.com/nouislider/slider-values/#section-range\n      range: {\n        min: this._rangeMin,\n        max: this._rangeMax\n      },\n\n      // If there are two handles, set the bar between the handles, but not\n      // between the handles and the sliders edges. If there is only one handle,\n      // set the bar from the slider edge to the handle.\n      // https://refreshless.com/nouislider/slider-options/#section-Connect\n      connect: this._value.length > 1\n        ? true\n        : [true, false],\n\n      // Define behaviour depending on number of handles\n      // https://refreshless.com/nouislider/behaviour-option/\n      behaviour: this._value.length > 1\n        ? 'tap-drag'\n        : 'tap',\n\n      // Use AUI namespace for css classes\n      // https://refreshless.com/nouislider/more/#section-styling\n      cssPrefix: `${CLASS_COMPONENT}__`\n    });\n    this._slider.noUiSlider.on(`update.${EVENT_NAMESPACE}`, (values, handle, unencoded, tap, positions) => this._onUpdate(values, handle, unencoded, tap, positions));\n\n    if (this._output) {\n      this._resizeObserver = new ResizeObserver();\n      this._resizeObserver.resized.add(this._resizedHandler = () => this._centerOutput());\n    }\n\n    if (this._element.classList.contains(CLASS_IS_DISABLED)) {\n      this.disable();\n    }\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    if (this._slider) {\n      this._slider.noUiSlider.off(`.${EVENT_NAMESPACE}`);\n    }\n    if (this._resizeObserver) {\n      this._resizeObserver.resized.remove(this._resizedHandler);\n      this._resizeObserver = null;\n    }\n  }\n\n  /**\n   * Enable component\n   */\n  enable() {\n    this._element.classList.remove(CLASS_IS_DISABLED);\n    this._slider.removeAttribute('disabled');\n  }\n\n  /**\n   * Disable component\n   */\n  disable() {\n    this._element.classList.add(CLASS_IS_DISABLED);\n    this._slider.setAttribute('disabled', true);\n  }\n\n  /**\n   * Handle on update\n   * @param {Array} values Current slider values\n   * @param {Integer} handle Handle that caused the event 0 or 1\n   * @param {Array} unencoded Slider values without formatting\n   * @param {boolean} tap Event was caused by the user tapping the slider\n   * @param {Array} positions Left offset of the handles in relation to the slider\n   */\n  _onUpdate(values, handle, unencoded, tap, positions) {\n    if (this._hiddenField) {\n      this._hiddenField.value = unencoded;\n    }\n\n    // Position output to center of slider handles\n    if (this._output) {\n      this._output.innerHTML = values.length > 1\n        ? `${values[0]} to ${values[1]}`\n        : `${values[0]}`;\n      this._centerOutput();\n    }\n  }\n\n  /**\n   * Center output bewteen handles.\n   */\n  _centerOutput() {\n    const unencoded = this._slider.noUiSlider.get();\n    const sliderAverage = typeof unencoded === 'object'\n      ? unencoded.reduce((previousValue, currentValue) => {\n          return previousValue + parseFloat(currentValue);\n        }, 0) / unencoded.length\n      : parseFloat(unencoded);\n    const maxRight = this._element.offsetWidth - this._output.offsetWidth;\n    const handleSize = this._slider.offsetHeight;\n    const position = mapLinear(sliderAverage, this._rangeMin, this._rangeMax, 0, 1) * this._slider.offsetWidth - this._output.offsetWidth / 2 + handleSize / 2;\n    this._output.style.left = `${limit(position, 0, maxRight)}px`;\n  }\n\n  /**\n   * Parse data to use with noUiSlider\n   * Returns given value as array of floats\n   * \"0,100\" => [0,100]\n   * @param {string} value Current slider values\n   * @returns {Array} values as floats\n   */\n  _parseData(value) {\n    return value && value.split(',').map(element => parseFloat(element));\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/slider/slider.js\n **/","/**\n * Linear mapping from range <a1, a2> to range <b1, b2>\n * @param {number} x The value to map\n * @param {number} a1 First endpoint of the range <a1, a2>\n * @param {number} a2 Final endpoint of the range <a1, a2>\n * @param {number} b1 First endpoint of the range <b1, b2>\n * @param {number} b2 Final endpoint of the range  <b1, b2>\n * @returns {number} The mapped value.\n */\nexport default function mapLinear(x, a1, a2, b1, b2) {\n  return b1 + (x - a1) * (b2 - b1) / (a2 - a1);\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/map-linear.js\n **/","/*! nouislider - 9.2.0 - 2017-01-11 10:35:34 */\r\n\r\n(function (factory) {\r\n\r\n    if ( typeof define === 'function' && define.amd ) {\r\n\r\n        // AMD. Register as an anonymous module.\r\n        define([], factory);\r\n\r\n    } else if ( typeof exports === 'object' ) {\r\n\r\n        // Node/CommonJS\r\n        module.exports = factory();\r\n\r\n    } else {\r\n\r\n        // Browser globals\r\n        window.noUiSlider = factory();\r\n    }\r\n\r\n}(function( ){\r\n\r\n\t'use strict';\r\n\r\n\tvar VERSION = '9.2.0';\r\n\r\n\r\n\t// Creates a node, adds it to target, returns the new node.\r\n\tfunction addNodeTo ( target, className ) {\r\n\t\tvar div = document.createElement('div');\r\n\t\taddClass(div, className);\r\n\t\ttarget.appendChild(div);\r\n\t\treturn div;\r\n\t}\r\n\r\n\t// Removes duplicates from an array.\r\n\tfunction unique ( array ) {\r\n\t\treturn array.filter(function(a){\r\n\t\t\treturn !this[a] ? this[a] = true : false;\r\n\t\t}, {});\r\n\t}\r\n\r\n\t// Round a value to the closest 'to'.\r\n\tfunction closest ( value, to ) {\r\n\t\treturn Math.round(value / to) * to;\r\n\t}\r\n\r\n\t// Current position of an element relative to the document.\r\n\tfunction offset ( elem, orientation ) {\r\n\r\n\tvar rect = elem.getBoundingClientRect(),\r\n\t\tdoc = elem.ownerDocument,\r\n\t\tdocElem = doc.documentElement,\r\n\t\tpageOffset = getPageOffset();\r\n\r\n\t\t// getBoundingClientRect contains left scroll in Chrome on Android.\r\n\t\t// I haven't found a feature detection that proves this. Worst case\r\n\t\t// scenario on mis-match: the 'tap' feature on horizontal sliders breaks.\r\n\t\tif ( /webkit.*Chrome.*Mobile/i.test(navigator.userAgent) ) {\r\n\t\t\tpageOffset.x = 0;\r\n\t\t}\r\n\r\n\t\treturn orientation ? (rect.top + pageOffset.y - docElem.clientTop) : (rect.left + pageOffset.x - docElem.clientLeft);\r\n\t}\r\n\r\n\t// Checks whether a value is numerical.\r\n\tfunction isNumeric ( a ) {\r\n\t\treturn typeof a === 'number' && !isNaN( a ) && isFinite( a );\r\n\t}\r\n\r\n\t// Sets a class and removes it after [duration] ms.\r\n\tfunction addClassFor ( element, className, duration ) {\r\n\t\tif (duration > 0) {\r\n\t\taddClass(element, className);\r\n\t\t\tsetTimeout(function(){\r\n\t\t\t\tremoveClass(element, className);\r\n\t\t\t}, duration);\r\n\t\t}\r\n\t}\r\n\r\n\t// Limits a value to 0 - 100\r\n\tfunction limit ( a ) {\r\n\t\treturn Math.max(Math.min(a, 100), 0);\r\n\t}\r\n\r\n\t// Wraps a variable as an array, if it isn't one yet.\r\n\t// Note that an input array is returned by reference!\r\n\tfunction asArray ( a ) {\r\n\t\treturn Array.isArray(a) ? a : [a];\r\n\t}\r\n\r\n\t// Counts decimals\r\n\tfunction countDecimals ( numStr ) {\r\n\t\tnumStr = String(numStr);\r\n\t\tvar pieces = numStr.split(\".\");\r\n\t\treturn pieces.length > 1 ? pieces[1].length : 0;\r\n\t}\r\n\r\n\t// http://youmightnotneedjquery.com/#add_class\r\n\tfunction addClass ( el, className ) {\r\n\t\tif ( el.classList ) {\r\n\t\t\tel.classList.add(className);\r\n\t\t} else {\r\n\t\t\tel.className += ' ' + className;\r\n\t\t}\r\n\t}\r\n\r\n\t// http://youmightnotneedjquery.com/#remove_class\r\n\tfunction removeClass ( el, className ) {\r\n\t\tif ( el.classList ) {\r\n\t\t\tel.classList.remove(className);\r\n\t\t} else {\r\n\t\t\tel.className = el.className.replace(new RegExp('(^|\\\\b)' + className.split(' ').join('|') + '(\\\\b|$)', 'gi'), ' ');\r\n\t\t}\r\n\t}\r\n\r\n\t// https://plainjs.com/javascript/attributes/adding-removing-and-testing-for-classes-9/\r\n\tfunction hasClass ( el, className ) {\r\n\t\treturn el.classList ? el.classList.contains(className) : new RegExp('\\\\b' + className + '\\\\b').test(el.className);\r\n\t}\r\n\r\n\t// https://developer.mozilla.org/en-US/docs/Web/API/Window/scrollY#Notes\r\n\tfunction getPageOffset ( ) {\r\n\r\n\t\tvar supportPageOffset = window.pageXOffset !== undefined,\r\n\t\t\tisCSS1Compat = ((document.compatMode || \"\") === \"CSS1Compat\"),\r\n\t\t\tx = supportPageOffset ? window.pageXOffset : isCSS1Compat ? document.documentElement.scrollLeft : document.body.scrollLeft,\r\n\t\t\ty = supportPageOffset ? window.pageYOffset : isCSS1Compat ? document.documentElement.scrollTop : document.body.scrollTop;\r\n\r\n\t\treturn {\r\n\t\t\tx: x,\r\n\t\t\ty: y\r\n\t\t};\r\n\t}\r\n\r\n\t// we provide a function to compute constants instead\r\n\t// of accessing window.* as soon as the module needs it\r\n\t// so that we do not compute anything if not needed\r\n\tfunction getActions ( ) {\r\n\r\n\t\t// Determine the events to bind. IE11 implements pointerEvents without\r\n\t\t// a prefix, which breaks compatibility with the IE10 implementation.\r\n\t\treturn window.navigator.pointerEnabled ? {\r\n\t\t\tstart: 'pointerdown',\r\n\t\t\tmove: 'pointermove',\r\n\t\t\tend: 'pointerup'\r\n\t\t} : window.navigator.msPointerEnabled ? {\r\n\t\t\tstart: 'MSPointerDown',\r\n\t\t\tmove: 'MSPointerMove',\r\n\t\t\tend: 'MSPointerUp'\r\n\t\t} : {\r\n\t\t\tstart: 'mousedown touchstart',\r\n\t\t\tmove: 'mousemove touchmove',\r\n\t\t\tend: 'mouseup touchend'\r\n\t\t};\r\n\t}\r\n\r\n\r\n// Value calculation\r\n\r\n\t// Determine the size of a sub-range in relation to a full range.\r\n\tfunction subRangeRatio ( pa, pb ) {\r\n\t\treturn (100 / (pb - pa));\r\n\t}\r\n\r\n\t// (percentage) How many percent is this value of this range?\r\n\tfunction fromPercentage ( range, value ) {\r\n\t\treturn (value * 100) / ( range[1] - range[0] );\r\n\t}\r\n\r\n\t// (percentage) Where is this value on this range?\r\n\tfunction toPercentage ( range, value ) {\r\n\t\treturn fromPercentage( range, range[0] < 0 ?\r\n\t\t\tvalue + Math.abs(range[0]) :\r\n\t\t\t\tvalue - range[0] );\r\n\t}\r\n\r\n\t// (value) How much is this percentage on this range?\r\n\tfunction isPercentage ( range, value ) {\r\n\t\treturn ((value * ( range[1] - range[0] )) / 100) + range[0];\r\n\t}\r\n\r\n\r\n// Range conversion\r\n\r\n\tfunction getJ ( value, arr ) {\r\n\r\n\t\tvar j = 1;\r\n\r\n\t\twhile ( value >= arr[j] ){\r\n\t\t\tj += 1;\r\n\t\t}\r\n\r\n\t\treturn j;\r\n\t}\r\n\r\n\t// (percentage) Input a value, find where, on a scale of 0-100, it applies.\r\n\tfunction toStepping ( xVal, xPct, value ) {\r\n\r\n\t\tif ( value >= xVal.slice(-1)[0] ){\r\n\t\t\treturn 100;\r\n\t\t}\r\n\r\n\t\tvar j = getJ( value, xVal ), va, vb, pa, pb;\r\n\r\n\t\tva = xVal[j-1];\r\n\t\tvb = xVal[j];\r\n\t\tpa = xPct[j-1];\r\n\t\tpb = xPct[j];\r\n\r\n\t\treturn pa + (toPercentage([va, vb], value) / subRangeRatio (pa, pb));\r\n\t}\r\n\r\n\t// (value) Input a percentage, find where it is on the specified range.\r\n\tfunction fromStepping ( xVal, xPct, value ) {\r\n\r\n\t\t// There is no range group that fits 100\r\n\t\tif ( value >= 100 ){\r\n\t\t\treturn xVal.slice(-1)[0];\r\n\t\t}\r\n\r\n\t\tvar j = getJ( value, xPct ), va, vb, pa, pb;\r\n\r\n\t\tva = xVal[j-1];\r\n\t\tvb = xVal[j];\r\n\t\tpa = xPct[j-1];\r\n\t\tpb = xPct[j];\r\n\r\n\t\treturn isPercentage([va, vb], (value - pa) * subRangeRatio (pa, pb));\r\n\t}\r\n\r\n\t// (percentage) Get the step that applies at a certain value.\r\n\tfunction getStep ( xPct, xSteps, snap, value ) {\r\n\r\n\t\tif ( value === 100 ) {\r\n\t\t\treturn value;\r\n\t\t}\r\n\r\n\t\tvar j = getJ( value, xPct ), a, b;\r\n\r\n\t\t// If 'snap' is set, steps are used as fixed points on the slider.\r\n\t\tif ( snap ) {\r\n\r\n\t\t\ta = xPct[j-1];\r\n\t\t\tb = xPct[j];\r\n\r\n\t\t\t// Find the closest position, a or b.\r\n\t\t\tif ((value - a) > ((b-a)/2)){\r\n\t\t\t\treturn b;\r\n\t\t\t}\r\n\r\n\t\t\treturn a;\r\n\t\t}\r\n\r\n\t\tif ( !xSteps[j-1] ){\r\n\t\t\treturn value;\r\n\t\t}\r\n\r\n\t\treturn xPct[j-1] + closest(\r\n\t\t\tvalue - xPct[j-1],\r\n\t\t\txSteps[j-1]\r\n\t\t);\r\n\t}\r\n\r\n\r\n// Entry parsing\r\n\r\n\tfunction handleEntryPoint ( index, value, that ) {\r\n\r\n\t\tvar percentage;\r\n\r\n\t\t// Wrap numerical input in an array.\r\n\t\tif ( typeof value === \"number\" ) {\r\n\t\t\tvalue = [value];\r\n\t\t}\r\n\r\n\t\t// Reject any invalid input, by testing whether value is an array.\r\n\t\tif ( Object.prototype.toString.call( value ) !== '[object Array]' ){\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' contains invalid value.\");\r\n\t\t}\r\n\r\n\t\t// Covert min/max syntax to 0 and 100.\r\n\t\tif ( index === 'min' ) {\r\n\t\t\tpercentage = 0;\r\n\t\t} else if ( index === 'max' ) {\r\n\t\t\tpercentage = 100;\r\n\t\t} else {\r\n\t\t\tpercentage = parseFloat( index );\r\n\t\t}\r\n\r\n\t\t// Check for correct input.\r\n\t\tif ( !isNumeric( percentage ) || !isNumeric( value[0] ) ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' value isn't numeric.\");\r\n\t\t}\r\n\r\n\t\t// Store values.\r\n\t\tthat.xPct.push( percentage );\r\n\t\tthat.xVal.push( value[0] );\r\n\r\n\t\t// NaN will evaluate to false too, but to keep\r\n\t\t// logging clear, set step explicitly. Make sure\r\n\t\t// not to override the 'step' setting with false.\r\n\t\tif ( !percentage ) {\r\n\t\t\tif ( !isNaN( value[1] ) ) {\r\n\t\t\t\tthat.xSteps[0] = value[1];\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthat.xSteps.push( isNaN(value[1]) ? false : value[1] );\r\n\t\t}\r\n\r\n\t\tthat.xHighestCompleteStep.push(0);\r\n\t}\r\n\r\n\tfunction handleStepPoint ( i, n, that ) {\r\n\r\n\t\t// Ignore 'false' stepping.\r\n\t\tif ( !n ) {\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\t// Factor to range ratio\r\n\t\tthat.xSteps[i] = fromPercentage([\r\n\t\t\t that.xVal[i]\r\n\t\t\t,that.xVal[i+1]\r\n\t\t], n) / subRangeRatio (\r\n\t\t\tthat.xPct[i],\r\n\t\t\tthat.xPct[i+1] );\r\n\r\n\t\tvar totalSteps = (that.xVal[i+1] - that.xVal[i]) / that.xNumSteps[i];\r\n\t\tvar highestStep = Math.ceil(Number(totalSteps.toFixed(3)) - 1);\r\n\t\tvar step = that.xVal[i] + (that.xNumSteps[i] * highestStep);\r\n\r\n\t\tthat.xHighestCompleteStep[i] = step;\r\n\t}\r\n\r\n\r\n// Interface\r\n\r\n\t// The interface to Spectrum handles all direction-based\r\n\t// conversions, so the above values are unaware.\r\n\r\n\tfunction Spectrum ( entry, snap, direction, singleStep ) {\r\n\r\n\t\tthis.xPct = [];\r\n\t\tthis.xVal = [];\r\n\t\tthis.xSteps = [ singleStep || false ];\r\n\t\tthis.xNumSteps = [ false ];\r\n\t\tthis.xHighestCompleteStep = [];\r\n\r\n\t\tthis.snap = snap;\r\n\t\tthis.direction = direction;\r\n\r\n\t\tvar index, ordered = [ /* [0, 'min'], [1, '50%'], [2, 'max'] */ ];\r\n\r\n\t\t// Map the object keys to an array.\r\n\t\tfor ( index in entry ) {\r\n\t\t\tif ( entry.hasOwnProperty(index) ) {\r\n\t\t\t\tordered.push([entry[index], index]);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Sort all entries by value (numeric sort).\r\n\t\tif ( ordered.length && typeof ordered[0][0] === \"object\" ) {\r\n\t\t\tordered.sort(function(a, b) { return a[0][0] - b[0][0]; });\r\n\t\t} else {\r\n\t\t\tordered.sort(function(a, b) { return a[0] - b[0]; });\r\n\t\t}\r\n\r\n\r\n\t\t// Convert all entries to subranges.\r\n\t\tfor ( index = 0; index < ordered.length; index++ ) {\r\n\t\t\thandleEntryPoint(ordered[index][1], ordered[index][0], this);\r\n\t\t}\r\n\r\n\t\t// Store the actual step values.\r\n\t\t// xSteps is sorted in the same order as xPct and xVal.\r\n\t\tthis.xNumSteps = this.xSteps.slice(0);\r\n\r\n\t\t// Convert all numeric steps to the percentage of the subrange they represent.\r\n\t\tfor ( index = 0; index < this.xNumSteps.length; index++ ) {\r\n\t\t\thandleStepPoint(index, this.xNumSteps[index], this);\r\n\t\t}\r\n\t}\r\n\r\n\tSpectrum.prototype.getMargin = function ( value ) {\r\n\r\n\t\tvar step = this.xNumSteps[0];\r\n\r\n\t\tif ( step && ((value / step) % 1) !== 0 ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'limit', 'margin' and 'padding' must be divisible by step.\");\r\n\t\t}\r\n\r\n\t\treturn this.xPct.length === 2 ? fromPercentage(this.xVal, value) : false;\r\n\t};\r\n\r\n\tSpectrum.prototype.toStepping = function ( value ) {\r\n\r\n\t\tvalue = toStepping( this.xVal, this.xPct, value );\r\n\r\n\t\treturn value;\r\n\t};\r\n\r\n\tSpectrum.prototype.fromStepping = function ( value ) {\r\n\r\n\t\treturn fromStepping( this.xVal, this.xPct, value );\r\n\t};\r\n\r\n\tSpectrum.prototype.getStep = function ( value ) {\r\n\r\n\t\tvalue = getStep(this.xPct, this.xSteps, this.snap, value );\r\n\r\n\t\treturn value;\r\n\t};\r\n\r\n\tSpectrum.prototype.getNearbySteps = function ( value ) {\r\n\r\n\t\tvar j = getJ(value, this.xPct);\r\n\r\n\t\treturn {\r\n\t\t\tstepBefore: { startValue: this.xVal[j-2], step: this.xNumSteps[j-2], highestStep: this.xHighestCompleteStep[j-2] },\r\n\t\t\tthisStep: { startValue: this.xVal[j-1], step: this.xNumSteps[j-1], highestStep: this.xHighestCompleteStep[j-1] },\r\n\t\t\tstepAfter: { startValue: this.xVal[j-0], step: this.xNumSteps[j-0], highestStep: this.xHighestCompleteStep[j-0] }\r\n\t\t};\r\n\t};\r\n\r\n\tSpectrum.prototype.countStepDecimals = function () {\r\n\t\tvar stepDecimals = this.xNumSteps.map(countDecimals);\r\n\t\treturn Math.max.apply(null, stepDecimals);\r\n \t};\r\n\r\n\t// Outside testing\r\n\tSpectrum.prototype.convert = function ( value ) {\r\n\t\treturn this.getStep(this.toStepping(value));\r\n\t};\r\n\r\n/*\tEvery input option is tested and parsed. This'll prevent\r\n\tendless validation in internal methods. These tests are\r\n\tstructured with an item for every option available. An\r\n\toption can be marked as required by setting the 'r' flag.\r\n\tThe testing function is provided with three arguments:\r\n\t\t- The provided value for the option;\r\n\t\t- A reference to the options object;\r\n\t\t- The name for the option;\r\n\r\n\tThe testing function returns false when an error is detected,\r\n\tor true when everything is OK. It can also modify the option\r\n\tobject, to make sure all values can be correctly looped elsewhere. */\r\n\r\n\tvar defaultFormatter = { 'to': function( value ){\r\n\t\treturn value !== undefined && value.toFixed(2);\r\n\t}, 'from': Number };\r\n\r\n\tfunction testStep ( parsed, entry ) {\r\n\r\n\t\tif ( !isNumeric( entry ) ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'step' is not numeric.\");\r\n\t\t}\r\n\r\n\t\t// The step option can still be used to set stepping\r\n\t\t// for linear sliders. Overwritten if set in 'range'.\r\n\t\tparsed.singleStep = entry;\r\n\t}\r\n\r\n\tfunction testRange ( parsed, entry ) {\r\n\r\n\t\t// Filter incorrect input.\r\n\t\tif ( typeof entry !== 'object' || Array.isArray(entry) ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' is not an object.\");\r\n\t\t}\r\n\r\n\t\t// Catch missing start or end.\r\n\t\tif ( entry.min === undefined || entry.max === undefined ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): Missing 'min' or 'max' in 'range'.\");\r\n\t\t}\r\n\r\n\t\t// Catch equal start or end.\r\n\t\tif ( entry.min === entry.max ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'range' 'min' and 'max' cannot be equal.\");\r\n\t\t}\r\n\r\n\t\tparsed.spectrum = new Spectrum(entry, parsed.snap, parsed.dir, parsed.singleStep);\r\n\t}\r\n\r\n\tfunction testStart ( parsed, entry ) {\r\n\r\n\t\tentry = asArray(entry);\r\n\r\n\t\t// Validate input. Values aren't tested, as the public .val method\r\n\t\t// will always provide a valid location.\r\n\t\tif ( !Array.isArray( entry ) || !entry.length ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'start' option is incorrect.\");\r\n\t\t}\r\n\r\n\t\t// Store the number of handles.\r\n\t\tparsed.handles = entry.length;\r\n\r\n\t\t// When the slider is initialized, the .val method will\r\n\t\t// be called with the start options.\r\n\t\tparsed.start = entry;\r\n\t}\r\n\r\n\tfunction testSnap ( parsed, entry ) {\r\n\r\n\t\t// Enforce 100% stepping within subranges.\r\n\t\tparsed.snap = entry;\r\n\r\n\t\tif ( typeof entry !== 'boolean' ){\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'snap' option must be a boolean.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testAnimate ( parsed, entry ) {\r\n\r\n\t\t// Enforce 100% stepping within subranges.\r\n\t\tparsed.animate = entry;\r\n\r\n\t\tif ( typeof entry !== 'boolean' ){\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'animate' option must be a boolean.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testAnimationDuration ( parsed, entry ) {\r\n\r\n\t\tparsed.animationDuration = entry;\r\n\r\n\t\tif ( typeof entry !== 'number' ){\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'animationDuration' option must be a number.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testConnect ( parsed, entry ) {\r\n\r\n\t\tvar connect = [false];\r\n\t\tvar i;\r\n\r\n\t\t// Map legacy options\r\n\t\tif ( entry === 'lower' ) {\r\n\t\t\tentry = [true, false];\r\n\t\t}\r\n\r\n\t\telse if ( entry === 'upper' ) {\r\n\t\t\tentry = [false, true];\r\n\t\t}\r\n\r\n\t\t// Handle boolean options\r\n\t\tif ( entry === true || entry === false ) {\r\n\r\n\t\t\tfor ( i = 1; i < parsed.handles; i++ ) {\r\n\t\t\t\tconnect.push(entry);\r\n\t\t\t}\r\n\r\n\t\t\tconnect.push(false);\r\n\t\t}\r\n\r\n\t\t// Reject invalid input\r\n\t\telse if ( !Array.isArray( entry ) || !entry.length || entry.length !== parsed.handles + 1 ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'connect' option doesn't match handle count.\");\r\n\t\t}\r\n\r\n\t\telse {\r\n\t\t\tconnect = entry;\r\n\t\t}\r\n\r\n\t\tparsed.connect = connect;\r\n\t}\r\n\r\n\tfunction testOrientation ( parsed, entry ) {\r\n\r\n\t\t// Set orientation to an a numerical value for easy\r\n\t\t// array selection.\r\n\t\tswitch ( entry ){\r\n\t\t  case 'horizontal':\r\n\t\t\tparsed.ort = 0;\r\n\t\t\tbreak;\r\n\t\t  case 'vertical':\r\n\t\t\tparsed.ort = 1;\r\n\t\t\tbreak;\r\n\t\t  default:\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'orientation' option is invalid.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testMargin ( parsed, entry ) {\r\n\r\n\t\tif ( !isNumeric(entry) ){\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'margin' option must be numeric.\");\r\n\t\t}\r\n\r\n\t\t// Issue #582\r\n\t\tif ( entry === 0 ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tparsed.margin = parsed.spectrum.getMargin(entry);\r\n\r\n\t\tif ( !parsed.margin ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'margin' option is only supported on linear sliders.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testLimit ( parsed, entry ) {\r\n\r\n\t\tif ( !isNumeric(entry) ){\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'limit' option must be numeric.\");\r\n\t\t}\r\n\r\n\t\tparsed.limit = parsed.spectrum.getMargin(entry);\r\n\r\n\t\tif ( !parsed.limit || parsed.handles < 2 ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'limit' option is only supported on linear sliders with 2 or more handles.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testPadding ( parsed, entry ) {\r\n\r\n\t\tif ( !isNumeric(entry) ){\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option must be numeric.\");\r\n\t\t}\r\n\r\n\t\tif ( entry === 0 ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tparsed.padding = parsed.spectrum.getMargin(entry);\r\n\r\n\t\tif ( !parsed.padding ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option is only supported on linear sliders.\");\r\n\t\t}\r\n\r\n\t\tif ( parsed.padding < 0 ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option must be a positive number.\");\r\n\t\t}\r\n\r\n\t\tif ( parsed.padding >= 50 ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'padding' option must be less than half the range.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testDirection ( parsed, entry ) {\r\n\r\n\t\t// Set direction as a numerical value for easy parsing.\r\n\t\t// Invert connection for RTL sliders, so that the proper\r\n\t\t// handles get the connect/background classes.\r\n\t\tswitch ( entry ) {\r\n\t\t  case 'ltr':\r\n\t\t\tparsed.dir = 0;\r\n\t\t\tbreak;\r\n\t\t  case 'rtl':\r\n\t\t\tparsed.dir = 1;\r\n\t\t\tbreak;\r\n\t\t  default:\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'direction' option was not recognized.\");\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testBehaviour ( parsed, entry ) {\r\n\r\n\t\t// Make sure the input is a string.\r\n\t\tif ( typeof entry !== 'string' ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'behaviour' must be a string containing options.\");\r\n\t\t}\r\n\r\n\t\t// Check if the string contains any keywords.\r\n\t\t// None are required.\r\n\t\tvar tap = entry.indexOf('tap') >= 0;\r\n\t\tvar drag = entry.indexOf('drag') >= 0;\r\n\t\tvar fixed = entry.indexOf('fixed') >= 0;\r\n\t\tvar snap = entry.indexOf('snap') >= 0;\r\n\t\tvar hover = entry.indexOf('hover') >= 0;\r\n\r\n\t\tif ( fixed ) {\r\n\r\n\t\t\tif ( parsed.handles !== 2 ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'fixed' behaviour must be used with 2 handles\");\r\n\t\t\t}\r\n\r\n\t\t\t// Use margin to enforce fixed state\r\n\t\t\ttestMargin(parsed, parsed.start[1] - parsed.start[0]);\r\n\t\t}\r\n\r\n\t\tparsed.events = {\r\n\t\t\ttap: tap || snap,\r\n\t\t\tdrag: drag,\r\n\t\t\tfixed: fixed,\r\n\t\t\tsnap: snap,\r\n\t\t\thover: hover\r\n\t\t};\r\n\t}\r\n\r\n\tfunction testTooltips ( parsed, entry ) {\r\n\r\n\t\tif ( entry === false ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\telse if ( entry === true ) {\r\n\r\n\t\t\tparsed.tooltips = [];\r\n\r\n\t\t\tfor ( var i = 0; i < parsed.handles; i++ ) {\r\n\t\t\t\tparsed.tooltips.push(true);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\telse {\r\n\r\n\t\t\tparsed.tooltips = asArray(entry);\r\n\r\n\t\t\tif ( parsed.tooltips.length !== parsed.handles ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): must pass a formatter for all handles.\");\r\n\t\t\t}\r\n\r\n\t\t\tparsed.tooltips.forEach(function(formatter){\r\n\t\t\t\tif ( typeof formatter !== 'boolean' && (typeof formatter !== 'object' || typeof formatter.to !== 'function') ) {\r\n\t\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'tooltips' must be passed a formatter or 'false'.\");\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testFormat ( parsed, entry ) {\r\n\r\n\t\tparsed.format = entry;\r\n\r\n\t\t// Any object with a to and from method is supported.\r\n\t\tif ( typeof entry.to === 'function' && typeof entry.from === 'function' ) {\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'format' requires 'to' and 'from' methods.\");\r\n\t}\r\n\r\n\tfunction testCssPrefix ( parsed, entry ) {\r\n\r\n\t\tif ( entry !== undefined && typeof entry !== 'string' && entry !== false ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'cssPrefix' must be a string or `false`.\");\r\n\t\t}\r\n\r\n\t\tparsed.cssPrefix = entry;\r\n\t}\r\n\r\n\tfunction testCssClasses ( parsed, entry ) {\r\n\r\n\t\tif ( entry !== undefined && typeof entry !== 'object' ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'cssClasses' must be an object.\");\r\n\t\t}\r\n\r\n\t\tif ( typeof parsed.cssPrefix === 'string' ) {\r\n\t\t\tparsed.cssClasses = {};\r\n\r\n\t\t\tfor ( var key in entry ) {\r\n\t\t\t\tif ( !entry.hasOwnProperty(key) ) { continue; }\r\n\r\n\t\t\t\tparsed.cssClasses[key] = parsed.cssPrefix + entry[key];\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tparsed.cssClasses = entry;\r\n\t\t}\r\n\t}\r\n\r\n\tfunction testUseRaf ( parsed, entry ) {\r\n\t\tif ( entry === true || entry === false ) {\r\n\t\t\tparsed.useRequestAnimationFrame = entry;\r\n\t\t} else {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'useRequestAnimationFrame' option should be true (default) or false.\");\r\n\t\t}\r\n\t}\r\n\r\n\t// Test all developer settings and parse to assumption-safe values.\r\n\tfunction testOptions ( options ) {\r\n\r\n\t\t// To prove a fix for #537, freeze options here.\r\n\t\t// If the object is modified, an error will be thrown.\r\n\t\t// Object.freeze(options);\r\n\r\n\t\tvar parsed = {\r\n\t\t\tmargin: 0,\r\n\t\t\tlimit: 0,\r\n\t\t\tpadding: 0,\r\n\t\t\tanimate: true,\r\n\t\t\tanimationDuration: 300,\r\n\t\t\tformat: defaultFormatter\r\n\t\t};\r\n\r\n\t\t// Tests are executed in the order they are presented here.\r\n\t\tvar tests = {\r\n\t\t\t'step': { r: false, t: testStep },\r\n\t\t\t'start': { r: true, t: testStart },\r\n\t\t\t'connect': { r: true, t: testConnect },\r\n\t\t\t'direction': { r: true, t: testDirection },\r\n\t\t\t'snap': { r: false, t: testSnap },\r\n\t\t\t'animate': { r: false, t: testAnimate },\r\n\t\t\t'animationDuration': { r: false, t: testAnimationDuration },\r\n\t\t\t'range': { r: true, t: testRange },\r\n\t\t\t'orientation': { r: false, t: testOrientation },\r\n\t\t\t'margin': { r: false, t: testMargin },\r\n\t\t\t'limit': { r: false, t: testLimit },\r\n\t\t\t'padding': { r: false, t: testPadding },\r\n\t\t\t'behaviour': { r: true, t: testBehaviour },\r\n\t\t\t'format': { r: false, t: testFormat },\r\n\t\t\t'tooltips': { r: false, t: testTooltips },\r\n\t\t\t'cssPrefix': { r: false, t: testCssPrefix },\r\n\t\t\t'cssClasses': { r: false, t: testCssClasses },\r\n\t\t\t'useRequestAnimationFrame': { r: false, t: testUseRaf }\r\n\t\t};\r\n\r\n\t\tvar defaults = {\r\n\t\t\t'connect': false,\r\n\t\t\t'direction': 'ltr',\r\n\t\t\t'behaviour': 'tap',\r\n\t\t\t'orientation': 'horizontal',\r\n\t\t\t'cssPrefix' : 'noUi-',\r\n\t\t\t'cssClasses': {\r\n\t\t\t\ttarget: 'target',\r\n\t\t\t\tbase: 'base',\r\n\t\t\t\torigin: 'origin',\r\n\t\t\t\thandle: 'handle',\r\n\t\t\t\thandleLower: 'handle-lower',\r\n\t\t\t\thandleUpper: 'handle-upper',\r\n\t\t\t\thorizontal: 'horizontal',\r\n\t\t\t\tvertical: 'vertical',\r\n\t\t\t\tbackground: 'background',\r\n\t\t\t\tconnect: 'connect',\r\n\t\t\t\tltr: 'ltr',\r\n\t\t\t\trtl: 'rtl',\r\n\t\t\t\tdraggable: 'draggable',\r\n\t\t\t\tdrag: 'state-drag',\r\n\t\t\t\ttap: 'state-tap',\r\n\t\t\t\tactive: 'active',\r\n\t\t\t\ttooltip: 'tooltip',\r\n\t\t\t\tpips: 'pips',\r\n\t\t\t\tpipsHorizontal: 'pips-horizontal',\r\n\t\t\t\tpipsVertical: 'pips-vertical',\r\n\t\t\t\tmarker: 'marker',\r\n\t\t\t\tmarkerHorizontal: 'marker-horizontal',\r\n\t\t\t\tmarkerVertical: 'marker-vertical',\r\n\t\t\t\tmarkerNormal: 'marker-normal',\r\n\t\t\t\tmarkerLarge: 'marker-large',\r\n\t\t\t\tmarkerSub: 'marker-sub',\r\n\t\t\t\tvalue: 'value',\r\n\t\t\t\tvalueHorizontal: 'value-horizontal',\r\n\t\t\t\tvalueVertical: 'value-vertical',\r\n\t\t\t\tvalueNormal: 'value-normal',\r\n\t\t\t\tvalueLarge: 'value-large',\r\n\t\t\t\tvalueSub: 'value-sub'\r\n\t\t\t},\r\n\t\t\t'useRequestAnimationFrame': true\r\n\t\t};\r\n\r\n\t\t// Run all options through a testing mechanism to ensure correct\r\n\t\t// input. It should be noted that options might get modified to\r\n\t\t// be handled properly. E.g. wrapping integers in arrays.\r\n\t\tObject.keys(tests).forEach(function( name ){\r\n\r\n\t\t\t// If the option isn't set, but it is required, throw an error.\r\n\t\t\tif ( options[name] === undefined && defaults[name] === undefined ) {\r\n\r\n\t\t\t\tif ( tests[name].r ) {\r\n\t\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): '\" + name + \"' is required.\");\r\n\t\t\t\t}\r\n\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\r\n\t\t\ttests[name].t( parsed, options[name] === undefined ? defaults[name] : options[name] );\r\n\t\t});\r\n\r\n\t\t// Forward pips options\r\n\t\tparsed.pips = options.pips;\r\n\r\n\t\tvar styles = [['left', 'top'], ['right', 'bottom']];\r\n\r\n\t\t// Pre-define the styles.\r\n\t\tparsed.style = styles[parsed.dir][parsed.ort];\r\n\t\tparsed.styleOposite = styles[parsed.dir?0:1][parsed.ort];\r\n\r\n\t\treturn parsed;\r\n\t}\r\n\r\n\r\nfunction closure ( target, options, originalOptions ){\r\n\r\n\tvar actions = getActions( );\r\n\r\n\t// All variables local to 'closure' are prefixed with 'scope_'\r\n\tvar scope_Target = target;\r\n\tvar scope_Locations = [];\r\n\tvar scope_Base;\r\n\tvar scope_Handles;\r\n\tvar scope_HandleNumbers = [];\r\n\tvar scope_ActiveHandle = false;\r\n\tvar scope_Connects;\r\n\tvar scope_Spectrum = options.spectrum;\r\n\tvar scope_Values = [];\r\n\tvar scope_Events = {};\r\n\tvar scope_Self;\r\n\r\n\r\n\t// Append a origin to the base\r\n\tfunction addOrigin ( base, handleNumber ) {\r\n\r\n\t\tvar origin = addNodeTo(base, options.cssClasses.origin);\r\n\t\tvar handle = addNodeTo(origin, options.cssClasses.handle);\r\n\r\n\t\thandle.setAttribute('data-handle', handleNumber);\r\n\r\n\t\tif ( handleNumber === 0 ) {\r\n\t\t\taddClass(handle, options.cssClasses.handleLower);\r\n\t\t}\r\n\r\n\t\telse if ( handleNumber === options.handles - 1 ) {\r\n\t\t\taddClass(handle, options.cssClasses.handleUpper);\r\n\t\t}\r\n\r\n\t\treturn origin;\r\n\t}\r\n\r\n\t// Insert nodes for connect elements\r\n\tfunction addConnect ( base, add ) {\r\n\r\n\t\tif ( !add ) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\treturn addNodeTo(base, options.cssClasses.connect);\r\n\t}\r\n\r\n\t// Add handles to the slider base.\r\n\tfunction addElements ( connectOptions, base ) {\r\n\r\n\t\tscope_Handles = [];\r\n\t\tscope_Connects = [];\r\n\r\n\t\tscope_Connects.push(addConnect(base, connectOptions[0]));\r\n\r\n\t\t// [::::O====O====O====]\r\n\t\t// connectOptions = [0, 1, 1, 1]\r\n\r\n\t\tfor ( var i = 0; i < options.handles; i++ ) {\r\n\t\t\t// Keep a list of all added handles.\r\n\t\t\tscope_Handles.push(addOrigin(base, i));\r\n\t\t\tscope_HandleNumbers[i] = i;\r\n\t\t\tscope_Connects.push(addConnect(base, connectOptions[i + 1]));\r\n\t\t}\r\n\t}\r\n\r\n\t// Initialize a single slider.\r\n\tfunction addSlider ( target ) {\r\n\r\n\t\t// Apply classes and data to the target.\r\n\t\taddClass(target, options.cssClasses.target);\r\n\r\n\t\tif ( options.dir === 0 ) {\r\n\t\t\taddClass(target, options.cssClasses.ltr);\r\n\t\t} else {\r\n\t\t\taddClass(target, options.cssClasses.rtl);\r\n\t\t}\r\n\r\n\t\tif ( options.ort === 0 ) {\r\n\t\t\taddClass(target, options.cssClasses.horizontal);\r\n\t\t} else {\r\n\t\t\taddClass(target, options.cssClasses.vertical);\r\n\t\t}\r\n\r\n\t\tscope_Base = addNodeTo(target, options.cssClasses.base);\r\n\t}\r\n\r\n\r\n\tfunction addTooltip ( handle, handleNumber ) {\r\n\r\n\t\tif ( !options.tooltips[handleNumber] ) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\treturn addNodeTo(handle.firstChild, options.cssClasses.tooltip);\r\n\t}\r\n\r\n\t// The tooltips option is a shorthand for using the 'update' event.\r\n\tfunction tooltips ( ) {\r\n\r\n\t\t// Tooltips are added with options.tooltips in original order.\r\n\t\tvar tips = scope_Handles.map(addTooltip);\r\n\r\n\t\tbindEvent('update', function(values, handleNumber, unencoded) {\r\n\r\n\t\t\tif ( !tips[handleNumber] ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tvar formattedValue = values[handleNumber];\r\n\r\n\t\t\tif ( options.tooltips[handleNumber] !== true ) {\r\n\t\t\t\tformattedValue = options.tooltips[handleNumber].to(unencoded[handleNumber]);\r\n\t\t\t}\r\n\r\n\t\t\ttips[handleNumber].innerHTML = formattedValue;\r\n\t\t});\r\n\t}\r\n\r\n\r\n\tfunction getGroup ( mode, values, stepped ) {\r\n\r\n\t\t// Use the range.\r\n\t\tif ( mode === 'range' || mode === 'steps' ) {\r\n\t\t\treturn scope_Spectrum.xVal;\r\n\t\t}\r\n\r\n\t\tif ( mode === 'count' ) {\r\n\r\n\t\t\tif ( !values ) {\r\n\t\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): 'values' required for mode 'count'.\");\r\n\t\t\t}\r\n\r\n\t\t\t// Divide 0 - 100 in 'count' parts.\r\n\t\t\tvar spread = ( 100 / (values - 1) );\r\n\t\t\tvar v;\r\n\t\t\tvar i = 0;\r\n\r\n\t\t\tvalues = [];\r\n\r\n\t\t\t// List these parts and have them handled as 'positions'.\r\n\t\t\twhile ( (v = i++ * spread) <= 100 ) {\r\n\t\t\t\tvalues.push(v);\r\n\t\t\t}\r\n\r\n\t\t\tmode = 'positions';\r\n\t\t}\r\n\r\n\t\tif ( mode === 'positions' ) {\r\n\r\n\t\t\t// Map all percentages to on-range values.\r\n\t\t\treturn values.map(function( value ){\r\n\t\t\t\treturn scope_Spectrum.fromStepping( stepped ? scope_Spectrum.getStep( value ) : value );\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\tif ( mode === 'values' ) {\r\n\r\n\t\t\t// If the value must be stepped, it needs to be converted to a percentage first.\r\n\t\t\tif ( stepped ) {\r\n\r\n\t\t\t\treturn values.map(function( value ){\r\n\r\n\t\t\t\t\t// Convert to percentage, apply step, return to value.\r\n\t\t\t\t\treturn scope_Spectrum.fromStepping( scope_Spectrum.getStep( scope_Spectrum.toStepping( value ) ) );\r\n\t\t\t\t});\r\n\r\n\t\t\t}\r\n\r\n\t\t\t// Otherwise, we can simply use the values.\r\n\t\t\treturn values;\r\n\t\t}\r\n\t}\r\n\r\n\tfunction generateSpread ( density, mode, group ) {\r\n\r\n\t\tfunction safeIncrement(value, increment) {\r\n\t\t\t// Avoid floating point variance by dropping the smallest decimal places.\r\n\t\t\treturn (value + increment).toFixed(7) / 1;\r\n\t\t}\r\n\r\n\t\tvar indexes = {};\r\n\t\tvar firstInRange = scope_Spectrum.xVal[0];\r\n\t\tvar lastInRange = scope_Spectrum.xVal[scope_Spectrum.xVal.length-1];\r\n\t\tvar ignoreFirst = false;\r\n\t\tvar ignoreLast = false;\r\n\t\tvar prevPct = 0;\r\n\r\n\t\t// Create a copy of the group, sort it and filter away all duplicates.\r\n\t\tgroup = unique(group.slice().sort(function(a, b){ return a - b; }));\r\n\r\n\t\t// Make sure the range starts with the first element.\r\n\t\tif ( group[0] !== firstInRange ) {\r\n\t\t\tgroup.unshift(firstInRange);\r\n\t\t\tignoreFirst = true;\r\n\t\t}\r\n\r\n\t\t// Likewise for the last one.\r\n\t\tif ( group[group.length - 1] !== lastInRange ) {\r\n\t\t\tgroup.push(lastInRange);\r\n\t\t\tignoreLast = true;\r\n\t\t}\r\n\r\n\t\tgroup.forEach(function ( current, index ) {\r\n\r\n\t\t\t// Get the current step and the lower + upper positions.\r\n\t\t\tvar step;\r\n\t\t\tvar i;\r\n\t\t\tvar q;\r\n\t\t\tvar low = current;\r\n\t\t\tvar high = group[index+1];\r\n\t\t\tvar newPct;\r\n\t\t\tvar pctDifference;\r\n\t\t\tvar pctPos;\r\n\t\t\tvar type;\r\n\t\t\tvar steps;\r\n\t\t\tvar realSteps;\r\n\t\t\tvar stepsize;\r\n\r\n\t\t\t// When using 'steps' mode, use the provided steps.\r\n\t\t\t// Otherwise, we'll step on to the next subrange.\r\n\t\t\tif ( mode === 'steps' ) {\r\n\t\t\t\tstep = scope_Spectrum.xNumSteps[ index ];\r\n\t\t\t}\r\n\r\n\t\t\t// Default to a 'full' step.\r\n\t\t\tif ( !step ) {\r\n\t\t\t\tstep = high-low;\r\n\t\t\t}\r\n\r\n\t\t\t// Low can be 0, so test for false. If high is undefined,\r\n\t\t\t// we are at the last subrange. Index 0 is already handled.\r\n\t\t\tif ( low === false || high === undefined ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\t// Make sure step isn't 0, which would cause an infinite loop (#654)\r\n\t\t\tstep = Math.max(step, 0.0000001);\r\n\r\n\t\t\t// Find all steps in the subrange.\r\n\t\t\tfor ( i = low; i <= high; i = safeIncrement(i, step) ) {\r\n\r\n\t\t\t\t// Get the percentage value for the current step,\r\n\t\t\t\t// calculate the size for the subrange.\r\n\t\t\t\tnewPct = scope_Spectrum.toStepping( i );\r\n\t\t\t\tpctDifference = newPct - prevPct;\r\n\r\n\t\t\t\tsteps = pctDifference / density;\r\n\t\t\t\trealSteps = Math.round(steps);\r\n\r\n\t\t\t\t// This ratio represents the ammount of percentage-space a point indicates.\r\n\t\t\t\t// For a density 1 the points/percentage = 1. For density 2, that percentage needs to be re-devided.\r\n\t\t\t\t// Round the percentage offset to an even number, then divide by two\r\n\t\t\t\t// to spread the offset on both sides of the range.\r\n\t\t\t\tstepsize = pctDifference/realSteps;\r\n\r\n\t\t\t\t// Divide all points evenly, adding the correct number to this subrange.\r\n\t\t\t\t// Run up to <= so that 100% gets a point, event if ignoreLast is set.\r\n\t\t\t\tfor ( q = 1; q <= realSteps; q += 1 ) {\r\n\r\n\t\t\t\t\t// The ratio between the rounded value and the actual size might be ~1% off.\r\n\t\t\t\t\t// Correct the percentage offset by the number of points\r\n\t\t\t\t\t// per subrange. density = 1 will result in 100 points on the\r\n\t\t\t\t\t// full range, 2 for 50, 4 for 25, etc.\r\n\t\t\t\t\tpctPos = prevPct + ( q * stepsize );\r\n\t\t\t\t\tindexes[pctPos.toFixed(5)] = ['x', 0];\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Determine the point type.\r\n\t\t\t\ttype = (group.indexOf(i) > -1) ? 1 : ( mode === 'steps' ? 2 : 0 );\r\n\r\n\t\t\t\t// Enforce the 'ignoreFirst' option by overwriting the type for 0.\r\n\t\t\t\tif ( !index && ignoreFirst ) {\r\n\t\t\t\t\ttype = 0;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif ( !(i === high && ignoreLast)) {\r\n\t\t\t\t\t// Mark the 'type' of this point. 0 = plain, 1 = real value, 2 = step value.\r\n\t\t\t\t\tindexes[newPct.toFixed(5)] = [i, type];\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Update the percentage count.\r\n\t\t\t\tprevPct = newPct;\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\treturn indexes;\r\n\t}\r\n\r\n\tfunction addMarking ( spread, filterFunc, formatter ) {\r\n\r\n\t\tvar element = document.createElement('div');\r\n\t\tvar out = '';\r\n\t\tvar valueSizeClasses = [\r\n\t\t\toptions.cssClasses.valueNormal,\r\n\t\t\toptions.cssClasses.valueLarge,\r\n\t\t\toptions.cssClasses.valueSub\r\n\t\t];\r\n\t\tvar markerSizeClasses = [\r\n\t\t\toptions.cssClasses.markerNormal,\r\n\t\t\toptions.cssClasses.markerLarge,\r\n\t\t\toptions.cssClasses.markerSub\r\n\t\t];\r\n\t\tvar valueOrientationClasses = [\r\n\t\t\toptions.cssClasses.valueHorizontal,\r\n\t\t\toptions.cssClasses.valueVertical\r\n\t\t];\r\n\t\tvar markerOrientationClasses = [\r\n\t\t\toptions.cssClasses.markerHorizontal,\r\n\t\t\toptions.cssClasses.markerVertical\r\n\t\t];\r\n\r\n\t\taddClass(element, options.cssClasses.pips);\r\n\t\taddClass(element, options.ort === 0 ? options.cssClasses.pipsHorizontal : options.cssClasses.pipsVertical);\r\n\r\n\t\tfunction getClasses( type, source ){\r\n\t\t\tvar a = source === options.cssClasses.value;\r\n\t\t\tvar orientationClasses = a ? valueOrientationClasses : markerOrientationClasses;\r\n\t\t\tvar sizeClasses = a ? valueSizeClasses : markerSizeClasses;\r\n\r\n\t\t\treturn source + ' ' + orientationClasses[options.ort] + ' ' + sizeClasses[type];\r\n\t\t}\r\n\r\n\t\tfunction getTags( offset, source, values ) {\r\n\t\t\treturn 'class=\"' + getClasses(values[1], source) + '\" style=\"' + options.style + ': ' + offset + '%\"';\r\n\t\t}\r\n\r\n\t\tfunction addSpread ( offset, values ){\r\n\r\n\t\t\t// Apply the filter function, if it is set.\r\n\t\t\tvalues[1] = (values[1] && filterFunc) ? filterFunc(values[0], values[1]) : values[1];\r\n\r\n\t\t\t// Add a marker for every point\r\n\t\t\tout += '<div ' + getTags(offset, options.cssClasses.marker, values) + '></div>';\r\n\r\n\t\t\t// Values are only appended for points marked '1' or '2'.\r\n\t\t\tif ( values[1] ) {\r\n\t\t\t\tout += '<div ' + getTags(offset, options.cssClasses.value, values) + '>' + formatter.to(values[0]) + '</div>';\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Append all points.\r\n\t\tObject.keys(spread).forEach(function(a){\r\n\t\t\taddSpread(a, spread[a]);\r\n\t\t});\r\n\r\n\t\telement.innerHTML = out;\r\n\r\n\t\treturn element;\r\n\t}\r\n\r\n\tfunction pips ( grid ) {\r\n\r\n\t\tvar mode = grid.mode;\r\n\t\tvar density = grid.density || 1;\r\n\t\tvar filter = grid.filter || false;\r\n\t\tvar values = grid.values || false;\r\n\t\tvar stepped = grid.stepped || false;\r\n\t\tvar group = getGroup( mode, values, stepped );\r\n\t\tvar spread = generateSpread( density, mode, group );\r\n\t\tvar format = grid.format || {\r\n\t\t\tto: Math.round\r\n\t\t};\r\n\r\n\t\treturn scope_Target.appendChild(addMarking(\r\n\t\t\tspread,\r\n\t\t\tfilter,\r\n\t\t\tformat\r\n\t\t));\r\n\t}\r\n\r\n\r\n\t// Shorthand for base dimensions.\r\n\tfunction baseSize ( ) {\r\n\t\tvar rect = scope_Base.getBoundingClientRect(), alt = 'offset' + ['Width', 'Height'][options.ort];\r\n\t\treturn options.ort === 0 ? (rect.width||scope_Base[alt]) : (rect.height||scope_Base[alt]);\r\n\t}\r\n\r\n\t// Handler for attaching events trough a proxy.\r\n\tfunction attachEvent ( events, element, callback, data ) {\r\n\r\n\t\t// This function can be used to 'filter' events to the slider.\r\n\t\t// element is a node, not a nodeList\r\n\r\n\t\tvar method = function ( e ){\r\n\r\n\t\t\tif ( scope_Target.hasAttribute('disabled') ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\t// Stop if an active 'tap' transition is taking place.\r\n\t\t\tif ( hasClass(scope_Target, options.cssClasses.tap) ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\te = fixEvent(e, data.pageOffset);\r\n\r\n\t\t\t// Handle reject of multitouch\r\n\t\t\tif ( !e ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\t// Ignore right or middle clicks on start #454\r\n\t\t\tif ( events === actions.start && e.buttons !== undefined && e.buttons > 1 ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\t// Ignore right or middle clicks on start #454\r\n\t\t\tif ( data.hover && e.buttons ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\te.calcPoint = e.points[ options.ort ];\r\n\r\n\t\t\t// Call the event handler with the event [ and additional data ].\r\n\t\t\tcallback ( e, data );\r\n\t\t};\r\n\r\n\t\tvar methods = [];\r\n\r\n\t\t// Bind a closure on the target for every event type.\r\n\t\tevents.split(' ').forEach(function( eventName ){\r\n\t\t\telement.addEventListener(eventName, method, false);\r\n\t\t\tmethods.push([eventName, method]);\r\n\t\t});\r\n\r\n\t\treturn methods;\r\n\t}\r\n\r\n\t// Provide a clean event with standardized offset values.\r\n\tfunction fixEvent ( e, pageOffset ) {\r\n\r\n\t\t// Prevent scrolling and panning on touch events, while\r\n\t\t// attempting to slide. The tap event also depends on this.\r\n\t\te.preventDefault();\r\n\r\n\t\t// Filter the event to register the type, which can be\r\n\t\t// touch, mouse or pointer. Offset changes need to be\r\n\t\t// made on an event specific basis.\r\n\t\tvar touch = e.type.indexOf('touch') === 0;\r\n\t\tvar mouse = e.type.indexOf('mouse') === 0;\r\n\t\tvar pointer = e.type.indexOf('pointer') === 0;\r\n\t\tvar x;\r\n\t\tvar y;\r\n\r\n\t\t// IE10 implemented pointer events with a prefix;\r\n\t\tif ( e.type.indexOf('MSPointer') === 0 ) {\r\n\t\t\tpointer = true;\r\n\t\t}\r\n\r\n\t\tif ( touch ) {\r\n\r\n\t\t\t// Fix bug when user touches with two or more fingers on mobile devices.\r\n\t\t\t// It's useful when you have two or more sliders on one page,\r\n\t\t\t// that can be touched simultaneously.\r\n\t\t\t// #649, #663, #668\r\n\t\t\tif ( e.touches.length > 1 ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\t// noUiSlider supports one movement at a time,\r\n\t\t\t// so we can select the first 'changedTouch'.\r\n\t\t\tx = e.changedTouches[0].pageX;\r\n\t\t\ty = e.changedTouches[0].pageY;\r\n\t\t}\r\n\r\n\t\tpageOffset = pageOffset || getPageOffset();\r\n\r\n\t\tif ( mouse || pointer ) {\r\n\t\t\tx = e.clientX + pageOffset.x;\r\n\t\t\ty = e.clientY + pageOffset.y;\r\n\t\t}\r\n\r\n\t\te.pageOffset = pageOffset;\r\n\t\te.points = [x, y];\r\n\t\te.cursor = mouse || pointer; // Fix #435\r\n\r\n\t\treturn e;\r\n\t}\r\n\r\n\t// Translate a coordinate in the document to a percentage on the slider\r\n\tfunction calcPointToPercentage ( calcPoint ) {\r\n\t\tvar location = calcPoint - offset(scope_Base, options.ort);\r\n\t\tvar proposal = ( location * 100 ) / baseSize();\r\n\t\treturn options.dir ? 100 - proposal : proposal;\r\n\t}\r\n\r\n\t// Find handle closest to a certain percentage on the slider\r\n\tfunction getClosestHandle ( proposal ) {\r\n\r\n\t\tvar closest = 100;\r\n\t\tvar handleNumber = false;\r\n\r\n\t\tscope_Handles.forEach(function(handle, index){\r\n\r\n\t\t\t// Disabled handles are ignored\r\n\t\t\tif ( handle.hasAttribute('disabled') ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tvar pos = Math.abs(scope_Locations[index] - proposal);\r\n\r\n\t\t\tif ( pos < closest ) {\r\n\t\t\t\thandleNumber = index;\r\n\t\t\t\tclosest = pos;\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\treturn handleNumber;\r\n\t}\r\n\r\n\t// Moves handle(s) by a percentage\r\n\t// (bool, % to move, [% where handle started, ...], [index in scope_Handles, ...])\r\n\tfunction moveHandles ( upward, proposal, locations, handleNumbers ) {\r\n\r\n\t\tvar proposals = locations.slice();\r\n\r\n\t\tvar b = [!upward, upward];\r\n\t\tvar f = [upward, !upward];\r\n\r\n\t\t// Copy handleNumbers so we don't change the dataset\r\n\t\thandleNumbers = handleNumbers.slice();\r\n\r\n\t\t// Check to see which handle is 'leading'.\r\n\t\t// If that one can't move the second can't either.\r\n\t\tif ( upward ) {\r\n\t\t\thandleNumbers.reverse();\r\n\t\t}\r\n\r\n\t\t// Step 1: get the maximum percentage that any of the handles can move\r\n\t\tif ( handleNumbers.length > 1 ) {\r\n\r\n\t\t\thandleNumbers.forEach(function(handleNumber, o) {\r\n\r\n\t\t\t\tvar to = checkHandlePosition(proposals, handleNumber, proposals[handleNumber] + proposal, b[o], f[o]);\r\n\r\n\t\t\t\t// Stop if one of the handles can't move.\r\n\t\t\t\tif ( to === false ) {\r\n\t\t\t\t\tproposal = 0;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tproposal = to - proposals[handleNumber];\r\n\t\t\t\t\tproposals[handleNumber] = to;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\t// If using one handle, check backward AND forward\r\n\t\telse {\r\n\t\t\tb = f = [true];\r\n\t\t}\r\n\r\n\t\tvar state = false;\r\n\r\n\t\t// Step 2: Try to set the handles with the found percentage\r\n\t\thandleNumbers.forEach(function(handleNumber, o) {\r\n\t\t\tstate = setHandle(handleNumber, locations[handleNumber] + proposal, b[o], f[o]) || state;\r\n\t\t});\r\n\r\n\t\t// Step 3: If a handle moved, fire events\r\n\t\tif ( state ) {\r\n\t\t\thandleNumbers.forEach(function(handleNumber){\r\n\t\t\t\tfireEvent('update', handleNumber);\r\n\t\t\t\tfireEvent('slide', handleNumber);\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\t// External event handling\r\n\tfunction fireEvent ( eventName, handleNumber, tap ) {\r\n\r\n\t\tObject.keys(scope_Events).forEach(function( targetEvent ) {\r\n\r\n\t\t\tvar eventType = targetEvent.split('.')[0];\r\n\r\n\t\t\tif ( eventName === eventType ) {\r\n\t\t\t\tscope_Events[targetEvent].forEach(function( callback ) {\r\n\r\n\t\t\t\t\tcallback.call(\r\n\t\t\t\t\t\t// Use the slider public API as the scope ('this')\r\n\t\t\t\t\t\tscope_Self,\r\n\t\t\t\t\t\t// Return values as array, so arg_1[arg_2] is always valid.\r\n\t\t\t\t\t\tscope_Values.map(options.format.to),\r\n\t\t\t\t\t\t// Handle index, 0 or 1\r\n\t\t\t\t\t\thandleNumber,\r\n\t\t\t\t\t\t// Unformatted slider values\r\n\t\t\t\t\t\tscope_Values.slice(),\r\n\t\t\t\t\t\t// Event is fired by tap, true or false\r\n\t\t\t\t\t\ttap || false,\r\n\t\t\t\t\t\t// Left offset of the handle, in relation to the slider\r\n\t\t\t\t\t\tscope_Locations.slice()\r\n\t\t\t\t\t);\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\r\n\t// Fire 'end' when a mouse or pen leaves the document.\r\n\tfunction documentLeave ( event, data ) {\r\n\t\tif ( event.type === \"mouseout\" && event.target.nodeName === \"HTML\" && event.relatedTarget === null ){\r\n\t\t\teventEnd (event, data);\r\n\t\t}\r\n\t}\r\n\r\n\t// Handle movement on document for handle and range drag.\r\n\tfunction eventMove ( event, data ) {\r\n\r\n\t\t// Fix #498\r\n\t\t// Check value of .buttons in 'start' to work around a bug in IE10 mobile (data.buttonsProperty).\r\n\t\t// https://connect.microsoft.com/IE/feedback/details/927005/mobile-ie10-windows-phone-buttons-property-of-pointermove-event-always-zero\r\n\t\t// IE9 has .buttons and .which zero on mousemove.\r\n\t\t// Firefox breaks the spec MDN defines.\r\n\t\tif ( navigator.appVersion.indexOf(\"MSIE 9\") === -1 && event.buttons === 0 && data.buttonsProperty !== 0 ) {\r\n\t\t\treturn eventEnd(event, data);\r\n\t\t}\r\n\r\n\t\t// Check if we are moving up or down\r\n\t\tvar movement = (options.dir ? -1 : 1) * (event.calcPoint - data.startCalcPoint);\r\n\r\n\t\t// Convert the movement into a percentage of the slider width/height\r\n\t\tvar proposal = (movement * 100) / data.baseSize;\r\n\r\n\t\tmoveHandles(movement > 0, proposal, data.locations, data.handleNumbers);\r\n\t}\r\n\r\n\t// Unbind move events on document, call callbacks.\r\n\tfunction eventEnd ( event, data ) {\r\n\r\n\t\t// The handle is no longer active, so remove the class.\r\n\t\tif ( scope_ActiveHandle ) {\r\n\t\t\tremoveClass(scope_ActiveHandle, options.cssClasses.active);\r\n\t\t\tscope_ActiveHandle = false;\r\n\t\t}\r\n\r\n\t\t// Remove cursor styles and text-selection events bound to the body.\r\n\t\tif ( event.cursor ) {\r\n\t\t\tdocument.body.style.cursor = '';\r\n\t\t\tdocument.body.removeEventListener('selectstart', document.body.noUiListener);\r\n\t\t}\r\n\r\n\t\t// Unbind the move and end events, which are added on 'start'.\r\n\t\tdocument.documentElement.noUiListeners.forEach(function( c ) {\r\n\t\t\tdocument.documentElement.removeEventListener(c[0], c[1]);\r\n\t\t});\r\n\r\n\t\t// Remove dragging class.\r\n\t\tremoveClass(scope_Target, options.cssClasses.drag);\r\n\r\n\t\tsetZindex();\r\n\r\n\t\tdata.handleNumbers.forEach(function(handleNumber){\r\n\t\t\tfireEvent('set', handleNumber);\r\n\t\t\tfireEvent('change', handleNumber);\r\n\t\t\tfireEvent('end', handleNumber);\r\n\t\t});\r\n\t}\r\n\r\n\t// Bind move events on document.\r\n\tfunction eventStart ( event, data ) {\r\n\r\n\t\tif ( data.handleNumbers.length === 1 ) {\r\n\r\n\t\t\tvar handle = scope_Handles[data.handleNumbers[0]];\r\n\r\n\t\t\t// Ignore 'disabled' handles\r\n\t\t\tif ( handle.hasAttribute('disabled') ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\t// Mark the handle as 'active' so it can be styled.\r\n\t\t\tscope_ActiveHandle = handle.children[0];\r\n\t\t\taddClass(scope_ActiveHandle, options.cssClasses.active);\r\n\t\t}\r\n\r\n\t\t// Fix #551, where a handle gets selected instead of dragged.\r\n\t\tevent.preventDefault();\r\n\r\n\t\t// A drag should never propagate up to the 'tap' event.\r\n\t\tevent.stopPropagation();\r\n\r\n\t\t// Attach the move and end events.\r\n\t\tvar moveEvent = attachEvent(actions.move, document.documentElement, eventMove, {\r\n\t\t\tstartCalcPoint: event.calcPoint,\r\n\t\t\tbaseSize: baseSize(),\r\n\t\t\tpageOffset: event.pageOffset,\r\n\t\t\thandleNumbers: data.handleNumbers,\r\n\t\t\tbuttonsProperty: event.buttons,\r\n\t\t\tlocations: scope_Locations.slice()\r\n\t\t});\r\n\r\n\t\tvar endEvent = attachEvent(actions.end, document.documentElement, eventEnd, {\r\n\t\t\thandleNumbers: data.handleNumbers\r\n\t\t});\r\n\r\n\t\tvar outEvent = attachEvent(\"mouseout\", document.documentElement, documentLeave, {\r\n\t\t\thandleNumbers: data.handleNumbers\r\n\t\t});\r\n\r\n\t\tdocument.documentElement.noUiListeners = moveEvent.concat(endEvent, outEvent);\r\n\r\n\t\t// Text selection isn't an issue on touch devices,\r\n\t\t// so adding cursor styles can be skipped.\r\n\t\tif ( event.cursor ) {\r\n\r\n\t\t\t// Prevent the 'I' cursor and extend the range-drag cursor.\r\n\t\t\tdocument.body.style.cursor = getComputedStyle(event.target).cursor;\r\n\r\n\t\t\t// Mark the target with a dragging state.\r\n\t\t\tif ( scope_Handles.length > 1 ) {\r\n\t\t\t\taddClass(scope_Target, options.cssClasses.drag);\r\n\t\t\t}\r\n\r\n\t\t\tvar f = function(){\r\n\t\t\t\treturn false;\r\n\t\t\t};\r\n\r\n\t\t\tdocument.body.noUiListener = f;\r\n\r\n\t\t\t// Prevent text selection when dragging the handles.\r\n\t\t\tdocument.body.addEventListener('selectstart', f, false);\r\n\t\t}\r\n\r\n\t\tdata.handleNumbers.forEach(function(handleNumber){\r\n\t\t\tfireEvent('start', handleNumber);\r\n\t\t});\r\n\t}\r\n\r\n\t// Move closest handle to tapped location.\r\n\tfunction eventTap ( event ) {\r\n\r\n\t\t// The tap event shouldn't propagate up\r\n\t\tevent.stopPropagation();\r\n\r\n\t\tvar proposal = calcPointToPercentage(event.calcPoint);\r\n\t\tvar handleNumber = getClosestHandle(proposal);\r\n\r\n\t\t// Tackle the case that all handles are 'disabled'.\r\n\t\tif ( handleNumber === false ) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\t// Flag the slider as it is now in a transitional state.\r\n\t\t// Transition takes a configurable amount of ms (default 300). Re-enable the slider after that.\r\n\t\tif ( !options.events.snap ) {\r\n\t\t\taddClassFor(scope_Target, options.cssClasses.tap, options.animationDuration);\r\n\t\t}\r\n\r\n\t\tsetHandle(handleNumber, proposal, true, true);\r\n\r\n\t\tsetZindex();\r\n\r\n\t\tfireEvent('slide', handleNumber, true);\r\n\t\tfireEvent('set', handleNumber, true);\r\n\t\tfireEvent('change', handleNumber, true);\r\n\t\tfireEvent('update', handleNumber, true);\r\n\r\n\t\tif ( options.events.snap ) {\r\n\t\t\teventStart(event, { handleNumbers: [handleNumber] });\r\n\t\t}\r\n\t}\r\n\r\n\t// Fires a 'hover' event for a hovered mouse/pen position.\r\n\tfunction eventHover ( event ) {\r\n\r\n\t\tvar proposal = calcPointToPercentage(event.calcPoint);\r\n\r\n\t\tvar to = scope_Spectrum.getStep(proposal);\r\n\t\tvar value = scope_Spectrum.fromStepping(to);\r\n\r\n\t\tObject.keys(scope_Events).forEach(function( targetEvent ) {\r\n\t\t\tif ( 'hover' === targetEvent.split('.')[0] ) {\r\n\t\t\t\tscope_Events[targetEvent].forEach(function( callback ) {\r\n\t\t\t\t\tcallback.call( scope_Self, value );\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t// Attach events to several slider parts.\r\n\tfunction bindSliderEvents ( behaviour ) {\r\n\r\n\t\t// Attach the standard drag event to the handles.\r\n\t\tif ( !behaviour.fixed ) {\r\n\r\n\t\t\tscope_Handles.forEach(function( handle, index ){\r\n\r\n\t\t\t\t// These events are only bound to the visual handle\r\n\t\t\t\t// element, not the 'real' origin element.\r\n\t\t\t\tattachEvent ( actions.start, handle.children[0], eventStart, {\r\n\t\t\t\t\thandleNumbers: [index]\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\t// Attach the tap event to the slider base.\r\n\t\tif ( behaviour.tap ) {\r\n\t\t\tattachEvent (actions.start, scope_Base, eventTap, {});\r\n\t\t}\r\n\r\n\t\t// Fire hover events\r\n\t\tif ( behaviour.hover ) {\r\n\t\t\tattachEvent (actions.move, scope_Base, eventHover, { hover: true });\r\n\t\t}\r\n\r\n\t\t// Make the range draggable.\r\n\t\tif ( behaviour.drag ){\r\n\r\n\t\t\tscope_Connects.forEach(function( connect, index ){\r\n\r\n\t\t\t\tif ( connect === false || index === 0 || index === scope_Connects.length - 1 ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tvar handleBefore = scope_Handles[index - 1];\r\n\t\t\t\tvar handleAfter = scope_Handles[index];\r\n\t\t\t\tvar eventHolders = [connect];\r\n\r\n\t\t\t\taddClass(connect, options.cssClasses.draggable);\r\n\r\n\t\t\t\t// When the range is fixed, the entire range can\r\n\t\t\t\t// be dragged by the handles. The handle in the first\r\n\t\t\t\t// origin will propagate the start event upward,\r\n\t\t\t\t// but it needs to be bound manually on the other.\r\n\t\t\t\tif ( behaviour.fixed ) {\r\n\t\t\t\t\teventHolders.push(handleBefore.children[0]);\r\n\t\t\t\t\teventHolders.push(handleAfter.children[0]);\r\n\t\t\t\t}\r\n\r\n\t\t\t\teventHolders.forEach(function( eventHolder ) {\r\n\t\t\t\t\tattachEvent ( actions.start, eventHolder, eventStart, {\r\n\t\t\t\t\t\thandles: [handleBefore, handleAfter],\r\n\t\t\t\t\t\thandleNumbers: [index - 1, index]\r\n\t\t\t\t\t});\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\r\n\t// Split out the handle positioning logic so the Move event can use it, too\r\n\tfunction checkHandlePosition ( reference, handleNumber, to, lookBackward, lookForward ) {\r\n\r\n\t\t// For sliders with multiple handles, limit movement to the other handle.\r\n\t\t// Apply the margin option by adding it to the handle positions.\r\n\t\tif ( scope_Handles.length > 1 ) {\r\n\r\n\t\t\tif ( lookBackward && handleNumber > 0 ) {\r\n\t\t\t\tto = Math.max(to, reference[handleNumber - 1] + options.margin);\r\n\t\t\t}\r\n\r\n\t\t\tif ( lookForward && handleNumber < scope_Handles.length - 1 ) {\r\n\t\t\t\tto = Math.min(to, reference[handleNumber + 1] - options.margin);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// The limit option has the opposite effect, limiting handles to a\r\n\t\t// maximum distance from another. Limit must be > 0, as otherwise\r\n\t\t// handles would be unmoveable.\r\n\t\tif ( scope_Handles.length > 1 && options.limit ) {\r\n\r\n\t\t\tif ( lookBackward && handleNumber > 0 ) {\r\n\t\t\t\tto = Math.min(to, reference[handleNumber - 1] + options.limit);\r\n\t\t\t}\r\n\r\n\t\t\tif ( lookForward && handleNumber < scope_Handles.length - 1 ) {\r\n\t\t\t\tto = Math.max(to, reference[handleNumber + 1] - options.limit);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// The padding option keeps the handles a certain distance from the\r\n\t\t// edges of the slider. Padding must be > 0.\r\n\t\tif ( options.padding ) {\r\n\r\n\t\t\tif ( handleNumber === 0 ) {\r\n\t\t\t\tto = Math.max(to, options.padding);\r\n\t\t\t}\r\n\r\n\t\t\tif ( handleNumber === scope_Handles.length - 1 ) {\r\n\t\t\t\tto = Math.min(to, 100 - options.padding);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tto = scope_Spectrum.getStep(to);\r\n\r\n\t\t// Limit percentage to the 0 - 100 range\r\n\t\tto = limit(to);\r\n\r\n\t\t// Return false if handle can't move\r\n\t\tif ( to === reference[handleNumber] ) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\treturn to;\r\n\t}\r\n\r\n\tfunction toPct ( pct ) {\r\n\t\treturn pct + '%';\r\n\t}\r\n\r\n\t// Updates scope_Locations and scope_Values, updates visual state\r\n\tfunction updateHandlePosition ( handleNumber, to ) {\r\n\r\n\t\t// Update locations.\r\n\t\tscope_Locations[handleNumber] = to;\r\n\r\n\t\t// Convert the value to the slider stepping/range.\r\n\t\tscope_Values[handleNumber] = scope_Spectrum.fromStepping(to);\r\n\r\n\t\t// Called synchronously or on the next animationFrame\r\n\t\tvar stateUpdate = function() {\r\n\t\t\tscope_Handles[handleNumber].style[options.style] = toPct(to);\r\n\t\t\tupdateConnect(handleNumber);\r\n\t\t\tupdateConnect(handleNumber + 1);\r\n\t\t};\r\n\r\n\t\t// Set the handle to the new position.\r\n\t\t// Use requestAnimationFrame for efficient painting.\r\n\t\t// No significant effect in Chrome, Edge sees dramatic performace improvements.\r\n\t\t// Option to disable is useful for unit tests, and single-step debugging.\r\n\t\tif ( window.requestAnimationFrame && options.useRequestAnimationFrame ) {\r\n\t\t\twindow.requestAnimationFrame(stateUpdate);\r\n\t\t} else {\r\n\t\t\tstateUpdate();\r\n\t\t}\r\n\t}\r\n\r\n\tfunction setZindex ( ) {\r\n\r\n\t\tscope_HandleNumbers.forEach(function(handleNumber){\r\n\t\t\t// Handles before the slider middle are stacked later = higher,\r\n\t\t\t// Handles after the middle later is lower\r\n\t\t\t// [[7] [8] .......... | .......... [5] [4]\r\n\t\t\tvar dir = (scope_Locations[handleNumber] > 50 ? -1 : 1);\r\n\t\t\tvar zIndex = 3 + (scope_Handles.length + (dir * handleNumber));\r\n\t\t\tscope_Handles[handleNumber].childNodes[0].style.zIndex = zIndex;\r\n\t\t});\r\n\t}\r\n\r\n\t// Test suggested values and apply margin, step.\r\n\tfunction setHandle ( handleNumber, to, lookBackward, lookForward ) {\r\n\r\n\t\tto = checkHandlePosition(scope_Locations, handleNumber, to, lookBackward, lookForward);\r\n\r\n\t\tif ( to === false ) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tupdateHandlePosition(handleNumber, to);\r\n\r\n\t\treturn true;\r\n\t}\r\n\r\n\t// Updates style attribute for connect nodes\r\n\tfunction updateConnect ( index ) {\r\n\r\n\t\t// Skip connects set to false\r\n\t\tif ( !scope_Connects[index] ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tvar l = 0;\r\n\t\tvar h = 100;\r\n\r\n\t\tif ( index !== 0 ) {\r\n\t\t\tl = scope_Locations[index - 1];\r\n\t\t}\r\n\r\n\t\tif ( index !== scope_Connects.length - 1 ) {\r\n\t\t\th = scope_Locations[index];\r\n\t\t}\r\n\r\n\t\tscope_Connects[index].style[options.style] = toPct(l);\r\n\t\tscope_Connects[index].style[options.styleOposite] = toPct(100 - h);\r\n\t}\r\n\r\n\t// ...\r\n\tfunction setValue ( to, handleNumber ) {\r\n\r\n\t\t// Setting with null indicates an 'ignore'.\r\n\t\t// Inputting 'false' is invalid.\r\n\t\tif ( to === null || to === false ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\t// If a formatted number was passed, attemt to decode it.\r\n\t\tif ( typeof to === 'number' ) {\r\n\t\t\tto = String(to);\r\n\t\t}\r\n\r\n\t\tto = options.format.from(to);\r\n\r\n\t\t// Request an update for all links if the value was invalid.\r\n\t\t// Do so too if setting the handle fails.\r\n\t\tif ( to !== false && !isNaN(to) ) {\r\n\t\t\tsetHandle(handleNumber, scope_Spectrum.toStepping(to), false, false);\r\n\t\t}\r\n\t}\r\n\r\n\t// Set the slider value.\r\n\tfunction valueSet ( input, fireSetEvent ) {\r\n\r\n\t\tvar values = asArray(input);\r\n\t\tvar isInit = scope_Locations[0] === undefined;\r\n\r\n\t\t// Event fires by default\r\n\t\tfireSetEvent = (fireSetEvent === undefined ? true : !!fireSetEvent);\r\n\r\n\t\tvalues.forEach(setValue);\r\n\r\n\t\t// Animation is optional.\r\n\t\t// Make sure the initial values were set before using animated placement.\r\n\t\tif ( options.animate && !isInit ) {\r\n\t\t\taddClassFor(scope_Target, options.cssClasses.tap, options.animationDuration);\r\n\t\t}\r\n\r\n\t\t// Now that all base values are set, apply constraints\r\n\t\tscope_HandleNumbers.forEach(function(handleNumber){\r\n\t\t\tsetHandle(handleNumber, scope_Locations[handleNumber], true, false);\r\n\t\t});\r\n\r\n\t\tsetZindex();\r\n\r\n\t\tscope_HandleNumbers.forEach(function(handleNumber){\r\n\r\n\t\t\tfireEvent('update', handleNumber);\r\n\r\n\t\t\t// Fire the event only for handles that received a new value, as per #579\r\n\t\t\tif ( values[handleNumber] !== null && fireSetEvent ) {\r\n\t\t\t\tfireEvent('set', handleNumber);\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t// Reset slider to initial values\r\n\tfunction valueReset ( fireSetEvent ) {\r\n\t\tvalueSet(options.start, fireSetEvent);\r\n\t}\r\n\r\n\t// Get the slider value.\r\n\tfunction valueGet ( ) {\r\n\r\n\t\tvar values = scope_Values.map(options.format.to);\r\n\r\n\t\t// If only one handle is used, return a single value.\r\n\t\tif ( values.length === 1 ){\r\n\t\t\treturn values[0];\r\n\t\t}\r\n\r\n\t\treturn values;\r\n\t}\r\n\r\n\t// Removes classes from the root and empties it.\r\n\tfunction destroy ( ) {\r\n\r\n\t\tfor ( var key in options.cssClasses ) {\r\n\t\t\tif ( !options.cssClasses.hasOwnProperty(key) ) { continue; }\r\n\t\t\tremoveClass(scope_Target, options.cssClasses[key]);\r\n\t\t}\r\n\r\n\t\twhile (scope_Target.firstChild) {\r\n\t\t\tscope_Target.removeChild(scope_Target.firstChild);\r\n\t\t}\r\n\r\n\t\tdelete scope_Target.noUiSlider;\r\n\t}\r\n\r\n\t// Get the current step size for the slider.\r\n\tfunction getCurrentStep ( ) {\r\n\r\n\t\t// Check all locations, map them to their stepping point.\r\n\t\t// Get the step point, then find it in the input list.\r\n\t\treturn scope_Locations.map(function( location, index ){\r\n\r\n\t\t\tvar nearbySteps = scope_Spectrum.getNearbySteps( location );\r\n\t\t\tvar value = scope_Values[index];\r\n\t\t\tvar increment = nearbySteps.thisStep.step;\r\n\t\t\tvar decrement = null;\r\n\r\n\t\t\t// If the next value in this step moves into the next step,\r\n\t\t\t// the increment is the start of the next step - the current value\r\n\t\t\tif ( increment !== false ) {\r\n\t\t\t\tif ( value + increment > nearbySteps.stepAfter.startValue ) {\r\n\t\t\t\t\tincrement = nearbySteps.stepAfter.startValue - value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\r\n\t\t\t// If the value is beyond the starting point\r\n\t\t\tif ( value > nearbySteps.thisStep.startValue ) {\r\n\t\t\t\tdecrement = nearbySteps.thisStep.step;\r\n\t\t\t}\r\n\r\n\t\t\telse if ( nearbySteps.stepBefore.step === false ) {\r\n\t\t\t\tdecrement = false;\r\n\t\t\t}\r\n\r\n\t\t\t// If a handle is at the start of a step, it always steps back into the previous step first\r\n\t\t\telse {\r\n\t\t\t\tdecrement = value - nearbySteps.stepBefore.highestStep;\r\n\t\t\t}\r\n\r\n\r\n\t\t\t// Now, if at the slider edges, there is not in/decrement\r\n\t\t\tif ( location === 100 ) {\r\n\t\t\t\tincrement = null;\r\n\t\t\t}\r\n\r\n\t\t\telse if ( location === 0 ) {\r\n\t\t\t\tdecrement = null;\r\n\t\t\t}\r\n\r\n\t\t\t// As per #391, the comparison for the decrement step can have some rounding issues.\r\n\t\t\tvar stepDecimals = scope_Spectrum.countStepDecimals();\r\n\r\n\t\t\t// Round per #391\r\n\t\t\tif ( increment !== null && increment !== false ) {\r\n\t\t\t\tincrement = Number(increment.toFixed(stepDecimals));\r\n\t\t\t}\r\n\r\n\t\t\tif ( decrement !== null && decrement !== false ) {\r\n\t\t\t\tdecrement = Number(decrement.toFixed(stepDecimals));\r\n\t\t\t}\r\n\r\n\t\t\treturn [decrement, increment];\r\n\t\t});\r\n\t}\r\n\r\n\t// Attach an event to this slider, possibly including a namespace\r\n\tfunction bindEvent ( namespacedEvent, callback ) {\r\n\t\tscope_Events[namespacedEvent] = scope_Events[namespacedEvent] || [];\r\n\t\tscope_Events[namespacedEvent].push(callback);\r\n\r\n\t\t// If the event bound is 'update,' fire it immediately for all handles.\r\n\t\tif ( namespacedEvent.split('.')[0] === 'update' ) {\r\n\t\t\tscope_Handles.forEach(function(a, index){\r\n\t\t\t\tfireEvent('update', index);\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\t// Undo attachment of event\r\n\tfunction removeEvent ( namespacedEvent ) {\r\n\r\n\t\tvar event = namespacedEvent && namespacedEvent.split('.')[0];\r\n\t\tvar namespace = event && namespacedEvent.substring(event.length);\r\n\r\n\t\tObject.keys(scope_Events).forEach(function( bind ){\r\n\r\n\t\t\tvar tEvent = bind.split('.')[0],\r\n\t\t\t\ttNamespace = bind.substring(tEvent.length);\r\n\r\n\t\t\tif ( (!event || event === tEvent) && (!namespace || namespace === tNamespace) ) {\r\n\t\t\t\tdelete scope_Events[bind];\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t// Updateable: margin, limit, padding, step, range, animate, snap\r\n\tfunction updateOptions ( optionsToUpdate, fireSetEvent ) {\r\n\r\n\t\t// Spectrum is created using the range, snap, direction and step options.\r\n\t\t// 'snap' and 'step' can be updated, 'direction' cannot, due to event binding.\r\n\t\t// If 'snap' and 'step' are not passed, they should remain unchanged.\r\n\t\tvar v = valueGet();\r\n\r\n\t\tvar updateAble = ['margin', 'limit', 'padding', 'range', 'animate', 'snap', 'step', 'format'];\r\n\r\n\t\t// Only change options that we're actually passed to update.\r\n\t\tupdateAble.forEach(function(name){\r\n\t\t\tif ( optionsToUpdate[name] !== undefined ) {\r\n\t\t\t\toriginalOptions[name] = optionsToUpdate[name];\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tvar newOptions = testOptions(originalOptions);\r\n\r\n\t\t// Load new options into the slider state\r\n\t\tupdateAble.forEach(function(name){\r\n\t\t\tif ( optionsToUpdate[name] !== undefined ) {\r\n\t\t\t\toptions[name] = newOptions[name];\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\t// Save current spectrum direction as testOptions in testRange call\r\n\t\t// doesn't rely on current direction\r\n\t\tnewOptions.spectrum.direction = scope_Spectrum.direction;\r\n\t\tscope_Spectrum = newOptions.spectrum;\r\n\r\n\t\t// Limit, margin and padding depend on the spectrum but are stored outside of it. (#677)\r\n\t\toptions.margin = newOptions.margin;\r\n\t\toptions.limit = newOptions.limit;\r\n\t\toptions.padding = newOptions.padding;\r\n\r\n\t\t// Invalidate the current positioning so valueSet forces an update.\r\n\t\tscope_Locations = [];\r\n\t\tvalueSet(optionsToUpdate.start || v, fireSetEvent);\r\n\t}\r\n\r\n\t// Throw an error if the slider was already initialized.\r\n\tif ( scope_Target.noUiSlider ) {\r\n\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): Slider was already initialized.\");\r\n\t}\r\n\r\n\t// Create the base element, initialise HTML and set classes.\r\n\t// Add handles and connect elements.\r\n\taddSlider(scope_Target);\r\n\taddElements(options.connect, scope_Base);\r\n\r\n\tscope_Self = {\r\n\t\tdestroy: destroy,\r\n\t\tsteps: getCurrentStep,\r\n\t\ton: bindEvent,\r\n\t\toff: removeEvent,\r\n\t\tget: valueGet,\r\n\t\tset: valueSet,\r\n\t\treset: valueReset,\r\n\t\t// Exposed for unit testing, don't use this in your application.\r\n\t\t__moveHandles: function(a, b, c) { moveHandles(a, b, scope_Locations, c); },\r\n\t\toptions: originalOptions, // Issue #600, #678\r\n\t\tupdateOptions: updateOptions,\r\n\t\ttarget: scope_Target, // Issue #597\r\n\t\tpips: pips // Issue #594\r\n\t};\r\n\r\n\t// Attach user events.\r\n\tbindSliderEvents(options.events);\r\n\r\n\t// Use the public value method to set the start values.\r\n\tvalueSet(options.start);\r\n\r\n\tif ( options.pips ) {\r\n\t\tpips(options.pips);\r\n\t}\r\n\r\n\tif ( options.tooltips ) {\r\n\t\ttooltips();\r\n\t}\r\n\r\n\treturn scope_Self;\r\n\r\n}\r\n\r\n\r\n\t// Run the standard initializer\r\n\tfunction initialize ( target, originalOptions ) {\r\n\r\n\t\tif ( !target.nodeName ) {\r\n\t\t\tthrow new Error(\"noUiSlider (\" + VERSION + \"): create requires a single element.\");\r\n\t\t}\r\n\r\n\t\t// Test the options and create the slider environment;\r\n\t\tvar options = testOptions( originalOptions, target );\r\n\t\tvar api = closure( target, options, originalOptions );\r\n\r\n\t\ttarget.noUiSlider = api;\r\n\r\n\t\treturn api;\r\n\t}\r\n\r\n\t// Use an object instead of a function for future expansibility;\r\n\treturn {\r\n\t\tversion: VERSION,\r\n\t\tcreate: initialize\r\n\t};\r\n\r\n}));\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/nouislider/distribute/nouislider.js\n ** module id = 39\n ** module chunks = 0\n **/","import Component from '../component/component';\nimport clamp from '../util/clamp';\n\nconst SELECTOR_COMPONENT = '.aui-js-indicator';\nconst CLASS_ITEM = 'aui-indicator__item';\nconst CLASS_ACTION = 'aui-indicator__action';\nconst CLASS_INDICATOR = 'aui-indicator__indicator';\nconst CLASS_IS_ACTIVE = 'is-active';\n\n/**\n * Class constructor for Indicator AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Indicator extends Component {\n\n  /**\n   * Upgrades all Indicator AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Indicator(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n  }\n\n  init() {\n    super.init();\n\n    this._actions = Array.from(this._element.querySelectorAll(`.${CLASS_ACTION}`));\n    this._listItems = Array.from(this._element.querySelectorAll(`.${CLASS_ITEM}`));\n\n    this._indicator = document.createElement('span');\n    this._indicator.classList.add(CLASS_INDICATOR);\n    this._element.appendChild(this._indicator);\n\n    this._element.addEventListener('click', this.clickHandler = (event) => this._onClick(event));\n  }\n\n  /**\n   * Handle click.\n   * @param {Event} event The event that fired.\n   * @private\n   */\n  _onClick(event) {\n    if (!event.target.classList.contains(CLASS_ACTION)) {\n      return;\n    }\n    event.preventDefault();\n\n    this.selectAction(event.target);\n  }\n\n  /**\n   * Select item with given action element.\n   * @param {HTMLElement} actionElement Action child element of the list item to select.\n   * @private\n   */\n  selectAction(actionElement) {\n    if (actionElement) {\n      // Find index\n      const listItem = actionElement.parentNode;\n      const index = this._listItems.indexOf(listItem);\n      this.select(index);\n    }\n  }\n\n  /**\n   * Select item.\n   * @param {Integer} index Zero-based index of the list item to select.\n   * @private\n   */\n  select(index = 0) {\n    index = clamp(index, 0, this._actions.length - 1);\n    const activeItem = this._actions[index];\n\n    // Update actions\n    this._actions.forEach(item => {\n      item.classList.remove(CLASS_IS_ACTIVE);\n    });\n    activeItem.classList.add(CLASS_IS_ACTIVE);\n\n    // Update indicator position\n    const rectContainer = this._element.getBoundingClientRect();\n    const rectTarget = activeItem.getBoundingClientRect();\n    const indicatorLeft = rectTarget.left - rectContainer.left;\n    this._indicator.style.left = `${indicatorLeft}px`;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/indicator/indicator.js\n **/","/**\n * Clamps `number` within the inclusive `lower` and `upper` bounds.\n *\n * @since 4.0.0\n * @category Number\n * @param {number} number The number to clamp.\n * @param {number} lower The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n * @example\n *\n * clamp(-10, -5, 5)\n * // => -5\n *\n * clamp(10, -5, 5)\n * // => 5\n */\nexport default function clamp(number, lower, upper) {\n  number = +number;\n  lower = +lower;\n  upper = +upper;\n  lower = lower === lower ? lower : 0;\n  upper = upper === upper ? upper : 0;\n  if (number === number) {\n    number = number <= upper ? number : upper;\n    number = number >= lower ? number : lower;\n  }\n  return number;\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/clamp.js\n **/","import Component from '../component/component';\nimport ObjectResize from '../util/object-resize';\nimport limit from '../util/limit';\nimport bezierEasing from 'bezier-easing';\n\nconst SELECTOR_COMPONENT = '.aui-js-spinner';\nconst CLASS_CONTINUOUS = 'aui-spinner--continuous';\nconst CLASS_SHAPE = 'aui-spinner__svg';\nconst CLASS_PATH = 'aui-spinner__path';\nconst CLASS_PATH_PROGRESS = 'aui-spinner__path--progress';\nconst CLASS_GROUP = 'aui-spinner__group';\nconst CLASS_GROUP_BASE_PATH = 'aui-spinner__group-base';\nconst CLASS_GROUP_PROGRESS_PATH = 'aui-spinner__group-progress';\nconst CLASS_VALUE = 'aui-spinner__value';\nconst CLASS_IS_PENDING = 'is-pending';\nconst CLASS_IS_LOADING = 'is-loading';\nconst CLASS_IS_COMPLETE = 'is-complete';\nconst SIZE = 48;\nconst RADIUS = 22;\nconst STROKE_WIDTH = 3;\nconst LOOP_ANIMATION_DURATION = 1.5;\nconst LOOP_ANIMATION = [\n  {\n    dashLength: 0,\n    dashOffset: 0,\n    rotate: 0,\n  },{\n    dashLength: 0.65,\n    dashOffset: -1,\n    rotate: 360,\n  }\n];\n\n/**\n * Class constructor for Spinner AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Spinner extends Component {\n\n  /**\n   * Upgrades all Spinner AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Spinner(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n  }\n\n  init() {\n    super.init();\n\n    this._objectResize = new ObjectResize(this._element, this.resize, this);\n\n    this._continuous = this._element.classList.contains(CLASS_CONTINUOUS);\n\n    // Add value element, if required:\n    if (!this._continuous) {\n      this._value = document.createElement('span');\n      this._value.classList.add(CLASS_VALUE);\n      this._element.appendChild(this._value);\n    }\n\n    // Add SVG graphic:\n    // <svg class=\"aui-spinner__shape\" viewBox=\"0 0 200 200\">\n    //   <g class=\"aui-spinner__group\">\n    //     <circle class=\"aui-spinner__path\" cx=\"0\" cy=\"0\" r=\"100\" />\n    //     <circle class=\"aui-spinner__path aui-spinner__path--progress\" cx=\"0\" cy=\"0\" r=\"100\" />\n    //   </g>\n    // </svg>\n    let shape = this.createSvgNode('svg', {\n      class: CLASS_SHAPE,\n      viewBox: `0 0 ${SIZE} ${SIZE}`,\n    });\n    let group = this.createSvgNode('g', {class: CLASS_GROUP});\n    let groupCircle1 = this.createSvgNode('g', {class: CLASS_GROUP_BASE_PATH});\n    let groupCircle2 = this.createSvgNode('g', {class: CLASS_GROUP_PROGRESS_PATH});\n    let circle1 = this.createSvgNode('circle', {\n      class: CLASS_PATH,\n      cx: 0,\n      cy: 0,\n      r: RADIUS\n    });\n    let circle2 = this.createSvgNode('circle', {\n      class: `${CLASS_PATH} ${CLASS_PATH_PROGRESS}`,\n      cx: 0,\n      cy: 0,\n      r: RADIUS,\n      transform: 'rotate(-90)',\n    });\n    groupCircle1.appendChild(circle1);\n    groupCircle2.appendChild(circle2);\n    group.appendChild(groupCircle1);\n    group.appendChild(groupCircle2);\n    shape.appendChild(group);\n    this._element.appendChild(shape);\n    this._shape = shape;\n    this._group = group;\n    this._progressPath = circle2;\n    this._basePath = circle1;\n    this._groupProgress = groupCircle2;\n\n    this._easing = bezierEasing(0.75, 0.02, 0.5, 1);\n    this._easingDasharray = bezierEasing(0.4, 0, 0, 1);\n    this._progressPath.style.strokeOpacity = 0;\n\n    this.resize();\n    this.progress(0);\n  }\n\n  progress(ratio) {\n    ratio = limit(ratio, 0, 1);\n    this._progress = ratio;\n    const pathLength = this._getCircleLength(this._progressPath);\n\n    if (!this._continuous) {\n      this._progressPath.style.strokeDasharray = this._progress === 1\n        ? 'none'\n        : `${this._progress * pathLength}, ${pathLength}`;\n      this._progressPath.style.strokeOpacity = this._progress === 0\n        ? 0\n        : 1;\n    }\n\n    if (this._value) {\n      this._value.innerHTML = `${Math.round(this._progress * 100)}`;\n    }\n\n    this._updateClasses();\n  }\n\n  loop() {\n    if (this._continuous) {\n      this._progressPath.style.strokeOpacity = 1;\n      window.requestAnimationFrame(timestamp => this._animateLoop(timestamp));\n    }\n  }\n\n  stop() {}\n\n  resize() {\n    const size = this._element.offsetWidth;\n    const radius = (size - STROKE_WIDTH) / 2;\n    this._shape.setAttributeNS(null, 'viewBox', `${size / -2} ${size / -2} ${size} ${size}`);\n    this._basePath.setAttributeNS(null, 'r', `${radius}`);\n    this._progressPath.setAttributeNS(null, 'r', `${radius}`);\n  }\n\n  // TODO Optimize calculations; wording.\n  _animateLoop(timestamp) {\n    if (!this._loopStart) {\n      this._loopStart = timestamp;\n    }\n\n    // The progress in seconds 0 <= progress <= LOOP_ANIMATION_DURATION\n    let progress = (timestamp - this._loopStart) / 1000;\n    // The progress ratio between 0 <= progressRatio <= 1\n    let progressRatio = (progress / LOOP_ANIMATION_DURATION);\n    if (progressRatio > 1 || progressRatio === 0) {\n      this._animationEndSet = false;\n      progress = 0;\n      progressRatio = 0;\n      this._loopStart = timestamp;\n      this._dashLengthStart = LOOP_ANIMATION[0].dashLength;\n      this._dashOffsetStart = LOOP_ANIMATION[0].dashOffset;\n      this._dashLengthEnd = LOOP_ANIMATION[1].dashLength;\n      this._dashOffsetEnd = LOOP_ANIMATION[1].dashOffset;\n    }\n    const ease = this._easing(progressRatio);\n    const pathLength = this._getCircleLength(this._progressPath);\n    this._dashLengthRatio = this._dashLengthStart + (this._dashLengthEnd - this._dashLengthStart) * this._easingDasharray(progressRatio);\n    this._dashOffsetRatio = this._dashOffsetStart + (this._dashOffsetEnd - this._dashOffsetStart) * ease;\n    this._rotate = LOOP_ANIMATION[1].rotate * ease;\n\n    const dashLength = pathLength * this._dashLengthRatio;\n    const dashOffset = pathLength * this._dashOffsetRatio;\n\n    this._progressPath.style.strokeDasharray = `${dashLength}, ${pathLength}`;\n    this._progressPath.style.strokeDashoffset = `${dashOffset}`;\n    // this._group.setAttributeNS(null, 'transform', `rotate(${this._rotate})`);\n    this._groupProgress.setAttributeNS(null, 'transform', `rotate(${this._rotate})`);\n\n    window.requestAnimationFrame(timestamp => this._animateLoop(timestamp));\n  }\n\n  _updateClasses() {\n    if (this._progress === 0) {\n      this._element.classList.add(CLASS_IS_PENDING);\n    } else {\n      this._element.classList.remove(CLASS_IS_PENDING);\n    }\n\n    if (this._progress > 0 && this._progress < 1) {\n      this._element.classList.add(CLASS_IS_LOADING);\n    } else {\n      this._element.classList.remove(CLASS_IS_LOADING);\n    }\n\n    if (this._progress === 1) {\n      this._element.classList.add(CLASS_IS_COMPLETE);\n    } else {\n      this._element.classList.remove(CLASS_IS_COMPLETE);\n    }\n  }\n\n  _getCircleLength(circle) {\n    const r = circle.getAttribute('r');\n    return 2 * Math.PI * r;\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/spinner/spinner.js\n **/","export default class ObjectResize {\n\n  constructor(parent, callback, callbackScope) {\n\n    let isIE = navigator.userAgent.match(/Trident/);\n\n    // NOTE\n    // this._parent.style.position != 'static'\n    // this._parent.style.display = 'block'\n\n    this._parent = parent;\n    this._helperElement = document.createElement('object');\n    this._helperElement.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; pointer-events: none; z-index: -1; border: 0px; opacity: 0;');\n    this._helperElement.setAttribute('border', '0');\n    this._helperElement.onload = () => this._onLoad();\n    this._helperElement.type = 'text/html';\n    if (isIE) {\n      this._parent.appendChild(this._helperElement);\n    }\n    this._helperElement.data = 'about:blank';\n    if (!isIE) {\n      this._parent.appendChild(this._helperElement);\n    }\n\n    this._callback = callback;\n    this._callbackScope = callbackScope;\n\n    this._ticking = false;\n  }\n\n  _onLoad(event) {\n    this._helperElement.contentDocument.defaultView.addEventListener('resize', this._resizeHandler = (event) => this._onResize(event));\n  }\n\n  _onResize(event) {\n    if (!this._ticking) {\n      window.requestAnimationFrame(() => {\n        this._ticking = false;\n        this._callback.call(this._callbackScope);\n      });\n    }\n    this._ticking = true;\n  }\n\n  dispose() {\n    this._helperElement.contentDocument.defaultView.removeEventListener('resize', this._resizeHandler);\n    this._parent.removeChild(this._helperElement);\n  }\n}\n\n// (function() {\n//   var attachEvent = document.attachEvent;\n//   var isIE = navigator.userAgent.match(/Trident/);\n//   var requestFrame = (function() {\n//     var raf = window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame ||\n//       function(fn) {\n//         return window.setTimeout(fn, 20);\n//       };\n//     return function(fn) {\n//       return raf(fn);\n//     };\n//   })();\n//\n//   var cancelFrame = (function() {\n//     var cancel = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.webkitCancelAnimationFrame ||\n//       window.clearTimeout;\n//     return function(id) {\n//       return cancel(id);\n//     };\n//   })();\n//\n//   function resizeListener(e) {\n//     var win = e.target || e.srcElement;\n//     if (win.__resizeRAF__) cancelFrame(win.__resizeRAF__);\n//     win.__resizeRAF__ = requestFrame(function() {\n//       var trigger = win.__resizeTrigger__;\n//       trigger.__resizeListeners__.forEach(function(fn) {\n//         fn.call(trigger, e);\n//       });\n//     });\n//   }\n//\n//   function objectLoad(e) {\n//     this.contentDocument.defaultView.__resizeTrigger__ = this.__resizeElement__;\n//     this.contentDocument.defaultView.addEventListener('resize', resizeListener);\n//   }\n//\n//   window.addResizeListener = function(element, fn) {\n//     if (!element.__resizeListeners__) {\n//       element.__resizeListeners__ = [];\n//       if (attachEvent) {\n//         element.__resizeTrigger__ = element;\n//         element.attachEvent('onresize', resizeListener);\n//       } else {\n//         if (getComputedStyle(element).position === 'static') element.style.position = 'relative';\n//         var obj = element.__resizeTrigger__ = document.createElement('object');\n//         obj.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; pointer-events: none; z-index: -1;');\n//         obj.__resizeElement__ = element;\n//         obj.onload = objectLoad;\n//         obj.type = 'text/html';\n//         if (isIE) element.appendChild(obj);\n//         obj.data = 'about:blank';\n//         if (!isIE) element.appendChild(obj);\n//       }\n//     }\n//     element.__resizeListeners__.push(fn);\n//   };\n//\n//   window.removeResizeListener = function(element, fn) {\n//     element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);\n//     if (!element.__resizeListeners__.length) {\n//       if (attachEvent) element.detachEvent('onresize', resizeListener);\n//       else {\n//         element.__resizeTrigger__.contentDocument.defaultView.removeEventListener('resize', resizeListener);\n//         element.__resizeTrigger__ = !element.removeChild(element.__resizeTrigger__);\n//       }\n//     }\n//   }\n// })();\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/util/object-resize.js\n **/","/**\n * https://github.com/gre/bezier-easing\n * BezierEasing - use bezier curve for transition easing function\n * by Gaëtan Renaudeau 2014 - 2015 – MIT License\n */\n\n// These values are established by empiricism with tests (tradeoff: performance VS precision)\nvar NEWTON_ITERATIONS = 4;\nvar NEWTON_MIN_SLOPE = 0.001;\nvar SUBDIVISION_PRECISION = 0.0000001;\nvar SUBDIVISION_MAX_ITERATIONS = 10;\n\nvar kSplineTableSize = 11;\nvar kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\n\nvar float32ArraySupported = typeof Float32Array === 'function';\n\nfunction A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }\nfunction B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }\nfunction C (aA1)      { return 3.0 * aA1; }\n\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nfunction calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }\n\n// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.\nfunction getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }\n\nfunction binarySubdivide (aX, aA, aB, mX1, mX2) {\n  var currentX, currentT, i = 0;\n  do {\n    currentT = aA + (aB - aA) / 2.0;\n    currentX = calcBezier(currentT, mX1, mX2) - aX;\n    if (currentX > 0.0) {\n      aB = currentT;\n    } else {\n      aA = currentT;\n    }\n  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n  return currentT;\n}\n\nfunction newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {\n for (var i = 0; i < NEWTON_ITERATIONS; ++i) {\n   var currentSlope = getSlope(aGuessT, mX1, mX2);\n   if (currentSlope === 0.0) {\n     return aGuessT;\n   }\n   var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n   aGuessT -= currentX / currentSlope;\n }\n return aGuessT;\n}\n\nfunction LinearEasing (x) {\n  return x;\n}\n\nmodule.exports = function bezier (mX1, mY1, mX2, mY2) {\n  if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {\n    throw new Error('bezier x values must be in [0, 1] range');\n  }\n\n  if (mX1 === mY1 && mX2 === mY2) {\n    return LinearEasing;\n  }\n\n  // Precompute samples table\n  var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);\n  for (var i = 0; i < kSplineTableSize; ++i) {\n    sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n  }\n\n  function getTForX (aX) {\n    var intervalStart = 0.0;\n    var currentSample = 1;\n    var lastSample = kSplineTableSize - 1;\n\n    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n      intervalStart += kSampleStepSize;\n    }\n    --currentSample;\n\n    // Interpolate to provide an initial guess for t\n    var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n    var guessForT = intervalStart + dist * kSampleStepSize;\n\n    var initialSlope = getSlope(guessForT, mX1, mX2);\n    if (initialSlope >= NEWTON_MIN_SLOPE) {\n      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n    } else if (initialSlope === 0.0) {\n      return guessForT;\n    } else {\n      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n    }\n  }\n\n  return function BezierEasing (x) {\n    // Because JavaScript number are imprecise, we should guarantee the extremes are right.\n    if (x === 0) {\n      return 0;\n    }\n    if (x === 1) {\n      return 1;\n    }\n    return calcBezier(getTForX(x), mY1, mY2);\n  };\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/bezier-easing/src/index.js\n ** module id = 44\n ** module chunks = 0\n **/","import Component from '../component/component';\n\nconst SELECTOR_COMPONENT = '.aui-js-textfield';\nconst CLASS_FIELD = 'aui-textfield__field';\nconst CLASS_INPUT = 'aui-textfield__input';\nconst CLASS_LABEL = 'aui-textfield__label';\nconst CLASS_FOCUS_LINE = 'aui-textfield__focus-line';\nconst CLASS_COUNTER = 'aui-textfield__counter';\nconst CLASS_COUNTER_VALUE = 'aui-textfield__counter-value';\nconst CLASS_IS_FOCUS = 'is-focused';\nconst CLASS_IS_DIRTY = 'is-dirty';\nconst CLASS_IS_INVALID = 'is-invalid';\nconst CLASS_IS_DISABLED = 'is-disabled';\nconst CLASS_IS_EQUAL_MAX_CHARS = 'is-equal-max-length';\nconst CLASS_IS_GREATER_MAX_CHARS = 'is-greater-max-length';\nconst ATTR_AUTOSIZE = 'data-autosize';\n\n/**\n * Class constructor for Textfield AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Textfield extends Component {\n\n  /**\n   * Upgrades all Textfield AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Textfield(element));\n      }\n    });\n    return components;\n  };\n\n  constructor(element) {\n    super(element);\n  }\n\n  init() {\n    super.init();\n\n    this._input = this._element.querySelector(`.${CLASS_INPUT}`);\n    this._input.addEventListener('input', this._inputHandler = (event) => this._onInput(event));\n    this._input.addEventListener('focus', this._focusHandler = (event) => this._onFocus(event));\n    this._input.addEventListener('blur', this._blurHandler = (event) => this._onBlur(event));\n    this._input.addEventListener('change', this._changeHandler = (event) => this._onChange(event));\n    this._input.addEventListener('reset', this._resetHandler = (event) => this._onReset(event));\n\n    // Insert counter if data attribute 'count' is present:\n    if (this._element.getAttribute('data-count')) {\n      this._maxChars = parseInt(this._element.getAttribute('data-count')) || 0;\n      this._label = this._element.querySelector(`.${CLASS_FIELD}`);\n      this._counter = document.createElement('span');\n      this._counter.classList.add(CLASS_COUNTER);\n      this._label.parentNode.insertBefore(this._counter, this._label.nextSibling);\n      this._counterValue = document.createElement('span');\n      this._counterValue.classList.add(CLASS_COUNTER_VALUE);\n      this._counterValue.innerHTML = this._maxChars;\n      this._counter.appendChild(this._counterValue);\n      this._hasCounter = true;\n    }\n\n    // Insert thick focus line after label element:\n    this._label = this._element.querySelector(`.${CLASS_LABEL}`);\n    let focusLine = document.createElement('span');\n    focusLine.classList.add(CLASS_FOCUS_LINE);\n    this._label.parentNode.insertBefore(focusLine, this._label.nextSibling);\n\n    // If textarea should adjust height to content\n    if (this._element.hasAttribute(ATTR_AUTOSIZE) && this._element.getAttribute(ATTR_AUTOSIZE) !== 'false') {\n      let style = window.getComputedStyle(this._input);\n      this._inputPadding = parseInt(style.paddingTop) + parseInt(style.paddingBottom) || 0;\n      this._inputBorder = parseInt(style.borderTop) + parseInt(style.borderBottom) || 0;\n      this._input.addEventListener('keyup', this._keyupHandler = event => this._onKeyup(event));\n      this._autosize = true;\n    }\n\n    this.updateClasses();\n  }\n\n  update() {\n    this.updateClasses();\n    this.updateCounter();\n    if (this._autosize) {\n      this.adjustHeightToContent();\n    }\n  }\n\n  updateClasses() {\n    this.checkDisabled();\n    this.checkDirty();\n    this.checkFocus();\n  }\n\n  updateCounter() {\n    if (this._counterValue) {\n      let numChars = this._input.value.length;\n      let remainingChars = this._maxChars - numChars;\n      this._counterValue.innerHTML = remainingChars;\n\n      if (remainingChars === 0) {\n        this._element.classList.add(CLASS_IS_EQUAL_MAX_CHARS);\n      } else {\n        this._element.classList.remove(CLASS_IS_EQUAL_MAX_CHARS);\n      }\n\n      if (remainingChars < 0) {\n        this._element.classList.add(CLASS_IS_GREATER_MAX_CHARS);\n        this._element.classList.add(CLASS_IS_INVALID);\n      } else {\n        this._element.classList.remove(CLASS_IS_GREATER_MAX_CHARS);\n        this._element.classList.remove(CLASS_IS_INVALID);\n      }\n    }\n  }\n\n  /**\n   * Check the disabled state and update field accordingly.\n   */\n  checkDisabled() {\n    if (this._input.disabled) {\n      this._element.classList.add(CLASS_IS_DISABLED);\n    } else {\n      this._element.classList.remove(CLASS_IS_DISABLED);\n    }\n  }\n\n  /**\n   * Check the dirty state and update field accordingly.\n   */\n  checkDirty() {\n    if (this._input.value && this._input.value.length > 0) {\n      this._element.classList.add(CLASS_IS_DIRTY);\n    } else {\n      this._element.classList.remove(CLASS_IS_DIRTY);\n    }\n  }\n\n  /**\n   * Check the focus state and update field accordingly.\n   */\n  checkFocus() {\n    if (Boolean(this._element.querySelector(':focus'))) {\n      this._element.classList.add(CLASS_IS_FOCUS);\n    } else {\n      this._element.classList.remove(CLASS_IS_FOCUS);\n    }\n  }\n\n  /**\n   * Resize textarea\n   */\n  adjustHeightToContent() {\n    let htmlTop = window.pageYOffset;\n    let bodyTop = document.body.scrollTop;\n    let originalHeight = this._input.style.height;\n\n    this._input.style.height = 'auto';\n    if (this._input.scrollHeight === 0) {\n      // If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.\n      this._input.style.height = originalHeight;\n      return;\n    }\n    this._input.style.height = `${this._input.scrollHeight + this._inputBorder}px`;\n\n    // prevents scroll position jump\n    document.documentElement.scrollTop = htmlTop;\n    document.body.scrollTop = bodyTop;\n  }\n\n  /**\n   * Disable text field.\n   */\n  disable() {\n    this._input.disabled = true;\n    this.updateClasses();\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    super.dispose();\n\n    this._input.removeEventListener('input', this._inputHandler);\n    this._input.removeEventListener('focus', this._focusHandler);\n    this._input.removeEventListener('blur', this._blurHandler);\n    this._input.removeEventListener('change', this._changeHandler);\n    this._input.removeEventListener('reset', this._resetHandler);\n\n    super.removeChild(this._element.querySelector(`.${CLASS_FOCUS_LINE}`));\n    super.removeChild(this._element.querySelector(`.${CLASS_COUNTER}`));\n  }\n\n  /**\n   * Event Handler\n   */\n\n  _onInput(event) {\n    this.update();\n  }\n\n  _onFocus(event) {\n    this.update();\n  }\n\n  _onBlur(event) {\n    this.update();\n  }\n\n  _onChange(event) {\n    this.update();\n  }\n\n  _onReset(event) {\n    this.update();\n  }\n\n  _onKeyup(event) {\n    this.updateCounter();\n    if (this._autosize) {\n      this.adjustHeightToContent();\n    }\n  }\n\n  /**\n   * Getter and Setter\n   */\n\n  get input() {\n    return this._input;\n  }\n\n  get autoSize() {\n    return this._autosize;\n  }\n\n  set autoSize(value) {\n    return this._autosize = Boolean(value);\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/textfield/textfield.js\n **/","import Component from '../component/component';\n\nconst SELECTOR_COMPONENT = '.aui-js-tooltip';\nconst CLASS_TRIANGLE = 'aui-tooltip__triangle';\nconst CLASS_IS_UPGRADED = 'is-upgraded';\nconst CLASS_IS_ACTIVE = 'is-active';\nconst CLASS_IS_TOP = 'is-top';\nconst OFFSET_VIEWPORT_X = 10;\nconst OFFSET_TARGET_TOP = 12;\nconst OFFSET_TARGET_BOTTOM = 12;\nconst OPEN_DELAY = 400;\n\n/**\n * Class constructor for Tooltip AUI component.\n * Implements AUI component design pattern defined at:\n * https://github.com/...\n *\n * @param {HTMLElement} element The element that will be upgraded.\n */\nexport default class Tooltip extends Component {\n\n  /**\n   * Upgrades all Tooltip AUI components.\n   * @returns {Array} Returns an array of all newly upgraded components.\n   */\n  static upgradeElements() {\n    let components = [];\n    Array.from(document.querySelectorAll(SELECTOR_COMPONENT)).forEach(element => {\n      if (!Component.isElementUpgraded(element)) {\n        components.push(new Tooltip(element));\n      }\n    });\n    return components;\n  };\n\n  /**\n   * Initialize component\n   */\n  init() {\n    super.init();\n\n    let forId = this._element.getAttribute('for');\n\n    if (forId) {\n      this._trigger = document.getElementById(forId);\n    }\n\n    if (this._trigger) {\n      // Add triangle shape\n      this._triangle = document.createElement('span');\n      this._triangle.classList.add(CLASS_TRIANGLE);\n      this._element.appendChild(this._triangle);\n\n      // Prevent accidental text selection on Android\n      if (!this._trigger.hasAttribute('tabindex')) {\n        this._trigger.setAttribute('tabindex', '0');\n      }\n\n      this._trigger.addEventListener('mouseenter', this._boundMouseenter = (event) => this._onTriggerEnter(event));\n      this._trigger.addEventListener('mouseleave', this._boundMouseleave = (event) => this._onTriggerLeave(event));\n      this._trigger.addEventListener('focusin', this._boundfocusin = (event) => this._onTriggerEnter(event));\n      this._trigger.addEventListener('focusout', this._boundfocusout = (event) => this._onTriggerLeave(event));\n      this._trigger.addEventListener('touchstart', this._boundTouchstart = (event) => this._onTriggerEnter(event));\n      window.addEventListener('touchend', this._boundTouchendWindow = (event) => this._onTriggerLeaveOutside(event));\n    }\n  }\n\n  /**\n   * Dispose component\n   */\n  dispose() {\n    this._trigger.removeEventListener('mouseenter', this._boundMouseenter);\n    this._trigger.removeEventListener('mouseleave', this._boundMouseleave);\n    this._trigger.removeEventListener('mousemove', this._boundMouseMove);\n    this._trigger.removeEventListener('focusin', this._boundfocusin);\n    this._trigger.removeEventListener('focusout', this._boundfocusout);\n    this._trigger.removeEventListener('touchstart', this._boundTouchstart);\n    window.removeEventListener('touchend', this._boundTouchendWindow);\n    window.removeEventListener('scroll', this._boundScrollWindow);\n\n    this._element.classList.remove(CLASS_IS_TOP, CLASS_IS_ACTIVE, CLASS_IS_UPGRADED);\n    this._element.removeAttribute('style');\n    this._element.removeChild(this._triangle);\n  }\n\n  /**\n   * Open tooltip\n   * @param {HTMLElement} trigger element that opens the tooltip.\n   * @param {number} clientX the x-coordinate of trigger (mouse/touch).\n   */\n  open(trigger, clientX) {\n    if (!trigger) {\n      return;\n    }\n\n    const rect = trigger.getBoundingClientRect();\n    this._element.style.left = `0px`;\n    this._element.style.top = `0px`;\n    clientX = clientX || rect.left + rect.width / 2;\n    const triggerX = clientX - rect.left;\n    const yTop = rect.top - this._element.offsetHeight - OFFSET_TARGET_TOP;\n    const yBottom = rect.bottom + OFFSET_TARGET_BOTTOM + 2;\n    let x = rect.left + rect.width / 2 - this._element.offsetWidth / 2;\n    let y = yBottom;\n    let triangleX = 0;\n\n    this._element.classList.remove(CLASS_IS_TOP);\n\n    x = rect.left + triggerX - this._element.offsetWidth / 2;\n\n    if (x < OFFSET_VIEWPORT_X) {\n      x = OFFSET_VIEWPORT_X;\n    }\n\n    // If tooltip would be out of viewport on the right\n    if (x + this._element.offsetWidth > window.innerWidth - OFFSET_VIEWPORT_X) {\n      x = window.innerWidth - OFFSET_VIEWPORT_X - this._element.offsetWidth;\n    }\n\n    // If viewport height isn't large enough, place tooltip on top if possible\n    if (yBottom + this._element.offsetHeight > window.innerHeight - OFFSET_VIEWPORT_X) {\n      y = yTop;\n      this._element.classList.add(CLASS_IS_TOP);\n    }\n\n    triangleX = triggerX + rect.left - x;\n\n    this._element.classList.add(CLASS_IS_ACTIVE);\n    this._element.style.left = `${x}px`;\n    this._element.style.top = `${y}px`;\n\n    this._triangle.style.left = `${triangleX}px`;\n\n    this._scrolled = false;\n    window.addEventListener('scroll', this._boundScrollWindow = (event) => this._onScrollWindow(event));\n  }\n\n  /**\n   * Close tooltip.\n   */\n  close() {\n    clearTimeout(this.openTimeout);\n    window.removeEventListener('scroll', this._boundScrollWindow);\n    this._element.classList.remove(CLASS_IS_ACTIVE);\n  }\n\n  /**\n   * Handle enter event.\n   * @param {Event} event that fired.\n   */\n  _onTriggerEnter(event) {\n    // this.open(event.target, event.clientX);\n    this.openPositionX = event.clientX;\n    this._trigger.addEventListener('mousemove', this._boundMouseMove = (event) => this._onTriggerMove(event));\n\n    clearTimeout(this.openTimeout);\n    this.openTimeout = setTimeout(() => {\n      this._trigger.removeEventListener('mousemove', this._boundMouseMove);\n      this.open(event.target, this.openPositionX);\n    }, OPEN_DELAY);\n  }\n\n  /**\n   * Handle mousemove event.\n   * @param {Event} event that fired.\n   */\n  _onTriggerMove(event) {\n    this.openPositionX = event.clientX;\n  }\n\n  /**\n   * Handle leave event.\n   * @param {Event} event that fired.\n   */\n  _onTriggerLeave(event) {\n    this.close();\n  }\n\n  /**\n   * Handle leave outside event.\n   * @param {Event} event that fired.\n   */\n  _onTriggerLeaveOutside(event) {\n    console.log('leaveoutside', event);\n    if (!this._element.contains(event.target) && !this._trigger.contains(event.target)) {\n      console.log('-> close');\n      this.close();\n    };\n  }\n\n  /**\n   * Handle scroll event.\n   * @param {Event} event that fired.\n   */\n  _onScrollWindow(event) {\n    window.removeEventListener('scroll', this._boundScrollWindow);\n    if (!this._scrolled) {\n      this.close();\n      this._scrolled = true;\n    }\n  }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/eslint-loader!./src/tooltip/tooltip.js\n **/"],"sourceRoot":""}