{"version":3,"sources":["webpack:///0-b651c482e105b9da9547.js","webpack:///./js/components/index.js","webpack:///./js/core/index.js","webpack:///./node_modules/lodash/isObject.js","webpack:///./node_modules/lodash/_root.js","webpack:///./js/components/init-check-device.js","webpack:///./node_modules/lodash/toNumber.js","webpack:///./node_modules/lodash/_baseGetTag.js","webpack:///./node_modules/lodash/_Symbol.js","webpack:///./node_modules/lodash/identity.js","webpack:///./node_modules/tether/dist/js/tether.js","webpack:///./js/components/init-iframe.js","webpack:///./js/components/init-menu.js","webpack:///./node_modules/lodash/throttle.js","webpack:///./node_modules/lodash/debounce.js","webpack:///./node_modules/lodash/now.js","webpack:///./node_modules/lodash/_freeGlobal.js","webpack:///./node_modules/lodash/isSymbol.js","webpack:///./node_modules/lodash/_getRawTag.js","webpack:///./node_modules/lodash/_objectToString.js","webpack:///./node_modules/lodash/isObjectLike.js","webpack:///./js/components/init-external-link-modal.js","webpack:///./js/components/init-responsive-table.js","webpack:///./node_modules/lodash/delay.js","webpack:///./node_modules/lodash/_baseDelay.js","webpack:///./node_modules/lodash/_baseRest.js","webpack:///./node_modules/lodash/_overRest.js","webpack:///./node_modules/lodash/_apply.js","webpack:///./node_modules/lodash/_setToString.js","webpack:///./node_modules/lodash/_baseSetToString.js","webpack:///./node_modules/lodash/constant.js","webpack:///./node_modules/lodash/_defineProperty.js","webpack:///./node_modules/lodash/_getNative.js","webpack:///./node_modules/lodash/_baseIsNative.js","webpack:///./node_modules/lodash/isFunction.js","webpack:///./node_modules/lodash/_isMasked.js","webpack:///./node_modules/lodash/_coreJsData.js","webpack:///./node_modules/lodash/_toSource.js","webpack:///./node_modules/lodash/_getValue.js","webpack:///./node_modules/lodash/_shortOut.js","webpack:///./js/components/init-show-hide.js","webpack:///./js/components/init-scroll-up.js","webpack:///./js/components/init-scroll-section.js","webpack:///./js/components/init-svg4everybody.js","webpack:///./node_modules/svg4everybody/dist/svg4everybody.js","webpack:///./js/components/init-validation-tooltip.js","webpack:///./node_modules/tooltip.js/dist/umd/tooltip.js","webpack:///./node_modules/popper.js/dist/esm/popper.js","webpack:///./js/core/components/index.js","webpack:///./js/core/components/calendar.js","webpack:///./node_modules/pikaday/pikaday.js","webpack:///./js/core/components/select.js","webpack:///./js/core/components/tooltip.js","webpack:///./node_modules/tether-tooltip/dist/js/tooltip.js","webpack:///./node_modules/tether-drop/dist/js/drop.js","webpack:///./js/core/titon.js"],"names":["webpackJsonp","130","module","exports","__webpack_require__","require","131","Object","defineProperty","value","_components","351","isObject","type","361","freeGlobal","freeSelf","self","root","Function","366","_interopRequireDefault","obj","__esModule","default","_classCallCheck","instance","Constructor","TypeError","DESKTOP_MEDIA_QUERY","DESKTOP","TABLET_MEDIA_QUERY","TABLET","MOBILE_MEDIA_QUERY","MOBILE","undefined","_createClass","defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","key","protoProps","staticProps","prototype","_jquery2","_jquery","_throttle2","_throttle","deviceType","MobileChecker","window","on","this","checkDeviceSize","get","Modernizr","mq","367","toNumber","isSymbol","NAN","other","valueOf","replace","reTrim","isBinary","reIsBinary","test","reIsOctal","freeParseInt","slice","reIsBadHex","parseInt","368","baseGetTag","undefinedTag","nullTag","symToStringTag","getRawTag","objectToString","Symbol","toStringTag","369","370","identity","384","factory","getActualBoundingClientRect","node","boundingRect","getBoundingClientRect","rect","k","ownerDocument","document","_frameElement","defaultView","frameElement","frameRect","top","bottom","left","right","err","getScrollParents","el","computedStyle","getComputedStyle","position","parents","parent","parentNode","nodeType","style","push","_style","overflow","overflowX","overflowY","indexOf","body","removeUtilElements","zeroElement","removeChild","getBounds","doc","documentElement","docEl","box","origin","getOrigin","width","scrollWidth","height","scrollHeight","clientTop","clientLeft","clientWidth","clientHeight","getOffsetParent","offsetParent","getScrollBarSize","_scrollBarSize","inner","createElement","outer","extend","pointerEvents","visibility","appendChild","widthContained","offsetWidth","widthScroll","out","arguments","args","Array","apply","forEach","hasOwnProperty","call","removeClass","name","classList","split","cls","trim","remove","regex","RegExp","join","className","getClassName","setClassName","addClass","add","hasClass","contains","SVGAnimatedString","baseVal","setAttribute","updateClasses","all","_inherits","subClass","superClass","create","constructor","setPrototypeOf","__proto__","within","a","b","diff","now","performance","Date","addOffset","_len","offsets","_key","_ref","parseFloat","offsetToPx","offset","size","getBoundingRect","tether","to","scrollParents","pageXOffset","pageYOffset","innerWidth","innerHeight","pos","win","BOUNDS_FORMAT","side","toUpperCase","substr","TetherBase","modules","uniqueId","id","zeroPosCache","getAttribute","defer","deferred","fn","flush","pop","Evented","event","handler","ctx","once","bindings","splice","_bindings$event$i","context","Utils","_slicedToArray","sliceIterator","arr","_arr","_n","_d","_e","_s","_i","iterator","next","done","isArray","_get","_x6","_x7","_x8","_again","object","property","receiver","desc","getOwnPropertyDescriptor","getter","getPrototypeOf","Error","_TetherBase$Utils","transformKey","transforms","tethers","lastCall","lastDuration","pendingTimeout","tick","Math","min","setTimeout","clearTimeout","addEventListener","MIRROR_LR","center","MIRROR_TB","middle","OFFSET_MAP","autoToFixedAttachment","attachment","relativeToAttachment","attachmentToOffset","parseOffset","_value$split","_value$split2","parseAttachment","TetherClass","_Evented","options","_this","bind","history","setOptions","initialize","classes","classPrefix","_this2","defaults","targetOffset","targetAttachment","_options","element","targetModifier","jquery","querySelector","getClass","addTargetClasses","disable","enabled","enable","bounds","hasBottomScroll","scrollBottom","borderTopWidth","borderBottomWidth","borderLeftWidth","fitAdj","pow","max","scrollPercentage","scrollTop","_cache","_this3","_this4","removeEventListener","_this5","elementAttach","targetAttach","_this6","sides","_addAttachClasses","_this7","flushChanges","clearCache","updateAttachClasses","elementPos","cache","lastSize","_lastSize","targetPos","getTargetBounds","targetSize","manualOffset","manualTargetOffset","_module2","ret","scrollbarSize","page","viewport","parentElement","optimizations","moveElement","offsetPosition","offsetParentStyle","offsetParentSize","offsetBorder","toLowerCase","scrollLeft","move","unshift","_this8","same","found","point","css","transcribe","_same","_pos","gpu","yPos","xPos","devicePixelRatio","round","moved","bodyElement","offsetParentIsBody","currentNode","tagName","e","d","fullscreenElement","webkitFullscreenElement","mozFullScreenElement","msFullscreenElement","writeCSS","write","val","trigger","Tether","constraints","targetHeight","targetWidth","allClasses","constraint","outOfBoundsClass","pinnedClass","addClasses","tAttachment","eAttachment","pin","changeAttachX","changeAttachY","_attachment$split","_attachment$split2","map","p","pinned","oob","oobClass","abutted","targetPosSide","shift","shiftTop","shiftLeft","_shift","_shift2","385","onload","iframe","subnavs","querySelectorAll","subnav","onclick","preventDefault","attributes","src","386","$mobMenuBtn","$mobMenuLinks","currentTarget","toggleClass","387","throttle","func","wait","leading","trailing","FUNC_ERROR_TEXT","debounce","388","invokeFunc","time","lastArgs","thisArg","lastThis","lastInvokeTime","result","leadingEdge","timerId","timerExpired","remainingWait","timeSinceLastCall","lastCallTime","timeSinceLastInvoke","timeWaiting","maxing","nativeMin","maxWait","shouldInvoke","trailingEdge","cancel","debounced","isInvoking","nativeMax","389","390","global","391","isObjectLike","symbolTag","392","isOwn","tag","unmasked","nativeObjectToString","objectProto","toString","393","394","395","$externalLinkBtn","$externalModal","$externalLinkCloseBtn","396","scrollTable","$responsiveTable","each","index","isMobile","isTablet","$fixedColumn","$table","eq","clone","insertBefore","find","floor","isDesktop","_delay2","_delay","_initCheckDevice2","_initCheckDevice","ready","397","baseDelay","baseRest","delay","398","399","start","setToString","overRest","400","transform","array","otherArgs","401","402","baseSetToString","shortOut","403","constant","string","404","405","getNative","406","getValue","baseIsNative","407","isMasked","isFunction","reIsNative","reIsHostCtor","toSource","reRegExpChar","funcProto","funcToString","408","funcTag","genTag","asyncTag","proxyTag","409","maskSrcKey","coreJsData","uid","exec","keys","IE_PROTO","410","411","412","413","count","lastCalled","stamp","nativeNow","remaining","HOT_SPAN","HOT_COUNT","414","$showHideSection","$showHideArea","$showHideBtn","$this","slideToggle","415","click","animate","416","location","hash","preAnchor","attrName","anchor","attr","417","_svg4everybody2","_svg4everybody","418","svg4everybody","embed","svg","fragment","createDocumentFragment","viewBox","hasAttribute","cloneNode","childNodes","firstChild","loadreadystatechange","xhr","onreadystatechange","readyState","cachedDocument","_cachedDocument","implementation","createHTMLDocument","innerHTML","responseText","_cachedTarget","_embeds","item","getElementById","rawopts","oninterval","uses","use","getSVGAncestor","opts","attributeName","polyfill","validate","srcSplit","url","requests","XMLHttpRequest","open","send","numberOfSvgUseElementsToBypass","requestAnimationFrame","newerIEUA","webkitUA","olderEdgeUA","edgeUA","inIframe","navigator","userAgent","match","getElementsByTagName","nodeName","419","_tooltip","420","Popper","functionToCheck","getType","classCallCheck","createClass","_extends","assign","source","DEFAULT_OPTIONS","container","html","placement","title","template","arrowSelector","innerSelector","_initialiseProps","show","_show","reference","hide","_hide","dispose","_dispose","toggle","_isOpen","updateTitleContent","_updateTitleContent","_events","_setTooltipNodeEvent","evt","relatedreference","toElement","relatedTarget","callback","evt2","relatedreference2","_tooltipNode","_scheduleHide","Tooltip","events","filter","_popperOptions","_setEventListeners","allowHtml","tooltipGenerator","tooltipNode","random","titleNode","_addTitleContent","textContent","_isOpening","popperInstance","update","_create","_findContainer","_append","popperOptions","modifiers","arrow","boundariesElement","preventOverflow","destroy","removeOnDestroy","directEvents","oppositeEvents","usedByTooltip","_scheduleShow","closeOnClickOutside","popper","computedDelay","_showTimeout","_clearTitleContent","lastTitle","421","__webpack_exports__","microtaskDebounce","called","Promise","resolve","then","taskDebounce","scheduled","timeoutDuration","getStyleComputedProperty","getParentNode","host","getScrollParent","_getStyleComputedProp","getReferenceNode","referenceNode","isIE","version","isIE11","isIE10","noOffsetParent","nextElementSibling","isOffsetContainer","firstElementChild","getRoot","findCommonOffsetParent","element1","element2","order","compareDocumentPosition","Node","DOCUMENT_POSITION_FOLLOWING","end","range","createRange","setStart","setEnd","commonAncestorContainer","element1root","getScroll","upperSide","scrollingElement","includeScroll","subtract","modifier","getBordersSize","styles","axis","sideA","sideB","getSize","getWindowSizes","getClientRect","sizes","horizScrollbar","vertScrollbar","offsetHeight","getOffsetRectRelativeToArbitraryNode","children","fixedPosition","isHTML","childrenRect","parentRect","scrollParent","marginTop","marginLeft","getViewportOffsetRectRelativeToArtbitraryNode","excludeScroll","relativeOffset","isFixed","getFixedPositionOffsetParent","getBoundaries","padding","boundaries","boundariesNode","_getWindowSizes","isPaddingNumber","getArea","computeAutoPlacement","refRect","rects","sortedAreas","area","sort","filteredAreas","_ref2","computedPlacement","variation","getReferenceOffsets","state","getOuterSizes","x","marginBottom","y","marginRight","getOppositePlacement","matched","getPopperOffsets","referenceOffsets","popperRect","popperOffsets","isHoriz","mainSide","secondarySide","measurement","secondaryMeasurement","check","findIndex","prop","cur","runModifiers","data","ends","console","warn","isDestroyed","arrowStyles","flipped","positionFixed","flip","originalPlacement","isCreated","onUpdate","onCreate","isModifierEnabled","modifierName","some","getSupportedPropertyName","prefixes","upperProp","charAt","prefix","toCheck","removeAttribute","willChange","disableEventListeners","getWindow","attachToScrollParents","isBody","passive","setupEventListeners","updateBound","scrollElement","eventsEnabled","enableEventListeners","scheduleUpdate","removeEventListeners","cancelAnimationFrame","isNumeric","n","isNaN","isFinite","setStyles","unit","setAttributes","applyStyle","arrowElement","applyStyleOnLoad","modifierOptions","getRoundedOffsets","shouldRound","_data$offsets","noRound","v","referenceWidth","popperWidth","isVertical","isVariation","sameWidthParity","bothOddWidth","horizontalToInteger","verticalToInteger","computeStyle","legacyGpuAccelerationOption","gpuAcceleration","offsetParentRect","isFirefox","prefixedProperty","invertTop","invertLeft","isModifierRequired","requestingName","requestedName","requesting","isRequired","_requesting","requested","_data$offsets$arrow","len","sideCapitalized","altSide","opSide","arrowElementSize","popperMarginSide","popperBorderSide","sideValue","getOppositeVariation","clockwise","counter","validPlacements","concat","reverse","placementOpposite","flipOrder","behavior","BEHAVIORS","FLIP","CLOCKWISE","COUNTERCLOCKWISE","step","refOffsets","overlapsRef","overflowsLeft","overflowsRight","overflowsTop","overflowsBottom","overflowsBoundaries","flippedVariationByRef","flipVariations","flippedVariationByContent","flipVariationsByContent","flippedVariation","keepTogether","toValue","str","basePlacement","useHeight","fragments","frag","divider","search","splitRegex","ops","op","mergeWithPrevious","reduce","index2","transformProp","popperStyles","priority","primary","escapeWithReference","secondary","shiftvariation","shiftOffsets","bound","subtractLength","isBrowser","longerTimeoutBrowsers","supportsMicroTasks","MSInputMethodContext","documentMode","placements","onLoad","Defaults","PopperUtils","423","_calendar","_select","424","calendar","fieldSelector","triggerSelector","$date","selector","$trigger","locals","field","Pikaday","_pikaday2","_pikaday","firstDay","theme","425","moment","hasMoment","hasEventListeners","sto","addEvent","capture","attachEvent","removeEvent","detachEvent","cn","isDate","getTime","isWeekend","date","day","getDay","isLeapYear","year","getDaysInMonth","month","setToStartOfDay","setHours","compareDates","from","overwrite","hasProp","fireEvent","eventName","ev","createEvent","initEvent","dispatchEvent","createEventObject","adjustCalendar","ceil","abs","ariaLabel","reposition","format","parse","defaultDate","setDefaultDate","formatStrict","minDate","maxDate","yearRange","showWeekNumber","pickWholeWeek","minYear","maxYear","minMonth","maxMonth","startRange","endRange","isRTL","yearSuffix","showMonthAfterYear","showDaysInNextAndPreviousMonths","enableSelectionDaysInNextAndPreviousMonths","numberOfMonths","mainCalendar","blurFieldOnSelect","i18n","previousMonth","nextMonth","months","weekdays","weekdaysShort","onSelect","onOpen","onClose","onDraw","keyboardInput","renderDayName","abbr","renderDay","ariaSelected","isEmpty","isDisabled","isToday","isSelected","hasEvent","isInRange","isStartRange","isEndRange","renderWeek","m","onejan","renderRow","days","isRowSelected","renderBody","rows","renderHead","renderTitle","c","refYear","randId","j","monthHtml","yearHtml","_o","isMinYear","isMaxYear","prev","renderTable","config","_onMouseDown","_v","srcElement","prevMonth","setDate","blur","_c","returnValue","_onChange","gotoMonth","gotoYear","_onKeyChange","isVisible","keyCode","adjustDate","_onInputChange","firedBy","isValid","toDate","_onInputFocus","_onInputClick","_onInputBlur","pEl","activeElement","_b","_onClick","onchange","nextSibling","defDate","gotoDate","disableWeekends","disableDayFn","nom","setMinDate","setMaxDate","fallback","getFullYear","toDateString","getMoment","setMoment","preventOnSelect","isMoment","getDate","draw","newCalendar","calendars","firstVisibleDate","lastVisibleDate","visibleDate","setMonth","getMonth","adjustCalendars","sign","newDay","difference","gotoToday","setStartRange","setEndRange","force","_y","_m","render","focus","adjustPosition","viewportWidth","viewportHeight","clientRect","leftAligned","bottomAligned","offsetLeft","offsetTop","before","row","yearOfPreviousMonth","yearOfNextMonth","daysInPreviousMonth","cells","after","isWeekSelected","r","dayNumber","monthNumber","yearNumber","dayConfig","426","select","inputSelect","arrowTemplate","453","tooltip","$item","content","removeAttr","constrainToWindow","openOn","tetherOptions","is","_tetherTooltip2","_tetherTooltip","454","Drop","_Drop","createContext","constrainToScrollParent","tooltipCount","contentEl","drop","close","initialized","init","tooltipElements","autoinit","455","sortAttach","_str$split","_str$split2","first","second","removeFromArray","results","_bind","DropInstance","drops","defaultOptions","beforeClose","openDelay","closeDelay","focusDelay","blurDelay","hoverOpenDelay","hoverCloseDelay","allDrops","updateBodyClasses","anyOpen","isOpened","dataPrefix","contentAttr","attrsOverride","override","_boundEvents","bindMethods","setupElements","setupEvents","setupTether","transitionEndHandler","_transitionEndHandler","generateAndSetContent","contentElementOrHTML","dropAttach","MIRROR_ATTACH","openHandler","closeHandler","clickEvents","clickEvent","_on","inTimeout","outTimeout","inHandler","outHandler","transitionEndEvent","shouldClose","isClosing","beforeCloseHandler","_boundEvents$i","_event","_x2","_x3","_x4","_Tether$Utils","transitionEndEvents","_name","tempEl","456","Toolkit","namespace"],"mappings":"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","file":"0-b651c482e105b9da9547.js","sourcesContent":["webpackJsonp([0],{\n\n/***/ 130:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n__webpack_require__(385);\n__webpack_require__(386);\n__webpack_require__(366);\n__webpack_require__(395);\n__webpack_require__(396);\n__webpack_require__(414);\n__webpack_require__(415);\n__webpack_require__(416);\n__webpack_require__(417);\n__webpack_require__(419);\n__webpack_require__(422);\n\n/***/ }),\n\n/***/ 131:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _components = __webpack_require__(423);\n\nObject.keys(_components).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _components[key];\n    }\n  });\n});\n\n__webpack_require__(456);\n\n/***/ }),\n\n/***/ 351:\n/***/ (function(module, exports) {\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n\n\n/***/ }),\n\n/***/ 361:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar freeGlobal = __webpack_require__(390);\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n\n\n/***/ }),\n\n/***/ 366:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.DESKTOP_MEDIA_QUERY = exports.DESKTOP = exports.TABLET_MEDIA_QUERY = exports.TABLET = exports.MOBILE_MEDIA_QUERY = exports.MOBILE = undefined;\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 _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _throttle = __webpack_require__(387);\n\nvar _throttle2 = _interopRequireDefault(_throttle);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/** Constant media query states. */\nvar MOBILE = exports.MOBILE = 'MOBILE';\nvar MOBILE_MEDIA_QUERY = exports.MOBILE_MEDIA_QUERY = '(max-width: 767px)';\nvar TABLET = exports.TABLET = 'TABLET';\nvar TABLET_MEDIA_QUERY = exports.TABLET_MEDIA_QUERY = '(min-width: 768px) and (max-width: 1199px)';\nvar DESKTOP = exports.DESKTOP = 'DESKTOP';\nvar DESKTOP_MEDIA_QUERY = exports.DESKTOP_MEDIA_QUERY = '(min-width: 1200px)';\n\n/** Local reference to device type, allows the value to be read-only. */\nvar deviceType = '';\n\n/** Singleton instance. */\nvar instance = void 0;\n\n/** Check the existing device state, singleton. */\n\nvar MobileChecker = function () {\n  _createClass(MobileChecker, null, [{\n    key: 'instance',\n    get: function get() {\n      if (instance === undefined) {\n        instance = new MobileChecker();\n      }\n      return instance;\n    }\n  }]);\n\n  function MobileChecker() {\n    _classCallCheck(this, MobileChecker);\n\n    (0, _jquery2.default)(window).on('resize', (0, _throttle2.default)(this.checkDeviceSize, 100));\n    this.checkDeviceSize();\n  }\n  /** Get device type. */\n\n\n  _createClass(MobileChecker, [{\n    key: 'checkDeviceSize',\n\n    /** Set device type based on media queries. */\n    value: function checkDeviceSize() {\n      if (Modernizr.mq(MOBILE_MEDIA_QUERY)) {\n        deviceType = MOBILE;\n      }\n\n      if (Modernizr.mq(TABLET_MEDIA_QUERY)) {\n        deviceType = TABLET;\n      }\n\n      if (Modernizr.mq(DESKTOP_MEDIA_QUERY)) {\n        deviceType = DESKTOP;\n      }\n\n      return this.deviceType;\n    }\n    /** Check if mobile media query is true. */\n\n  }, {\n    key: 'isMobile',\n    value: function isMobile() {\n      return this.deviceType === MOBILE;\n    }\n    /** Check if tablet media query is true. */\n\n  }, {\n    key: 'isTablet',\n    value: function isTablet() {\n      return this.deviceType === TABLET;\n    }\n    /** Check if desktop media query is true. */\n\n  }, {\n    key: 'isDesktop',\n    value: function isDesktop() {\n      return this.deviceType === DESKTOP;\n    }\n  }, {\n    key: 'deviceType',\n    get: function get() {\n      // eslint-disable-line class-methods-use-this\n      return deviceType;\n    }\n  }]);\n\n  return MobileChecker;\n}();\n\nexports.default = MobileChecker;\n\n/***/ }),\n\n/***/ 367:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(351),\n    isSymbol = __webpack_require__(391);\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n\n\n/***/ }),\n\n/***/ 368:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Symbol = __webpack_require__(369),\n    getRawTag = __webpack_require__(392),\n    objectToString = __webpack_require__(393);\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n\n\n/***/ }),\n\n/***/ 369:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar root = __webpack_require__(361);\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n\n\n/***/ }),\n\n/***/ 370:\n/***/ (function(module, exports) {\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = identity;\n\n\n/***/ }),\n\n/***/ 384:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! tether 1.4.7 */\n\n(function(root, factory) {\n  if (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\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  try {\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  } catch (err) {\n    // Ignore \"Access is denied\" in IE11/Edge\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 (typeof window.devicePixelRatio === 'number' && devicePixelRatio % 1 === 0) {\n            xPos = Math.round(xPos * devicePixelRatio) / devicePixelRatio;\n            yPos = Math.round(yPos * devicePixelRatio) / devicePixelRatio;\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 isFullscreenElement = function isFullscreenElement(e) {\n            var d = e.ownerDocument;\n            var fe = d.fullscreenElement || d.webkitFullscreenElement || d.mozFullScreenElement || d.msFullscreenElement;\n            return fe === e;\n          };\n\n          var offsetParentIsBody = true;\n\n          var currentNode = this.element.parentNode;\n          while (currentNode && currentNode.nodeType === 1 && currentNode.tagName !== 'BODY' && !isFullscreenElement(currentNode)) {\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/***/ 385:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nwindow.onload = function () {\n  var iframe = document.querySelector('.js-iframe');\n  if (!iframe) {\n    return;\n  }\n  var subnavs = document.querySelectorAll('.js-sub-nav');\n  for (var i = 0; i < subnavs.length; i += 1) {\n    var subnav = subnavs[i];\n    subnav.onclick = function (e) {\n      e.preventDefault();\n      if (e.target.attributes['data-url'] != null) {\n        iframe.src = e.target.attributes['data-url'].value;\n      }\n    };\n  }\n};\n\n/***/ }),\n\n/***/ 386:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar $mobMenuBtn = (0, _jquery2.default)('.js-mob-menu');\nvar $mobMenuLinks = (0, _jquery2.default)('.js-mob-links');\n\nif ($mobMenuBtn.length > 0) {\n  $mobMenuBtn.on('click tap', function (e) {\n    var $this = (0, _jquery2.default)(e.currentTarget);\n    $this.toggleClass('is-active');\n    $mobMenuLinks.toggleClass('is-active');\n  });\n}\n\n/***/ }),\n\n/***/ 387:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar debounce = __webpack_require__(388),\n    isObject = __webpack_require__(351);\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n\n\n/***/ }),\n\n/***/ 388:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(351),\n    now = __webpack_require__(389),\n    toNumber = __webpack_require__(367);\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n\n\n/***/ }),\n\n/***/ 389:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar root = __webpack_require__(361);\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n\n\n/***/ }),\n\n/***/ 390:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(66)))\n\n/***/ }),\n\n/***/ 391:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar baseGetTag = __webpack_require__(368),\n    isObjectLike = __webpack_require__(394);\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n\n\n/***/ }),\n\n/***/ 392:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Symbol = __webpack_require__(369);\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n\n\n/***/ }),\n\n/***/ 393:\n/***/ (function(module, exports) {\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n\n\n/***/ }),\n\n/***/ 394:\n/***/ (function(module, exports) {\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n\n\n/***/ }),\n\n/***/ 395:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar $externalLinkBtn = (0, _jquery2.default)('.js-external-link');\nvar $externalModal = (0, _jquery2.default)('.js-external-link-modal');\nvar $externalLinkCloseBtn = (0, _jquery2.default)('.js-close-external-modal');\n\nif ($externalLinkBtn.length > 0) {\n  $externalLinkBtn.on('click tap', function () {\n    $externalModal.addClass('is-active');\n  });\n\n  $externalLinkCloseBtn.on('click tap', function () {\n    $externalModal.removeClass('is-active');\n  });\n}\n\n/***/ }),\n\n/***/ 396:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _delay = __webpack_require__(397);\n\nvar _delay2 = _interopRequireDefault(_delay);\n\nvar _initCheckDevice = __webpack_require__(366);\n\nvar _initCheckDevice2 = _interopRequireDefault(_initCheckDevice);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar $table = (0, _jquery2.default)('.js-responsive-table'); /* eslint-disable func-names, max-len */\n\nvar $responsiveTable = (0, _jquery2.default)('.js-table-responsive');\n\n(0, _jquery2.default)(window).on('resize', scrollTable);\n\nfunction scrollTable() {\n  (0, _delay2.default)(function () {\n    $responsiveTable.each(function (index) {\n      if (_initCheckDevice2.default.instance.isMobile() || _initCheckDevice2.default.instance.isTablet()) {\n        var $fixedColumn = $table.eq(index).clone().insertBefore($table.eq(index)).addClass('fixed-column');\n        var tableWidth = $table.innerWidth();\n        var contentWidth = (0, _jquery2.default)('.js-main-content').innerWidth();\n\n        if (tableWidth > contentWidth - 50) {\n          $responsiveTable.eq(index).addClass('make-scrollable');\n        } else {\n          $responsiveTable.eq(index).removeClass('make-scrollable');\n        }\n\n        $fixedColumn.find('th:not(:first-child),td:not(:first-child)').remove();\n        $fixedColumn.find('tr').each(function (i) {\n          (0, _jquery2.default)(this).height(Math.floor($table.eq(index).find('tr:eq(' + i + ')').height()));\n        });\n\n        $fixedColumn.css({ width: 108 });\n      }\n\n      if (_initCheckDevice2.default.instance.isDesktop()) {\n        $responsiveTable.eq(index).removeClass('make-scrollable');\n      }\n    });\n  }, 200);\n}\n\n(0, _jquery2.default)(document).ready(function () {\n  if ($table.length) {\n    scrollTable();\n  }\n});\n\n/***/ }),\n\n/***/ 397:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar baseDelay = __webpack_require__(398),\n    baseRest = __webpack_require__(399),\n    toNumber = __webpack_require__(367);\n\n/**\n * Invokes `func` after `wait` milliseconds. Any additional arguments are\n * provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {number} Returns the timer id.\n * @example\n *\n * _.delay(function(text) {\n *   console.log(text);\n * }, 1000, 'later');\n * // => Logs 'later' after one second.\n */\nvar delay = baseRest(function(func, wait, args) {\n  return baseDelay(func, toNumber(wait) || 0, args);\n});\n\nmodule.exports = delay;\n\n\n/***/ }),\n\n/***/ 398:\n/***/ (function(module, exports) {\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * The base implementation of `_.delay` and `_.defer` which accepts `args`\n * to provide to `func`.\n *\n * @private\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {Array} args The arguments to provide to `func`.\n * @returns {number|Object} Returns the timer id or timeout object.\n */\nfunction baseDelay(func, wait, args) {\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  return setTimeout(function() { func.apply(undefined, args); }, wait);\n}\n\nmodule.exports = baseDelay;\n\n\n/***/ }),\n\n/***/ 399:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar identity = __webpack_require__(370),\n    overRest = __webpack_require__(400),\n    setToString = __webpack_require__(402);\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n\n\n/***/ }),\n\n/***/ 400:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar apply = __webpack_require__(401);\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\nmodule.exports = overRest;\n\n\n/***/ }),\n\n/***/ 401:\n/***/ (function(module, exports) {\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n\n\n/***/ }),\n\n/***/ 402:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar baseSetToString = __webpack_require__(403),\n    shortOut = __webpack_require__(413);\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n\n\n/***/ }),\n\n/***/ 403:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar constant = __webpack_require__(404),\n    defineProperty = __webpack_require__(405),\n    identity = __webpack_require__(370);\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\nmodule.exports = baseSetToString;\n\n\n/***/ }),\n\n/***/ 404:\n/***/ (function(module, exports) {\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nmodule.exports = constant;\n\n\n/***/ }),\n\n/***/ 405:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar getNative = __webpack_require__(406);\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n\n\n/***/ }),\n\n/***/ 406:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar baseIsNative = __webpack_require__(407),\n    getValue = __webpack_require__(412);\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n\n\n/***/ }),\n\n/***/ 407:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isFunction = __webpack_require__(408),\n    isMasked = __webpack_require__(409),\n    isObject = __webpack_require__(351),\n    toSource = __webpack_require__(411);\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n\n\n/***/ }),\n\n/***/ 408:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar baseGetTag = __webpack_require__(368),\n    isObject = __webpack_require__(351);\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n\n\n/***/ }),\n\n/***/ 409:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar coreJsData = __webpack_require__(410);\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n\n\n/***/ }),\n\n/***/ 410:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar root = __webpack_require__(361);\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n\n\n/***/ }),\n\n/***/ 411:\n/***/ (function(module, exports) {\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n\n\n/***/ }),\n\n/***/ 412:\n/***/ (function(module, exports) {\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n\n\n/***/ }),\n\n/***/ 413:\n/***/ (function(module, exports) {\n\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nmodule.exports = shortOut;\n\n\n/***/ }),\n\n/***/ 414:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar $showHideSection = (0, _jquery2.default)('.js-table-section'); /* eslint-disable func-names, max-len, no-new, no-plusplus, no-shadow, no-underscore-dangle, no-console */\n\nvar $showHideArea = (0, _jquery2.default)('.js-show-hide-content');\nvar $showHideBtn = (0, _jquery2.default)('.js-show-hide-btn');\n\nif ($showHideArea.length > 0) {\n  $showHideBtn.on('click tap', function (e) {\n    var $this = (0, _jquery2.default)(e.currentTarget);\n    $this.toggleClass('is-active');\n\n    $this.parents($showHideSection).find($showHideArea).slideToggle();\n  });\n}\n\n/***/ }),\n\n/***/ 415:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n(0, _jquery2.default)(function () {\n  var $elements = (0, _jquery2.default)('.js-scroll-top');\n\n  $elements.click(function (event) {\n    event.preventDefault();\n    (0, _jquery2.default)('html, body').animate({ scrollTop: 0 });\n  });\n});\n\n/***/ }),\n\n/***/ 416:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n(0, _jquery2.default)(document).ready(function () {\n  if (window.location.hash) {\n    var preAnchor = window.location.hash.substr(1);\n    (0, _jquery2.default)('html, body').scrollTop(0);\n\n    setTimeout(function () {\n      var attrName = (0, _jquery2.default)('a[name=\"' + preAnchor + '\"]');\n      (0, _jquery2.default)('html,body').animate({\n        scrollTop: attrName.offset().top\n      }, 500);\n    }, 200);\n  }\n\n  (0, _jquery2.default)('.js-scroll').click(function (event) {\n    if ((0, _jquery2.default)('.home-page').length) {\n      event.preventDefault();\n    }\n\n    var anchor = (0, _jquery2.default)(event.currentTarget).attr('data-attr-scroll');\n    var anchorOffset = 0;\n\n    if (!anchorOffset) {\n      var attrName = (0, _jquery2.default)('a[name=\"' + anchor + '\"]');\n      (0, _jquery2.default)('html,body').animate({\n        scrollTop: attrName.offset().top\n      }, 500);\n    }\n  });\n});\n\n/***/ }),\n\n/***/ 417:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _svg4everybody = __webpack_require__(418);\n\nvar _svg4everybody2 = _interopRequireDefault(_svg4everybody);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n(0, _jquery2.default)(document).ready(function () {\n  (0, _svg4everybody2.default)();\n});\n\n/***/ }),\n\n/***/ 418:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!function(root, factory) {\n     true ? // AMD. Register as an anonymous module unless amdModuleId is set\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {\n        return root.svg4everybody = factory();\n    }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : \"object\" == typeof module && module.exports ? // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory() : root.svg4everybody = factory();\n}(this, function() {\n    /*! svg4everybody v2.1.9 | github.com/jonathantneal/svg4everybody */\n    function embed(parent, svg, target) {\n        // if the target exists\n        if (target) {\n            // create a document fragment to hold the contents of the target\n            var fragment = document.createDocumentFragment(), viewBox = !svg.hasAttribute(\"viewBox\") && target.getAttribute(\"viewBox\");\n            // conditionally set the viewBox on the svg\n            viewBox && svg.setAttribute(\"viewBox\", viewBox);\n            // copy the contents of the clone into the fragment\n            for (// clone the target\n            var clone = target.cloneNode(!0); clone.childNodes.length; ) {\n                fragment.appendChild(clone.firstChild);\n            }\n            // append the fragment into the svg\n            parent.appendChild(fragment);\n        }\n    }\n    function loadreadystatechange(xhr) {\n        // listen to changes in the request\n        xhr.onreadystatechange = function() {\n            // if the request is ready\n            if (4 === xhr.readyState) {\n                // get the cached html document\n                var cachedDocument = xhr._cachedDocument;\n                // ensure the cached html document based on the xhr response\n                cachedDocument || (cachedDocument = xhr._cachedDocument = document.implementation.createHTMLDocument(\"\"), \n                cachedDocument.body.innerHTML = xhr.responseText, xhr._cachedTarget = {}), // clear the xhr embeds list and embed each item\n                xhr._embeds.splice(0).map(function(item) {\n                    // get the cached target\n                    var target = xhr._cachedTarget[item.id];\n                    // ensure the cached target\n                    target || (target = xhr._cachedTarget[item.id] = cachedDocument.getElementById(item.id)), \n                    // embed the target into the svg\n                    embed(item.parent, item.svg, target);\n                });\n            }\n        }, // test the ready state change immediately\n        xhr.onreadystatechange();\n    }\n    function svg4everybody(rawopts) {\n        function oninterval() {\n            // while the index exists in the live <use> collection\n            for (// get the cached <use> index\n            var index = 0; index < uses.length; ) {\n                // get the current <use>\n                var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent), src = use.getAttribute(\"xlink:href\") || use.getAttribute(\"href\");\n                if (!src && opts.attributeName && (src = use.getAttribute(opts.attributeName)), \n                svg && src) {\n                    if (polyfill) {\n                        if (!opts.validate || opts.validate(src, svg, use)) {\n                            // remove the <use> element\n                            parent.removeChild(use);\n                            // parse the src and get the url and id\n                            var srcSplit = src.split(\"#\"), url = srcSplit.shift(), id = srcSplit.join(\"#\");\n                            // if the link is external\n                            if (url.length) {\n                                // get the cached xhr request\n                                var xhr = requests[url];\n                                // ensure the xhr request exists\n                                xhr || (xhr = requests[url] = new XMLHttpRequest(), xhr.open(\"GET\", url), xhr.send(), \n                                xhr._embeds = []), // add the svg and id as an item to the xhr embeds list\n                                xhr._embeds.push({\n                                    parent: parent,\n                                    svg: svg,\n                                    id: id\n                                }), // prepare the xhr ready state change event\n                                loadreadystatechange(xhr);\n                            } else {\n                                // embed the local id into the svg\n                                embed(parent, svg, document.getElementById(id));\n                            }\n                        } else {\n                            // increase the index when the previous value was not \"valid\"\n                            ++index, ++numberOfSvgUseElementsToBypass;\n                        }\n                    }\n                } else {\n                    // increase the index when the previous value was not \"valid\"\n                    ++index;\n                }\n            }\n            // continue the interval\n            (!uses.length || uses.length - numberOfSvgUseElementsToBypass > 0) && requestAnimationFrame(oninterval, 67);\n        }\n        var polyfill, opts = Object(rawopts), newerIEUA = /\\bTrident\\/[567]\\b|\\bMSIE (?:9|10)\\.0\\b/, webkitUA = /\\bAppleWebKit\\/(\\d+)\\b/, olderEdgeUA = /\\bEdge\\/12\\.(\\d+)\\b/, edgeUA = /\\bEdge\\/.(\\d+)\\b/, inIframe = window.top !== window.self;\n        polyfill = \"polyfill\" in opts ? opts.polyfill : newerIEUA.test(navigator.userAgent) || (navigator.userAgent.match(olderEdgeUA) || [])[1] < 10547 || (navigator.userAgent.match(webkitUA) || [])[1] < 537 || edgeUA.test(navigator.userAgent) && inIframe;\n        // create xhr requests object\n        var requests = {}, requestAnimationFrame = window.requestAnimationFrame || setTimeout, uses = document.getElementsByTagName(\"use\"), numberOfSvgUseElementsToBypass = 0;\n        // conditionally start the interval if the polyfill is active\n        polyfill && oninterval();\n    }\n    function getSVGAncestor(node) {\n        for (var svg = node; \"svg\" !== svg.nodeName.toLowerCase() && (svg = svg.parentNode); ) {}\n        return svg;\n    }\n    return svg4everybody;\n});\n\n/***/ }),\n\n/***/ 419:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _tooltip = __webpack_require__(420);\n\nvar _tooltip2 = _interopRequireDefault(_tooltip);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/***/ }),\n\n/***/ 420:\n/***/ (function(module, exports, __webpack_require__) {\n\n/**!\n * @fileOverview Kickass library to create and place poppers near their reference elements.\n * @version 1.3.3\n * @license\n * Copyright (c) 2016 Federico Zivolo and contributors\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n(function (global, factory) {\n\t true ? module.exports = factory(__webpack_require__(421)) :\n\ttypeof define === 'function' && define.amd ? define(['popper.js'], factory) :\n\t(global.Tooltip = factory(global.Popper));\n}(this, (function (Popper) { 'use strict';\n\nPopper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;\n\n/**\n * Check if the given variable is a function\n * @method\n * @memberof Popper.Utils\n * @argument {Any} functionToCheck - variable to check\n * @returns {Boolean} answer to: is a function?\n */\nfunction isFunction(functionToCheck) {\n  var getType = {};\n  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n\n\n\n\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar DEFAULT_OPTIONS = {\n  container: false,\n  delay: 0,\n  html: false,\n  placement: 'top',\n  title: '',\n  template: '<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>',\n  trigger: 'hover focus',\n  offset: 0,\n  arrowSelector: '.tooltip-arrow, .tooltip__arrow',\n  innerSelector: '.tooltip-inner, .tooltip__inner'\n};\n\nvar Tooltip = function () {\n  /**\n   * Create a new Tooltip.js instance\n   * @class Tooltip\n   * @param {HTMLElement} reference - The DOM node used as reference of the tooltip (it can be a jQuery element).\n   * @param {Object} options\n   * @param {String} options.placement='top'\n   *      Placement of the popper accepted values: `top(-start, -end), right(-start, -end), bottom(-start, -end),\n   *      left(-start, -end)`\n   * @param {String} [options.arrowSelector='.tooltip-arrow, .tooltip__arrow'] - className used to locate the DOM arrow element in the tooltip.\n   * @param {String} [options.innerSelector='.tooltip-inner, .tooltip__inner'] - className used to locate the DOM inner element in the tooltip.\n   * @param {HTMLElement|String|false} options.container=false - Append the tooltip to a specific element.\n   * @param {Number|Object} options.delay=0\n   *      Delay showing and hiding the tooltip (ms) - does not apply to manual trigger type.\n   *      If a number is supplied, delay is applied to both hide/show.\n   *      Object structure is: `{ show: 500, hide: 100 }`\n   * @param {Boolean} options.html=false - Insert HTML into the tooltip. If false, the content will inserted with `textContent`.\n   * @param {String} [options.template='<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>']\n   *      Base HTML to used when creating the tooltip.\n   *      The tooltip's `title` will be injected into the `.tooltip-inner` or `.tooltip__inner`.\n   *      `.tooltip-arrow` or `.tooltip__arrow` will become the tooltip's arrow.\n   *      The outermost wrapper element should have the `.tooltip` class.\n   * @param {String|HTMLElement|TitleFunction} options.title='' - Default title value if `title` attribute isn't present.\n   * @param {String} [options.trigger='hover focus']\n   *      How tooltip is triggered - click, hover, focus, manual.\n   *      You may pass multiple triggers; separate them with a space. `manual` cannot be combined with any other trigger.\n   * @param {Boolean} options.closeOnClickOutside=false - Close a popper on click outside of the popper and reference element. This has effect only when options.trigger is 'click'.\n   * @param {String|HTMLElement} options.boundariesElement\n   *      The element used as boundaries for the tooltip. For more information refer to Popper.js'\n   *      [boundariesElement docs](https://popper.js.org/popper-documentation.html)\n   * @param {Number|String} options.offset=0 - Offset of the tooltip relative to its reference. For more information refer to Popper.js'\n   *      [offset docs](https://popper.js.org/popper-documentation.html)\n   * @param {Object} options.popperOptions={} - Popper options, will be passed directly to popper instance. For more information refer to Popper.js'\n   *      [options docs](https://popper.js.org/popper-documentation.html)\n   * @return {Object} instance - The generated tooltip instance\n   */\n  function Tooltip(reference, options) {\n    classCallCheck(this, Tooltip);\n\n    _initialiseProps.call(this);\n\n    // apply user options over default ones\n    options = _extends({}, DEFAULT_OPTIONS, options);\n\n    reference.jquery && (reference = reference[0]);\n\n    // cache reference and options\n    this.reference = reference;\n    this.options = options;\n\n    // get events list\n    var events = typeof options.trigger === 'string' ? options.trigger.split(' ').filter(function (trigger) {\n      return ['click', 'hover', 'focus'].indexOf(trigger) !== -1;\n    }) : [];\n\n    // set initial state\n    this._isOpen = false;\n    this._popperOptions = {};\n\n    // set event listeners\n    this._setEventListeners(reference, events, options);\n  }\n\n  //\n  // Public methods\n  //\n\n  /**\n   * Reveals an element's tooltip. This is considered a \"manual\" triggering of the tooltip.\n   * Tooltips with zero-length titles are never displayed.\n   * @method Tooltip#show\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Hides an element’s tooltip. This is considered a “manual” triggering of the tooltip.\n   * @method Tooltip#hide\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Hides and destroys an element’s tooltip.\n   * @method Tooltip#dispose\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Toggles an element’s tooltip. This is considered a “manual” triggering of the tooltip.\n   * @method Tooltip#toggle\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Updates the tooltip's title content\n   * @method Tooltip#updateTitleContent\n   * @memberof Tooltip\n   * @param {String|HTMLElement} title - The new content to use for the title\n   */\n\n\n  //\n  // Private methods\n  //\n\n  createClass(Tooltip, [{\n    key: '_create',\n\n\n    /**\n     * Creates a new tooltip node\n     * @memberof Tooltip\n     * @private\n     * @param {HTMLElement} reference\n     * @param {String} template\n     * @param {String|HTMLElement|TitleFunction} title\n     * @param {Boolean} allowHtml\n     * @return {HTMLElement} tooltipNode\n     */\n    value: function _create(reference, template, title, allowHtml) {\n      // create tooltip element\n      var tooltipGenerator = window.document.createElement('div');\n      tooltipGenerator.innerHTML = template.trim();\n      var tooltipNode = tooltipGenerator.childNodes[0];\n\n      // add unique ID to our tooltip (needed for accessibility reasons)\n      tooltipNode.id = 'tooltip_' + Math.random().toString(36).substr(2, 10);\n\n      // set initial `aria-hidden` state to `false` (it's visible!)\n      tooltipNode.setAttribute('aria-hidden', 'false');\n\n      // add title to tooltip\n      var titleNode = tooltipGenerator.querySelector(this.options.innerSelector);\n      this._addTitleContent(reference, title, allowHtml, titleNode);\n\n      // return the generated tooltip node\n      return tooltipNode;\n    }\n  }, {\n    key: '_addTitleContent',\n    value: function _addTitleContent(reference, title, allowHtml, titleNode) {\n      if (title.nodeType === 1 || title.nodeType === 11) {\n        // if title is a element node or document fragment, append it only if allowHtml is true\n        allowHtml && titleNode.appendChild(title);\n      } else if (isFunction(title)) {\n        // Recursively call ourself so that the return value of the function gets handled appropriately - either\n        // as a dom node, a string, or even as another function.\n        this._addTitleContent(reference, title.call(reference), allowHtml, titleNode);\n      } else {\n        // if it's just a simple text, set textContent or innerHtml depending by `allowHtml` value\n        allowHtml ? titleNode.innerHTML = title : titleNode.textContent = title;\n      }\n    }\n  }, {\n    key: '_show',\n    value: function _show(reference, options) {\n      // don't show if it's already visible\n      // or if it's not being showed\n      if (this._isOpen && !this._isOpening) {\n        return this;\n      }\n      this._isOpen = true;\n\n      // if the tooltipNode already exists, just show it\n      if (this._tooltipNode) {\n        this._tooltipNode.style.visibility = 'visible';\n        this._tooltipNode.setAttribute('aria-hidden', 'false');\n        this.popperInstance.update();\n        return this;\n      }\n\n      // get title\n      var title = reference.getAttribute('title') || options.title;\n\n      // don't show tooltip if no title is defined\n      if (!title) {\n        return this;\n      }\n\n      // create tooltip node\n      var tooltipNode = this._create(reference, options.template, title, options.html);\n\n      // Add `aria-describedby` to our reference element for accessibility reasons\n      reference.setAttribute('aria-describedby', tooltipNode.id);\n\n      // append tooltip to container\n      var container = this._findContainer(options.container, reference);\n\n      this._append(tooltipNode, container);\n\n      this._popperOptions = _extends({}, options.popperOptions, {\n        placement: options.placement\n      });\n\n      this._popperOptions.modifiers = _extends({}, this._popperOptions.modifiers, {\n        arrow: _extends({}, this._popperOptions.modifiers && this._popperOptions.modifiers.arrow, {\n          element: options.arrowSelector\n        }),\n        offset: _extends({}, this._popperOptions.modifiers && this._popperOptions.modifiers.offset, {\n          offset: options.offset || this._popperOptions.modifiers && this._popperOptions.modifiers.offset && this._popperOptions.modifiers.offset.offset || options.offset\n        })\n      });\n\n      if (options.boundariesElement) {\n        this._popperOptions.modifiers.preventOverflow = {\n          boundariesElement: options.boundariesElement\n        };\n      }\n\n      this.popperInstance = new Popper(reference, tooltipNode, this._popperOptions);\n\n      this._tooltipNode = tooltipNode;\n\n      return this;\n    }\n  }, {\n    key: '_hide',\n    value: function _hide() /*reference, options*/{\n      // don't hide if it's already hidden\n      if (!this._isOpen) {\n        return this;\n      }\n\n      this._isOpen = false;\n\n      // hide tooltipNode\n      this._tooltipNode.style.visibility = 'hidden';\n      this._tooltipNode.setAttribute('aria-hidden', 'true');\n\n      return this;\n    }\n  }, {\n    key: '_dispose',\n    value: function _dispose() {\n      var _this = this;\n\n      // remove event listeners first to prevent any unexpected behaviour\n      this._events.forEach(function (_ref) {\n        var func = _ref.func,\n            event = _ref.event;\n\n        _this.reference.removeEventListener(event, func);\n      });\n      this._events = [];\n\n      if (this._tooltipNode) {\n        this._hide();\n\n        // destroy instance\n        this.popperInstance.destroy();\n\n        // destroy tooltipNode if removeOnDestroy is not set, as popperInstance.destroy() already removes the element\n        if (!this.popperInstance.options.removeOnDestroy) {\n          this._tooltipNode.parentNode.removeChild(this._tooltipNode);\n          this._tooltipNode = null;\n        }\n      }\n      return this;\n    }\n  }, {\n    key: '_findContainer',\n    value: function _findContainer(container, reference) {\n      // if container is a query, get the relative element\n      if (typeof container === 'string') {\n        container = window.document.querySelector(container);\n      } else if (container === false) {\n        // if container is `false`, set it to reference parent\n        container = reference.parentNode;\n      }\n      return container;\n    }\n\n    /**\n     * Append tooltip to container\n     * @memberof Tooltip\n     * @private\n     * @param {HTMLElement} tooltipNode\n     * @param {HTMLElement|String|false} container\n     */\n\n  }, {\n    key: '_append',\n    value: function _append(tooltipNode, container) {\n      container.appendChild(tooltipNode);\n    }\n  }, {\n    key: '_setEventListeners',\n    value: function _setEventListeners(reference, events, options) {\n      var _this2 = this;\n\n      var directEvents = [];\n      var oppositeEvents = [];\n\n      events.forEach(function (event) {\n        switch (event) {\n          case 'hover':\n            directEvents.push('mouseenter');\n            oppositeEvents.push('mouseleave');\n            break;\n          case 'focus':\n            directEvents.push('focus');\n            oppositeEvents.push('blur');\n            break;\n          case 'click':\n            directEvents.push('click');\n            oppositeEvents.push('click');\n            break;\n        }\n      });\n\n      // schedule show tooltip\n      directEvents.forEach(function (event) {\n        var func = function func(evt) {\n          if (_this2._isOpening === true) {\n            return;\n          }\n          evt.usedByTooltip = true;\n          _this2._scheduleShow(reference, options.delay, options, evt);\n        };\n        _this2._events.push({ event: event, func: func });\n        reference.addEventListener(event, func);\n      });\n\n      // schedule hide tooltip\n      oppositeEvents.forEach(function (event) {\n        var func = function func(evt) {\n          if (evt.usedByTooltip === true) {\n            return;\n          }\n          _this2._scheduleHide(reference, options.delay, options, evt);\n        };\n        _this2._events.push({ event: event, func: func });\n        reference.addEventListener(event, func);\n        if (event === 'click' && options.closeOnClickOutside) {\n          document.addEventListener('mousedown', function (e) {\n            if (!_this2._isOpening) {\n              return;\n            }\n            var popper = _this2.popperInstance.popper;\n            if (reference.contains(e.target) || popper.contains(e.target)) {\n              return;\n            }\n            func(e);\n          }, true);\n        }\n      });\n    }\n  }, {\n    key: '_scheduleShow',\n    value: function _scheduleShow(reference, delay, options /*, evt */) {\n      var _this3 = this;\n\n      this._isOpening = true;\n      // defaults to 0\n      var computedDelay = delay && delay.show || delay || 0;\n      this._showTimeout = window.setTimeout(function () {\n        return _this3._show(reference, options);\n      }, computedDelay);\n    }\n  }, {\n    key: '_scheduleHide',\n    value: function _scheduleHide(reference, delay, options, evt) {\n      var _this4 = this;\n\n      this._isOpening = false;\n      // defaults to 0\n      var computedDelay = delay && delay.hide || delay || 0;\n      window.clearTimeout(this._showTimeout);\n      window.setTimeout(function () {\n        if (_this4._isOpen === false) {\n          return;\n        }\n        if (!document.body.contains(_this4._tooltipNode)) {\n          return;\n        }\n\n        // if we are hiding because of a mouseleave, we must check that the new\n        // reference isn't the tooltip, because in this case we don't want to hide it\n        if (evt.type === 'mouseleave') {\n          var isSet = _this4._setTooltipNodeEvent(evt, reference, delay, options);\n\n          // if we set the new event, don't hide the tooltip yet\n          // the new event will take care to hide it if necessary\n          if (isSet) {\n            return;\n          }\n        }\n\n        _this4._hide(reference, options);\n      }, computedDelay);\n    }\n  }, {\n    key: '_updateTitleContent',\n    value: function _updateTitleContent(title) {\n      if (typeof this._tooltipNode === 'undefined') {\n        if (typeof this.options.title !== 'undefined') {\n          this.options.title = title;\n        }\n        return;\n      }\n      var titleNode = this._tooltipNode.querySelector(this.options.innerSelector);\n      this._clearTitleContent(titleNode, this.options.html, this.reference.getAttribute('title') || this.options.title);\n      this._addTitleContent(this.reference, title, this.options.html, titleNode);\n      this.options.title = title;\n      this.popperInstance.update();\n    }\n  }, {\n    key: '_clearTitleContent',\n    value: function _clearTitleContent(titleNode, allowHtml, lastTitle) {\n      if (lastTitle.nodeType === 1 || lastTitle.nodeType === 11) {\n        allowHtml && titleNode.removeChild(lastTitle);\n      } else {\n        allowHtml ? titleNode.innerHTML = '' : titleNode.textContent = '';\n      }\n    }\n  }]);\n  return Tooltip;\n}();\n\n/**\n * Title function, its context is the Tooltip instance.\n * @memberof Tooltip\n * @callback TitleFunction\n * @return {String} placement - The desired title.\n */\n\n\nvar _initialiseProps = function _initialiseProps() {\n  var _this5 = this;\n\n  this.show = function () {\n    return _this5._show(_this5.reference, _this5.options);\n  };\n\n  this.hide = function () {\n    return _this5._hide();\n  };\n\n  this.dispose = function () {\n    return _this5._dispose();\n  };\n\n  this.toggle = function () {\n    if (_this5._isOpen) {\n      return _this5.hide();\n    } else {\n      return _this5.show();\n    }\n  };\n\n  this.updateTitleContent = function (title) {\n    return _this5._updateTitleContent(title);\n  };\n\n  this._events = [];\n\n  this._setTooltipNodeEvent = function (evt, reference, delay, options) {\n    var relatedreference = evt.relatedreference || evt.toElement || evt.relatedTarget;\n\n    var callback = function callback(evt2) {\n      var relatedreference2 = evt2.relatedreference || evt2.toElement || evt2.relatedTarget;\n\n      // Remove event listener after call\n      _this5._tooltipNode.removeEventListener(evt.type, callback);\n\n      // If the new reference is not the reference element\n      if (!reference.contains(relatedreference2)) {\n        // Schedule to hide tooltip\n        _this5._scheduleHide(reference, options.delay, options, evt2);\n      }\n    };\n\n    if (_this5._tooltipNode.contains(relatedreference)) {\n      // listen to mouseleave on the tooltip element to be able to hide the tooltip\n      _this5._tooltipNode.addEventListener(evt.type, callback);\n      return true;\n    }\n\n    return false;\n  };\n};\n\nreturn Tooltip;\n\n})));\n//# sourceMappingURL=tooltip.js.map\n\n\n/***/ }),\n\n/***/ 421:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* WEBPACK VAR INJECTION */(function(global) {/**!\n * @fileOverview Kickass library to create and place poppers near their reference elements.\n * @version 1.16.1\n * @license\n * Copyright (c) 2016 Federico Zivolo and contributors\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';\n\nvar timeoutDuration = function () {\n  var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];\n  for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {\n    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {\n      return 1;\n    }\n  }\n  return 0;\n}();\n\nfunction microtaskDebounce(fn) {\n  var called = false;\n  return function () {\n    if (called) {\n      return;\n    }\n    called = true;\n    window.Promise.resolve().then(function () {\n      called = false;\n      fn();\n    });\n  };\n}\n\nfunction taskDebounce(fn) {\n  var scheduled = false;\n  return function () {\n    if (!scheduled) {\n      scheduled = true;\n      setTimeout(function () {\n        scheduled = false;\n        fn();\n      }, timeoutDuration);\n    }\n  };\n}\n\nvar supportsMicroTasks = isBrowser && window.Promise;\n\n/**\n* Create a debounced version of a method, that's asynchronously deferred\n* but called in the minimum time possible.\n*\n* @method\n* @memberof Popper.Utils\n* @argument {Function} fn\n* @returns {Function}\n*/\nvar debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;\n\n/**\n * Check if the given variable is a function\n * @method\n * @memberof Popper.Utils\n * @argument {Any} functionToCheck - variable to check\n * @returns {Boolean} answer to: is a function?\n */\nfunction isFunction(functionToCheck) {\n  var getType = {};\n  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';\n}\n\n/**\n * Get CSS computed property of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Eement} element\n * @argument {String} property\n */\nfunction getStyleComputedProperty(element, property) {\n  if (element.nodeType !== 1) {\n    return [];\n  }\n  // NOTE: 1 DOM access here\n  var window = element.ownerDocument.defaultView;\n  var css = window.getComputedStyle(element, null);\n  return property ? css[property] : css;\n}\n\n/**\n * Returns the parentNode or the host of the element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} parent\n */\nfunction getParentNode(element) {\n  if (element.nodeName === 'HTML') {\n    return element;\n  }\n  return element.parentNode || element.host;\n}\n\n/**\n * Returns the scrolling parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} scroll parent\n */\nfunction getScrollParent(element) {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  if (!element) {\n    return document.body;\n  }\n\n  switch (element.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return element.ownerDocument.body;\n    case '#document':\n      return element.body;\n  }\n\n  // Firefox want us to check `-x` and `-y` variations as well\n\n  var _getStyleComputedProp = getStyleComputedProperty(element),\n      overflow = _getStyleComputedProp.overflow,\n      overflowX = _getStyleComputedProp.overflowX,\n      overflowY = _getStyleComputedProp.overflowY;\n\n  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {\n    return element;\n  }\n\n  return getScrollParent(getParentNode(element));\n}\n\n/**\n * Returns the reference node of the reference object, or the reference object itself.\n * @method\n * @memberof Popper.Utils\n * @param {Element|Object} reference - the reference element (the popper will be relative to this)\n * @returns {Element} parent\n */\nfunction getReferenceNode(reference) {\n  return reference && reference.referenceNode ? reference.referenceNode : reference;\n}\n\nvar isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);\nvar isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);\n\n/**\n * Determines if the browser is Internet Explorer\n * @method\n * @memberof Popper.Utils\n * @param {Number} version to check\n * @returns {Boolean} isIE\n */\nfunction isIE(version) {\n  if (version === 11) {\n    return isIE11;\n  }\n  if (version === 10) {\n    return isIE10;\n  }\n  return isIE11 || isIE10;\n}\n\n/**\n * Returns the offset parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} offset parent\n */\nfunction getOffsetParent(element) {\n  if (!element) {\n    return document.documentElement;\n  }\n\n  var noOffsetParent = isIE(10) ? document.body : null;\n\n  // NOTE: 1 DOM access here\n  var offsetParent = element.offsetParent || null;\n  // Skip hidden elements which don't have an offsetParent\n  while (offsetParent === noOffsetParent && element.nextElementSibling) {\n    offsetParent = (element = element.nextElementSibling).offsetParent;\n  }\n\n  var nodeName = offsetParent && offsetParent.nodeName;\n\n  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {\n    return element ? element.ownerDocument.documentElement : document.documentElement;\n  }\n\n  // .offsetParent will return the closest TH, TD or TABLE in case\n  // no offsetParent is present, I hate this job...\n  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {\n    return getOffsetParent(offsetParent);\n  }\n\n  return offsetParent;\n}\n\nfunction isOffsetContainer(element) {\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY') {\n    return false;\n  }\n  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;\n}\n\n/**\n * Finds the root node (document, shadowDOM root) of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} node\n * @returns {Element} root node\n */\nfunction getRoot(node) {\n  if (node.parentNode !== null) {\n    return getRoot(node.parentNode);\n  }\n\n  return node;\n}\n\n/**\n * Finds the offset parent common to the two provided nodes\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element1\n * @argument {Element} element2\n * @returns {Element} common offset parent\n */\nfunction findCommonOffsetParent(element1, element2) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {\n    return document.documentElement;\n  }\n\n  // Here we make sure to give as \"start\" the element that comes first in the DOM\n  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;\n  var start = order ? element1 : element2;\n  var end = order ? element2 : element1;\n\n  // Get common ancestor container\n  var range = document.createRange();\n  range.setStart(start, 0);\n  range.setEnd(end, 0);\n  var commonAncestorContainer = range.commonAncestorContainer;\n\n  // Both nodes are inside #document\n\n  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {\n    if (isOffsetContainer(commonAncestorContainer)) {\n      return commonAncestorContainer;\n    }\n\n    return getOffsetParent(commonAncestorContainer);\n  }\n\n  // one of the nodes is inside shadowDOM, find which one\n  var element1root = getRoot(element1);\n  if (element1root.host) {\n    return findCommonOffsetParent(element1root.host, element2);\n  } else {\n    return findCommonOffsetParent(element1, getRoot(element2).host);\n  }\n}\n\n/**\n * Gets the scroll value of the given element in the given side (top and left)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {String} side `top` or `left`\n * @returns {number} amount of scrolled pixels\n */\nfunction getScroll(element) {\n  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';\n\n  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    var html = element.ownerDocument.documentElement;\n    var scrollingElement = element.ownerDocument.scrollingElement || html;\n    return scrollingElement[upperSide];\n  }\n\n  return element[upperSide];\n}\n\n/*\n * Sum or subtract the element scroll values (left and top) from a given rect object\n * @method\n * @memberof Popper.Utils\n * @param {Object} rect - Rect object you want to change\n * @param {HTMLElement} element - The element from the function reads the scroll values\n * @param {Boolean} subtract - set to true if you want to subtract the scroll values\n * @return {Object} rect - The modifier rect object\n */\nfunction includeScroll(rect, element) {\n  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var scrollTop = getScroll(element, 'top');\n  var scrollLeft = getScroll(element, 'left');\n  var modifier = subtract ? -1 : 1;\n  rect.top += scrollTop * modifier;\n  rect.bottom += scrollTop * modifier;\n  rect.left += scrollLeft * modifier;\n  rect.right += scrollLeft * modifier;\n  return rect;\n}\n\n/*\n * Helper to detect borders of a given element\n * @method\n * @memberof Popper.Utils\n * @param {CSSStyleDeclaration} styles\n * Result of `getStyleComputedProperty` on the given element\n * @param {String} axis - `x` or `y`\n * @return {number} borders - The borders size of the given axis\n */\n\nfunction getBordersSize(styles, axis) {\n  var sideA = axis === 'x' ? 'Left' : 'Top';\n  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';\n\n  return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']);\n}\n\nfunction getSize(axis, body, html, computedStyle) {\n  return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);\n}\n\nfunction getWindowSizes(document) {\n  var body = document.body;\n  var html = document.documentElement;\n  var computedStyle = isIE(10) && getComputedStyle(html);\n\n  return {\n    height: getSize('Height', body, html, computedStyle),\n    width: getSize('Width', body, html, computedStyle)\n  };\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n\n\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\n/**\n * Given element offsets, generate an output similar to getBoundingClientRect\n * @method\n * @memberof Popper.Utils\n * @argument {Object} offsets\n * @returns {Object} ClientRect like output\n */\nfunction getClientRect(offsets) {\n  return _extends({}, offsets, {\n    right: offsets.left + offsets.width,\n    bottom: offsets.top + offsets.height\n  });\n}\n\n/**\n * Get bounding client rect of given element\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} element\n * @return {Object} client rect\n */\nfunction getBoundingClientRect(element) {\n  var rect = {};\n\n  // IE10 10 FIX: Please, don't ask, the element isn't\n  // considered in DOM in some circumstances...\n  // This isn't reproducible in IE10 compatibility mode of IE11\n  try {\n    if (isIE(10)) {\n      rect = element.getBoundingClientRect();\n      var scrollTop = getScroll(element, 'top');\n      var scrollLeft = getScroll(element, 'left');\n      rect.top += scrollTop;\n      rect.left += scrollLeft;\n      rect.bottom += scrollTop;\n      rect.right += scrollLeft;\n    } else {\n      rect = element.getBoundingClientRect();\n    }\n  } catch (e) {}\n\n  var result = {\n    left: rect.left,\n    top: rect.top,\n    width: rect.right - rect.left,\n    height: rect.bottom - rect.top\n  };\n\n  // subtract scrollbar size from sizes\n  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};\n  var width = sizes.width || element.clientWidth || result.width;\n  var height = sizes.height || element.clientHeight || result.height;\n\n  var horizScrollbar = element.offsetWidth - width;\n  var vertScrollbar = element.offsetHeight - height;\n\n  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`\n  // we make this check conditional for performance reasons\n  if (horizScrollbar || vertScrollbar) {\n    var styles = getStyleComputedProperty(element);\n    horizScrollbar -= getBordersSize(styles, 'x');\n    vertScrollbar -= getBordersSize(styles, 'y');\n\n    result.width -= horizScrollbar;\n    result.height -= vertScrollbar;\n  }\n\n  return getClientRect(result);\n}\n\nfunction getOffsetRectRelativeToArbitraryNode(children, parent) {\n  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var isIE10 = isIE(10);\n  var isHTML = parent.nodeName === 'HTML';\n  var childrenRect = getBoundingClientRect(children);\n  var parentRect = getBoundingClientRect(parent);\n  var scrollParent = getScrollParent(children);\n\n  var styles = getStyleComputedProperty(parent);\n  var borderTopWidth = parseFloat(styles.borderTopWidth);\n  var borderLeftWidth = parseFloat(styles.borderLeftWidth);\n\n  // In cases where the parent is fixed, we must ignore negative scroll in offset calc\n  if (fixedPosition && isHTML) {\n    parentRect.top = Math.max(parentRect.top, 0);\n    parentRect.left = Math.max(parentRect.left, 0);\n  }\n  var offsets = getClientRect({\n    top: childrenRect.top - parentRect.top - borderTopWidth,\n    left: childrenRect.left - parentRect.left - borderLeftWidth,\n    width: childrenRect.width,\n    height: childrenRect.height\n  });\n  offsets.marginTop = 0;\n  offsets.marginLeft = 0;\n\n  // Subtract margins of documentElement in case it's being used as parent\n  // we do this only on HTML because it's the only element that behaves\n  // differently when margins are applied to it. The margins are included in\n  // the box of the documentElement, in the other cases not.\n  if (!isIE10 && isHTML) {\n    var marginTop = parseFloat(styles.marginTop);\n    var marginLeft = parseFloat(styles.marginLeft);\n\n    offsets.top -= borderTopWidth - marginTop;\n    offsets.bottom -= borderTopWidth - marginTop;\n    offsets.left -= borderLeftWidth - marginLeft;\n    offsets.right -= borderLeftWidth - marginLeft;\n\n    // Attach marginTop and marginLeft because in some circumstances we may need them\n    offsets.marginTop = marginTop;\n    offsets.marginLeft = marginLeft;\n  }\n\n  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {\n    offsets = includeScroll(offsets, parent);\n  }\n\n  return offsets;\n}\n\nfunction getViewportOffsetRectRelativeToArtbitraryNode(element) {\n  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var html = element.ownerDocument.documentElement;\n  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);\n  var width = Math.max(html.clientWidth, window.innerWidth || 0);\n  var height = Math.max(html.clientHeight, window.innerHeight || 0);\n\n  var scrollTop = !excludeScroll ? getScroll(html) : 0;\n  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;\n\n  var offset = {\n    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,\n    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,\n    width: width,\n    height: height\n  };\n\n  return getClientRect(offset);\n}\n\n/**\n * Check if the given element is fixed or is inside a fixed parent\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {Element} customContainer\n * @returns {Boolean} answer to \"isFixed?\"\n */\nfunction isFixed(element) {\n  var nodeName = element.nodeName;\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    return false;\n  }\n  if (getStyleComputedProperty(element, 'position') === 'fixed') {\n    return true;\n  }\n  var parentNode = getParentNode(element);\n  if (!parentNode) {\n    return false;\n  }\n  return isFixed(parentNode);\n}\n\n/**\n * Finds the first parent of an element that has a transformed property defined\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} first transformed parent or documentElement\n */\n\nfunction getFixedPositionOffsetParent(element) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element || !element.parentElement || isIE()) {\n    return document.documentElement;\n  }\n  var el = element.parentElement;\n  while (el && getStyleComputedProperty(el, 'transform') === 'none') {\n    el = el.parentElement;\n  }\n  return el || document.documentElement;\n}\n\n/**\n * Computed the boundaries limits and return them\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} popper\n * @param {HTMLElement} reference\n * @param {number} padding\n * @param {HTMLElement} boundariesElement - Element used to define the boundaries\n * @param {Boolean} fixedPosition - Is in fixed position mode\n * @returns {Object} Coordinates of the boundaries\n */\nfunction getBoundaries(popper, reference, padding, boundariesElement) {\n  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n  // NOTE: 1 DOM access here\n\n  var boundaries = { top: 0, left: 0 };\n  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n\n  // Handle viewport case\n  if (boundariesElement === 'viewport') {\n    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);\n  } else {\n    // Handle other cases based on DOM element used as boundaries\n    var boundariesNode = void 0;\n    if (boundariesElement === 'scrollParent') {\n      boundariesNode = getScrollParent(getParentNode(reference));\n      if (boundariesNode.nodeName === 'BODY') {\n        boundariesNode = popper.ownerDocument.documentElement;\n      }\n    } else if (boundariesElement === 'window') {\n      boundariesNode = popper.ownerDocument.documentElement;\n    } else {\n      boundariesNode = boundariesElement;\n    }\n\n    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);\n\n    // In case of HTML, we need a different computation\n    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {\n      var _getWindowSizes = getWindowSizes(popper.ownerDocument),\n          height = _getWindowSizes.height,\n          width = _getWindowSizes.width;\n\n      boundaries.top += offsets.top - offsets.marginTop;\n      boundaries.bottom = height + offsets.top;\n      boundaries.left += offsets.left - offsets.marginLeft;\n      boundaries.right = width + offsets.left;\n    } else {\n      // for all the other DOM elements, this one is good\n      boundaries = offsets;\n    }\n  }\n\n  // Add paddings\n  padding = padding || 0;\n  var isPaddingNumber = typeof padding === 'number';\n  boundaries.left += isPaddingNumber ? padding : padding.left || 0;\n  boundaries.top += isPaddingNumber ? padding : padding.top || 0;\n  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;\n  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;\n\n  return boundaries;\n}\n\nfunction getArea(_ref) {\n  var width = _ref.width,\n      height = _ref.height;\n\n  return width * height;\n}\n\n/**\n * Utility used to transform the `auto` placement to the placement with more\n * available space.\n * @method\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {\n  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;\n\n  if (placement.indexOf('auto') === -1) {\n    return placement;\n  }\n\n  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);\n\n  var rects = {\n    top: {\n      width: boundaries.width,\n      height: refRect.top - boundaries.top\n    },\n    right: {\n      width: boundaries.right - refRect.right,\n      height: boundaries.height\n    },\n    bottom: {\n      width: boundaries.width,\n      height: boundaries.bottom - refRect.bottom\n    },\n    left: {\n      width: refRect.left - boundaries.left,\n      height: boundaries.height\n    }\n  };\n\n  var sortedAreas = Object.keys(rects).map(function (key) {\n    return _extends({\n      key: key\n    }, rects[key], {\n      area: getArea(rects[key])\n    });\n  }).sort(function (a, b) {\n    return b.area - a.area;\n  });\n\n  var filteredAreas = sortedAreas.filter(function (_ref2) {\n    var width = _ref2.width,\n        height = _ref2.height;\n    return width >= popper.clientWidth && height >= popper.clientHeight;\n  });\n\n  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;\n\n  var variation = placement.split('-')[1];\n\n  return computedPlacement + (variation ? '-' + variation : '');\n}\n\n/**\n * Get offsets to the reference element\n * @method\n * @memberof Popper.Utils\n * @param {Object} state\n * @param {Element} popper - the popper element\n * @param {Element} reference - the reference element (the popper will be relative to this)\n * @param {Element} fixedPosition - is in fixed position mode\n * @returns {Object} An object containing the offsets which will be applied to the popper\n */\nfunction getReferenceOffsets(state, popper, reference) {\n  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n\n  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);\n}\n\n/**\n * Get the outer sizes of the given element (offset size + margins)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Object} object containing width and height properties\n */\nfunction getOuterSizes(element) {\n  var window = element.ownerDocument.defaultView;\n  var styles = window.getComputedStyle(element);\n  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);\n  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);\n  var result = {\n    width: element.offsetWidth + y,\n    height: element.offsetHeight + x\n  };\n  return result;\n}\n\n/**\n * Get the opposite placement of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement\n * @returns {String} flipped placement\n */\nfunction getOppositePlacement(placement) {\n  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };\n  return placement.replace(/left|right|bottom|top/g, function (matched) {\n    return hash[matched];\n  });\n}\n\n/**\n * Get offsets to the popper\n * @method\n * @memberof Popper.Utils\n * @param {Object} position - CSS position the Popper will get applied\n * @param {HTMLElement} popper - the popper element\n * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)\n * @param {String} placement - one of the valid placement options\n * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper\n */\nfunction getPopperOffsets(popper, referenceOffsets, placement) {\n  placement = placement.split('-')[0];\n\n  // Get popper node sizes\n  var popperRect = getOuterSizes(popper);\n\n  // Add position, width and height to our offsets object\n  var popperOffsets = {\n    width: popperRect.width,\n    height: popperRect.height\n  };\n\n  // depending by the popper placement we have to compute its offsets slightly differently\n  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;\n  var mainSide = isHoriz ? 'top' : 'left';\n  var secondarySide = isHoriz ? 'left' : 'top';\n  var measurement = isHoriz ? 'height' : 'width';\n  var secondaryMeasurement = !isHoriz ? 'height' : 'width';\n\n  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;\n  if (placement === secondarySide) {\n    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];\n  } else {\n    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];\n  }\n\n  return popperOffsets;\n}\n\n/**\n * Mimics the `find` method of Array\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction find(arr, check) {\n  // use native find if supported\n  if (Array.prototype.find) {\n    return arr.find(check);\n  }\n\n  // use `filter` to obtain the same behavior of `find`\n  return arr.filter(check)[0];\n}\n\n/**\n * Return the index of the matching object\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction findIndex(arr, prop, value) {\n  // use native findIndex if supported\n  if (Array.prototype.findIndex) {\n    return arr.findIndex(function (cur) {\n      return cur[prop] === value;\n    });\n  }\n\n  // use `find` + `indexOf` if `findIndex` isn't supported\n  var match = find(arr, function (obj) {\n    return obj[prop] === value;\n  });\n  return arr.indexOf(match);\n}\n\n/**\n * Loop trough the list of modifiers and run them in order,\n * each of them will then edit the data object.\n * @method\n * @memberof Popper.Utils\n * @param {dataObject} data\n * @param {Array} modifiers\n * @param {String} ends - Optional modifier name used as stopper\n * @returns {dataObject}\n */\nfunction runModifiers(modifiers, data, ends) {\n  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));\n\n  modifiersToRun.forEach(function (modifier) {\n    if (modifier['function']) {\n      // eslint-disable-line dot-notation\n      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');\n    }\n    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation\n    if (modifier.enabled && isFunction(fn)) {\n      // Add properties to offsets to make them a complete clientRect object\n      // we do this before each modifier to make sure the previous one doesn't\n      // mess with these values\n      data.offsets.popper = getClientRect(data.offsets.popper);\n      data.offsets.reference = getClientRect(data.offsets.reference);\n\n      data = fn(data, modifier);\n    }\n  });\n\n  return data;\n}\n\n/**\n * Updates the position of the popper, computing the new offsets and applying\n * the new style.<br />\n * Prefer `scheduleUpdate` over `update` because of performance reasons.\n * @method\n * @memberof Popper\n */\nfunction update() {\n  // if popper is destroyed, don't perform any further update\n  if (this.state.isDestroyed) {\n    return;\n  }\n\n  var data = {\n    instance: this,\n    styles: {},\n    arrowStyles: {},\n    attributes: {},\n    flipped: false,\n    offsets: {}\n  };\n\n  // compute reference element offsets\n  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);\n\n  // store the computed placement inside `originalPlacement`\n  data.originalPlacement = data.placement;\n\n  data.positionFixed = this.options.positionFixed;\n\n  // compute the popper offsets\n  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);\n\n  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';\n\n  // run the modifiers\n  data = runModifiers(this.modifiers, data);\n\n  // the first `update` will call `onCreate` callback\n  // the other ones will call `onUpdate` callback\n  if (!this.state.isCreated) {\n    this.state.isCreated = true;\n    this.options.onCreate(data);\n  } else {\n    this.options.onUpdate(data);\n  }\n}\n\n/**\n * Helper used to know if the given modifier is enabled.\n * @method\n * @memberof Popper.Utils\n * @returns {Boolean}\n */\nfunction isModifierEnabled(modifiers, modifierName) {\n  return modifiers.some(function (_ref) {\n    var name = _ref.name,\n        enabled = _ref.enabled;\n    return enabled && name === modifierName;\n  });\n}\n\n/**\n * Get the prefixed supported property name\n * @method\n * @memberof Popper.Utils\n * @argument {String} property (camelCase)\n * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)\n */\nfunction getSupportedPropertyName(property) {\n  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];\n  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);\n\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefix = prefixes[i];\n    var toCheck = prefix ? '' + prefix + upperProp : property;\n    if (typeof document.body.style[toCheck] !== 'undefined') {\n      return toCheck;\n    }\n  }\n  return null;\n}\n\n/**\n * Destroys the popper.\n * @method\n * @memberof Popper\n */\nfunction destroy() {\n  this.state.isDestroyed = true;\n\n  // touch DOM only if `applyStyle` modifier is enabled\n  if (isModifierEnabled(this.modifiers, 'applyStyle')) {\n    this.popper.removeAttribute('x-placement');\n    this.popper.style.position = '';\n    this.popper.style.top = '';\n    this.popper.style.left = '';\n    this.popper.style.right = '';\n    this.popper.style.bottom = '';\n    this.popper.style.willChange = '';\n    this.popper.style[getSupportedPropertyName('transform')] = '';\n  }\n\n  this.disableEventListeners();\n\n  // remove the popper if user explicitly asked for the deletion on destroy\n  // do not use `remove` because IE11 doesn't support it\n  if (this.options.removeOnDestroy) {\n    this.popper.parentNode.removeChild(this.popper);\n  }\n  return this;\n}\n\n/**\n * Get the window associated with the element\n * @argument {Element} element\n * @returns {Window}\n */\nfunction getWindow(element) {\n  var ownerDocument = element.ownerDocument;\n  return ownerDocument ? ownerDocument.defaultView : window;\n}\n\nfunction attachToScrollParents(scrollParent, event, callback, scrollParents) {\n  var isBody = scrollParent.nodeName === 'BODY';\n  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;\n  target.addEventListener(event, callback, { passive: true });\n\n  if (!isBody) {\n    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);\n  }\n  scrollParents.push(target);\n}\n\n/**\n * Setup needed event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction setupEventListeners(reference, options, state, updateBound) {\n  // Resize event listener on window\n  state.updateBound = updateBound;\n  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });\n\n  // Scroll event listener on scroll parents\n  var scrollElement = getScrollParent(reference);\n  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);\n  state.scrollElement = scrollElement;\n  state.eventsEnabled = true;\n\n  return state;\n}\n\n/**\n * It will add resize/scroll events and start recalculating\n * position of the popper element when they are triggered.\n * @method\n * @memberof Popper\n */\nfunction enableEventListeners() {\n  if (!this.state.eventsEnabled) {\n    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);\n  }\n}\n\n/**\n * Remove event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction removeEventListeners(reference, state) {\n  // Remove resize event listener on window\n  getWindow(reference).removeEventListener('resize', state.updateBound);\n\n  // Remove scroll event listener on scroll parents\n  state.scrollParents.forEach(function (target) {\n    target.removeEventListener('scroll', state.updateBound);\n  });\n\n  // Reset state\n  state.updateBound = null;\n  state.scrollParents = [];\n  state.scrollElement = null;\n  state.eventsEnabled = false;\n  return state;\n}\n\n/**\n * It will remove resize/scroll events and won't recalculate popper position\n * when they are triggered. It also won't trigger `onUpdate` callback anymore,\n * unless you call `update` method manually.\n * @method\n * @memberof Popper\n */\nfunction disableEventListeners() {\n  if (this.state.eventsEnabled) {\n    cancelAnimationFrame(this.scheduleUpdate);\n    this.state = removeEventListeners(this.reference, this.state);\n  }\n}\n\n/**\n * Tells if a given input is a number\n * @method\n * @memberof Popper.Utils\n * @param {*} input to check\n * @return {Boolean}\n */\nfunction isNumeric(n) {\n  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);\n}\n\n/**\n * Set the style to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the style to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setStyles(element, styles) {\n  Object.keys(styles).forEach(function (prop) {\n    var unit = '';\n    // add unit if the value is numeric and is one of the following\n    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {\n      unit = 'px';\n    }\n    element.style[prop] = styles[prop] + unit;\n  });\n}\n\n/**\n * Set the attributes to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the attributes to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setAttributes(element, attributes) {\n  Object.keys(attributes).forEach(function (prop) {\n    var value = attributes[prop];\n    if (value !== false) {\n      element.setAttribute(prop, attributes[prop]);\n    } else {\n      element.removeAttribute(prop);\n    }\n  });\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} data.styles - List of style properties - values to apply to popper element\n * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The same data object\n */\nfunction applyStyle(data) {\n  // any property present in `data.styles` will be applied to the popper,\n  // in this way we can make the 3rd party modifiers add custom styles to it\n  // Be aware, modifiers could override the properties defined in the previous\n  // lines of this modifier!\n  setStyles(data.instance.popper, data.styles);\n\n  // any property present in `data.attributes` will be applied to the popper,\n  // they will be set as HTML attributes of the element\n  setAttributes(data.instance.popper, data.attributes);\n\n  // if arrowElement is defined and arrowStyles has some properties\n  if (data.arrowElement && Object.keys(data.arrowStyles).length) {\n    setStyles(data.arrowElement, data.arrowStyles);\n  }\n\n  return data;\n}\n\n/**\n * Set the x-placement attribute before everything else because it could be used\n * to add margins to the popper margins needs to be calculated to get the\n * correct popper offsets.\n * @method\n * @memberof Popper.modifiers\n * @param {HTMLElement} reference - The reference element used to position the popper\n * @param {HTMLElement} popper - The HTML element used as popper\n * @param {Object} options - Popper.js options\n */\nfunction applyStyleOnLoad(reference, popper, options, modifierOptions, state) {\n  // compute reference element offsets\n  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);\n\n  popper.setAttribute('x-placement', placement);\n\n  // Apply `position` to popper before anything else because\n  // without the position applied we can't guarantee correct computations\n  setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });\n\n  return options;\n}\n\n/**\n * @function\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Boolean} shouldRound - If the offsets should be rounded at all\n * @returns {Object} The popper's position offsets rounded\n *\n * The tale of pixel-perfect positioning. It's still not 100% perfect, but as\n * good as it can be within reason.\n * Discussion here: https://github.com/FezVrasta/popper.js/pull/715\n *\n * Low DPI screens cause a popper to be blurry if not using full pixels (Safari\n * as well on High DPI screens).\n *\n * Firefox prefers no rounding for positioning and does not have blurriness on\n * high DPI screens.\n *\n * Only horizontal placement and left/right values need to be considered.\n */\nfunction getRoundedOffsets(data, shouldRound) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n  var round = Math.round,\n      floor = Math.floor;\n\n  var noRound = function noRound(v) {\n    return v;\n  };\n\n  var referenceWidth = round(reference.width);\n  var popperWidth = round(popper.width);\n\n  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;\n  var isVariation = data.placement.indexOf('-') !== -1;\n  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;\n  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;\n\n  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;\n  var verticalToInteger = !shouldRound ? noRound : round;\n\n  return {\n    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),\n    top: verticalToInteger(popper.top),\n    bottom: verticalToInteger(popper.bottom),\n    right: horizontalToInteger(popper.right)\n  };\n}\n\nvar isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeStyle(data, options) {\n  var x = options.x,\n      y = options.y;\n  var popper = data.offsets.popper;\n\n  // Remove this legacy support in Popper.js v2\n\n  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'applyStyle';\n  }).gpuAcceleration;\n  if (legacyGpuAccelerationOption !== undefined) {\n    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');\n  }\n  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;\n\n  var offsetParent = getOffsetParent(data.instance.popper);\n  var offsetParentRect = getBoundingClientRect(offsetParent);\n\n  // Styles\n  var styles = {\n    position: popper.position\n  };\n\n  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);\n\n  var sideA = x === 'bottom' ? 'top' : 'bottom';\n  var sideB = y === 'right' ? 'left' : 'right';\n\n  // if gpuAcceleration is set to `true` and transform is supported,\n  //  we use `translate3d` to apply the position to the popper we\n  // automatically use the supported prefixed version if needed\n  var prefixedProperty = getSupportedPropertyName('transform');\n\n  // now, let's make a step back and look at this code closely (wtf?)\n  // If the content of the popper grows once it's been positioned, it\n  // may happen that the popper gets misplaced because of the new content\n  // overflowing its reference element\n  // To avoid this problem, we provide two options (x and y), which allow\n  // the consumer to define the offset origin.\n  // If we position a popper on top of a reference element, we can set\n  // `x` to `top` to make the popper grow towards its top instead of\n  // its bottom.\n  var left = void 0,\n      top = void 0;\n  if (sideA === 'bottom') {\n    // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)\n    // and not the bottom of the html element\n    if (offsetParent.nodeName === 'HTML') {\n      top = -offsetParent.clientHeight + offsets.bottom;\n    } else {\n      top = -offsetParentRect.height + offsets.bottom;\n    }\n  } else {\n    top = offsets.top;\n  }\n  if (sideB === 'right') {\n    if (offsetParent.nodeName === 'HTML') {\n      left = -offsetParent.clientWidth + offsets.right;\n    } else {\n      left = -offsetParentRect.width + offsets.right;\n    }\n  } else {\n    left = offsets.left;\n  }\n  if (gpuAcceleration && prefixedProperty) {\n    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';\n    styles[sideA] = 0;\n    styles[sideB] = 0;\n    styles.willChange = 'transform';\n  } else {\n    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties\n    var invertTop = sideA === 'bottom' ? -1 : 1;\n    var invertLeft = sideB === 'right' ? -1 : 1;\n    styles[sideA] = top * invertTop;\n    styles[sideB] = left * invertLeft;\n    styles.willChange = sideA + ', ' + sideB;\n  }\n\n  // Attributes\n  var attributes = {\n    'x-placement': data.placement\n  };\n\n  // Update `data` attributes, styles and arrowStyles\n  data.attributes = _extends({}, attributes, data.attributes);\n  data.styles = _extends({}, styles, data.styles);\n  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);\n\n  return data;\n}\n\n/**\n * Helper used to know if the given modifier depends from another one.<br />\n * It checks if the needed modifier is listed and enabled.\n * @method\n * @memberof Popper.Utils\n * @param {Array} modifiers - list of modifiers\n * @param {String} requestingName - name of requesting modifier\n * @param {String} requestedName - name of requested modifier\n * @returns {Boolean}\n */\nfunction isModifierRequired(modifiers, requestingName, requestedName) {\n  var requesting = find(modifiers, function (_ref) {\n    var name = _ref.name;\n    return name === requestingName;\n  });\n\n  var isRequired = !!requesting && modifiers.some(function (modifier) {\n    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;\n  });\n\n  if (!isRequired) {\n    var _requesting = '`' + requestingName + '`';\n    var requested = '`' + requestedName + '`';\n    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');\n  }\n  return isRequired;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction arrow(data, options) {\n  var _data$offsets$arrow;\n\n  // arrow depends on keepTogether in order to work\n  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {\n    return data;\n  }\n\n  var arrowElement = options.element;\n\n  // if arrowElement is a string, suppose it's a CSS selector\n  if (typeof arrowElement === 'string') {\n    arrowElement = data.instance.popper.querySelector(arrowElement);\n\n    // if arrowElement is not found, don't run the modifier\n    if (!arrowElement) {\n      return data;\n    }\n  } else {\n    // if the arrowElement isn't a query selector we must check that the\n    // provided DOM node is child of its popper node\n    if (!data.instance.popper.contains(arrowElement)) {\n      console.warn('WARNING: `arrow.element` must be child of its popper element!');\n      return data;\n    }\n  }\n\n  var placement = data.placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isVertical = ['left', 'right'].indexOf(placement) !== -1;\n\n  var len = isVertical ? 'height' : 'width';\n  var sideCapitalized = isVertical ? 'Top' : 'Left';\n  var side = sideCapitalized.toLowerCase();\n  var altSide = isVertical ? 'left' : 'top';\n  var opSide = isVertical ? 'bottom' : 'right';\n  var arrowElementSize = getOuterSizes(arrowElement)[len];\n\n  //\n  // extends keepTogether behavior making sure the popper and its\n  // reference have enough pixels in conjunction\n  //\n\n  // top/left side\n  if (reference[opSide] - arrowElementSize < popper[side]) {\n    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);\n  }\n  // bottom/right side\n  if (reference[side] + arrowElementSize > popper[opSide]) {\n    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];\n  }\n  data.offsets.popper = getClientRect(data.offsets.popper);\n\n  // compute center of the popper\n  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;\n\n  // Compute the sideValue using the updated popper offsets\n  // take popper margin in account because we don't have this info available\n  var css = getStyleComputedProperty(data.instance.popper);\n  var popperMarginSide = parseFloat(css['margin' + sideCapitalized]);\n  var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width']);\n  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;\n\n  // prevent arrowElement from being placed not contiguously to its popper\n  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);\n\n  data.arrowElement = arrowElement;\n  data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);\n\n  return data;\n}\n\n/**\n * Get the opposite placement variation of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement variation\n * @returns {String} flipped placement variation\n */\nfunction getOppositeVariation(variation) {\n  if (variation === 'end') {\n    return 'start';\n  } else if (variation === 'start') {\n    return 'end';\n  }\n  return variation;\n}\n\n/**\n * List of accepted placements to use as values of the `placement` option.<br />\n * Valid placements are:\n * - `auto`\n * - `top`\n * - `right`\n * - `bottom`\n * - `left`\n *\n * Each placement can have a variation from this list:\n * - `-start`\n * - `-end`\n *\n * Variations are interpreted easily if you think of them as the left to right\n * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`\n * is right.<br />\n * Vertically (`left` and `right`), `start` is top and `end` is bottom.\n *\n * Some valid examples are:\n * - `top-end` (on top of reference, right aligned)\n * - `right-start` (on right of reference, top aligned)\n * - `bottom` (on bottom, centered)\n * - `auto-end` (on the side with more space available, alignment depends by placement)\n *\n * @static\n * @type {Array}\n * @enum {String}\n * @readonly\n * @method placements\n * @memberof Popper\n */\nvar placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];\n\n// Get rid of `auto` `auto-start` and `auto-end`\nvar validPlacements = placements.slice(3);\n\n/**\n * Given an initial placement, returns all the subsequent placements\n * clockwise (or counter-clockwise).\n *\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement - A valid placement (it accepts variations)\n * @argument {Boolean} counter - Set to true to walk the placements counterclockwise\n * @returns {Array} placements including their variations\n */\nfunction clockwise(placement) {\n  var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var index = validPlacements.indexOf(placement);\n  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));\n  return counter ? arr.reverse() : arr;\n}\n\nvar BEHAVIORS = {\n  FLIP: 'flip',\n  CLOCKWISE: 'clockwise',\n  COUNTERCLOCKWISE: 'counterclockwise'\n};\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction flip(data, options) {\n  // if `inner` modifier is enabled, we can't use the `flip` modifier\n  if (isModifierEnabled(data.instance.modifiers, 'inner')) {\n    return data;\n  }\n\n  if (data.flipped && data.placement === data.originalPlacement) {\n    // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides\n    return data;\n  }\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);\n\n  var placement = data.placement.split('-')[0];\n  var placementOpposite = getOppositePlacement(placement);\n  var variation = data.placement.split('-')[1] || '';\n\n  var flipOrder = [];\n\n  switch (options.behavior) {\n    case BEHAVIORS.FLIP:\n      flipOrder = [placement, placementOpposite];\n      break;\n    case BEHAVIORS.CLOCKWISE:\n      flipOrder = clockwise(placement);\n      break;\n    case BEHAVIORS.COUNTERCLOCKWISE:\n      flipOrder = clockwise(placement, true);\n      break;\n    default:\n      flipOrder = options.behavior;\n  }\n\n  flipOrder.forEach(function (step, index) {\n    if (placement !== step || flipOrder.length === index + 1) {\n      return data;\n    }\n\n    placement = data.placement.split('-')[0];\n    placementOpposite = getOppositePlacement(placement);\n\n    var popperOffsets = data.offsets.popper;\n    var refOffsets = data.offsets.reference;\n\n    // using floor because the reference offsets may contain decimals we are not going to consider here\n    var floor = Math.floor;\n    var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);\n\n    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);\n    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);\n    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);\n    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);\n\n    var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;\n\n    // flip the variation if required\n    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n\n    // flips variation if reference element overflows boundaries\n    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);\n\n    // flips variation if popper content overflows boundaries\n    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);\n\n    var flippedVariation = flippedVariationByRef || flippedVariationByContent;\n\n    if (overlapsRef || overflowsBoundaries || flippedVariation) {\n      // this boolean to detect any flip loop\n      data.flipped = true;\n\n      if (overlapsRef || overflowsBoundaries) {\n        placement = flipOrder[index + 1];\n      }\n\n      if (flippedVariation) {\n        variation = getOppositeVariation(variation);\n      }\n\n      data.placement = placement + (variation ? '-' + variation : '');\n\n      // this object contains `position`, we want to preserve it along with\n      // any additional property we may add in the future\n      data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));\n\n      data = runModifiers(data.instance.modifiers, data, 'flip');\n    }\n  });\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction keepTogether(data) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var placement = data.placement.split('-')[0];\n  var floor = Math.floor;\n  var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n  var side = isVertical ? 'right' : 'bottom';\n  var opSide = isVertical ? 'left' : 'top';\n  var measurement = isVertical ? 'width' : 'height';\n\n  if (popper[side] < floor(reference[opSide])) {\n    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];\n  }\n  if (popper[opSide] > floor(reference[side])) {\n    data.offsets.popper[opSide] = floor(reference[side]);\n  }\n\n  return data;\n}\n\n/**\n * Converts a string containing value + unit into a px value number\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} str - Value + unit string\n * @argument {String} measurement - `height` or `width`\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @returns {Number|String}\n * Value in pixels, or original string if no values were extracted\n */\nfunction toValue(str, measurement, popperOffsets, referenceOffsets) {\n  // separate value from unit\n  var split = str.match(/((?:\\-|\\+)?\\d*\\.?\\d*)(.*)/);\n  var value = +split[1];\n  var unit = split[2];\n\n  // If it's not a number it's an operator, I guess\n  if (!value) {\n    return str;\n  }\n\n  if (unit.indexOf('%') === 0) {\n    var element = void 0;\n    switch (unit) {\n      case '%p':\n        element = popperOffsets;\n        break;\n      case '%':\n      case '%r':\n      default:\n        element = referenceOffsets;\n    }\n\n    var rect = getClientRect(element);\n    return rect[measurement] / 100 * value;\n  } else if (unit === 'vh' || unit === 'vw') {\n    // if is a vh or vw, we calculate the size based on the viewport\n    var size = void 0;\n    if (unit === 'vh') {\n      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);\n    } else {\n      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n    }\n    return size / 100 * value;\n  } else {\n    // if is an explicit pixel unit, we get rid of the unit and keep the value\n    // if is an implicit unit, it's px, and we return just the value\n    return value;\n  }\n}\n\n/**\n * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} offset\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @argument {String} basePlacement\n * @returns {Array} a two cells array with x and y offsets in numbers\n */\nfunction parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {\n  var offsets = [0, 0];\n\n  // Use height if placement is left or right and index is 0 otherwise use width\n  // in this way the first offset will use an axis and the second one\n  // will use the other one\n  var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;\n\n  // Split the offset string to obtain a list of values and operands\n  // The regex addresses values with the plus or minus sign in front (+10, -20, etc)\n  var fragments = offset.split(/(\\+|\\-)/).map(function (frag) {\n    return frag.trim();\n  });\n\n  // Detect if the offset string contains a pair of values or a single one\n  // they could be separated by comma or space\n  var divider = fragments.indexOf(find(fragments, function (frag) {\n    return frag.search(/,|\\s/) !== -1;\n  }));\n\n  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {\n    console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');\n  }\n\n  // If divider is found, we divide the list of values and operands to divide\n  // them by ofset X and Y.\n  var splitRegex = /\\s*,\\s*|\\s+/;\n  var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];\n\n  // Convert the values with units to absolute pixels to allow our computations\n  ops = ops.map(function (op, index) {\n    // Most of the units rely on the orientation of the popper\n    var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';\n    var mergeWithPrevious = false;\n    return op\n    // This aggregates any `+` or `-` sign that aren't considered operators\n    // e.g.: 10 + +5 => [10, +, +5]\n    .reduce(function (a, b) {\n      if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {\n        a[a.length - 1] = b;\n        mergeWithPrevious = true;\n        return a;\n      } else if (mergeWithPrevious) {\n        a[a.length - 1] += b;\n        mergeWithPrevious = false;\n        return a;\n      } else {\n        return a.concat(b);\n      }\n    }, [])\n    // Here we convert the string values into number values (in px)\n    .map(function (str) {\n      return toValue(str, measurement, popperOffsets, referenceOffsets);\n    });\n  });\n\n  // Loop trough the offsets arrays and execute the operations\n  ops.forEach(function (op, index) {\n    op.forEach(function (frag, index2) {\n      if (isNumeric(frag)) {\n        offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);\n      }\n    });\n  });\n  return offsets;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @argument {Number|String} options.offset=0\n * The offset value as described in the modifier description\n * @returns {Object} The data object, properly modified\n */\nfunction offset(data, _ref) {\n  var offset = _ref.offset;\n  var placement = data.placement,\n      _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var basePlacement = placement.split('-')[0];\n\n  var offsets = void 0;\n  if (isNumeric(+offset)) {\n    offsets = [+offset, 0];\n  } else {\n    offsets = parseOffset(offset, popper, reference, basePlacement);\n  }\n\n  if (basePlacement === 'left') {\n    popper.top += offsets[0];\n    popper.left -= offsets[1];\n  } else if (basePlacement === 'right') {\n    popper.top += offsets[0];\n    popper.left += offsets[1];\n  } else if (basePlacement === 'top') {\n    popper.left += offsets[0];\n    popper.top -= offsets[1];\n  } else if (basePlacement === 'bottom') {\n    popper.left += offsets[0];\n    popper.top += offsets[1];\n  }\n\n  data.popper = popper;\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction preventOverflow(data, options) {\n  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);\n\n  // If offsetParent is the reference element, we really want to\n  // go one step up and use the next offsetParent as reference to\n  // avoid to make this modifier completely useless and look like broken\n  if (data.instance.reference === boundariesElement) {\n    boundariesElement = getOffsetParent(boundariesElement);\n  }\n\n  // NOTE: DOM access here\n  // resets the popper's position so that the document size can be calculated excluding\n  // the size of the popper element itself\n  var transformProp = getSupportedPropertyName('transform');\n  var popperStyles = data.instance.popper.style; // assignment to help minification\n  var top = popperStyles.top,\n      left = popperStyles.left,\n      transform = popperStyles[transformProp];\n\n  popperStyles.top = '';\n  popperStyles.left = '';\n  popperStyles[transformProp] = '';\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);\n\n  // NOTE: DOM access here\n  // restores the original style properties after the offsets have been computed\n  popperStyles.top = top;\n  popperStyles.left = left;\n  popperStyles[transformProp] = transform;\n\n  options.boundaries = boundaries;\n\n  var order = options.priority;\n  var popper = data.offsets.popper;\n\n  var check = {\n    primary: function primary(placement) {\n      var value = popper[placement];\n      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {\n        value = Math.max(popper[placement], boundaries[placement]);\n      }\n      return defineProperty({}, placement, value);\n    },\n    secondary: function secondary(placement) {\n      var mainSide = placement === 'right' ? 'left' : 'top';\n      var value = popper[mainSide];\n      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {\n        value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));\n      }\n      return defineProperty({}, mainSide, value);\n    }\n  };\n\n  order.forEach(function (placement) {\n    var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';\n    popper = _extends({}, popper, check[side](placement));\n  });\n\n  data.offsets.popper = popper;\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction shift(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var shiftvariation = placement.split('-')[1];\n\n  // if shift shiftvariation is specified, run the modifier\n  if (shiftvariation) {\n    var _data$offsets = data.offsets,\n        reference = _data$offsets.reference,\n        popper = _data$offsets.popper;\n\n    var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;\n    var side = isVertical ? 'left' : 'top';\n    var measurement = isVertical ? 'width' : 'height';\n\n    var shiftOffsets = {\n      start: defineProperty({}, side, reference[side]),\n      end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])\n    };\n\n    data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction hide(data) {\n  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {\n    return data;\n  }\n\n  var refRect = data.offsets.reference;\n  var bound = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'preventOverflow';\n  }).boundaries;\n\n  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === true) {\n      return data;\n    }\n\n    data.hide = true;\n    data.attributes['x-out-of-boundaries'] = '';\n  } else {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === false) {\n      return data;\n    }\n\n    data.hide = false;\n    data.attributes['x-out-of-boundaries'] = false;\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction inner(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;\n\n  var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;\n\n  popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);\n\n  data.placement = getOppositePlacement(placement);\n  data.offsets.popper = getClientRect(popper);\n\n  return data;\n}\n\n/**\n * Modifier function, each modifier can have a function of this type assigned\n * to its `fn` property.<br />\n * These functions will be called on each update, this means that you must\n * make sure they are performant enough to avoid performance bottlenecks.\n *\n * @function ModifierFn\n * @argument {dataObject} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {dataObject} The data object, properly modified\n */\n\n/**\n * Modifiers are plugins used to alter the behavior of your poppers.<br />\n * Popper.js uses a set of 9 modifiers to provide all the basic functionalities\n * needed by the library.\n *\n * Usually you don't want to override the `order`, `fn` and `onLoad` props.\n * All the other properties are configurations that could be tweaked.\n * @namespace modifiers\n */\nvar modifiers = {\n  /**\n   * Modifier used to shift the popper on the start or end of its reference\n   * element.<br />\n   * It will read the variation of the `placement` property.<br />\n   * It can be one either `-end` or `-start`.\n   * @memberof modifiers\n   * @inner\n   */\n  shift: {\n    /** @prop {number} order=100 - Index used to define the order of execution */\n    order: 100,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: shift\n  },\n\n  /**\n   * The `offset` modifier can shift your popper on both its axis.\n   *\n   * It accepts the following units:\n   * - `px` or unit-less, interpreted as pixels\n   * - `%` or `%r`, percentage relative to the length of the reference element\n   * - `%p`, percentage relative to the length of the popper element\n   * - `vw`, CSS viewport width unit\n   * - `vh`, CSS viewport height unit\n   *\n   * For length is intended the main axis relative to the placement of the popper.<br />\n   * This means that if the placement is `top` or `bottom`, the length will be the\n   * `width`. In case of `left` or `right`, it will be the `height`.\n   *\n   * You can provide a single value (as `Number` or `String`), or a pair of values\n   * as `String` divided by a comma or one (or more) white spaces.<br />\n   * The latter is a deprecated method because it leads to confusion and will be\n   * removed in v2.<br />\n   * Additionally, it accepts additions and subtractions between different units.\n   * Note that multiplications and divisions aren't supported.\n   *\n   * Valid examples are:\n   * ```\n   * 10\n   * '10%'\n   * '10, 10'\n   * '10%, 10'\n   * '10 + 10%'\n   * '10 - 5vh + 3%'\n   * '-10px + 5vh, 5px - 6%'\n   * ```\n   * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap\n   * > with their reference element, unfortunately, you will have to disable the `flip` modifier.\n   * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  offset: {\n    /** @prop {number} order=200 - Index used to define the order of execution */\n    order: 200,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: offset,\n    /** @prop {Number|String} offset=0\n     * The offset value as described in the modifier description\n     */\n    offset: 0\n  },\n\n  /**\n   * Modifier used to prevent the popper from being positioned outside the boundary.\n   *\n   * A scenario exists where the reference itself is not within the boundaries.<br />\n   * We can say it has \"escaped the boundaries\" — or just \"escaped\".<br />\n   * In this case we need to decide whether the popper should either:\n   *\n   * - detach from the reference and remain \"trapped\" in the boundaries, or\n   * - if it should ignore the boundary and \"escape with its reference\"\n   *\n   * When `escapeWithReference` is set to`true` and reference is completely\n   * outside its boundaries, the popper will overflow (or completely leave)\n   * the boundaries in order to remain attached to the edge of the reference.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  preventOverflow: {\n    /** @prop {number} order=300 - Index used to define the order of execution */\n    order: 300,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: preventOverflow,\n    /**\n     * @prop {Array} [priority=['left','right','top','bottom']]\n     * Popper will try to prevent overflow following these priorities by default,\n     * then, it could overflow on the left and on top of the `boundariesElement`\n     */\n    priority: ['left', 'right', 'top', 'bottom'],\n    /**\n     * @prop {number} padding=5\n     * Amount of pixel used to define a minimum distance between the boundaries\n     * and the popper. This makes sure the popper always has a little padding\n     * between the edges of its container\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='scrollParent'\n     * Boundaries used by the modifier. Can be `scrollParent`, `window`,\n     * `viewport` or any DOM element.\n     */\n    boundariesElement: 'scrollParent'\n  },\n\n  /**\n   * Modifier used to make sure the reference and its popper stay near each other\n   * without leaving any gap between the two. Especially useful when the arrow is\n   * enabled and you want to ensure that it points to its reference element.\n   * It cares only about the first axis. You can still have poppers with margin\n   * between the popper and its reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  keepTogether: {\n    /** @prop {number} order=400 - Index used to define the order of execution */\n    order: 400,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: keepTogether\n  },\n\n  /**\n   * This modifier is used to move the `arrowElement` of the popper to make\n   * sure it is positioned between the reference element and its popper element.\n   * It will read the outer size of the `arrowElement` node to detect how many\n   * pixels of conjunction are needed.\n   *\n   * It has no effect if no `arrowElement` is provided.\n   * @memberof modifiers\n   * @inner\n   */\n  arrow: {\n    /** @prop {number} order=500 - Index used to define the order of execution */\n    order: 500,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: arrow,\n    /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */\n    element: '[x-arrow]'\n  },\n\n  /**\n   * Modifier used to flip the popper's placement when it starts to overlap its\n   * reference element.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   *\n   * **NOTE:** this modifier will interrupt the current update cycle and will\n   * restart it if it detects the need to flip the placement.\n   * @memberof modifiers\n   * @inner\n   */\n  flip: {\n    /** @prop {number} order=600 - Index used to define the order of execution */\n    order: 600,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: flip,\n    /**\n     * @prop {String|Array} behavior='flip'\n     * The behavior used to change the popper's placement. It can be one of\n     * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid\n     * placements (with optional variations)\n     */\n    behavior: 'flip',\n    /**\n     * @prop {number} padding=5\n     * The popper will flip if it hits the edges of the `boundariesElement`\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='viewport'\n     * The element which will define the boundaries of the popper position.\n     * The popper will never be placed outside of the defined boundaries\n     * (except if `keepTogether` is enabled)\n     */\n    boundariesElement: 'viewport',\n    /**\n     * @prop {Boolean} flipVariations=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the reference element overlaps its boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariations: false,\n    /**\n     * @prop {Boolean} flipVariationsByContent=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the popper element overlaps its reference boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariationsByContent: false\n  },\n\n  /**\n   * Modifier used to make the popper flow toward the inner of the reference element.\n   * By default, when this modifier is disabled, the popper will be placed outside\n   * the reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  inner: {\n    /** @prop {number} order=700 - Index used to define the order of execution */\n    order: 700,\n    /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */\n    enabled: false,\n    /** @prop {ModifierFn} */\n    fn: inner\n  },\n\n  /**\n   * Modifier used to hide the popper when its reference element is outside of the\n   * popper boundaries. It will set a `x-out-of-boundaries` attribute which can\n   * be used to hide with a CSS selector the popper when its reference is\n   * out of boundaries.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   * @memberof modifiers\n   * @inner\n   */\n  hide: {\n    /** @prop {number} order=800 - Index used to define the order of execution */\n    order: 800,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: hide\n  },\n\n  /**\n   * Computes the style that will be applied to the popper element to gets\n   * properly positioned.\n   *\n   * Note that this modifier will not touch the DOM, it just prepares the styles\n   * so that `applyStyle` modifier can apply it. This separation is useful\n   * in case you need to replace `applyStyle` with a custom implementation.\n   *\n   * This modifier has `850` as `order` value to maintain backward compatibility\n   * with previous versions of Popper.js. Expect the modifiers ordering method\n   * to change in future major versions of the library.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  computeStyle: {\n    /** @prop {number} order=850 - Index used to define the order of execution */\n    order: 850,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: computeStyle,\n    /**\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: true,\n    /**\n     * @prop {string} [x='bottom']\n     * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.\n     * Change this if your popper should grow in a direction different from `bottom`\n     */\n    x: 'bottom',\n    /**\n     * @prop {string} [x='left']\n     * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.\n     * Change this if your popper should grow in a direction different from `right`\n     */\n    y: 'right'\n  },\n\n  /**\n   * Applies the computed styles to the popper element.\n   *\n   * All the DOM manipulations are limited to this modifier. This is useful in case\n   * you want to integrate Popper.js inside a framework or view library and you\n   * want to delegate all the DOM manipulations to it.\n   *\n   * Note that if you disable this modifier, you must make sure the popper element\n   * has its position set to `absolute` before Popper.js can do its work!\n   *\n   * Just disable this modifier and define your own to achieve the desired effect.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  applyStyle: {\n    /** @prop {number} order=900 - Index used to define the order of execution */\n    order: 900,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: applyStyle,\n    /** @prop {Function} */\n    onLoad: applyStyleOnLoad,\n    /**\n     * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: undefined\n  }\n};\n\n/**\n * The `dataObject` is an object containing all the information used by Popper.js.\n * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.\n * @name dataObject\n * @property {Object} data.instance The Popper.js instance\n * @property {String} data.placement Placement applied to popper\n * @property {String} data.originalPlacement Placement originally defined on init\n * @property {Boolean} data.flipped True if popper has been flipped by flip modifier\n * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper\n * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier\n * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.boundaries Offsets of the popper boundaries\n * @property {Object} data.offsets The measurements of popper, reference and arrow elements\n * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0\n */\n\n/**\n * Default options provided to Popper.js constructor.<br />\n * These can be overridden using the `options` argument of Popper.js.<br />\n * To override an option, simply pass an object with the same\n * structure of the `options` object, as the 3rd argument. For example:\n * ```\n * new Popper(ref, pop, {\n *   modifiers: {\n *     preventOverflow: { enabled: false }\n *   }\n * })\n * ```\n * @type {Object}\n * @static\n * @memberof Popper\n */\nvar Defaults = {\n  /**\n   * Popper's placement.\n   * @prop {Popper.placements} placement='bottom'\n   */\n  placement: 'bottom',\n\n  /**\n   * Set this to true if you want popper to position it self in 'fixed' mode\n   * @prop {Boolean} positionFixed=false\n   */\n  positionFixed: false,\n\n  /**\n   * Whether events (resize, scroll) are initially enabled.\n   * @prop {Boolean} eventsEnabled=true\n   */\n  eventsEnabled: true,\n\n  /**\n   * Set to true if you want to automatically remove the popper when\n   * you call the `destroy` method.\n   * @prop {Boolean} removeOnDestroy=false\n   */\n  removeOnDestroy: false,\n\n  /**\n   * Callback called when the popper is created.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onCreate}\n   */\n  onCreate: function onCreate() {},\n\n  /**\n   * Callback called when the popper is updated. This callback is not called\n   * on the initialization/creation of the popper, but only on subsequent\n   * updates.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onUpdate}\n   */\n  onUpdate: function onUpdate() {},\n\n  /**\n   * List of modifiers used to modify the offsets before they are applied to the popper.\n   * They provide most of the functionalities of Popper.js.\n   * @prop {modifiers}\n   */\n  modifiers: modifiers\n};\n\n/**\n * @callback onCreate\n * @param {dataObject} data\n */\n\n/**\n * @callback onUpdate\n * @param {dataObject} data\n */\n\n// Utils\n// Methods\nvar Popper = function () {\n  /**\n   * Creates a new Popper.js instance.\n   * @class Popper\n   * @param {Element|referenceObject} reference - The reference element used to position the popper\n   * @param {Element} popper - The HTML / XML element used as the popper\n   * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)\n   * @return {Object} instance - The generated Popper.js instance\n   */\n  function Popper(reference, popper) {\n    var _this = this;\n\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    classCallCheck(this, Popper);\n\n    this.scheduleUpdate = function () {\n      return requestAnimationFrame(_this.update);\n    };\n\n    // make update() debounced, so that it only runs at most once-per-tick\n    this.update = debounce(this.update.bind(this));\n\n    // with {} we create a new object with the options inside it\n    this.options = _extends({}, Popper.Defaults, options);\n\n    // init state\n    this.state = {\n      isDestroyed: false,\n      isCreated: false,\n      scrollParents: []\n    };\n\n    // get reference and popper elements (allow jQuery wrappers)\n    this.reference = reference && reference.jquery ? reference[0] : reference;\n    this.popper = popper && popper.jquery ? popper[0] : popper;\n\n    // Deep merge modifiers options\n    this.options.modifiers = {};\n    Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {\n      _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});\n    });\n\n    // Refactoring modifiers' list (Object => Array)\n    this.modifiers = Object.keys(this.options.modifiers).map(function (name) {\n      return _extends({\n        name: name\n      }, _this.options.modifiers[name]);\n    })\n    // sort the modifiers by order\n    .sort(function (a, b) {\n      return a.order - b.order;\n    });\n\n    // modifiers have the ability to execute arbitrary code when Popper.js get inited\n    // such code is executed in the same order of its modifier\n    // they could add new properties to their options configuration\n    // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!\n    this.modifiers.forEach(function (modifierOptions) {\n      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {\n        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);\n      }\n    });\n\n    // fire the first update to position the popper in the right place\n    this.update();\n\n    var eventsEnabled = this.options.eventsEnabled;\n    if (eventsEnabled) {\n      // setup event listeners, they will take care of update the position in specific situations\n      this.enableEventListeners();\n    }\n\n    this.state.eventsEnabled = eventsEnabled;\n  }\n\n  // We can't use class properties because they don't get listed in the\n  // class prototype and break stuff like Sinon stubs\n\n\n  createClass(Popper, [{\n    key: 'update',\n    value: function update$$1() {\n      return update.call(this);\n    }\n  }, {\n    key: 'destroy',\n    value: function destroy$$1() {\n      return destroy.call(this);\n    }\n  }, {\n    key: 'enableEventListeners',\n    value: function enableEventListeners$$1() {\n      return enableEventListeners.call(this);\n    }\n  }, {\n    key: 'disableEventListeners',\n    value: function disableEventListeners$$1() {\n      return disableEventListeners.call(this);\n    }\n\n    /**\n     * Schedules an update. It will run on the next UI update available.\n     * @method scheduleUpdate\n     * @memberof Popper\n     */\n\n\n    /**\n     * Collection of utilities useful when writing custom modifiers.\n     * Starting from version 1.7, this method is available only if you\n     * include `popper-utils.js` before `popper.js`.\n     *\n     * **DEPRECATION**: This way to access PopperUtils is deprecated\n     * and will be removed in v2! Use the PopperUtils module directly instead.\n     * Due to the high instability of the methods contained in Utils, we can't\n     * guarantee them to follow semver. Use them at your own risk!\n     * @static\n     * @private\n     * @type {Object}\n     * @deprecated since version 1.8\n     * @member Utils\n     * @memberof Popper\n     */\n\n  }]);\n  return Popper;\n}();\n\n/**\n * The `referenceObject` is an object that provides an interface compatible with Popper.js\n * and lets you use it as replacement of a real DOM node.<br />\n * You can use this method to position a popper relatively to a set of coordinates\n * in case you don't have a DOM node to use as reference.\n *\n * ```\n * new Popper(referenceObject, popperNode);\n * ```\n *\n * NB: This feature isn't supported in Internet Explorer 10.\n * @name referenceObject\n * @property {Function} data.getBoundingClientRect\n * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.\n * @property {number} data.clientWidth\n * An ES6 getter that will return the width of the virtual reference element.\n * @property {number} data.clientHeight\n * An ES6 getter that will return the height of the virtual reference element.\n */\n\n\nPopper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;\nPopper.placements = placements;\nPopper.Defaults = Defaults;\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (Popper);\n//# sourceMappingURL=popper.js.map\n\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(66)))\n\n/***/ }),\n\n/***/ 423:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _calendar = __webpack_require__(424);\n\nObject.defineProperty(exports, 'calendar', {\n  enumerable: true,\n  get: function get() {\n    return _interopRequireDefault(_calendar).default;\n  }\n});\n\nvar _select = __webpack_require__(426);\n\nObject.defineProperty(exports, 'select', {\n  enumerable: true,\n  get: function get() {\n    return _interopRequireDefault(_select).default;\n  }\n});\n\nvar _tooltip = __webpack_require__(453);\n\nObject.defineProperty(exports, 'tooltip', {\n  enumerable: true,\n  get: function get() {\n    return _interopRequireDefault(_tooltip).default;\n  }\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/***/ }),\n\n/***/ 424:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /* eslint-disable no-unused-vars */\n\n\nexports.default = calendar;\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _pikaday = __webpack_require__(425);\n\nvar _pikaday2 = _interopRequireDefault(_pikaday);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar defaults = {\n  firstDay: 1,\n  position: 'bottom right',\n  theme: 'netc-calendar-theme'\n};\n\nfunction calendar(fieldSelector, triggerSelector) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  var $date = (0, _jquery2.default)(selector); // eslint-disable-line\n  var $trigger = (0, _jquery2.default)(triggerSelector);\n\n  var locals = _extends({}, defaults, options);\n\n  locals.field = $date[0];\n  locals.trigger = $trigger[0];\n\n  if (!$date.length) {\n    return;\n  }\n\n  if (!Modernizr.mq('(min-width: 1025px)')) {\n    return;\n  }\n\n  return new _pikaday2.default(locals); // eslint-disable-line\n}\n\n/***/ }),\n\n/***/ 425:\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Pikaday\n *\n * Copyright © 2014 David Bushell | BSD & MIT license | https://github.com/Pikaday/Pikaday\n */\n\n(function (root, factory)\n{\n    'use strict';\n\n    var moment;\n    if (true) {\n        // CommonJS module\n        // Load moment.js as an optional dependency\n        try { moment = __webpack_require__(!(function webpackMissingModule() { var e = new Error(\"Cannot find module \\\"moment\\\"\"); e.code = 'MODULE_NOT_FOUND'; throw e; }())); } catch (e) {}\n        module.exports = factory(moment);\n    } else if (typeof define === 'function' && define.amd) {\n        // AMD. Register as an anonymous module.\n        define(function (req)\n        {\n            // Load moment.js as an optional dependency\n            var id = 'moment';\n            try { moment = req(id); } catch (e) {}\n            return factory(moment);\n        });\n    } else {\n        root.Pikaday = factory(root.moment);\n    }\n}(this, function (moment)\n{\n    'use strict';\n\n    /**\n     * feature detection and helper functions\n     */\n    var hasMoment = typeof moment === 'function',\n\n    hasEventListeners = !!window.addEventListener,\n\n    document = window.document,\n\n    sto = window.setTimeout,\n\n    addEvent = function(el, e, callback, capture)\n    {\n        if (hasEventListeners) {\n            el.addEventListener(e, callback, !!capture);\n        } else {\n            el.attachEvent('on' + e, callback);\n        }\n    },\n\n    removeEvent = function(el, e, callback, capture)\n    {\n        if (hasEventListeners) {\n            el.removeEventListener(e, callback, !!capture);\n        } else {\n            el.detachEvent('on' + e, callback);\n        }\n    },\n\n    trim = function(str)\n    {\n        return str.trim ? str.trim() : str.replace(/^\\s+|\\s+$/g,'');\n    },\n\n    hasClass = function(el, cn)\n    {\n        return (' ' + el.className + ' ').indexOf(' ' + cn + ' ') !== -1;\n    },\n\n    addClass = function(el, cn)\n    {\n        if (!hasClass(el, cn)) {\n            el.className = (el.className === '') ? cn : el.className + ' ' + cn;\n        }\n    },\n\n    removeClass = function(el, cn)\n    {\n        el.className = trim((' ' + el.className + ' ').replace(' ' + cn + ' ', ' '));\n    },\n\n    isArray = function(obj)\n    {\n        return (/Array/).test(Object.prototype.toString.call(obj));\n    },\n\n    isDate = function(obj)\n    {\n        return (/Date/).test(Object.prototype.toString.call(obj)) && !isNaN(obj.getTime());\n    },\n\n    isWeekend = function(date)\n    {\n        var day = date.getDay();\n        return day === 0 || day === 6;\n    },\n\n    isLeapYear = function(year)\n    {\n        // solution by Matti Virkkunen: http://stackoverflow.com/a/4881951\n        return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n    },\n\n    getDaysInMonth = function(year, month)\n    {\n        return [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];\n    },\n\n    setToStartOfDay = function(date)\n    {\n        if (isDate(date)) date.setHours(0,0,0,0);\n    },\n\n    compareDates = function(a,b)\n    {\n        // weak date comparison (use setToStartOfDay(date) to ensure correct result)\n        return a.getTime() === b.getTime();\n    },\n\n    extend = function(to, from, overwrite)\n    {\n        var prop, hasProp;\n        for (prop in from) {\n            hasProp = to[prop] !== undefined;\n            if (hasProp && typeof from[prop] === 'object' && from[prop] !== null && from[prop].nodeName === undefined) {\n                if (isDate(from[prop])) {\n                    if (overwrite) {\n                        to[prop] = new Date(from[prop].getTime());\n                    }\n                }\n                else if (isArray(from[prop])) {\n                    if (overwrite) {\n                        to[prop] = from[prop].slice(0);\n                    }\n                } else {\n                    to[prop] = extend({}, from[prop], overwrite);\n                }\n            } else if (overwrite || !hasProp) {\n                to[prop] = from[prop];\n            }\n        }\n        return to;\n    },\n\n    fireEvent = function(el, eventName, data)\n    {\n        var ev;\n\n        if (document.createEvent) {\n            ev = document.createEvent('HTMLEvents');\n            ev.initEvent(eventName, true, false);\n            ev = extend(ev, data);\n            el.dispatchEvent(ev);\n        } else if (document.createEventObject) {\n            ev = document.createEventObject();\n            ev = extend(ev, data);\n            el.fireEvent('on' + eventName, ev);\n        }\n    },\n\n    adjustCalendar = function(calendar) {\n        if (calendar.month < 0) {\n            calendar.year -= Math.ceil(Math.abs(calendar.month)/12);\n            calendar.month += 12;\n        }\n        if (calendar.month > 11) {\n            calendar.year += Math.floor(Math.abs(calendar.month)/12);\n            calendar.month -= 12;\n        }\n        return calendar;\n    },\n\n    /**\n     * defaults and localisation\n     */\n    defaults = {\n\n        // bind the picker to a form field\n        field: null,\n\n        // automatically show/hide the picker on `field` focus (default `true` if `field` is set)\n        bound: undefined,\n\n        // data-attribute on the input field with an aria assistance tekst (only applied when `bound` is set)\n        ariaLabel: 'Use the arrow keys to pick a date',\n\n        // position of the datepicker, relative to the field (default to bottom & left)\n        // ('bottom' & 'left' keywords are not used, 'top' & 'right' are modifier on the bottom/left position)\n        position: 'bottom left',\n\n        // automatically fit in the viewport even if it means repositioning from the position option\n        reposition: true,\n\n        // the default output format for `.toString()` and `field` value\n        format: 'YYYY-MM-DD',\n\n        // the toString function which gets passed a current date object and format\n        // and returns a string\n        toString: null,\n\n        // used to create date object from current input string\n        parse: null,\n\n        // the initial date to view when first opened\n        defaultDate: null,\n\n        // make the `defaultDate` the initial selected value\n        setDefaultDate: false,\n\n        // first day of week (0: Sunday, 1: Monday etc)\n        firstDay: 0,\n\n        // the default flag for moment's strict date parsing\n        formatStrict: false,\n\n        // the minimum/earliest date that can be selected\n        minDate: null,\n        // the maximum/latest date that can be selected\n        maxDate: null,\n\n        // number of years either side, or array of upper/lower range\n        yearRange: 10,\n\n        // show week numbers at head of row\n        showWeekNumber: false,\n\n        // Week picker mode\n        pickWholeWeek: false,\n\n        // used internally (don't config outside)\n        minYear: 0,\n        maxYear: 9999,\n        minMonth: undefined,\n        maxMonth: undefined,\n\n        startRange: null,\n        endRange: null,\n\n        isRTL: false,\n\n        // Additional text to append to the year in the calendar title\n        yearSuffix: '',\n\n        // Render the month after year in the calendar title\n        showMonthAfterYear: false,\n\n        // Render days of the calendar grid that fall in the next or previous month\n        showDaysInNextAndPreviousMonths: false,\n\n        // Allows user to select days that fall in the next or previous month\n        enableSelectionDaysInNextAndPreviousMonths: false,\n\n        // how many months are visible\n        numberOfMonths: 1,\n\n        // when numberOfMonths is used, this will help you to choose where the main calendar will be (default `left`, can be set to `right`)\n        // only used for the first display or when a selected date is not visible\n        mainCalendar: 'left',\n\n        // Specify a DOM element to render the calendar in\n        container: undefined,\n\n        // Blur field when date is selected\n        blurFieldOnSelect : true,\n\n        // internationalization\n        i18n: {\n            previousMonth : 'Previous Month',\n            nextMonth     : 'Next Month',\n            months        : ['January','February','March','April','May','June','July','August','September','October','November','December'],\n            weekdays      : ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],\n            weekdaysShort : ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']\n        },\n\n        // Theme Classname\n        theme: null,\n\n        // events array\n        events: [],\n\n        // callback function\n        onSelect: null,\n        onOpen: null,\n        onClose: null,\n        onDraw: null,\n\n        // Enable keyboard input\n        keyboardInput: true\n    },\n\n\n    /**\n     * templating functions to abstract HTML rendering\n     */\n    renderDayName = function(opts, day, abbr)\n    {\n        day += opts.firstDay;\n        while (day >= 7) {\n            day -= 7;\n        }\n        return abbr ? opts.i18n.weekdaysShort[day] : opts.i18n.weekdays[day];\n    },\n\n    renderDay = function(opts)\n    {\n        var arr = [];\n        var ariaSelected = 'false';\n        if (opts.isEmpty) {\n            if (opts.showDaysInNextAndPreviousMonths) {\n                arr.push('is-outside-current-month');\n\n                if(!opts.enableSelectionDaysInNextAndPreviousMonths) {\n                    arr.push('is-selection-disabled');\n                }\n\n            } else {\n                return '<td class=\"is-empty\"></td>';\n            }\n        }\n        if (opts.isDisabled) {\n            arr.push('is-disabled');\n        }\n        if (opts.isToday) {\n            arr.push('is-today');\n        }\n        if (opts.isSelected) {\n            arr.push('is-selected');\n            ariaSelected = 'true';\n        }\n        if (opts.hasEvent) {\n            arr.push('has-event');\n        }\n        if (opts.isInRange) {\n            arr.push('is-inrange');\n        }\n        if (opts.isStartRange) {\n            arr.push('is-startrange');\n        }\n        if (opts.isEndRange) {\n            arr.push('is-endrange');\n        }\n        return '<td data-day=\"' + opts.day + '\" class=\"' + arr.join(' ') + '\" aria-selected=\"' + ariaSelected + '\">' +\n                 '<button class=\"pika-button pika-day\" type=\"button\" ' +\n                    'data-pika-year=\"' + opts.year + '\" data-pika-month=\"' + opts.month + '\" data-pika-day=\"' + opts.day + '\">' +\n                        opts.day +\n                 '</button>' +\n               '</td>';\n    },\n\n    renderWeek = function (d, m, y) {\n        // Lifted from http://javascript.about.com/library/blweekyear.htm, lightly modified.\n        var onejan = new Date(y, 0, 1),\n            weekNum = Math.ceil((((new Date(y, m, d) - onejan) / 86400000) + onejan.getDay()+1)/7);\n        return '<td class=\"pika-week\">' + weekNum + '</td>';\n    },\n\n    renderRow = function(days, isRTL, pickWholeWeek, isRowSelected)\n    {\n        return '<tr class=\"pika-row' + (pickWholeWeek ? ' pick-whole-week' : '') + (isRowSelected ? ' is-selected' : '') + '\">' + (isRTL ? days.reverse() : days).join('') + '</tr>';\n    },\n\n    renderBody = function(rows)\n    {\n        return '<tbody>' + rows.join('') + '</tbody>';\n    },\n\n    renderHead = function(opts)\n    {\n        var i, arr = [];\n        if (opts.showWeekNumber) {\n            arr.push('<th></th>');\n        }\n        for (i = 0; i < 7; i++) {\n            arr.push('<th scope=\"col\"><abbr title=\"' + renderDayName(opts, i) + '\">' + renderDayName(opts, i, true) + '</abbr></th>');\n        }\n        return '<thead><tr>' + (opts.isRTL ? arr.reverse() : arr).join('') + '</tr></thead>';\n    },\n\n    renderTitle = function(instance, c, year, month, refYear, randId)\n    {\n        var i, j, arr,\n            opts = instance._o,\n            isMinYear = year === opts.minYear,\n            isMaxYear = year === opts.maxYear,\n            html = '<div id=\"' + randId + '\" class=\"pika-title\" role=\"heading\" aria-live=\"assertive\">',\n            monthHtml,\n            yearHtml,\n            prev = true,\n            next = true;\n\n        for (arr = [], i = 0; i < 12; i++) {\n            arr.push('<option value=\"' + (year === refYear ? i - c : 12 + i - c) + '\"' +\n                (i === month ? ' selected=\"selected\"': '') +\n                ((isMinYear && i < opts.minMonth) || (isMaxYear && i > opts.maxMonth) ? 'disabled=\"disabled\"' : '') + '>' +\n                opts.i18n.months[i] + '</option>');\n        }\n\n        monthHtml = '<div class=\"pika-label\">' + opts.i18n.months[month] + '<select class=\"pika-select pika-select-month\" tabindex=\"-1\">' + arr.join('') + '</select></div>';\n\n        if (isArray(opts.yearRange)) {\n            i = opts.yearRange[0];\n            j = opts.yearRange[1] + 1;\n        } else {\n            i = year - opts.yearRange;\n            j = 1 + year + opts.yearRange;\n        }\n\n        for (arr = []; i < j && i <= opts.maxYear; i++) {\n            if (i >= opts.minYear) {\n                arr.push('<option value=\"' + i + '\"' + (i === year ? ' selected=\"selected\"': '') + '>' + (i) + '</option>');\n            }\n        }\n        yearHtml = '<div class=\"pika-label\">' + year + opts.yearSuffix + '<select class=\"pika-select pika-select-year\" tabindex=\"-1\">' + arr.join('') + '</select></div>';\n\n        if (opts.showMonthAfterYear) {\n            html += yearHtml + monthHtml;\n        } else {\n            html += monthHtml + yearHtml;\n        }\n\n        if (isMinYear && (month === 0 || opts.minMonth >= month)) {\n            prev = false;\n        }\n\n        if (isMaxYear && (month === 11 || opts.maxMonth <= month)) {\n            next = false;\n        }\n\n        if (c === 0) {\n            html += '<button class=\"pika-prev' + (prev ? '' : ' is-disabled') + '\" type=\"button\">' + opts.i18n.previousMonth + '</button>';\n        }\n        if (c === (instance._o.numberOfMonths - 1) ) {\n            html += '<button class=\"pika-next' + (next ? '' : ' is-disabled') + '\" type=\"button\">' + opts.i18n.nextMonth + '</button>';\n        }\n\n        return html += '</div>';\n    },\n\n    renderTable = function(opts, data, randId)\n    {\n        return '<table cellpadding=\"0\" cellspacing=\"0\" class=\"pika-table\" role=\"grid\" aria-labelledby=\"' + randId + '\">' + renderHead(opts) + renderBody(data) + '</table>';\n    },\n\n\n    /**\n     * Pikaday constructor\n     */\n    Pikaday = function(options)\n    {\n        var self = this,\n            opts = self.config(options);\n\n        self._onMouseDown = function(e)\n        {\n            if (!self._v) {\n                return;\n            }\n            e = e || window.event;\n            var target = e.target || e.srcElement;\n            if (!target) {\n                return;\n            }\n\n            if (!hasClass(target, 'is-disabled')) {\n                if (hasClass(target, 'pika-button') && !hasClass(target, 'is-empty') && !hasClass(target.parentNode, 'is-disabled')) {\n                    self.setDate(new Date(target.getAttribute('data-pika-year'), target.getAttribute('data-pika-month'), target.getAttribute('data-pika-day')));\n                    if (opts.bound) {\n                        sto(function() {\n                            self.hide();\n                            if (opts.blurFieldOnSelect && opts.field) {\n                                opts.field.blur();\n                            }\n                        }, 100);\n                    }\n                }\n                else if (hasClass(target, 'pika-prev')) {\n                    self.prevMonth();\n                }\n                else if (hasClass(target, 'pika-next')) {\n                    self.nextMonth();\n                }\n            }\n            if (!hasClass(target, 'pika-select')) {\n                // if this is touch event prevent mouse events emulation\n                if (e.preventDefault) {\n                    e.preventDefault();\n                } else {\n                    e.returnValue = false;\n                    return false;\n                }\n            } else {\n                self._c = true;\n            }\n        };\n\n        self._onChange = function(e)\n        {\n            e = e || window.event;\n            var target = e.target || e.srcElement;\n            if (!target) {\n                return;\n            }\n            if (hasClass(target, 'pika-select-month')) {\n                self.gotoMonth(target.value);\n            }\n            else if (hasClass(target, 'pika-select-year')) {\n                self.gotoYear(target.value);\n            }\n        };\n\n        self._onKeyChange = function(e)\n        {\n            e = e || window.event;\n\n            if (self.isVisible()) {\n\n                switch(e.keyCode){\n                    case 13:\n                    case 27:\n                        if (opts.field) {\n                            opts.field.blur();\n                        }\n                        break;\n                    case 37:\n                        e.preventDefault();\n                        self.adjustDate('subtract', 1);\n                        break;\n                    case 38:\n                        self.adjustDate('subtract', 7);\n                        break;\n                    case 39:\n                        self.adjustDate('add', 1);\n                        break;\n                    case 40:\n                        self.adjustDate('add', 7);\n                        break;\n                }\n            }\n        };\n\n        self._onInputChange = function(e)\n        {\n            var date;\n\n            if (e.firedBy === self) {\n                return;\n            }\n            if (opts.parse) {\n                date = opts.parse(opts.field.value, opts.format);\n            } else if (hasMoment) {\n                date = moment(opts.field.value, opts.format, opts.formatStrict);\n                date = (date && date.isValid()) ? date.toDate() : null;\n            }\n            else {\n                date = new Date(Date.parse(opts.field.value));\n            }\n            if (isDate(date)) {\n              self.setDate(date);\n            }\n            if (!self._v) {\n                self.show();\n            }\n        };\n\n        self._onInputFocus = function()\n        {\n            self.show();\n        };\n\n        self._onInputClick = function()\n        {\n            self.show();\n        };\n\n        self._onInputBlur = function()\n        {\n            // IE allows pika div to gain focus; catch blur the input field\n            var pEl = document.activeElement;\n            do {\n                if (hasClass(pEl, 'pika-single')) {\n                    return;\n                }\n            }\n            while ((pEl = pEl.parentNode));\n\n            if (!self._c) {\n                self._b = sto(function() {\n                    self.hide();\n                }, 50);\n            }\n            self._c = false;\n        };\n\n        self._onClick = function(e)\n        {\n            e = e || window.event;\n            var target = e.target || e.srcElement,\n                pEl = target;\n            if (!target) {\n                return;\n            }\n            if (!hasEventListeners && hasClass(target, 'pika-select')) {\n                if (!target.onchange) {\n                    target.setAttribute('onchange', 'return;');\n                    addEvent(target, 'change', self._onChange);\n                }\n            }\n            do {\n                if (hasClass(pEl, 'pika-single') || pEl === opts.trigger) {\n                    return;\n                }\n            }\n            while ((pEl = pEl.parentNode));\n            if (self._v && target !== opts.trigger && pEl !== opts.trigger) {\n                self.hide();\n            }\n        };\n\n        self.el = document.createElement('div');\n        self.el.className = 'pika-single' + (opts.isRTL ? ' is-rtl' : '') + (opts.theme ? ' ' + opts.theme : '');\n\n        addEvent(self.el, 'mousedown', self._onMouseDown, true);\n        addEvent(self.el, 'touchend', self._onMouseDown, true);\n        addEvent(self.el, 'change', self._onChange);\n\n        if (opts.keyboardInput) {\n            addEvent(document, 'keydown', self._onKeyChange);\n        }\n\n        if (opts.field) {\n            if (opts.container) {\n                opts.container.appendChild(self.el);\n            } else if (opts.bound) {\n                document.body.appendChild(self.el);\n            } else {\n                opts.field.parentNode.insertBefore(self.el, opts.field.nextSibling);\n            }\n            addEvent(opts.field, 'change', self._onInputChange);\n\n            if (!opts.defaultDate) {\n                if (hasMoment && opts.field.value) {\n                    opts.defaultDate = moment(opts.field.value, opts.format).toDate();\n                } else {\n                    opts.defaultDate = new Date(Date.parse(opts.field.value));\n                }\n                opts.setDefaultDate = true;\n            }\n        }\n\n        var defDate = opts.defaultDate;\n\n        if (isDate(defDate)) {\n            if (opts.setDefaultDate) {\n                self.setDate(defDate, true);\n            } else {\n                self.gotoDate(defDate);\n            }\n        } else {\n            self.gotoDate(new Date());\n        }\n\n        if (opts.bound) {\n            this.hide();\n            self.el.className += ' is-bound';\n            addEvent(opts.trigger, 'click', self._onInputClick);\n            addEvent(opts.trigger, 'focus', self._onInputFocus);\n            addEvent(opts.trigger, 'blur', self._onInputBlur);\n        } else {\n            this.show();\n        }\n    };\n\n\n    /**\n     * public Pikaday API\n     */\n    Pikaday.prototype = {\n\n\n        /**\n         * configure functionality\n         */\n        config: function(options)\n        {\n            if (!this._o) {\n                this._o = extend({}, defaults, true);\n            }\n\n            var opts = extend(this._o, options, true);\n\n            opts.isRTL = !!opts.isRTL;\n\n            opts.field = (opts.field && opts.field.nodeName) ? opts.field : null;\n\n            opts.theme = (typeof opts.theme) === 'string' && opts.theme ? opts.theme : null;\n\n            opts.bound = !!(opts.bound !== undefined ? opts.field && opts.bound : opts.field);\n\n            opts.trigger = (opts.trigger && opts.trigger.nodeName) ? opts.trigger : opts.field;\n\n            opts.disableWeekends = !!opts.disableWeekends;\n\n            opts.disableDayFn = (typeof opts.disableDayFn) === 'function' ? opts.disableDayFn : null;\n\n            var nom = parseInt(opts.numberOfMonths, 10) || 1;\n            opts.numberOfMonths = nom > 4 ? 4 : nom;\n\n            if (!isDate(opts.minDate)) {\n                opts.minDate = false;\n            }\n            if (!isDate(opts.maxDate)) {\n                opts.maxDate = false;\n            }\n            if ((opts.minDate && opts.maxDate) && opts.maxDate < opts.minDate) {\n                opts.maxDate = opts.minDate = false;\n            }\n            if (opts.minDate) {\n                this.setMinDate(opts.minDate);\n            }\n            if (opts.maxDate) {\n                this.setMaxDate(opts.maxDate);\n            }\n\n            if (isArray(opts.yearRange)) {\n                var fallback = new Date().getFullYear() - 10;\n                opts.yearRange[0] = parseInt(opts.yearRange[0], 10) || fallback;\n                opts.yearRange[1] = parseInt(opts.yearRange[1], 10) || fallback;\n            } else {\n                opts.yearRange = Math.abs(parseInt(opts.yearRange, 10)) || defaults.yearRange;\n                if (opts.yearRange > 100) {\n                    opts.yearRange = 100;\n                }\n            }\n\n            return opts;\n        },\n\n        /**\n         * return a formatted string of the current selection (using Moment.js if available)\n         */\n        toString: function(format)\n        {\n            format = format || this._o.format;\n            if (!isDate(this._d)) {\n                return '';\n            }\n            if (this._o.toString) {\n              return this._o.toString(this._d, format);\n            }\n            if (hasMoment) {\n              return moment(this._d).format(format);\n            }\n            return this._d.toDateString();\n        },\n\n        /**\n         * return a Moment.js object of the current selection (if available)\n         */\n        getMoment: function()\n        {\n            return hasMoment ? moment(this._d) : null;\n        },\n\n        /**\n         * set the current selection from a Moment.js object (if available)\n         */\n        setMoment: function(date, preventOnSelect)\n        {\n            if (hasMoment && moment.isMoment(date)) {\n                this.setDate(date.toDate(), preventOnSelect);\n            }\n        },\n\n        /**\n         * return a Date object of the current selection\n         */\n        getDate: function()\n        {\n            return isDate(this._d) ? new Date(this._d.getTime()) : null;\n        },\n\n        /**\n         * set the current selection\n         */\n        setDate: function(date, preventOnSelect)\n        {\n            if (!date) {\n                this._d = null;\n\n                if (this._o.field) {\n                    this._o.field.value = '';\n                    fireEvent(this._o.field, 'change', { firedBy: this });\n                }\n\n                return this.draw();\n            }\n            if (typeof date === 'string') {\n                date = new Date(Date.parse(date));\n            }\n            if (!isDate(date)) {\n                return;\n            }\n\n            var min = this._o.minDate,\n                max = this._o.maxDate;\n\n            if (isDate(min) && date < min) {\n                date = min;\n            } else if (isDate(max) && date > max) {\n                date = max;\n            }\n\n            this._d = new Date(date.getTime());\n            setToStartOfDay(this._d);\n            this.gotoDate(this._d);\n\n            if (this._o.field) {\n                this._o.field.value = this.toString();\n                fireEvent(this._o.field, 'change', { firedBy: this });\n            }\n            if (!preventOnSelect && typeof this._o.onSelect === 'function') {\n                this._o.onSelect.call(this, this.getDate());\n            }\n        },\n\n        /**\n         * change view to a specific date\n         */\n        gotoDate: function(date)\n        {\n            var newCalendar = true;\n\n            if (!isDate(date)) {\n                return;\n            }\n\n            if (this.calendars) {\n                var firstVisibleDate = new Date(this.calendars[0].year, this.calendars[0].month, 1),\n                    lastVisibleDate = new Date(this.calendars[this.calendars.length-1].year, this.calendars[this.calendars.length-1].month, 1),\n                    visibleDate = date.getTime();\n                // get the end of the month\n                lastVisibleDate.setMonth(lastVisibleDate.getMonth()+1);\n                lastVisibleDate.setDate(lastVisibleDate.getDate()-1);\n                newCalendar = (visibleDate < firstVisibleDate.getTime() || lastVisibleDate.getTime() < visibleDate);\n            }\n\n            if (newCalendar) {\n                this.calendars = [{\n                    month: date.getMonth(),\n                    year: date.getFullYear()\n                }];\n                if (this._o.mainCalendar === 'right') {\n                    this.calendars[0].month += 1 - this._o.numberOfMonths;\n                }\n            }\n\n            this.adjustCalendars();\n        },\n\n        adjustDate: function(sign, days) {\n\n            var day = this.getDate() || new Date();\n            var difference = parseInt(days)*24*60*60*1000;\n\n            var newDay;\n\n            if (sign === 'add') {\n                newDay = new Date(day.valueOf() + difference);\n            } else if (sign === 'subtract') {\n                newDay = new Date(day.valueOf() - difference);\n            }\n\n            this.setDate(newDay);\n        },\n\n        adjustCalendars: function() {\n            this.calendars[0] = adjustCalendar(this.calendars[0]);\n            for (var c = 1; c < this._o.numberOfMonths; c++) {\n                this.calendars[c] = adjustCalendar({\n                    month: this.calendars[0].month + c,\n                    year: this.calendars[0].year\n                });\n            }\n            this.draw();\n        },\n\n        gotoToday: function()\n        {\n            this.gotoDate(new Date());\n        },\n\n        /**\n         * change view to a specific month (zero-index, e.g. 0: January)\n         */\n        gotoMonth: function(month)\n        {\n            if (!isNaN(month)) {\n                this.calendars[0].month = parseInt(month, 10);\n                this.adjustCalendars();\n            }\n        },\n\n        nextMonth: function()\n        {\n            this.calendars[0].month++;\n            this.adjustCalendars();\n        },\n\n        prevMonth: function()\n        {\n            this.calendars[0].month--;\n            this.adjustCalendars();\n        },\n\n        /**\n         * change view to a specific full year (e.g. \"2012\")\n         */\n        gotoYear: function(year)\n        {\n            if (!isNaN(year)) {\n                this.calendars[0].year = parseInt(year, 10);\n                this.adjustCalendars();\n            }\n        },\n\n        /**\n         * change the minDate\n         */\n        setMinDate: function(value)\n        {\n            if(value instanceof Date) {\n                setToStartOfDay(value);\n                this._o.minDate = value;\n                this._o.minYear  = value.getFullYear();\n                this._o.minMonth = value.getMonth();\n            } else {\n                this._o.minDate = defaults.minDate;\n                this._o.minYear  = defaults.minYear;\n                this._o.minMonth = defaults.minMonth;\n                this._o.startRange = defaults.startRange;\n            }\n\n            this.draw();\n        },\n\n        /**\n         * change the maxDate\n         */\n        setMaxDate: function(value)\n        {\n            if(value instanceof Date) {\n                setToStartOfDay(value);\n                this._o.maxDate = value;\n                this._o.maxYear = value.getFullYear();\n                this._o.maxMonth = value.getMonth();\n            } else {\n                this._o.maxDate = defaults.maxDate;\n                this._o.maxYear = defaults.maxYear;\n                this._o.maxMonth = defaults.maxMonth;\n                this._o.endRange = defaults.endRange;\n            }\n\n            this.draw();\n        },\n\n        setStartRange: function(value)\n        {\n            this._o.startRange = value;\n        },\n\n        setEndRange: function(value)\n        {\n            this._o.endRange = value;\n        },\n\n        /**\n         * refresh the HTML\n         */\n        draw: function(force)\n        {\n            if (!this._v && !force) {\n                return;\n            }\n            var opts = this._o,\n                minYear = opts.minYear,\n                maxYear = opts.maxYear,\n                minMonth = opts.minMonth,\n                maxMonth = opts.maxMonth,\n                html = '',\n                randId;\n\n            if (this._y <= minYear) {\n                this._y = minYear;\n                if (!isNaN(minMonth) && this._m < minMonth) {\n                    this._m = minMonth;\n                }\n            }\n            if (this._y >= maxYear) {\n                this._y = maxYear;\n                if (!isNaN(maxMonth) && this._m > maxMonth) {\n                    this._m = maxMonth;\n                }\n            }\n\n            randId = 'pika-title-' + Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 2);\n\n            for (var c = 0; c < opts.numberOfMonths; c++) {\n                html += '<div class=\"pika-lendar\">' + renderTitle(this, c, this.calendars[c].year, this.calendars[c].month, this.calendars[0].year, randId) + this.render(this.calendars[c].year, this.calendars[c].month, randId) + '</div>';\n            }\n\n            this.el.innerHTML = html;\n\n            if (opts.bound) {\n                if(opts.field.type !== 'hidden') {\n                    sto(function() {\n                        opts.trigger.focus();\n                    }, 1);\n                }\n            }\n\n            if (typeof this._o.onDraw === 'function') {\n                this._o.onDraw(this);\n            }\n\n            if (opts.bound) {\n                // let the screen reader user know to use arrow keys\n                opts.field.setAttribute('aria-label', opts.ariaLabel);\n            }\n        },\n\n        adjustPosition: function()\n        {\n            var field, pEl, width, height, viewportWidth, viewportHeight, scrollTop, left, top, clientRect, leftAligned, bottomAligned;\n\n            if (this._o.container) return;\n\n            this.el.style.position = 'absolute';\n\n            field = this._o.trigger;\n            pEl = field;\n            width = this.el.offsetWidth;\n            height = this.el.offsetHeight;\n            viewportWidth = window.innerWidth || document.documentElement.clientWidth;\n            viewportHeight = window.innerHeight || document.documentElement.clientHeight;\n            scrollTop = window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop;\n            leftAligned = true;\n            bottomAligned = true;\n\n            if (typeof field.getBoundingClientRect === 'function') {\n                clientRect = field.getBoundingClientRect();\n                left = clientRect.left + window.pageXOffset;\n                top = clientRect.bottom + window.pageYOffset;\n            } else {\n                left = pEl.offsetLeft;\n                top  = pEl.offsetTop + pEl.offsetHeight;\n                while((pEl = pEl.offsetParent)) {\n                    left += pEl.offsetLeft;\n                    top  += pEl.offsetTop;\n                }\n            }\n\n            // default position is bottom & left\n            if ((this._o.reposition && left + width > viewportWidth) ||\n                (\n                    this._o.position.indexOf('right') > -1 &&\n                    left - width + field.offsetWidth > 0\n                )\n            ) {\n                left = left - width + field.offsetWidth;\n                leftAligned = false;\n            }\n            if ((this._o.reposition && top + height > viewportHeight + scrollTop) ||\n                (\n                    this._o.position.indexOf('top') > -1 &&\n                    top - height - field.offsetHeight > 0\n                )\n            ) {\n                top = top - height - field.offsetHeight;\n                bottomAligned = false;\n            }\n\n            this.el.style.left = left + 'px';\n            this.el.style.top = top + 'px';\n\n            addClass(this.el, leftAligned ? 'left-aligned' : 'right-aligned');\n            addClass(this.el, bottomAligned ? 'bottom-aligned' : 'top-aligned');\n            removeClass(this.el, !leftAligned ? 'left-aligned' : 'right-aligned');\n            removeClass(this.el, !bottomAligned ? 'bottom-aligned' : 'top-aligned');\n        },\n\n        /**\n         * render HTML for a particular month\n         */\n        render: function(year, month, randId)\n        {\n            var opts   = this._o,\n                now    = new Date(),\n                days   = getDaysInMonth(year, month),\n                before = new Date(year, month, 1).getDay(),\n                data   = [],\n                row    = [];\n            setToStartOfDay(now);\n            if (opts.firstDay > 0) {\n                before -= opts.firstDay;\n                if (before < 0) {\n                    before += 7;\n                }\n            }\n            var previousMonth = month === 0 ? 11 : month - 1,\n                nextMonth = month === 11 ? 0 : month + 1,\n                yearOfPreviousMonth = month === 0 ? year - 1 : year,\n                yearOfNextMonth = month === 11 ? year + 1 : year,\n                daysInPreviousMonth = getDaysInMonth(yearOfPreviousMonth, previousMonth);\n            var cells = days + before,\n                after = cells;\n            while(after > 7) {\n                after -= 7;\n            }\n            cells += 7 - after;\n            var isWeekSelected = false;\n            for (var i = 0, r = 0; i < cells; i++)\n            {\n                var day = new Date(year, month, 1 + (i - before)),\n                    isSelected = isDate(this._d) ? compareDates(day, this._d) : false,\n                    isToday = compareDates(day, now),\n                    hasEvent = opts.events.indexOf(day.toDateString()) !== -1 ? true : false,\n                    isEmpty = i < before || i >= (days + before),\n                    dayNumber = 1 + (i - before),\n                    monthNumber = month,\n                    yearNumber = year,\n                    isStartRange = opts.startRange && compareDates(opts.startRange, day),\n                    isEndRange = opts.endRange && compareDates(opts.endRange, day),\n                    isInRange = opts.startRange && opts.endRange && opts.startRange < day && day < opts.endRange,\n                    isDisabled = (opts.minDate && day < opts.minDate) ||\n                                 (opts.maxDate && day > opts.maxDate) ||\n                                 (opts.disableWeekends && isWeekend(day)) ||\n                                 (opts.disableDayFn && opts.disableDayFn(day));\n\n                if (isEmpty) {\n                    if (i < before) {\n                        dayNumber = daysInPreviousMonth + dayNumber;\n                        monthNumber = previousMonth;\n                        yearNumber = yearOfPreviousMonth;\n                    } else {\n                        dayNumber = dayNumber - days;\n                        monthNumber = nextMonth;\n                        yearNumber = yearOfNextMonth;\n                    }\n                }\n\n                var dayConfig = {\n                        day: dayNumber,\n                        month: monthNumber,\n                        year: yearNumber,\n                        hasEvent: hasEvent,\n                        isSelected: isSelected,\n                        isToday: isToday,\n                        isDisabled: isDisabled,\n                        isEmpty: isEmpty,\n                        isStartRange: isStartRange,\n                        isEndRange: isEndRange,\n                        isInRange: isInRange,\n                        showDaysInNextAndPreviousMonths: opts.showDaysInNextAndPreviousMonths,\n                        enableSelectionDaysInNextAndPreviousMonths: opts.enableSelectionDaysInNextAndPreviousMonths\n                    };\n\n                if (opts.pickWholeWeek && isSelected) {\n                    isWeekSelected = true;\n                }\n\n                row.push(renderDay(dayConfig));\n\n                if (++r === 7) {\n                    if (opts.showWeekNumber) {\n                        row.unshift(renderWeek(i - before, month, year));\n                    }\n                    data.push(renderRow(row, opts.isRTL, opts.pickWholeWeek, isWeekSelected));\n                    row = [];\n                    r = 0;\n                    isWeekSelected = false;\n                }\n            }\n            return renderTable(opts, data, randId);\n        },\n\n        isVisible: function()\n        {\n            return this._v;\n        },\n\n        show: function()\n        {\n            if (!this.isVisible()) {\n                this._v = true;\n                this.draw();\n                removeClass(this.el, 'is-hidden');\n                if (this._o.bound) {\n                    addEvent(document, 'click', this._onClick);\n                    this.adjustPosition();\n                }\n                if (typeof this._o.onOpen === 'function') {\n                    this._o.onOpen.call(this);\n                }\n            }\n        },\n\n        hide: function()\n        {\n            var v = this._v;\n            if (v !== false) {\n                if (this._o.bound) {\n                    removeEvent(document, 'click', this._onClick);\n                }\n                this.el.style.position = 'static'; // reset\n                this.el.style.left = 'auto';\n                this.el.style.top = 'auto';\n                addClass(this.el, 'is-hidden');\n                this._v = false;\n                if (v !== undefined && typeof this._o.onClose === 'function') {\n                    this._o.onClose.call(this);\n                }\n            }\n        },\n\n        /**\n         * GAME OVER\n         */\n        destroy: function()\n        {\n            var opts = this._o;\n\n            this.hide();\n            removeEvent(this.el, 'mousedown', this._onMouseDown, true);\n            removeEvent(this.el, 'touchend', this._onMouseDown, true);\n            removeEvent(this.el, 'change', this._onChange);\n            if (opts.keyboardInput) {\n                removeEvent(document, 'keydown', this._onKeyChange);\n            }\n            if (opts.field) {\n                removeEvent(opts.field, 'change', this._onInputChange);\n                if (opts.bound) {\n                    removeEvent(opts.trigger, 'click', this._onInputClick);\n                    removeEvent(opts.trigger, 'focus', this._onInputFocus);\n                    removeEvent(opts.trigger, 'blur', this._onInputBlur);\n                }\n            }\n            if (this.el.parentNode) {\n                this.el.parentNode.removeChild(this.el);\n            }\n        }\n\n    };\n\n    return Pikaday;\n}));\n\n\n/***/ }),\n\n/***/ 426:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = select;\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\n__webpack_require__(373);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction select(selector) {\n  var $select = (0, _jquery2.default)(selector);\n\n  if ($select.length) {\n    (0, _jquery2.default)('select').inputSelect({\n      arrowTemplate: '<i aria-hidden=\"true\"></i>'\n    });\n  }\n}\n\n/***/ }),\n\n/***/ 453:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = tooltip;\n\nvar _jquery = __webpack_require__(346);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _tetherTooltip = __webpack_require__(454);\n\nvar _tetherTooltip2 = _interopRequireDefault(_tetherTooltip);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction tooltip(selector) {\n  var $tooltip = (0, _jquery2.default)(selector);\n\n  $tooltip.each(function (index, element) {\n    var $item = (0, _jquery2.default)(element);\n    var content = $item.data('tooltip') || $item.attr('title');\n\n    // to stop the page to error if no attribut is found\n    if (!content) {\n      return;\n    }\n\n    $item.removeAttr('title');\n\n    // eslint-disable-next-line no-new\n    var instance = new _tetherTooltip2.default({\n      classes: 'netc-tooltip-theme',\n      constrainToWindow: true,\n      content: content,\n      position: 'top right',\n      target: $item[0],\n      openOn: 'focus',\n      tetherOptions: {\n        constraints: [{\n          to: 'scrollParent',\n          attachment: 'together',\n          pin: true\n        }]\n      }\n    });\n\n    if ($item.is(':focus')) {\n      instance.open();\n    }\n  });\n}\n\n/***/ }),\n\n/***/ 454:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! tether-tooltip 1.1.0 */\n\n(function(root, factory) {\n  if (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(455),__webpack_require__(384)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  } else if (typeof exports === 'object') {\n    module.exports = factory(require('tether-drop'), require('tether'));\n  } else {\n    root.Tooltip = factory(root.Drop, root.Tether);\n  }\n}(this, function(Drop, Tether) {\n\n/* global Tether Drop */\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 extend = Tether.Utils.extend;\n\nvar _Drop = Drop.createContext({\n  classPrefix: 'tooltip'\n});\n\nvar defaults = {\n  position: 'top center',\n  openOn: 'hover',\n  classes: 'tooltip-theme-arrows',\n  constrainToWindow: true,\n  constrainToScrollParent: false\n};\n\nvar tooltipCount = 0;\n\nvar Tooltip = (function () {\n  function Tooltip(options) {\n    _classCallCheck(this, Tooltip);\n\n    this.options = options;\n\n    if (!this.options.target) {\n      throw new Error('Tooltip Error: You must provide a target for Tooltip to attach to');\n    }\n\n    var position = this.options.target.getAttribute('data-tooltip-position');\n    if (position) {\n      if (typeof this.options.position === 'undefined') {\n        this.options.position = position;\n      }\n    }\n\n    var content = this.options.target.getAttribute('data-tooltip');\n\n    if (content) {\n      if (typeof this.options.content === 'undefined') {\n        var contentEl = document.createElement('div');\n        contentEl.innerHTML = content;\n\n        // Add ARIA attributes (see #50)\n        contentEl.setAttribute('role', 'tooltip');\n        contentEl.id = 'drop-tooltip-' + tooltipCount;\n        this.options.target.setAttribute('aria-describedby', contentEl.id);\n        tooltipCount += 1;\n\n        this.options.content = contentEl;\n      }\n    }\n\n    if (!this.options.content) {\n      throw new Error('Tooltip Error: You must provide content for Tooltip to display');\n    }\n\n    this.options = extend({}, defaults, this.options);\n\n    this.drop = new _Drop(this.options);\n  }\n\n  _createClass(Tooltip, [{\n    key: 'close',\n    value: function close() {\n      this.drop.close();\n    }\n  }, {\n    key: 'open',\n    value: function open() {\n      this.drop.open();\n    }\n  }, {\n    key: 'toggle',\n    value: function toggle() {\n      this.drop.toggle();\n    }\n  }, {\n    key: 'remove',\n    value: function remove() {\n      this.drop.remove();\n    }\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      this.drop.destroy();\n    }\n  }, {\n    key: 'position',\n    value: function position() {\n      this.drop.position();\n    }\n  }]);\n\n  return Tooltip;\n})();\n\nvar initialized = [];\n\nTooltip.init = function () {\n  var tooltipElements = document.querySelectorAll('[data-tooltip]');\n  var len = tooltipElements.length;\n  for (var i = 0; i < len; ++i) {\n    var el = tooltipElements[i];\n    if (initialized.indexOf(el) === -1) {\n      new Tooltip({\n        target: el\n      });\n      initialized.push(el);\n    }\n  }\n};\n\ndocument.addEventListener('DOMContentLoaded', function () {\n  if (Tooltip.autoinit !== false) {\n    Tooltip.init();\n  }\n});\nreturn Tooltip;\n\n}));\n\n\n/***/ }),\n\n/***/ 455:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! tether-drop 1.4.1 */\n\n(function(root, factory) {\n  if (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(384)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  } else if (typeof exports === 'object') {\n    module.exports = factory(require('tether'));\n  } else {\n    root.Drop = factory(root.Tether);\n  }\n}(this, function(Tether) {\n\n/* global Tether */\n'use strict';\n\nvar _bind = Function.prototype.bind;\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(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _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 { _x2 = parent; _x3 = property; _x4 = 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\nvar _Tether$Utils = Tether.Utils;\nvar extend = _Tether$Utils.extend;\nvar addClass = _Tether$Utils.addClass;\nvar removeClass = _Tether$Utils.removeClass;\nvar hasClass = _Tether$Utils.hasClass;\nvar Evented = _Tether$Utils.Evented;\n\nfunction sortAttach(str) {\n  var _str$split = str.split(' ');\n\n  var _str$split2 = _slicedToArray(_str$split, 2);\n\n  var first = _str$split2[0];\n  var second = _str$split2[1];\n\n  if (['left', 'right'].indexOf(first) >= 0) {\n    var _ref = [second, first];\n    first = _ref[0];\n    second = _ref[1];\n  }\n  return [first, second].join(' ');\n}\n\nfunction removeFromArray(arr, item) {\n  var index = undefined;\n  var results = [];\n  while ((index = arr.indexOf(item)) !== -1) {\n    results.push(arr.splice(index, 1));\n  }\n  return results;\n}\n\nvar clickEvents = ['click'];\nif ('ontouchstart' in document.documentElement) {\n  clickEvents.push('touchstart');\n}\n\nvar transitionEndEvents = {\n  'WebkitTransition': 'webkitTransitionEnd',\n  'MozTransition': 'transitionend',\n  'OTransition': 'otransitionend',\n  'transition': 'transitionend'\n};\n\nvar transitionEndEvent = '';\nfor (var _name in transitionEndEvents) {\n  if (({}).hasOwnProperty.call(transitionEndEvents, _name)) {\n    var tempEl = document.createElement('p');\n    if (typeof tempEl.style[_name] !== 'undefined') {\n      transitionEndEvent = transitionEndEvents[_name];\n    }\n  }\n}\n\nvar MIRROR_ATTACH = {\n  left: 'right',\n  right: 'left',\n  top: 'bottom',\n  bottom: 'top',\n  middle: 'middle',\n  center: 'center'\n};\n\nvar allDrops = {};\n\n// Drop can be included in external libraries.  Calling createContext gives you a fresh\n// copy of drop which won't interact with other copies on the page (beyond calling the document events).\n\nfunction createContext() {\n  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n  var drop = function drop() {\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return new (_bind.apply(DropInstance, [null].concat(args)))();\n  };\n\n  extend(drop, {\n    createContext: createContext,\n    drops: [],\n    defaults: {}\n  });\n\n  var defaultOptions = {\n    classPrefix: 'drop',\n    defaults: {\n      position: 'bottom left',\n      openOn: 'click',\n      beforeClose: null,\n      constrainToScrollParent: true,\n      constrainToWindow: true,\n      classes: '',\n      remove: false,\n      openDelay: 0,\n      closeDelay: 50,\n      // inherited from openDelay and closeDelay if not explicitly defined\n      focusDelay: null,\n      blurDelay: null,\n      hoverOpenDelay: null,\n      hoverCloseDelay: null,\n      tetherOptions: {}\n    }\n  };\n\n  extend(drop, defaultOptions, options);\n  extend(drop.defaults, defaultOptions.defaults, options.defaults);\n\n  if (typeof allDrops[drop.classPrefix] === 'undefined') {\n    allDrops[drop.classPrefix] = [];\n  }\n\n  drop.updateBodyClasses = function () {\n    // There is only one body, so despite the context concept, we still iterate through all\n    // drops which share our classPrefix.\n\n    var anyOpen = false;\n    var drops = allDrops[drop.classPrefix];\n    var len = drops.length;\n    for (var i = 0; i < len; ++i) {\n      if (drops[i].isOpened()) {\n        anyOpen = true;\n        break;\n      }\n    }\n\n    if (anyOpen) {\n      addClass(document.body, drop.classPrefix + '-open');\n    } else {\n      removeClass(document.body, drop.classPrefix + '-open');\n    }\n  };\n\n  var DropInstance = (function (_Evented) {\n    _inherits(DropInstance, _Evented);\n\n    function DropInstance(opts) {\n      _classCallCheck(this, DropInstance);\n\n      _get(Object.getPrototypeOf(DropInstance.prototype), 'constructor', this).call(this);\n      this.options = extend({}, drop.defaults, opts);\n      this.target = this.options.target;\n\n      if (typeof this.target === 'undefined') {\n        throw new Error('Drop Error: You must provide a target.');\n      }\n\n      var dataPrefix = 'data-' + drop.classPrefix;\n\n      var contentAttr = this.target.getAttribute(dataPrefix);\n      if (contentAttr && this.options.content == null) {\n        this.options.content = contentAttr;\n      }\n\n      var attrsOverride = ['position', 'openOn'];\n      for (var i = 0; i < attrsOverride.length; ++i) {\n\n        var override = this.target.getAttribute(dataPrefix + '-' + attrsOverride[i]);\n        if (override && this.options[attrsOverride[i]] == null) {\n          this.options[attrsOverride[i]] = override;\n        }\n      }\n\n      if (this.options.classes && this.options.addTargetClasses !== false) {\n        addClass(this.target, this.options.classes);\n      }\n\n      drop.drops.push(this);\n      allDrops[drop.classPrefix].push(this);\n\n      this._boundEvents = [];\n      this.bindMethods();\n      this.setupElements();\n      this.setupEvents();\n      this.setupTether();\n    }\n\n    _createClass(DropInstance, [{\n      key: '_on',\n      value: function _on(element, event, handler) {\n        this._boundEvents.push({ element: element, event: event, handler: handler });\n        element.addEventListener(event, handler);\n      }\n    }, {\n      key: 'bindMethods',\n      value: function bindMethods() {\n        this.transitionEndHandler = this._transitionEndHandler.bind(this);\n      }\n    }, {\n      key: 'setupElements',\n      value: function setupElements() {\n        var _this = this;\n\n        this.drop = document.createElement('div');\n        addClass(this.drop, drop.classPrefix);\n\n        if (this.options.classes) {\n          addClass(this.drop, this.options.classes);\n        }\n\n        this.content = document.createElement('div');\n        addClass(this.content, drop.classPrefix + '-content');\n\n        if (typeof this.options.content === 'function') {\n          var generateAndSetContent = function generateAndSetContent() {\n            // content function might return a string or an element\n            var contentElementOrHTML = _this.options.content.call(_this, _this);\n\n            if (typeof contentElementOrHTML === 'string') {\n              _this.content.innerHTML = contentElementOrHTML;\n            } else if (typeof contentElementOrHTML === 'object') {\n              _this.content.innerHTML = '';\n              _this.content.appendChild(contentElementOrHTML);\n            } else {\n              throw new Error('Drop Error: Content function should return a string or HTMLElement.');\n            }\n          };\n\n          generateAndSetContent();\n          this.on('open', generateAndSetContent.bind(this));\n        } else if (typeof this.options.content === 'object') {\n          this.content.appendChild(this.options.content);\n        } else {\n          this.content.innerHTML = this.options.content;\n        }\n\n        this.drop.appendChild(this.content);\n      }\n    }, {\n      key: 'setupTether',\n      value: function setupTether() {\n        // Tether expects two attachment points, one in the target element, one in the\n        // drop.  We use a single one, and use the order as well, to allow us to put\n        // the drop on either side of any of the four corners.  This magic converts between\n        // the two:\n        var dropAttach = this.options.position.split(' ');\n        dropAttach[0] = MIRROR_ATTACH[dropAttach[0]];\n        dropAttach = dropAttach.join(' ');\n\n        var constraints = [];\n        if (this.options.constrainToScrollParent) {\n          constraints.push({\n            to: 'scrollParent',\n            pin: 'top, bottom',\n            attachment: 'together none'\n          });\n        } else {\n          // To get 'out of bounds' classes\n          constraints.push({\n            to: 'scrollParent'\n          });\n        }\n\n        if (this.options.constrainToWindow !== false) {\n          constraints.push({\n            to: 'window',\n            attachment: 'together'\n          });\n        } else {\n          // To get 'out of bounds' classes\n          constraints.push({\n            to: 'window'\n          });\n        }\n\n        var opts = {\n          element: this.drop,\n          target: this.target,\n          attachment: sortAttach(dropAttach),\n          targetAttachment: sortAttach(this.options.position),\n          classPrefix: drop.classPrefix,\n          offset: '0 0',\n          targetOffset: '0 0',\n          enabled: false,\n          constraints: constraints,\n          addTargetClasses: this.options.addTargetClasses\n        };\n\n        if (this.options.tetherOptions !== false) {\n          this.tether = new Tether(extend({}, opts, this.options.tetherOptions));\n        }\n      }\n    }, {\n      key: 'setupEvents',\n      value: function setupEvents() {\n        var _this2 = this;\n\n        if (!this.options.openOn) {\n          return;\n        }\n\n        if (this.options.openOn === 'always') {\n          setTimeout(this.open.bind(this));\n          return;\n        }\n\n        var events = this.options.openOn.split(' ');\n\n        if (events.indexOf('click') >= 0) {\n          var openHandler = function openHandler(event) {\n            _this2.toggle(event);\n            event.preventDefault();\n          };\n\n          var closeHandler = function closeHandler(event) {\n            if (!_this2.isOpened()) {\n              return;\n            }\n\n            // Clicking inside dropdown\n            if (event.target === _this2.drop || _this2.drop.contains(event.target)) {\n              return;\n            }\n\n            // Clicking target\n            if (event.target === _this2.target || _this2.target.contains(event.target)) {\n              return;\n            }\n\n            _this2.close(event);\n          };\n\n          for (var i = 0; i < clickEvents.length; ++i) {\n            var clickEvent = clickEvents[i];\n            this._on(this.target, clickEvent, openHandler);\n            this._on(document, clickEvent, closeHandler);\n          }\n        }\n\n        var inTimeout = null;\n        var outTimeout = null;\n\n        var inHandler = function inHandler(event) {\n          if (outTimeout !== null) {\n            clearTimeout(outTimeout);\n          } else {\n            inTimeout = setTimeout(function () {\n              _this2.open(event);\n              inTimeout = null;\n            }, (event.type === 'focus' ? _this2.options.focusDelay : _this2.options.hoverOpenDelay) || _this2.options.openDelay);\n          }\n        };\n\n        var outHandler = function outHandler(event) {\n          if (inTimeout !== null) {\n            clearTimeout(inTimeout);\n          } else {\n            outTimeout = setTimeout(function () {\n              _this2.close(event);\n              outTimeout = null;\n            }, (event.type === 'blur' ? _this2.options.blurDelay : _this2.options.hoverCloseDelay) || _this2.options.closeDelay);\n          }\n        };\n\n        if (events.indexOf('hover') >= 0) {\n          this._on(this.target, 'mouseover', inHandler);\n          this._on(this.drop, 'mouseover', inHandler);\n          this._on(this.target, 'mouseout', outHandler);\n          this._on(this.drop, 'mouseout', outHandler);\n        }\n\n        if (events.indexOf('focus') >= 0) {\n          this._on(this.target, 'focus', inHandler);\n          this._on(this.drop, 'focus', inHandler);\n          this._on(this.target, 'blur', outHandler);\n          this._on(this.drop, 'blur', outHandler);\n        }\n      }\n    }, {\n      key: 'isOpened',\n      value: function isOpened() {\n        if (this.drop) {\n          return hasClass(this.drop, drop.classPrefix + '-open');\n        }\n      }\n    }, {\n      key: 'toggle',\n      value: function toggle(event) {\n        if (this.isOpened()) {\n          this.close(event);\n        } else {\n          this.open(event);\n        }\n      }\n    }, {\n      key: 'open',\n      value: function open(event) {\n        var _this3 = this;\n\n        /* eslint no-unused-vars: 0 */\n        if (this.isOpened()) {\n          return;\n        }\n\n        if (!this.drop.parentNode) {\n          document.body.appendChild(this.drop);\n        }\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.enable();\n        }\n\n        addClass(this.drop, drop.classPrefix + '-open');\n        addClass(this.drop, drop.classPrefix + '-open-transitionend');\n\n        setTimeout(function () {\n          if (_this3.drop) {\n            addClass(_this3.drop, drop.classPrefix + '-after-open');\n          }\n        });\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.position();\n        }\n\n        this.trigger('open');\n\n        drop.updateBodyClasses();\n      }\n    }, {\n      key: '_transitionEndHandler',\n      value: function _transitionEndHandler(e) {\n        if (e.target !== e.currentTarget) {\n          return;\n        }\n\n        if (!hasClass(this.drop, drop.classPrefix + '-open')) {\n          removeClass(this.drop, drop.classPrefix + '-open-transitionend');\n        }\n        this.drop.removeEventListener(transitionEndEvent, this.transitionEndHandler);\n      }\n    }, {\n      key: 'beforeCloseHandler',\n      value: function beforeCloseHandler(event) {\n        var shouldClose = true;\n\n        if (!this.isClosing && typeof this.options.beforeClose === 'function') {\n          this.isClosing = true;\n          shouldClose = this.options.beforeClose(event, this) !== false;\n        }\n\n        this.isClosing = false;\n\n        return shouldClose;\n      }\n    }, {\n      key: 'close',\n      value: function close(event) {\n        if (!this.isOpened()) {\n          return;\n        }\n\n        if (!this.beforeCloseHandler(event)) {\n          return;\n        }\n\n        removeClass(this.drop, drop.classPrefix + '-open');\n        removeClass(this.drop, drop.classPrefix + '-after-open');\n\n        this.drop.addEventListener(transitionEndEvent, this.transitionEndHandler);\n\n        this.trigger('close');\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.disable();\n        }\n\n        drop.updateBodyClasses();\n\n        if (this.options.remove) {\n          this.remove(event);\n        }\n      }\n    }, {\n      key: 'remove',\n      value: function remove(event) {\n        this.close(event);\n        if (this.drop.parentNode) {\n          this.drop.parentNode.removeChild(this.drop);\n        }\n      }\n    }, {\n      key: 'position',\n      value: function position() {\n        if (this.isOpened() && typeof this.tether !== 'undefined') {\n          this.tether.position();\n        }\n      }\n    }, {\n      key: 'destroy',\n      value: function destroy() {\n        this.remove();\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.destroy();\n        }\n\n        for (var i = 0; i < this._boundEvents.length; ++i) {\n          var _boundEvents$i = this._boundEvents[i];\n          var element = _boundEvents$i.element;\n          var _event = _boundEvents$i.event;\n          var handler = _boundEvents$i.handler;\n\n          element.removeEventListener(_event, handler);\n        }\n\n        this._boundEvents = [];\n\n        this.tether = null;\n        this.drop = null;\n        this.content = null;\n        this.target = null;\n\n        removeFromArray(allDrops[drop.classPrefix], this);\n        removeFromArray(drop.drops, this);\n      }\n    }]);\n\n    return DropInstance;\n  })(Evented);\n\n  return drop;\n}\n\nvar Drop = createContext();\n\ndocument.addEventListener('DOMContentLoaded', function () {\n  Drop.updateBodyClasses();\n});\nreturn Drop;\n\n}));\n\n\n/***/ }),\n\n/***/ 456:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n__webpack_require__(373);\n\nToolkit.namespace = 'netc-';\n\n/***/ })\n\n});\n\n\n// WEBPACK FOOTER //\n// 0-b651c482e105b9da9547.js","require('./init-iframe');\r\nrequire('./init-menu');\r\nrequire('./init-check-device');\r\nrequire('./init-external-link-modal');\r\nrequire('./init-responsive-table');\r\nrequire('./init-show-hide');\r\nrequire('./init-scroll-up');\r\nrequire('./init-scroll-section');\r\nrequire('./init-svg4everybody');\r\nrequire('./init-validation-tooltip');\r\nrequire('./init-video');\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/index.js","import './titon';\r\n\r\nexport * from './components';\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/core/index.js","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isObject.js\n// module id = 351\n// module chunks = 0","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_root.js\n// module id = 361\n// module chunks = 0","import $ from 'jquery';\r\nimport throttle from 'lodash/throttle';\r\n\r\n/** Constant media query states. */\r\nexport const MOBILE = 'MOBILE';\r\nexport const MOBILE_MEDIA_QUERY = '(max-width: 767px)';\r\nexport const TABLET = 'TABLET';\r\nexport const TABLET_MEDIA_QUERY = '(min-width: 768px) and (max-width: 1199px)';\r\nexport const DESKTOP = 'DESKTOP';\r\nexport const DESKTOP_MEDIA_QUERY = '(min-width: 1200px)';\r\n\r\n/** Local reference to device type, allows the value to be read-only. */\r\nlet deviceType = '';\r\n\r\n/** Singleton instance. */\r\nlet instance;\r\n\r\n/** Check the existing device state, singleton. */\r\nclass MobileChecker {\r\n  static get instance() {\r\n    if (instance === undefined) {\r\n      instance = new MobileChecker();\r\n    }\r\n    return instance;\r\n  }\r\n  constructor() {\r\n    $(window).on('resize', throttle(this.checkDeviceSize, 100));\r\n    this.checkDeviceSize();\r\n  }\r\n  /** Get device type. */\r\n  get deviceType() { // eslint-disable-line class-methods-use-this\r\n    return deviceType;\r\n  }\r\n  /** Set device type based on media queries. */\r\n  checkDeviceSize() {\r\n    if (Modernizr.mq(MOBILE_MEDIA_QUERY)) {\r\n      deviceType = MOBILE;\r\n    }\r\n\r\n    if (Modernizr.mq(TABLET_MEDIA_QUERY)) {\r\n      deviceType = TABLET;\r\n    }\r\n\r\n    if (Modernizr.mq(DESKTOP_MEDIA_QUERY)) {\r\n      deviceType = DESKTOP;\r\n    }\r\n\r\n    return this.deviceType;\r\n  }\r\n  /** Check if mobile media query is true. */\r\n  isMobile() {\r\n    return this.deviceType === MOBILE;\r\n  }\r\n  /** Check if tablet media query is true. */\r\n  isTablet() {\r\n    return this.deviceType === TABLET;\r\n  }\r\n  /** Check if desktop media query is true. */\r\n  isDesktop() {\r\n    return this.deviceType === DESKTOP;\r\n  }\r\n}\r\n\r\nexport default MobileChecker;\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-check-device.js","var isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/toNumber.js\n// module id = 367\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseGetTag.js\n// module id = 368\n// module chunks = 0","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Symbol.js\n// module id = 369\n// module chunks = 0","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = identity;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/identity.js\n// module id = 370\n// module chunks = 0","/*! tether 1.4.7 */\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  try {\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  } catch (err) {\n    // Ignore \"Access is denied\" in IE11/Edge\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 (typeof window.devicePixelRatio === 'number' && devicePixelRatio % 1 === 0) {\n            xPos = Math.round(xPos * devicePixelRatio) / devicePixelRatio;\n            yPos = Math.round(yPos * devicePixelRatio) / devicePixelRatio;\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 isFullscreenElement = function isFullscreenElement(e) {\n            var d = e.ownerDocument;\n            var fe = d.fullscreenElement || d.webkitFullscreenElement || d.mozFullScreenElement || d.msFullscreenElement;\n            return fe === e;\n          };\n\n          var offsetParentIsBody = true;\n\n          var currentNode = this.element.parentNode;\n          while (currentNode && currentNode.nodeType === 1 && currentNode.tagName !== 'BODY' && !isFullscreenElement(currentNode)) {\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// ./node_modules/tether/dist/js/tether.js\n// module id = 384\n// module chunks = 0","window.onload = () => {\r\n  const iframe = document.querySelector('.js-iframe');\r\n  if (!iframe) {\r\n    return;\r\n  }\r\n  const subnavs = document.querySelectorAll('.js-sub-nav');\r\n  for (let i = 0; i < subnavs.length; i += 1) {\r\n    const subnav = subnavs[i];\r\n    subnav.onclick = (e) => {\r\n      e.preventDefault();\r\n      if (e.target.attributes['data-url'] != null) {\r\n        iframe.src = e.target.attributes['data-url'].value;\r\n      }\r\n    };\r\n  }\r\n};\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-iframe.js","import $ from 'jquery';\r\n\r\nconst $mobMenuBtn = $('.js-mob-menu');\r\nconst $mobMenuLinks = $('.js-mob-links');\r\n\r\nif ($mobMenuBtn.length > 0) {\r\n  $mobMenuBtn.on('click tap', (e) => {\r\n    const $this = $(e.currentTarget);\r\n    $this.toggleClass('is-active');\r\n    $mobMenuLinks.toggleClass('is-active');\r\n  });\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-menu.js","var debounce = require('./debounce'),\n    isObject = require('./isObject');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/throttle.js\n// module id = 387\n// module chunks = 0","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/debounce.js\n// module id = 388\n// module chunks = 0","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/now.js\n// module id = 389\n// module chunks = 0","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_freeGlobal.js\n// module id = 390\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isSymbol.js\n// module id = 391\n// module chunks = 0","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getRawTag.js\n// module id = 392\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_objectToString.js\n// module id = 393\n// module chunks = 0","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isObjectLike.js\n// module id = 394\n// module chunks = 0","import $ from 'jquery';\r\n\r\nconst $externalLinkBtn = $('.js-external-link');\r\nconst $externalModal = $('.js-external-link-modal');\r\nconst $externalLinkCloseBtn = $('.js-close-external-modal');\r\n\r\nif ($externalLinkBtn.length > 0) {\r\n  $externalLinkBtn.on('click tap', () => {\r\n    $externalModal.addClass('is-active');\r\n  });\r\n\r\n  $externalLinkCloseBtn.on('click tap', () => {\r\n    $externalModal.removeClass('is-active');\r\n  });\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-external-link-modal.js","/* eslint-disable func-names, max-len */\r\nimport $ from 'jquery';\r\nimport delay from 'lodash/delay';\r\nimport MobileChecker from './init-check-device';\r\n\r\nconst $table = $('.js-responsive-table');\r\nconst $responsiveTable = $('.js-table-responsive');\r\n\r\n$(window).on('resize', scrollTable);\r\n\r\nfunction scrollTable() {\r\n  delay(() => {\r\n    $responsiveTable.each((index) => {\r\n      if (MobileChecker.instance.isMobile() || MobileChecker.instance.isTablet()) {\r\n        const $fixedColumn = $table.eq(index).clone().insertBefore($table.eq(index)).addClass('fixed-column');\r\n        const tableWidth = $table.innerWidth();\r\n        const contentWidth = $('.js-main-content').innerWidth();\r\n\r\n        if (tableWidth > (contentWidth - 50)) {\r\n          $responsiveTable.eq(index).addClass('make-scrollable');\r\n        } else {\r\n          $responsiveTable.eq(index).removeClass('make-scrollable');\r\n        }\r\n\r\n        $fixedColumn.find('th:not(:first-child),td:not(:first-child)').remove();\r\n        $fixedColumn.find('tr').each(function (i) {\r\n          $(this).height(Math.floor($table.eq(index).find(`tr:eq(${i})`).height()));\r\n        });\r\n\r\n        $fixedColumn.css({ width: 108 });\r\n      }\r\n\r\n      if (MobileChecker.instance.isDesktop()) {\r\n        $responsiveTable.eq(index).removeClass('make-scrollable');\r\n      }\r\n    });\r\n  }, 200);\r\n}\r\n\r\n$(document).ready(() => {\r\n  if ($table.length) {\r\n    scrollTable();\r\n  }\r\n});\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-responsive-table.js","var baseDelay = require('./_baseDelay'),\n    baseRest = require('./_baseRest'),\n    toNumber = require('./toNumber');\n\n/**\n * Invokes `func` after `wait` milliseconds. Any additional arguments are\n * provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {number} Returns the timer id.\n * @example\n *\n * _.delay(function(text) {\n *   console.log(text);\n * }, 1000, 'later');\n * // => Logs 'later' after one second.\n */\nvar delay = baseRest(function(func, wait, args) {\n  return baseDelay(func, toNumber(wait) || 0, args);\n});\n\nmodule.exports = delay;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/delay.js\n// module id = 397\n// module chunks = 0","/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * The base implementation of `_.delay` and `_.defer` which accepts `args`\n * to provide to `func`.\n *\n * @private\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {Array} args The arguments to provide to `func`.\n * @returns {number|Object} Returns the timer id or timeout object.\n */\nfunction baseDelay(func, wait, args) {\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  return setTimeout(function() { func.apply(undefined, args); }, wait);\n}\n\nmodule.exports = baseDelay;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseDelay.js\n// module id = 398\n// module chunks = 0","var identity = require('./identity'),\n    overRest = require('./_overRest'),\n    setToString = require('./_setToString');\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseRest.js\n// module id = 399\n// module chunks = 0","var apply = require('./_apply');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\nmodule.exports = overRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_overRest.js\n// module id = 400\n// module chunks = 0","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_apply.js\n// module id = 401\n// module chunks = 0","var baseSetToString = require('./_baseSetToString'),\n    shortOut = require('./_shortOut');\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_setToString.js\n// module id = 402\n// module chunks = 0","var constant = require('./constant'),\n    defineProperty = require('./_defineProperty'),\n    identity = require('./identity');\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\nmodule.exports = baseSetToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseSetToString.js\n// module id = 403\n// module chunks = 0","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nmodule.exports = constant;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/constant.js\n// module id = 404\n// module chunks = 0","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_defineProperty.js\n// module id = 405\n// module chunks = 0","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getNative.js\n// module id = 406\n// module chunks = 0","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseIsNative.js\n// module id = 407\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isFunction.js\n// module id = 408\n// module chunks = 0","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_isMasked.js\n// module id = 409\n// module chunks = 0","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_coreJsData.js\n// module id = 410\n// module chunks = 0","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_toSource.js\n// module id = 411\n// module chunks = 0","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getValue.js\n// module id = 412\n// module chunks = 0","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nmodule.exports = shortOut;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_shortOut.js\n// module id = 413\n// module chunks = 0","/* eslint-disable func-names, max-len, no-new, no-plusplus, no-shadow, no-underscore-dangle, no-console */\r\nimport $ from 'jquery';\r\n\r\nconst $showHideSection = $('.js-table-section');\r\nconst $showHideArea = $('.js-show-hide-content');\r\nconst $showHideBtn = $('.js-show-hide-btn');\r\n\r\nif ($showHideArea.length > 0) {\r\n  $showHideBtn.on('click tap', (e) => {\r\n    const $this = $(e.currentTarget);\r\n    $this.toggleClass('is-active');\r\n\r\n    $this.parents($showHideSection).find($showHideArea).slideToggle();\r\n  });\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-show-hide.js","import $ from 'jquery';\r\n\r\n$(() => {\r\n  const $elements = $('.js-scroll-top');\r\n\r\n  $elements.click((event) => {\r\n    event.preventDefault();\r\n    $('html, body').animate({ scrollTop: 0 });\r\n  });\r\n});\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-scroll-up.js","import $ from 'jquery';\r\n\r\n$(document).ready(() => {\r\n  if (window.location.hash) {\r\n    const preAnchor = window.location.hash.substr(1);\r\n    $('html, body').scrollTop(0);\r\n\r\n    setTimeout(() => {\r\n      const attrName = $(`a[name=\"${preAnchor}\"]`);\r\n      $('html,body').animate({\r\n        scrollTop: attrName.offset().top,\r\n      }, 500);\r\n    }, 200);\r\n  }\r\n\r\n  $('.js-scroll').click((event) => {\r\n    if ($('.home-page').length) {\r\n      event.preventDefault();\r\n    }\r\n\r\n    const anchor = $(event.currentTarget).attr('data-attr-scroll');\r\n    const anchorOffset = 0;\r\n\r\n    if (!anchorOffset) {\r\n      const attrName = $(`a[name=\"${anchor}\"]`);\r\n      $('html,body').animate({\r\n        scrollTop: attrName.offset().top,\r\n      }, 500);\r\n    }\r\n  });\r\n});\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-scroll-section.js","import $ from 'jquery';\r\nimport svg4everybody from 'svg4everybody/dist/svg4everybody';\r\n\r\n$(document).ready(() => {\r\n  svg4everybody();\r\n});\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-svg4everybody.js","!function(root, factory) {\n    \"function\" == typeof define && define.amd ? // AMD. Register as an anonymous module unless amdModuleId is set\n    define([], function() {\n        return root.svg4everybody = factory();\n    }) : \"object\" == typeof module && module.exports ? // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory() : root.svg4everybody = factory();\n}(this, function() {\n    /*! svg4everybody v2.1.9 | github.com/jonathantneal/svg4everybody */\n    function embed(parent, svg, target) {\n        // if the target exists\n        if (target) {\n            // create a document fragment to hold the contents of the target\n            var fragment = document.createDocumentFragment(), viewBox = !svg.hasAttribute(\"viewBox\") && target.getAttribute(\"viewBox\");\n            // conditionally set the viewBox on the svg\n            viewBox && svg.setAttribute(\"viewBox\", viewBox);\n            // copy the contents of the clone into the fragment\n            for (// clone the target\n            var clone = target.cloneNode(!0); clone.childNodes.length; ) {\n                fragment.appendChild(clone.firstChild);\n            }\n            // append the fragment into the svg\n            parent.appendChild(fragment);\n        }\n    }\n    function loadreadystatechange(xhr) {\n        // listen to changes in the request\n        xhr.onreadystatechange = function() {\n            // if the request is ready\n            if (4 === xhr.readyState) {\n                // get the cached html document\n                var cachedDocument = xhr._cachedDocument;\n                // ensure the cached html document based on the xhr response\n                cachedDocument || (cachedDocument = xhr._cachedDocument = document.implementation.createHTMLDocument(\"\"), \n                cachedDocument.body.innerHTML = xhr.responseText, xhr._cachedTarget = {}), // clear the xhr embeds list and embed each item\n                xhr._embeds.splice(0).map(function(item) {\n                    // get the cached target\n                    var target = xhr._cachedTarget[item.id];\n                    // ensure the cached target\n                    target || (target = xhr._cachedTarget[item.id] = cachedDocument.getElementById(item.id)), \n                    // embed the target into the svg\n                    embed(item.parent, item.svg, target);\n                });\n            }\n        }, // test the ready state change immediately\n        xhr.onreadystatechange();\n    }\n    function svg4everybody(rawopts) {\n        function oninterval() {\n            // while the index exists in the live <use> collection\n            for (// get the cached <use> index\n            var index = 0; index < uses.length; ) {\n                // get the current <use>\n                var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent), src = use.getAttribute(\"xlink:href\") || use.getAttribute(\"href\");\n                if (!src && opts.attributeName && (src = use.getAttribute(opts.attributeName)), \n                svg && src) {\n                    if (polyfill) {\n                        if (!opts.validate || opts.validate(src, svg, use)) {\n                            // remove the <use> element\n                            parent.removeChild(use);\n                            // parse the src and get the url and id\n                            var srcSplit = src.split(\"#\"), url = srcSplit.shift(), id = srcSplit.join(\"#\");\n                            // if the link is external\n                            if (url.length) {\n                                // get the cached xhr request\n                                var xhr = requests[url];\n                                // ensure the xhr request exists\n                                xhr || (xhr = requests[url] = new XMLHttpRequest(), xhr.open(\"GET\", url), xhr.send(), \n                                xhr._embeds = []), // add the svg and id as an item to the xhr embeds list\n                                xhr._embeds.push({\n                                    parent: parent,\n                                    svg: svg,\n                                    id: id\n                                }), // prepare the xhr ready state change event\n                                loadreadystatechange(xhr);\n                            } else {\n                                // embed the local id into the svg\n                                embed(parent, svg, document.getElementById(id));\n                            }\n                        } else {\n                            // increase the index when the previous value was not \"valid\"\n                            ++index, ++numberOfSvgUseElementsToBypass;\n                        }\n                    }\n                } else {\n                    // increase the index when the previous value was not \"valid\"\n                    ++index;\n                }\n            }\n            // continue the interval\n            (!uses.length || uses.length - numberOfSvgUseElementsToBypass > 0) && requestAnimationFrame(oninterval, 67);\n        }\n        var polyfill, opts = Object(rawopts), newerIEUA = /\\bTrident\\/[567]\\b|\\bMSIE (?:9|10)\\.0\\b/, webkitUA = /\\bAppleWebKit\\/(\\d+)\\b/, olderEdgeUA = /\\bEdge\\/12\\.(\\d+)\\b/, edgeUA = /\\bEdge\\/.(\\d+)\\b/, inIframe = window.top !== window.self;\n        polyfill = \"polyfill\" in opts ? opts.polyfill : newerIEUA.test(navigator.userAgent) || (navigator.userAgent.match(olderEdgeUA) || [])[1] < 10547 || (navigator.userAgent.match(webkitUA) || [])[1] < 537 || edgeUA.test(navigator.userAgent) && inIframe;\n        // create xhr requests object\n        var requests = {}, requestAnimationFrame = window.requestAnimationFrame || setTimeout, uses = document.getElementsByTagName(\"use\"), numberOfSvgUseElementsToBypass = 0;\n        // conditionally start the interval if the polyfill is active\n        polyfill && oninterval();\n    }\n    function getSVGAncestor(node) {\n        for (var svg = node; \"svg\" !== svg.nodeName.toLowerCase() && (svg = svg.parentNode); ) {}\n        return svg;\n    }\n    return svg4everybody;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/svg4everybody/dist/svg4everybody.js\n// module id = 418\n// module chunks = 0","/* eslint-disable no-unused-vars */\r\nimport $ from 'jquery';\r\nimport Tooltip from 'tooltip.js/dist/umd/tooltip';\r\n\r\n// $(document).ready(() => {\r\n//   const $validationSelector = $('.js-validation');\r\n//\r\n//   if ($validationSelector.length > 0) {\r\n//     $validationSelector.each((i, item) => {\r\n//       const $item = $(item);\r\n//       const instance = new Tooltip($item, {\r\n//         trigger: 'focus',\r\n//       });\r\n//       // instance.show();\r\n//     });\r\n//   }\r\n// });\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/components/init-validation-tooltip.js","/**!\n * @fileOverview Kickass library to create and place poppers near their reference elements.\n * @version 1.3.3\n * @license\n * Copyright (c) 2016 Federico Zivolo and contributors\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('popper.js')) :\n\ttypeof define === 'function' && define.amd ? define(['popper.js'], factory) :\n\t(global.Tooltip = factory(global.Popper));\n}(this, (function (Popper) { 'use strict';\n\nPopper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;\n\n/**\n * Check if the given variable is a function\n * @method\n * @memberof Popper.Utils\n * @argument {Any} functionToCheck - variable to check\n * @returns {Boolean} answer to: is a function?\n */\nfunction isFunction(functionToCheck) {\n  var getType = {};\n  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n\n\n\n\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar DEFAULT_OPTIONS = {\n  container: false,\n  delay: 0,\n  html: false,\n  placement: 'top',\n  title: '',\n  template: '<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>',\n  trigger: 'hover focus',\n  offset: 0,\n  arrowSelector: '.tooltip-arrow, .tooltip__arrow',\n  innerSelector: '.tooltip-inner, .tooltip__inner'\n};\n\nvar Tooltip = function () {\n  /**\n   * Create a new Tooltip.js instance\n   * @class Tooltip\n   * @param {HTMLElement} reference - The DOM node used as reference of the tooltip (it can be a jQuery element).\n   * @param {Object} options\n   * @param {String} options.placement='top'\n   *      Placement of the popper accepted values: `top(-start, -end), right(-start, -end), bottom(-start, -end),\n   *      left(-start, -end)`\n   * @param {String} [options.arrowSelector='.tooltip-arrow, .tooltip__arrow'] - className used to locate the DOM arrow element in the tooltip.\n   * @param {String} [options.innerSelector='.tooltip-inner, .tooltip__inner'] - className used to locate the DOM inner element in the tooltip.\n   * @param {HTMLElement|String|false} options.container=false - Append the tooltip to a specific element.\n   * @param {Number|Object} options.delay=0\n   *      Delay showing and hiding the tooltip (ms) - does not apply to manual trigger type.\n   *      If a number is supplied, delay is applied to both hide/show.\n   *      Object structure is: `{ show: 500, hide: 100 }`\n   * @param {Boolean} options.html=false - Insert HTML into the tooltip. If false, the content will inserted with `textContent`.\n   * @param {String} [options.template='<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>']\n   *      Base HTML to used when creating the tooltip.\n   *      The tooltip's `title` will be injected into the `.tooltip-inner` or `.tooltip__inner`.\n   *      `.tooltip-arrow` or `.tooltip__arrow` will become the tooltip's arrow.\n   *      The outermost wrapper element should have the `.tooltip` class.\n   * @param {String|HTMLElement|TitleFunction} options.title='' - Default title value if `title` attribute isn't present.\n   * @param {String} [options.trigger='hover focus']\n   *      How tooltip is triggered - click, hover, focus, manual.\n   *      You may pass multiple triggers; separate them with a space. `manual` cannot be combined with any other trigger.\n   * @param {Boolean} options.closeOnClickOutside=false - Close a popper on click outside of the popper and reference element. This has effect only when options.trigger is 'click'.\n   * @param {String|HTMLElement} options.boundariesElement\n   *      The element used as boundaries for the tooltip. For more information refer to Popper.js'\n   *      [boundariesElement docs](https://popper.js.org/popper-documentation.html)\n   * @param {Number|String} options.offset=0 - Offset of the tooltip relative to its reference. For more information refer to Popper.js'\n   *      [offset docs](https://popper.js.org/popper-documentation.html)\n   * @param {Object} options.popperOptions={} - Popper options, will be passed directly to popper instance. For more information refer to Popper.js'\n   *      [options docs](https://popper.js.org/popper-documentation.html)\n   * @return {Object} instance - The generated tooltip instance\n   */\n  function Tooltip(reference, options) {\n    classCallCheck(this, Tooltip);\n\n    _initialiseProps.call(this);\n\n    // apply user options over default ones\n    options = _extends({}, DEFAULT_OPTIONS, options);\n\n    reference.jquery && (reference = reference[0]);\n\n    // cache reference and options\n    this.reference = reference;\n    this.options = options;\n\n    // get events list\n    var events = typeof options.trigger === 'string' ? options.trigger.split(' ').filter(function (trigger) {\n      return ['click', 'hover', 'focus'].indexOf(trigger) !== -1;\n    }) : [];\n\n    // set initial state\n    this._isOpen = false;\n    this._popperOptions = {};\n\n    // set event listeners\n    this._setEventListeners(reference, events, options);\n  }\n\n  //\n  // Public methods\n  //\n\n  /**\n   * Reveals an element's tooltip. This is considered a \"manual\" triggering of the tooltip.\n   * Tooltips with zero-length titles are never displayed.\n   * @method Tooltip#show\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Hides an element’s tooltip. This is considered a “manual” triggering of the tooltip.\n   * @method Tooltip#hide\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Hides and destroys an element’s tooltip.\n   * @method Tooltip#dispose\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Toggles an element’s tooltip. This is considered a “manual” triggering of the tooltip.\n   * @method Tooltip#toggle\n   * @memberof Tooltip\n   */\n\n\n  /**\n   * Updates the tooltip's title content\n   * @method Tooltip#updateTitleContent\n   * @memberof Tooltip\n   * @param {String|HTMLElement} title - The new content to use for the title\n   */\n\n\n  //\n  // Private methods\n  //\n\n  createClass(Tooltip, [{\n    key: '_create',\n\n\n    /**\n     * Creates a new tooltip node\n     * @memberof Tooltip\n     * @private\n     * @param {HTMLElement} reference\n     * @param {String} template\n     * @param {String|HTMLElement|TitleFunction} title\n     * @param {Boolean} allowHtml\n     * @return {HTMLElement} tooltipNode\n     */\n    value: function _create(reference, template, title, allowHtml) {\n      // create tooltip element\n      var tooltipGenerator = window.document.createElement('div');\n      tooltipGenerator.innerHTML = template.trim();\n      var tooltipNode = tooltipGenerator.childNodes[0];\n\n      // add unique ID to our tooltip (needed for accessibility reasons)\n      tooltipNode.id = 'tooltip_' + Math.random().toString(36).substr(2, 10);\n\n      // set initial `aria-hidden` state to `false` (it's visible!)\n      tooltipNode.setAttribute('aria-hidden', 'false');\n\n      // add title to tooltip\n      var titleNode = tooltipGenerator.querySelector(this.options.innerSelector);\n      this._addTitleContent(reference, title, allowHtml, titleNode);\n\n      // return the generated tooltip node\n      return tooltipNode;\n    }\n  }, {\n    key: '_addTitleContent',\n    value: function _addTitleContent(reference, title, allowHtml, titleNode) {\n      if (title.nodeType === 1 || title.nodeType === 11) {\n        // if title is a element node or document fragment, append it only if allowHtml is true\n        allowHtml && titleNode.appendChild(title);\n      } else if (isFunction(title)) {\n        // Recursively call ourself so that the return value of the function gets handled appropriately - either\n        // as a dom node, a string, or even as another function.\n        this._addTitleContent(reference, title.call(reference), allowHtml, titleNode);\n      } else {\n        // if it's just a simple text, set textContent or innerHtml depending by `allowHtml` value\n        allowHtml ? titleNode.innerHTML = title : titleNode.textContent = title;\n      }\n    }\n  }, {\n    key: '_show',\n    value: function _show(reference, options) {\n      // don't show if it's already visible\n      // or if it's not being showed\n      if (this._isOpen && !this._isOpening) {\n        return this;\n      }\n      this._isOpen = true;\n\n      // if the tooltipNode already exists, just show it\n      if (this._tooltipNode) {\n        this._tooltipNode.style.visibility = 'visible';\n        this._tooltipNode.setAttribute('aria-hidden', 'false');\n        this.popperInstance.update();\n        return this;\n      }\n\n      // get title\n      var title = reference.getAttribute('title') || options.title;\n\n      // don't show tooltip if no title is defined\n      if (!title) {\n        return this;\n      }\n\n      // create tooltip node\n      var tooltipNode = this._create(reference, options.template, title, options.html);\n\n      // Add `aria-describedby` to our reference element for accessibility reasons\n      reference.setAttribute('aria-describedby', tooltipNode.id);\n\n      // append tooltip to container\n      var container = this._findContainer(options.container, reference);\n\n      this._append(tooltipNode, container);\n\n      this._popperOptions = _extends({}, options.popperOptions, {\n        placement: options.placement\n      });\n\n      this._popperOptions.modifiers = _extends({}, this._popperOptions.modifiers, {\n        arrow: _extends({}, this._popperOptions.modifiers && this._popperOptions.modifiers.arrow, {\n          element: options.arrowSelector\n        }),\n        offset: _extends({}, this._popperOptions.modifiers && this._popperOptions.modifiers.offset, {\n          offset: options.offset || this._popperOptions.modifiers && this._popperOptions.modifiers.offset && this._popperOptions.modifiers.offset.offset || options.offset\n        })\n      });\n\n      if (options.boundariesElement) {\n        this._popperOptions.modifiers.preventOverflow = {\n          boundariesElement: options.boundariesElement\n        };\n      }\n\n      this.popperInstance = new Popper(reference, tooltipNode, this._popperOptions);\n\n      this._tooltipNode = tooltipNode;\n\n      return this;\n    }\n  }, {\n    key: '_hide',\n    value: function _hide() /*reference, options*/{\n      // don't hide if it's already hidden\n      if (!this._isOpen) {\n        return this;\n      }\n\n      this._isOpen = false;\n\n      // hide tooltipNode\n      this._tooltipNode.style.visibility = 'hidden';\n      this._tooltipNode.setAttribute('aria-hidden', 'true');\n\n      return this;\n    }\n  }, {\n    key: '_dispose',\n    value: function _dispose() {\n      var _this = this;\n\n      // remove event listeners first to prevent any unexpected behaviour\n      this._events.forEach(function (_ref) {\n        var func = _ref.func,\n            event = _ref.event;\n\n        _this.reference.removeEventListener(event, func);\n      });\n      this._events = [];\n\n      if (this._tooltipNode) {\n        this._hide();\n\n        // destroy instance\n        this.popperInstance.destroy();\n\n        // destroy tooltipNode if removeOnDestroy is not set, as popperInstance.destroy() already removes the element\n        if (!this.popperInstance.options.removeOnDestroy) {\n          this._tooltipNode.parentNode.removeChild(this._tooltipNode);\n          this._tooltipNode = null;\n        }\n      }\n      return this;\n    }\n  }, {\n    key: '_findContainer',\n    value: function _findContainer(container, reference) {\n      // if container is a query, get the relative element\n      if (typeof container === 'string') {\n        container = window.document.querySelector(container);\n      } else if (container === false) {\n        // if container is `false`, set it to reference parent\n        container = reference.parentNode;\n      }\n      return container;\n    }\n\n    /**\n     * Append tooltip to container\n     * @memberof Tooltip\n     * @private\n     * @param {HTMLElement} tooltipNode\n     * @param {HTMLElement|String|false} container\n     */\n\n  }, {\n    key: '_append',\n    value: function _append(tooltipNode, container) {\n      container.appendChild(tooltipNode);\n    }\n  }, {\n    key: '_setEventListeners',\n    value: function _setEventListeners(reference, events, options) {\n      var _this2 = this;\n\n      var directEvents = [];\n      var oppositeEvents = [];\n\n      events.forEach(function (event) {\n        switch (event) {\n          case 'hover':\n            directEvents.push('mouseenter');\n            oppositeEvents.push('mouseleave');\n            break;\n          case 'focus':\n            directEvents.push('focus');\n            oppositeEvents.push('blur');\n            break;\n          case 'click':\n            directEvents.push('click');\n            oppositeEvents.push('click');\n            break;\n        }\n      });\n\n      // schedule show tooltip\n      directEvents.forEach(function (event) {\n        var func = function func(evt) {\n          if (_this2._isOpening === true) {\n            return;\n          }\n          evt.usedByTooltip = true;\n          _this2._scheduleShow(reference, options.delay, options, evt);\n        };\n        _this2._events.push({ event: event, func: func });\n        reference.addEventListener(event, func);\n      });\n\n      // schedule hide tooltip\n      oppositeEvents.forEach(function (event) {\n        var func = function func(evt) {\n          if (evt.usedByTooltip === true) {\n            return;\n          }\n          _this2._scheduleHide(reference, options.delay, options, evt);\n        };\n        _this2._events.push({ event: event, func: func });\n        reference.addEventListener(event, func);\n        if (event === 'click' && options.closeOnClickOutside) {\n          document.addEventListener('mousedown', function (e) {\n            if (!_this2._isOpening) {\n              return;\n            }\n            var popper = _this2.popperInstance.popper;\n            if (reference.contains(e.target) || popper.contains(e.target)) {\n              return;\n            }\n            func(e);\n          }, true);\n        }\n      });\n    }\n  }, {\n    key: '_scheduleShow',\n    value: function _scheduleShow(reference, delay, options /*, evt */) {\n      var _this3 = this;\n\n      this._isOpening = true;\n      // defaults to 0\n      var computedDelay = delay && delay.show || delay || 0;\n      this._showTimeout = window.setTimeout(function () {\n        return _this3._show(reference, options);\n      }, computedDelay);\n    }\n  }, {\n    key: '_scheduleHide',\n    value: function _scheduleHide(reference, delay, options, evt) {\n      var _this4 = this;\n\n      this._isOpening = false;\n      // defaults to 0\n      var computedDelay = delay && delay.hide || delay || 0;\n      window.clearTimeout(this._showTimeout);\n      window.setTimeout(function () {\n        if (_this4._isOpen === false) {\n          return;\n        }\n        if (!document.body.contains(_this4._tooltipNode)) {\n          return;\n        }\n\n        // if we are hiding because of a mouseleave, we must check that the new\n        // reference isn't the tooltip, because in this case we don't want to hide it\n        if (evt.type === 'mouseleave') {\n          var isSet = _this4._setTooltipNodeEvent(evt, reference, delay, options);\n\n          // if we set the new event, don't hide the tooltip yet\n          // the new event will take care to hide it if necessary\n          if (isSet) {\n            return;\n          }\n        }\n\n        _this4._hide(reference, options);\n      }, computedDelay);\n    }\n  }, {\n    key: '_updateTitleContent',\n    value: function _updateTitleContent(title) {\n      if (typeof this._tooltipNode === 'undefined') {\n        if (typeof this.options.title !== 'undefined') {\n          this.options.title = title;\n        }\n        return;\n      }\n      var titleNode = this._tooltipNode.querySelector(this.options.innerSelector);\n      this._clearTitleContent(titleNode, this.options.html, this.reference.getAttribute('title') || this.options.title);\n      this._addTitleContent(this.reference, title, this.options.html, titleNode);\n      this.options.title = title;\n      this.popperInstance.update();\n    }\n  }, {\n    key: '_clearTitleContent',\n    value: function _clearTitleContent(titleNode, allowHtml, lastTitle) {\n      if (lastTitle.nodeType === 1 || lastTitle.nodeType === 11) {\n        allowHtml && titleNode.removeChild(lastTitle);\n      } else {\n        allowHtml ? titleNode.innerHTML = '' : titleNode.textContent = '';\n      }\n    }\n  }]);\n  return Tooltip;\n}();\n\n/**\n * Title function, its context is the Tooltip instance.\n * @memberof Tooltip\n * @callback TitleFunction\n * @return {String} placement - The desired title.\n */\n\n\nvar _initialiseProps = function _initialiseProps() {\n  var _this5 = this;\n\n  this.show = function () {\n    return _this5._show(_this5.reference, _this5.options);\n  };\n\n  this.hide = function () {\n    return _this5._hide();\n  };\n\n  this.dispose = function () {\n    return _this5._dispose();\n  };\n\n  this.toggle = function () {\n    if (_this5._isOpen) {\n      return _this5.hide();\n    } else {\n      return _this5.show();\n    }\n  };\n\n  this.updateTitleContent = function (title) {\n    return _this5._updateTitleContent(title);\n  };\n\n  this._events = [];\n\n  this._setTooltipNodeEvent = function (evt, reference, delay, options) {\n    var relatedreference = evt.relatedreference || evt.toElement || evt.relatedTarget;\n\n    var callback = function callback(evt2) {\n      var relatedreference2 = evt2.relatedreference || evt2.toElement || evt2.relatedTarget;\n\n      // Remove event listener after call\n      _this5._tooltipNode.removeEventListener(evt.type, callback);\n\n      // If the new reference is not the reference element\n      if (!reference.contains(relatedreference2)) {\n        // Schedule to hide tooltip\n        _this5._scheduleHide(reference, options.delay, options, evt2);\n      }\n    };\n\n    if (_this5._tooltipNode.contains(relatedreference)) {\n      // listen to mouseleave on the tooltip element to be able to hide the tooltip\n      _this5._tooltipNode.addEventListener(evt.type, callback);\n      return true;\n    }\n\n    return false;\n  };\n};\n\nreturn Tooltip;\n\n})));\n//# sourceMappingURL=tooltip.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/tooltip.js/dist/umd/tooltip.js\n// module id = 420\n// module chunks = 0","/**!\n * @fileOverview Kickass library to create and place poppers near their reference elements.\n * @version 1.16.1\n * @license\n * Copyright (c) 2016 Federico Zivolo and contributors\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';\n\nvar timeoutDuration = function () {\n  var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];\n  for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {\n    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {\n      return 1;\n    }\n  }\n  return 0;\n}();\n\nfunction microtaskDebounce(fn) {\n  var called = false;\n  return function () {\n    if (called) {\n      return;\n    }\n    called = true;\n    window.Promise.resolve().then(function () {\n      called = false;\n      fn();\n    });\n  };\n}\n\nfunction taskDebounce(fn) {\n  var scheduled = false;\n  return function () {\n    if (!scheduled) {\n      scheduled = true;\n      setTimeout(function () {\n        scheduled = false;\n        fn();\n      }, timeoutDuration);\n    }\n  };\n}\n\nvar supportsMicroTasks = isBrowser && window.Promise;\n\n/**\n* Create a debounced version of a method, that's asynchronously deferred\n* but called in the minimum time possible.\n*\n* @method\n* @memberof Popper.Utils\n* @argument {Function} fn\n* @returns {Function}\n*/\nvar debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;\n\n/**\n * Check if the given variable is a function\n * @method\n * @memberof Popper.Utils\n * @argument {Any} functionToCheck - variable to check\n * @returns {Boolean} answer to: is a function?\n */\nfunction isFunction(functionToCheck) {\n  var getType = {};\n  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';\n}\n\n/**\n * Get CSS computed property of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Eement} element\n * @argument {String} property\n */\nfunction getStyleComputedProperty(element, property) {\n  if (element.nodeType !== 1) {\n    return [];\n  }\n  // NOTE: 1 DOM access here\n  var window = element.ownerDocument.defaultView;\n  var css = window.getComputedStyle(element, null);\n  return property ? css[property] : css;\n}\n\n/**\n * Returns the parentNode or the host of the element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} parent\n */\nfunction getParentNode(element) {\n  if (element.nodeName === 'HTML') {\n    return element;\n  }\n  return element.parentNode || element.host;\n}\n\n/**\n * Returns the scrolling parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} scroll parent\n */\nfunction getScrollParent(element) {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  if (!element) {\n    return document.body;\n  }\n\n  switch (element.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return element.ownerDocument.body;\n    case '#document':\n      return element.body;\n  }\n\n  // Firefox want us to check `-x` and `-y` variations as well\n\n  var _getStyleComputedProp = getStyleComputedProperty(element),\n      overflow = _getStyleComputedProp.overflow,\n      overflowX = _getStyleComputedProp.overflowX,\n      overflowY = _getStyleComputedProp.overflowY;\n\n  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {\n    return element;\n  }\n\n  return getScrollParent(getParentNode(element));\n}\n\n/**\n * Returns the reference node of the reference object, or the reference object itself.\n * @method\n * @memberof Popper.Utils\n * @param {Element|Object} reference - the reference element (the popper will be relative to this)\n * @returns {Element} parent\n */\nfunction getReferenceNode(reference) {\n  return reference && reference.referenceNode ? reference.referenceNode : reference;\n}\n\nvar isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);\nvar isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);\n\n/**\n * Determines if the browser is Internet Explorer\n * @method\n * @memberof Popper.Utils\n * @param {Number} version to check\n * @returns {Boolean} isIE\n */\nfunction isIE(version) {\n  if (version === 11) {\n    return isIE11;\n  }\n  if (version === 10) {\n    return isIE10;\n  }\n  return isIE11 || isIE10;\n}\n\n/**\n * Returns the offset parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} offset parent\n */\nfunction getOffsetParent(element) {\n  if (!element) {\n    return document.documentElement;\n  }\n\n  var noOffsetParent = isIE(10) ? document.body : null;\n\n  // NOTE: 1 DOM access here\n  var offsetParent = element.offsetParent || null;\n  // Skip hidden elements which don't have an offsetParent\n  while (offsetParent === noOffsetParent && element.nextElementSibling) {\n    offsetParent = (element = element.nextElementSibling).offsetParent;\n  }\n\n  var nodeName = offsetParent && offsetParent.nodeName;\n\n  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {\n    return element ? element.ownerDocument.documentElement : document.documentElement;\n  }\n\n  // .offsetParent will return the closest TH, TD or TABLE in case\n  // no offsetParent is present, I hate this job...\n  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {\n    return getOffsetParent(offsetParent);\n  }\n\n  return offsetParent;\n}\n\nfunction isOffsetContainer(element) {\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY') {\n    return false;\n  }\n  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;\n}\n\n/**\n * Finds the root node (document, shadowDOM root) of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} node\n * @returns {Element} root node\n */\nfunction getRoot(node) {\n  if (node.parentNode !== null) {\n    return getRoot(node.parentNode);\n  }\n\n  return node;\n}\n\n/**\n * Finds the offset parent common to the two provided nodes\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element1\n * @argument {Element} element2\n * @returns {Element} common offset parent\n */\nfunction findCommonOffsetParent(element1, element2) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {\n    return document.documentElement;\n  }\n\n  // Here we make sure to give as \"start\" the element that comes first in the DOM\n  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;\n  var start = order ? element1 : element2;\n  var end = order ? element2 : element1;\n\n  // Get common ancestor container\n  var range = document.createRange();\n  range.setStart(start, 0);\n  range.setEnd(end, 0);\n  var commonAncestorContainer = range.commonAncestorContainer;\n\n  // Both nodes are inside #document\n\n  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {\n    if (isOffsetContainer(commonAncestorContainer)) {\n      return commonAncestorContainer;\n    }\n\n    return getOffsetParent(commonAncestorContainer);\n  }\n\n  // one of the nodes is inside shadowDOM, find which one\n  var element1root = getRoot(element1);\n  if (element1root.host) {\n    return findCommonOffsetParent(element1root.host, element2);\n  } else {\n    return findCommonOffsetParent(element1, getRoot(element2).host);\n  }\n}\n\n/**\n * Gets the scroll value of the given element in the given side (top and left)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {String} side `top` or `left`\n * @returns {number} amount of scrolled pixels\n */\nfunction getScroll(element) {\n  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';\n\n  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    var html = element.ownerDocument.documentElement;\n    var scrollingElement = element.ownerDocument.scrollingElement || html;\n    return scrollingElement[upperSide];\n  }\n\n  return element[upperSide];\n}\n\n/*\n * Sum or subtract the element scroll values (left and top) from a given rect object\n * @method\n * @memberof Popper.Utils\n * @param {Object} rect - Rect object you want to change\n * @param {HTMLElement} element - The element from the function reads the scroll values\n * @param {Boolean} subtract - set to true if you want to subtract the scroll values\n * @return {Object} rect - The modifier rect object\n */\nfunction includeScroll(rect, element) {\n  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var scrollTop = getScroll(element, 'top');\n  var scrollLeft = getScroll(element, 'left');\n  var modifier = subtract ? -1 : 1;\n  rect.top += scrollTop * modifier;\n  rect.bottom += scrollTop * modifier;\n  rect.left += scrollLeft * modifier;\n  rect.right += scrollLeft * modifier;\n  return rect;\n}\n\n/*\n * Helper to detect borders of a given element\n * @method\n * @memberof Popper.Utils\n * @param {CSSStyleDeclaration} styles\n * Result of `getStyleComputedProperty` on the given element\n * @param {String} axis - `x` or `y`\n * @return {number} borders - The borders size of the given axis\n */\n\nfunction getBordersSize(styles, axis) {\n  var sideA = axis === 'x' ? 'Left' : 'Top';\n  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';\n\n  return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']);\n}\n\nfunction getSize(axis, body, html, computedStyle) {\n  return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);\n}\n\nfunction getWindowSizes(document) {\n  var body = document.body;\n  var html = document.documentElement;\n  var computedStyle = isIE(10) && getComputedStyle(html);\n\n  return {\n    height: getSize('Height', body, html, computedStyle),\n    width: getSize('Width', body, html, computedStyle)\n  };\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n\n\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\n/**\n * Given element offsets, generate an output similar to getBoundingClientRect\n * @method\n * @memberof Popper.Utils\n * @argument {Object} offsets\n * @returns {Object} ClientRect like output\n */\nfunction getClientRect(offsets) {\n  return _extends({}, offsets, {\n    right: offsets.left + offsets.width,\n    bottom: offsets.top + offsets.height\n  });\n}\n\n/**\n * Get bounding client rect of given element\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} element\n * @return {Object} client rect\n */\nfunction getBoundingClientRect(element) {\n  var rect = {};\n\n  // IE10 10 FIX: Please, don't ask, the element isn't\n  // considered in DOM in some circumstances...\n  // This isn't reproducible in IE10 compatibility mode of IE11\n  try {\n    if (isIE(10)) {\n      rect = element.getBoundingClientRect();\n      var scrollTop = getScroll(element, 'top');\n      var scrollLeft = getScroll(element, 'left');\n      rect.top += scrollTop;\n      rect.left += scrollLeft;\n      rect.bottom += scrollTop;\n      rect.right += scrollLeft;\n    } else {\n      rect = element.getBoundingClientRect();\n    }\n  } catch (e) {}\n\n  var result = {\n    left: rect.left,\n    top: rect.top,\n    width: rect.right - rect.left,\n    height: rect.bottom - rect.top\n  };\n\n  // subtract scrollbar size from sizes\n  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};\n  var width = sizes.width || element.clientWidth || result.width;\n  var height = sizes.height || element.clientHeight || result.height;\n\n  var horizScrollbar = element.offsetWidth - width;\n  var vertScrollbar = element.offsetHeight - height;\n\n  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`\n  // we make this check conditional for performance reasons\n  if (horizScrollbar || vertScrollbar) {\n    var styles = getStyleComputedProperty(element);\n    horizScrollbar -= getBordersSize(styles, 'x');\n    vertScrollbar -= getBordersSize(styles, 'y');\n\n    result.width -= horizScrollbar;\n    result.height -= vertScrollbar;\n  }\n\n  return getClientRect(result);\n}\n\nfunction getOffsetRectRelativeToArbitraryNode(children, parent) {\n  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var isIE10 = isIE(10);\n  var isHTML = parent.nodeName === 'HTML';\n  var childrenRect = getBoundingClientRect(children);\n  var parentRect = getBoundingClientRect(parent);\n  var scrollParent = getScrollParent(children);\n\n  var styles = getStyleComputedProperty(parent);\n  var borderTopWidth = parseFloat(styles.borderTopWidth);\n  var borderLeftWidth = parseFloat(styles.borderLeftWidth);\n\n  // In cases where the parent is fixed, we must ignore negative scroll in offset calc\n  if (fixedPosition && isHTML) {\n    parentRect.top = Math.max(parentRect.top, 0);\n    parentRect.left = Math.max(parentRect.left, 0);\n  }\n  var offsets = getClientRect({\n    top: childrenRect.top - parentRect.top - borderTopWidth,\n    left: childrenRect.left - parentRect.left - borderLeftWidth,\n    width: childrenRect.width,\n    height: childrenRect.height\n  });\n  offsets.marginTop = 0;\n  offsets.marginLeft = 0;\n\n  // Subtract margins of documentElement in case it's being used as parent\n  // we do this only on HTML because it's the only element that behaves\n  // differently when margins are applied to it. The margins are included in\n  // the box of the documentElement, in the other cases not.\n  if (!isIE10 && isHTML) {\n    var marginTop = parseFloat(styles.marginTop);\n    var marginLeft = parseFloat(styles.marginLeft);\n\n    offsets.top -= borderTopWidth - marginTop;\n    offsets.bottom -= borderTopWidth - marginTop;\n    offsets.left -= borderLeftWidth - marginLeft;\n    offsets.right -= borderLeftWidth - marginLeft;\n\n    // Attach marginTop and marginLeft because in some circumstances we may need them\n    offsets.marginTop = marginTop;\n    offsets.marginLeft = marginLeft;\n  }\n\n  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {\n    offsets = includeScroll(offsets, parent);\n  }\n\n  return offsets;\n}\n\nfunction getViewportOffsetRectRelativeToArtbitraryNode(element) {\n  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var html = element.ownerDocument.documentElement;\n  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);\n  var width = Math.max(html.clientWidth, window.innerWidth || 0);\n  var height = Math.max(html.clientHeight, window.innerHeight || 0);\n\n  var scrollTop = !excludeScroll ? getScroll(html) : 0;\n  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;\n\n  var offset = {\n    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,\n    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,\n    width: width,\n    height: height\n  };\n\n  return getClientRect(offset);\n}\n\n/**\n * Check if the given element is fixed or is inside a fixed parent\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {Element} customContainer\n * @returns {Boolean} answer to \"isFixed?\"\n */\nfunction isFixed(element) {\n  var nodeName = element.nodeName;\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    return false;\n  }\n  if (getStyleComputedProperty(element, 'position') === 'fixed') {\n    return true;\n  }\n  var parentNode = getParentNode(element);\n  if (!parentNode) {\n    return false;\n  }\n  return isFixed(parentNode);\n}\n\n/**\n * Finds the first parent of an element that has a transformed property defined\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} first transformed parent or documentElement\n */\n\nfunction getFixedPositionOffsetParent(element) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element || !element.parentElement || isIE()) {\n    return document.documentElement;\n  }\n  var el = element.parentElement;\n  while (el && getStyleComputedProperty(el, 'transform') === 'none') {\n    el = el.parentElement;\n  }\n  return el || document.documentElement;\n}\n\n/**\n * Computed the boundaries limits and return them\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} popper\n * @param {HTMLElement} reference\n * @param {number} padding\n * @param {HTMLElement} boundariesElement - Element used to define the boundaries\n * @param {Boolean} fixedPosition - Is in fixed position mode\n * @returns {Object} Coordinates of the boundaries\n */\nfunction getBoundaries(popper, reference, padding, boundariesElement) {\n  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n  // NOTE: 1 DOM access here\n\n  var boundaries = { top: 0, left: 0 };\n  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n\n  // Handle viewport case\n  if (boundariesElement === 'viewport') {\n    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);\n  } else {\n    // Handle other cases based on DOM element used as boundaries\n    var boundariesNode = void 0;\n    if (boundariesElement === 'scrollParent') {\n      boundariesNode = getScrollParent(getParentNode(reference));\n      if (boundariesNode.nodeName === 'BODY') {\n        boundariesNode = popper.ownerDocument.documentElement;\n      }\n    } else if (boundariesElement === 'window') {\n      boundariesNode = popper.ownerDocument.documentElement;\n    } else {\n      boundariesNode = boundariesElement;\n    }\n\n    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);\n\n    // In case of HTML, we need a different computation\n    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {\n      var _getWindowSizes = getWindowSizes(popper.ownerDocument),\n          height = _getWindowSizes.height,\n          width = _getWindowSizes.width;\n\n      boundaries.top += offsets.top - offsets.marginTop;\n      boundaries.bottom = height + offsets.top;\n      boundaries.left += offsets.left - offsets.marginLeft;\n      boundaries.right = width + offsets.left;\n    } else {\n      // for all the other DOM elements, this one is good\n      boundaries = offsets;\n    }\n  }\n\n  // Add paddings\n  padding = padding || 0;\n  var isPaddingNumber = typeof padding === 'number';\n  boundaries.left += isPaddingNumber ? padding : padding.left || 0;\n  boundaries.top += isPaddingNumber ? padding : padding.top || 0;\n  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;\n  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;\n\n  return boundaries;\n}\n\nfunction getArea(_ref) {\n  var width = _ref.width,\n      height = _ref.height;\n\n  return width * height;\n}\n\n/**\n * Utility used to transform the `auto` placement to the placement with more\n * available space.\n * @method\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {\n  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;\n\n  if (placement.indexOf('auto') === -1) {\n    return placement;\n  }\n\n  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);\n\n  var rects = {\n    top: {\n      width: boundaries.width,\n      height: refRect.top - boundaries.top\n    },\n    right: {\n      width: boundaries.right - refRect.right,\n      height: boundaries.height\n    },\n    bottom: {\n      width: boundaries.width,\n      height: boundaries.bottom - refRect.bottom\n    },\n    left: {\n      width: refRect.left - boundaries.left,\n      height: boundaries.height\n    }\n  };\n\n  var sortedAreas = Object.keys(rects).map(function (key) {\n    return _extends({\n      key: key\n    }, rects[key], {\n      area: getArea(rects[key])\n    });\n  }).sort(function (a, b) {\n    return b.area - a.area;\n  });\n\n  var filteredAreas = sortedAreas.filter(function (_ref2) {\n    var width = _ref2.width,\n        height = _ref2.height;\n    return width >= popper.clientWidth && height >= popper.clientHeight;\n  });\n\n  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;\n\n  var variation = placement.split('-')[1];\n\n  return computedPlacement + (variation ? '-' + variation : '');\n}\n\n/**\n * Get offsets to the reference element\n * @method\n * @memberof Popper.Utils\n * @param {Object} state\n * @param {Element} popper - the popper element\n * @param {Element} reference - the reference element (the popper will be relative to this)\n * @param {Element} fixedPosition - is in fixed position mode\n * @returns {Object} An object containing the offsets which will be applied to the popper\n */\nfunction getReferenceOffsets(state, popper, reference) {\n  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n\n  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);\n}\n\n/**\n * Get the outer sizes of the given element (offset size + margins)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Object} object containing width and height properties\n */\nfunction getOuterSizes(element) {\n  var window = element.ownerDocument.defaultView;\n  var styles = window.getComputedStyle(element);\n  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);\n  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);\n  var result = {\n    width: element.offsetWidth + y,\n    height: element.offsetHeight + x\n  };\n  return result;\n}\n\n/**\n * Get the opposite placement of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement\n * @returns {String} flipped placement\n */\nfunction getOppositePlacement(placement) {\n  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };\n  return placement.replace(/left|right|bottom|top/g, function (matched) {\n    return hash[matched];\n  });\n}\n\n/**\n * Get offsets to the popper\n * @method\n * @memberof Popper.Utils\n * @param {Object} position - CSS position the Popper will get applied\n * @param {HTMLElement} popper - the popper element\n * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)\n * @param {String} placement - one of the valid placement options\n * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper\n */\nfunction getPopperOffsets(popper, referenceOffsets, placement) {\n  placement = placement.split('-')[0];\n\n  // Get popper node sizes\n  var popperRect = getOuterSizes(popper);\n\n  // Add position, width and height to our offsets object\n  var popperOffsets = {\n    width: popperRect.width,\n    height: popperRect.height\n  };\n\n  // depending by the popper placement we have to compute its offsets slightly differently\n  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;\n  var mainSide = isHoriz ? 'top' : 'left';\n  var secondarySide = isHoriz ? 'left' : 'top';\n  var measurement = isHoriz ? 'height' : 'width';\n  var secondaryMeasurement = !isHoriz ? 'height' : 'width';\n\n  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;\n  if (placement === secondarySide) {\n    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];\n  } else {\n    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];\n  }\n\n  return popperOffsets;\n}\n\n/**\n * Mimics the `find` method of Array\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction find(arr, check) {\n  // use native find if supported\n  if (Array.prototype.find) {\n    return arr.find(check);\n  }\n\n  // use `filter` to obtain the same behavior of `find`\n  return arr.filter(check)[0];\n}\n\n/**\n * Return the index of the matching object\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction findIndex(arr, prop, value) {\n  // use native findIndex if supported\n  if (Array.prototype.findIndex) {\n    return arr.findIndex(function (cur) {\n      return cur[prop] === value;\n    });\n  }\n\n  // use `find` + `indexOf` if `findIndex` isn't supported\n  var match = find(arr, function (obj) {\n    return obj[prop] === value;\n  });\n  return arr.indexOf(match);\n}\n\n/**\n * Loop trough the list of modifiers and run them in order,\n * each of them will then edit the data object.\n * @method\n * @memberof Popper.Utils\n * @param {dataObject} data\n * @param {Array} modifiers\n * @param {String} ends - Optional modifier name used as stopper\n * @returns {dataObject}\n */\nfunction runModifiers(modifiers, data, ends) {\n  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));\n\n  modifiersToRun.forEach(function (modifier) {\n    if (modifier['function']) {\n      // eslint-disable-line dot-notation\n      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');\n    }\n    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation\n    if (modifier.enabled && isFunction(fn)) {\n      // Add properties to offsets to make them a complete clientRect object\n      // we do this before each modifier to make sure the previous one doesn't\n      // mess with these values\n      data.offsets.popper = getClientRect(data.offsets.popper);\n      data.offsets.reference = getClientRect(data.offsets.reference);\n\n      data = fn(data, modifier);\n    }\n  });\n\n  return data;\n}\n\n/**\n * Updates the position of the popper, computing the new offsets and applying\n * the new style.<br />\n * Prefer `scheduleUpdate` over `update` because of performance reasons.\n * @method\n * @memberof Popper\n */\nfunction update() {\n  // if popper is destroyed, don't perform any further update\n  if (this.state.isDestroyed) {\n    return;\n  }\n\n  var data = {\n    instance: this,\n    styles: {},\n    arrowStyles: {},\n    attributes: {},\n    flipped: false,\n    offsets: {}\n  };\n\n  // compute reference element offsets\n  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);\n\n  // store the computed placement inside `originalPlacement`\n  data.originalPlacement = data.placement;\n\n  data.positionFixed = this.options.positionFixed;\n\n  // compute the popper offsets\n  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);\n\n  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';\n\n  // run the modifiers\n  data = runModifiers(this.modifiers, data);\n\n  // the first `update` will call `onCreate` callback\n  // the other ones will call `onUpdate` callback\n  if (!this.state.isCreated) {\n    this.state.isCreated = true;\n    this.options.onCreate(data);\n  } else {\n    this.options.onUpdate(data);\n  }\n}\n\n/**\n * Helper used to know if the given modifier is enabled.\n * @method\n * @memberof Popper.Utils\n * @returns {Boolean}\n */\nfunction isModifierEnabled(modifiers, modifierName) {\n  return modifiers.some(function (_ref) {\n    var name = _ref.name,\n        enabled = _ref.enabled;\n    return enabled && name === modifierName;\n  });\n}\n\n/**\n * Get the prefixed supported property name\n * @method\n * @memberof Popper.Utils\n * @argument {String} property (camelCase)\n * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)\n */\nfunction getSupportedPropertyName(property) {\n  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];\n  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);\n\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefix = prefixes[i];\n    var toCheck = prefix ? '' + prefix + upperProp : property;\n    if (typeof document.body.style[toCheck] !== 'undefined') {\n      return toCheck;\n    }\n  }\n  return null;\n}\n\n/**\n * Destroys the popper.\n * @method\n * @memberof Popper\n */\nfunction destroy() {\n  this.state.isDestroyed = true;\n\n  // touch DOM only if `applyStyle` modifier is enabled\n  if (isModifierEnabled(this.modifiers, 'applyStyle')) {\n    this.popper.removeAttribute('x-placement');\n    this.popper.style.position = '';\n    this.popper.style.top = '';\n    this.popper.style.left = '';\n    this.popper.style.right = '';\n    this.popper.style.bottom = '';\n    this.popper.style.willChange = '';\n    this.popper.style[getSupportedPropertyName('transform')] = '';\n  }\n\n  this.disableEventListeners();\n\n  // remove the popper if user explicitly asked for the deletion on destroy\n  // do not use `remove` because IE11 doesn't support it\n  if (this.options.removeOnDestroy) {\n    this.popper.parentNode.removeChild(this.popper);\n  }\n  return this;\n}\n\n/**\n * Get the window associated with the element\n * @argument {Element} element\n * @returns {Window}\n */\nfunction getWindow(element) {\n  var ownerDocument = element.ownerDocument;\n  return ownerDocument ? ownerDocument.defaultView : window;\n}\n\nfunction attachToScrollParents(scrollParent, event, callback, scrollParents) {\n  var isBody = scrollParent.nodeName === 'BODY';\n  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;\n  target.addEventListener(event, callback, { passive: true });\n\n  if (!isBody) {\n    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);\n  }\n  scrollParents.push(target);\n}\n\n/**\n * Setup needed event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction setupEventListeners(reference, options, state, updateBound) {\n  // Resize event listener on window\n  state.updateBound = updateBound;\n  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });\n\n  // Scroll event listener on scroll parents\n  var scrollElement = getScrollParent(reference);\n  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);\n  state.scrollElement = scrollElement;\n  state.eventsEnabled = true;\n\n  return state;\n}\n\n/**\n * It will add resize/scroll events and start recalculating\n * position of the popper element when they are triggered.\n * @method\n * @memberof Popper\n */\nfunction enableEventListeners() {\n  if (!this.state.eventsEnabled) {\n    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);\n  }\n}\n\n/**\n * Remove event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction removeEventListeners(reference, state) {\n  // Remove resize event listener on window\n  getWindow(reference).removeEventListener('resize', state.updateBound);\n\n  // Remove scroll event listener on scroll parents\n  state.scrollParents.forEach(function (target) {\n    target.removeEventListener('scroll', state.updateBound);\n  });\n\n  // Reset state\n  state.updateBound = null;\n  state.scrollParents = [];\n  state.scrollElement = null;\n  state.eventsEnabled = false;\n  return state;\n}\n\n/**\n * It will remove resize/scroll events and won't recalculate popper position\n * when they are triggered. It also won't trigger `onUpdate` callback anymore,\n * unless you call `update` method manually.\n * @method\n * @memberof Popper\n */\nfunction disableEventListeners() {\n  if (this.state.eventsEnabled) {\n    cancelAnimationFrame(this.scheduleUpdate);\n    this.state = removeEventListeners(this.reference, this.state);\n  }\n}\n\n/**\n * Tells if a given input is a number\n * @method\n * @memberof Popper.Utils\n * @param {*} input to check\n * @return {Boolean}\n */\nfunction isNumeric(n) {\n  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);\n}\n\n/**\n * Set the style to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the style to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setStyles(element, styles) {\n  Object.keys(styles).forEach(function (prop) {\n    var unit = '';\n    // add unit if the value is numeric and is one of the following\n    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {\n      unit = 'px';\n    }\n    element.style[prop] = styles[prop] + unit;\n  });\n}\n\n/**\n * Set the attributes to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the attributes to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setAttributes(element, attributes) {\n  Object.keys(attributes).forEach(function (prop) {\n    var value = attributes[prop];\n    if (value !== false) {\n      element.setAttribute(prop, attributes[prop]);\n    } else {\n      element.removeAttribute(prop);\n    }\n  });\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} data.styles - List of style properties - values to apply to popper element\n * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The same data object\n */\nfunction applyStyle(data) {\n  // any property present in `data.styles` will be applied to the popper,\n  // in this way we can make the 3rd party modifiers add custom styles to it\n  // Be aware, modifiers could override the properties defined in the previous\n  // lines of this modifier!\n  setStyles(data.instance.popper, data.styles);\n\n  // any property present in `data.attributes` will be applied to the popper,\n  // they will be set as HTML attributes of the element\n  setAttributes(data.instance.popper, data.attributes);\n\n  // if arrowElement is defined and arrowStyles has some properties\n  if (data.arrowElement && Object.keys(data.arrowStyles).length) {\n    setStyles(data.arrowElement, data.arrowStyles);\n  }\n\n  return data;\n}\n\n/**\n * Set the x-placement attribute before everything else because it could be used\n * to add margins to the popper margins needs to be calculated to get the\n * correct popper offsets.\n * @method\n * @memberof Popper.modifiers\n * @param {HTMLElement} reference - The reference element used to position the popper\n * @param {HTMLElement} popper - The HTML element used as popper\n * @param {Object} options - Popper.js options\n */\nfunction applyStyleOnLoad(reference, popper, options, modifierOptions, state) {\n  // compute reference element offsets\n  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);\n\n  popper.setAttribute('x-placement', placement);\n\n  // Apply `position` to popper before anything else because\n  // without the position applied we can't guarantee correct computations\n  setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });\n\n  return options;\n}\n\n/**\n * @function\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Boolean} shouldRound - If the offsets should be rounded at all\n * @returns {Object} The popper's position offsets rounded\n *\n * The tale of pixel-perfect positioning. It's still not 100% perfect, but as\n * good as it can be within reason.\n * Discussion here: https://github.com/FezVrasta/popper.js/pull/715\n *\n * Low DPI screens cause a popper to be blurry if not using full pixels (Safari\n * as well on High DPI screens).\n *\n * Firefox prefers no rounding for positioning and does not have blurriness on\n * high DPI screens.\n *\n * Only horizontal placement and left/right values need to be considered.\n */\nfunction getRoundedOffsets(data, shouldRound) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n  var round = Math.round,\n      floor = Math.floor;\n\n  var noRound = function noRound(v) {\n    return v;\n  };\n\n  var referenceWidth = round(reference.width);\n  var popperWidth = round(popper.width);\n\n  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;\n  var isVariation = data.placement.indexOf('-') !== -1;\n  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;\n  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;\n\n  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;\n  var verticalToInteger = !shouldRound ? noRound : round;\n\n  return {\n    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),\n    top: verticalToInteger(popper.top),\n    bottom: verticalToInteger(popper.bottom),\n    right: horizontalToInteger(popper.right)\n  };\n}\n\nvar isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeStyle(data, options) {\n  var x = options.x,\n      y = options.y;\n  var popper = data.offsets.popper;\n\n  // Remove this legacy support in Popper.js v2\n\n  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'applyStyle';\n  }).gpuAcceleration;\n  if (legacyGpuAccelerationOption !== undefined) {\n    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');\n  }\n  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;\n\n  var offsetParent = getOffsetParent(data.instance.popper);\n  var offsetParentRect = getBoundingClientRect(offsetParent);\n\n  // Styles\n  var styles = {\n    position: popper.position\n  };\n\n  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);\n\n  var sideA = x === 'bottom' ? 'top' : 'bottom';\n  var sideB = y === 'right' ? 'left' : 'right';\n\n  // if gpuAcceleration is set to `true` and transform is supported,\n  //  we use `translate3d` to apply the position to the popper we\n  // automatically use the supported prefixed version if needed\n  var prefixedProperty = getSupportedPropertyName('transform');\n\n  // now, let's make a step back and look at this code closely (wtf?)\n  // If the content of the popper grows once it's been positioned, it\n  // may happen that the popper gets misplaced because of the new content\n  // overflowing its reference element\n  // To avoid this problem, we provide two options (x and y), which allow\n  // the consumer to define the offset origin.\n  // If we position a popper on top of a reference element, we can set\n  // `x` to `top` to make the popper grow towards its top instead of\n  // its bottom.\n  var left = void 0,\n      top = void 0;\n  if (sideA === 'bottom') {\n    // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)\n    // and not the bottom of the html element\n    if (offsetParent.nodeName === 'HTML') {\n      top = -offsetParent.clientHeight + offsets.bottom;\n    } else {\n      top = -offsetParentRect.height + offsets.bottom;\n    }\n  } else {\n    top = offsets.top;\n  }\n  if (sideB === 'right') {\n    if (offsetParent.nodeName === 'HTML') {\n      left = -offsetParent.clientWidth + offsets.right;\n    } else {\n      left = -offsetParentRect.width + offsets.right;\n    }\n  } else {\n    left = offsets.left;\n  }\n  if (gpuAcceleration && prefixedProperty) {\n    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';\n    styles[sideA] = 0;\n    styles[sideB] = 0;\n    styles.willChange = 'transform';\n  } else {\n    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties\n    var invertTop = sideA === 'bottom' ? -1 : 1;\n    var invertLeft = sideB === 'right' ? -1 : 1;\n    styles[sideA] = top * invertTop;\n    styles[sideB] = left * invertLeft;\n    styles.willChange = sideA + ', ' + sideB;\n  }\n\n  // Attributes\n  var attributes = {\n    'x-placement': data.placement\n  };\n\n  // Update `data` attributes, styles and arrowStyles\n  data.attributes = _extends({}, attributes, data.attributes);\n  data.styles = _extends({}, styles, data.styles);\n  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);\n\n  return data;\n}\n\n/**\n * Helper used to know if the given modifier depends from another one.<br />\n * It checks if the needed modifier is listed and enabled.\n * @method\n * @memberof Popper.Utils\n * @param {Array} modifiers - list of modifiers\n * @param {String} requestingName - name of requesting modifier\n * @param {String} requestedName - name of requested modifier\n * @returns {Boolean}\n */\nfunction isModifierRequired(modifiers, requestingName, requestedName) {\n  var requesting = find(modifiers, function (_ref) {\n    var name = _ref.name;\n    return name === requestingName;\n  });\n\n  var isRequired = !!requesting && modifiers.some(function (modifier) {\n    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;\n  });\n\n  if (!isRequired) {\n    var _requesting = '`' + requestingName + '`';\n    var requested = '`' + requestedName + '`';\n    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');\n  }\n  return isRequired;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction arrow(data, options) {\n  var _data$offsets$arrow;\n\n  // arrow depends on keepTogether in order to work\n  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {\n    return data;\n  }\n\n  var arrowElement = options.element;\n\n  // if arrowElement is a string, suppose it's a CSS selector\n  if (typeof arrowElement === 'string') {\n    arrowElement = data.instance.popper.querySelector(arrowElement);\n\n    // if arrowElement is not found, don't run the modifier\n    if (!arrowElement) {\n      return data;\n    }\n  } else {\n    // if the arrowElement isn't a query selector we must check that the\n    // provided DOM node is child of its popper node\n    if (!data.instance.popper.contains(arrowElement)) {\n      console.warn('WARNING: `arrow.element` must be child of its popper element!');\n      return data;\n    }\n  }\n\n  var placement = data.placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isVertical = ['left', 'right'].indexOf(placement) !== -1;\n\n  var len = isVertical ? 'height' : 'width';\n  var sideCapitalized = isVertical ? 'Top' : 'Left';\n  var side = sideCapitalized.toLowerCase();\n  var altSide = isVertical ? 'left' : 'top';\n  var opSide = isVertical ? 'bottom' : 'right';\n  var arrowElementSize = getOuterSizes(arrowElement)[len];\n\n  //\n  // extends keepTogether behavior making sure the popper and its\n  // reference have enough pixels in conjunction\n  //\n\n  // top/left side\n  if (reference[opSide] - arrowElementSize < popper[side]) {\n    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);\n  }\n  // bottom/right side\n  if (reference[side] + arrowElementSize > popper[opSide]) {\n    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];\n  }\n  data.offsets.popper = getClientRect(data.offsets.popper);\n\n  // compute center of the popper\n  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;\n\n  // Compute the sideValue using the updated popper offsets\n  // take popper margin in account because we don't have this info available\n  var css = getStyleComputedProperty(data.instance.popper);\n  var popperMarginSide = parseFloat(css['margin' + sideCapitalized]);\n  var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width']);\n  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;\n\n  // prevent arrowElement from being placed not contiguously to its popper\n  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);\n\n  data.arrowElement = arrowElement;\n  data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);\n\n  return data;\n}\n\n/**\n * Get the opposite placement variation of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement variation\n * @returns {String} flipped placement variation\n */\nfunction getOppositeVariation(variation) {\n  if (variation === 'end') {\n    return 'start';\n  } else if (variation === 'start') {\n    return 'end';\n  }\n  return variation;\n}\n\n/**\n * List of accepted placements to use as values of the `placement` option.<br />\n * Valid placements are:\n * - `auto`\n * - `top`\n * - `right`\n * - `bottom`\n * - `left`\n *\n * Each placement can have a variation from this list:\n * - `-start`\n * - `-end`\n *\n * Variations are interpreted easily if you think of them as the left to right\n * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`\n * is right.<br />\n * Vertically (`left` and `right`), `start` is top and `end` is bottom.\n *\n * Some valid examples are:\n * - `top-end` (on top of reference, right aligned)\n * - `right-start` (on right of reference, top aligned)\n * - `bottom` (on bottom, centered)\n * - `auto-end` (on the side with more space available, alignment depends by placement)\n *\n * @static\n * @type {Array}\n * @enum {String}\n * @readonly\n * @method placements\n * @memberof Popper\n */\nvar placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];\n\n// Get rid of `auto` `auto-start` and `auto-end`\nvar validPlacements = placements.slice(3);\n\n/**\n * Given an initial placement, returns all the subsequent placements\n * clockwise (or counter-clockwise).\n *\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement - A valid placement (it accepts variations)\n * @argument {Boolean} counter - Set to true to walk the placements counterclockwise\n * @returns {Array} placements including their variations\n */\nfunction clockwise(placement) {\n  var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var index = validPlacements.indexOf(placement);\n  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));\n  return counter ? arr.reverse() : arr;\n}\n\nvar BEHAVIORS = {\n  FLIP: 'flip',\n  CLOCKWISE: 'clockwise',\n  COUNTERCLOCKWISE: 'counterclockwise'\n};\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction flip(data, options) {\n  // if `inner` modifier is enabled, we can't use the `flip` modifier\n  if (isModifierEnabled(data.instance.modifiers, 'inner')) {\n    return data;\n  }\n\n  if (data.flipped && data.placement === data.originalPlacement) {\n    // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides\n    return data;\n  }\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);\n\n  var placement = data.placement.split('-')[0];\n  var placementOpposite = getOppositePlacement(placement);\n  var variation = data.placement.split('-')[1] || '';\n\n  var flipOrder = [];\n\n  switch (options.behavior) {\n    case BEHAVIORS.FLIP:\n      flipOrder = [placement, placementOpposite];\n      break;\n    case BEHAVIORS.CLOCKWISE:\n      flipOrder = clockwise(placement);\n      break;\n    case BEHAVIORS.COUNTERCLOCKWISE:\n      flipOrder = clockwise(placement, true);\n      break;\n    default:\n      flipOrder = options.behavior;\n  }\n\n  flipOrder.forEach(function (step, index) {\n    if (placement !== step || flipOrder.length === index + 1) {\n      return data;\n    }\n\n    placement = data.placement.split('-')[0];\n    placementOpposite = getOppositePlacement(placement);\n\n    var popperOffsets = data.offsets.popper;\n    var refOffsets = data.offsets.reference;\n\n    // using floor because the reference offsets may contain decimals we are not going to consider here\n    var floor = Math.floor;\n    var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);\n\n    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);\n    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);\n    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);\n    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);\n\n    var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;\n\n    // flip the variation if required\n    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n\n    // flips variation if reference element overflows boundaries\n    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);\n\n    // flips variation if popper content overflows boundaries\n    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);\n\n    var flippedVariation = flippedVariationByRef || flippedVariationByContent;\n\n    if (overlapsRef || overflowsBoundaries || flippedVariation) {\n      // this boolean to detect any flip loop\n      data.flipped = true;\n\n      if (overlapsRef || overflowsBoundaries) {\n        placement = flipOrder[index + 1];\n      }\n\n      if (flippedVariation) {\n        variation = getOppositeVariation(variation);\n      }\n\n      data.placement = placement + (variation ? '-' + variation : '');\n\n      // this object contains `position`, we want to preserve it along with\n      // any additional property we may add in the future\n      data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));\n\n      data = runModifiers(data.instance.modifiers, data, 'flip');\n    }\n  });\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction keepTogether(data) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var placement = data.placement.split('-')[0];\n  var floor = Math.floor;\n  var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n  var side = isVertical ? 'right' : 'bottom';\n  var opSide = isVertical ? 'left' : 'top';\n  var measurement = isVertical ? 'width' : 'height';\n\n  if (popper[side] < floor(reference[opSide])) {\n    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];\n  }\n  if (popper[opSide] > floor(reference[side])) {\n    data.offsets.popper[opSide] = floor(reference[side]);\n  }\n\n  return data;\n}\n\n/**\n * Converts a string containing value + unit into a px value number\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} str - Value + unit string\n * @argument {String} measurement - `height` or `width`\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @returns {Number|String}\n * Value in pixels, or original string if no values were extracted\n */\nfunction toValue(str, measurement, popperOffsets, referenceOffsets) {\n  // separate value from unit\n  var split = str.match(/((?:\\-|\\+)?\\d*\\.?\\d*)(.*)/);\n  var value = +split[1];\n  var unit = split[2];\n\n  // If it's not a number it's an operator, I guess\n  if (!value) {\n    return str;\n  }\n\n  if (unit.indexOf('%') === 0) {\n    var element = void 0;\n    switch (unit) {\n      case '%p':\n        element = popperOffsets;\n        break;\n      case '%':\n      case '%r':\n      default:\n        element = referenceOffsets;\n    }\n\n    var rect = getClientRect(element);\n    return rect[measurement] / 100 * value;\n  } else if (unit === 'vh' || unit === 'vw') {\n    // if is a vh or vw, we calculate the size based on the viewport\n    var size = void 0;\n    if (unit === 'vh') {\n      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);\n    } else {\n      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n    }\n    return size / 100 * value;\n  } else {\n    // if is an explicit pixel unit, we get rid of the unit and keep the value\n    // if is an implicit unit, it's px, and we return just the value\n    return value;\n  }\n}\n\n/**\n * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} offset\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @argument {String} basePlacement\n * @returns {Array} a two cells array with x and y offsets in numbers\n */\nfunction parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {\n  var offsets = [0, 0];\n\n  // Use height if placement is left or right and index is 0 otherwise use width\n  // in this way the first offset will use an axis and the second one\n  // will use the other one\n  var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;\n\n  // Split the offset string to obtain a list of values and operands\n  // The regex addresses values with the plus or minus sign in front (+10, -20, etc)\n  var fragments = offset.split(/(\\+|\\-)/).map(function (frag) {\n    return frag.trim();\n  });\n\n  // Detect if the offset string contains a pair of values or a single one\n  // they could be separated by comma or space\n  var divider = fragments.indexOf(find(fragments, function (frag) {\n    return frag.search(/,|\\s/) !== -1;\n  }));\n\n  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {\n    console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');\n  }\n\n  // If divider is found, we divide the list of values and operands to divide\n  // them by ofset X and Y.\n  var splitRegex = /\\s*,\\s*|\\s+/;\n  var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];\n\n  // Convert the values with units to absolute pixels to allow our computations\n  ops = ops.map(function (op, index) {\n    // Most of the units rely on the orientation of the popper\n    var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';\n    var mergeWithPrevious = false;\n    return op\n    // This aggregates any `+` or `-` sign that aren't considered operators\n    // e.g.: 10 + +5 => [10, +, +5]\n    .reduce(function (a, b) {\n      if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {\n        a[a.length - 1] = b;\n        mergeWithPrevious = true;\n        return a;\n      } else if (mergeWithPrevious) {\n        a[a.length - 1] += b;\n        mergeWithPrevious = false;\n        return a;\n      } else {\n        return a.concat(b);\n      }\n    }, [])\n    // Here we convert the string values into number values (in px)\n    .map(function (str) {\n      return toValue(str, measurement, popperOffsets, referenceOffsets);\n    });\n  });\n\n  // Loop trough the offsets arrays and execute the operations\n  ops.forEach(function (op, index) {\n    op.forEach(function (frag, index2) {\n      if (isNumeric(frag)) {\n        offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);\n      }\n    });\n  });\n  return offsets;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @argument {Number|String} options.offset=0\n * The offset value as described in the modifier description\n * @returns {Object} The data object, properly modified\n */\nfunction offset(data, _ref) {\n  var offset = _ref.offset;\n  var placement = data.placement,\n      _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var basePlacement = placement.split('-')[0];\n\n  var offsets = void 0;\n  if (isNumeric(+offset)) {\n    offsets = [+offset, 0];\n  } else {\n    offsets = parseOffset(offset, popper, reference, basePlacement);\n  }\n\n  if (basePlacement === 'left') {\n    popper.top += offsets[0];\n    popper.left -= offsets[1];\n  } else if (basePlacement === 'right') {\n    popper.top += offsets[0];\n    popper.left += offsets[1];\n  } else if (basePlacement === 'top') {\n    popper.left += offsets[0];\n    popper.top -= offsets[1];\n  } else if (basePlacement === 'bottom') {\n    popper.left += offsets[0];\n    popper.top += offsets[1];\n  }\n\n  data.popper = popper;\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction preventOverflow(data, options) {\n  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);\n\n  // If offsetParent is the reference element, we really want to\n  // go one step up and use the next offsetParent as reference to\n  // avoid to make this modifier completely useless and look like broken\n  if (data.instance.reference === boundariesElement) {\n    boundariesElement = getOffsetParent(boundariesElement);\n  }\n\n  // NOTE: DOM access here\n  // resets the popper's position so that the document size can be calculated excluding\n  // the size of the popper element itself\n  var transformProp = getSupportedPropertyName('transform');\n  var popperStyles = data.instance.popper.style; // assignment to help minification\n  var top = popperStyles.top,\n      left = popperStyles.left,\n      transform = popperStyles[transformProp];\n\n  popperStyles.top = '';\n  popperStyles.left = '';\n  popperStyles[transformProp] = '';\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);\n\n  // NOTE: DOM access here\n  // restores the original style properties after the offsets have been computed\n  popperStyles.top = top;\n  popperStyles.left = left;\n  popperStyles[transformProp] = transform;\n\n  options.boundaries = boundaries;\n\n  var order = options.priority;\n  var popper = data.offsets.popper;\n\n  var check = {\n    primary: function primary(placement) {\n      var value = popper[placement];\n      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {\n        value = Math.max(popper[placement], boundaries[placement]);\n      }\n      return defineProperty({}, placement, value);\n    },\n    secondary: function secondary(placement) {\n      var mainSide = placement === 'right' ? 'left' : 'top';\n      var value = popper[mainSide];\n      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {\n        value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));\n      }\n      return defineProperty({}, mainSide, value);\n    }\n  };\n\n  order.forEach(function (placement) {\n    var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';\n    popper = _extends({}, popper, check[side](placement));\n  });\n\n  data.offsets.popper = popper;\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction shift(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var shiftvariation = placement.split('-')[1];\n\n  // if shift shiftvariation is specified, run the modifier\n  if (shiftvariation) {\n    var _data$offsets = data.offsets,\n        reference = _data$offsets.reference,\n        popper = _data$offsets.popper;\n\n    var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;\n    var side = isVertical ? 'left' : 'top';\n    var measurement = isVertical ? 'width' : 'height';\n\n    var shiftOffsets = {\n      start: defineProperty({}, side, reference[side]),\n      end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])\n    };\n\n    data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction hide(data) {\n  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {\n    return data;\n  }\n\n  var refRect = data.offsets.reference;\n  var bound = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'preventOverflow';\n  }).boundaries;\n\n  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === true) {\n      return data;\n    }\n\n    data.hide = true;\n    data.attributes['x-out-of-boundaries'] = '';\n  } else {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === false) {\n      return data;\n    }\n\n    data.hide = false;\n    data.attributes['x-out-of-boundaries'] = false;\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction inner(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;\n\n  var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;\n\n  popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);\n\n  data.placement = getOppositePlacement(placement);\n  data.offsets.popper = getClientRect(popper);\n\n  return data;\n}\n\n/**\n * Modifier function, each modifier can have a function of this type assigned\n * to its `fn` property.<br />\n * These functions will be called on each update, this means that you must\n * make sure they are performant enough to avoid performance bottlenecks.\n *\n * @function ModifierFn\n * @argument {dataObject} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {dataObject} The data object, properly modified\n */\n\n/**\n * Modifiers are plugins used to alter the behavior of your poppers.<br />\n * Popper.js uses a set of 9 modifiers to provide all the basic functionalities\n * needed by the library.\n *\n * Usually you don't want to override the `order`, `fn` and `onLoad` props.\n * All the other properties are configurations that could be tweaked.\n * @namespace modifiers\n */\nvar modifiers = {\n  /**\n   * Modifier used to shift the popper on the start or end of its reference\n   * element.<br />\n   * It will read the variation of the `placement` property.<br />\n   * It can be one either `-end` or `-start`.\n   * @memberof modifiers\n   * @inner\n   */\n  shift: {\n    /** @prop {number} order=100 - Index used to define the order of execution */\n    order: 100,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: shift\n  },\n\n  /**\n   * The `offset` modifier can shift your popper on both its axis.\n   *\n   * It accepts the following units:\n   * - `px` or unit-less, interpreted as pixels\n   * - `%` or `%r`, percentage relative to the length of the reference element\n   * - `%p`, percentage relative to the length of the popper element\n   * - `vw`, CSS viewport width unit\n   * - `vh`, CSS viewport height unit\n   *\n   * For length is intended the main axis relative to the placement of the popper.<br />\n   * This means that if the placement is `top` or `bottom`, the length will be the\n   * `width`. In case of `left` or `right`, it will be the `height`.\n   *\n   * You can provide a single value (as `Number` or `String`), or a pair of values\n   * as `String` divided by a comma or one (or more) white spaces.<br />\n   * The latter is a deprecated method because it leads to confusion and will be\n   * removed in v2.<br />\n   * Additionally, it accepts additions and subtractions between different units.\n   * Note that multiplications and divisions aren't supported.\n   *\n   * Valid examples are:\n   * ```\n   * 10\n   * '10%'\n   * '10, 10'\n   * '10%, 10'\n   * '10 + 10%'\n   * '10 - 5vh + 3%'\n   * '-10px + 5vh, 5px - 6%'\n   * ```\n   * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap\n   * > with their reference element, unfortunately, you will have to disable the `flip` modifier.\n   * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  offset: {\n    /** @prop {number} order=200 - Index used to define the order of execution */\n    order: 200,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: offset,\n    /** @prop {Number|String} offset=0\n     * The offset value as described in the modifier description\n     */\n    offset: 0\n  },\n\n  /**\n   * Modifier used to prevent the popper from being positioned outside the boundary.\n   *\n   * A scenario exists where the reference itself is not within the boundaries.<br />\n   * We can say it has \"escaped the boundaries\" — or just \"escaped\".<br />\n   * In this case we need to decide whether the popper should either:\n   *\n   * - detach from the reference and remain \"trapped\" in the boundaries, or\n   * - if it should ignore the boundary and \"escape with its reference\"\n   *\n   * When `escapeWithReference` is set to`true` and reference is completely\n   * outside its boundaries, the popper will overflow (or completely leave)\n   * the boundaries in order to remain attached to the edge of the reference.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  preventOverflow: {\n    /** @prop {number} order=300 - Index used to define the order of execution */\n    order: 300,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: preventOverflow,\n    /**\n     * @prop {Array} [priority=['left','right','top','bottom']]\n     * Popper will try to prevent overflow following these priorities by default,\n     * then, it could overflow on the left and on top of the `boundariesElement`\n     */\n    priority: ['left', 'right', 'top', 'bottom'],\n    /**\n     * @prop {number} padding=5\n     * Amount of pixel used to define a minimum distance between the boundaries\n     * and the popper. This makes sure the popper always has a little padding\n     * between the edges of its container\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='scrollParent'\n     * Boundaries used by the modifier. Can be `scrollParent`, `window`,\n     * `viewport` or any DOM element.\n     */\n    boundariesElement: 'scrollParent'\n  },\n\n  /**\n   * Modifier used to make sure the reference and its popper stay near each other\n   * without leaving any gap between the two. Especially useful when the arrow is\n   * enabled and you want to ensure that it points to its reference element.\n   * It cares only about the first axis. You can still have poppers with margin\n   * between the popper and its reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  keepTogether: {\n    /** @prop {number} order=400 - Index used to define the order of execution */\n    order: 400,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: keepTogether\n  },\n\n  /**\n   * This modifier is used to move the `arrowElement` of the popper to make\n   * sure it is positioned between the reference element and its popper element.\n   * It will read the outer size of the `arrowElement` node to detect how many\n   * pixels of conjunction are needed.\n   *\n   * It has no effect if no `arrowElement` is provided.\n   * @memberof modifiers\n   * @inner\n   */\n  arrow: {\n    /** @prop {number} order=500 - Index used to define the order of execution */\n    order: 500,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: arrow,\n    /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */\n    element: '[x-arrow]'\n  },\n\n  /**\n   * Modifier used to flip the popper's placement when it starts to overlap its\n   * reference element.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   *\n   * **NOTE:** this modifier will interrupt the current update cycle and will\n   * restart it if it detects the need to flip the placement.\n   * @memberof modifiers\n   * @inner\n   */\n  flip: {\n    /** @prop {number} order=600 - Index used to define the order of execution */\n    order: 600,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: flip,\n    /**\n     * @prop {String|Array} behavior='flip'\n     * The behavior used to change the popper's placement. It can be one of\n     * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid\n     * placements (with optional variations)\n     */\n    behavior: 'flip',\n    /**\n     * @prop {number} padding=5\n     * The popper will flip if it hits the edges of the `boundariesElement`\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='viewport'\n     * The element which will define the boundaries of the popper position.\n     * The popper will never be placed outside of the defined boundaries\n     * (except if `keepTogether` is enabled)\n     */\n    boundariesElement: 'viewport',\n    /**\n     * @prop {Boolean} flipVariations=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the reference element overlaps its boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariations: false,\n    /**\n     * @prop {Boolean} flipVariationsByContent=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the popper element overlaps its reference boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariationsByContent: false\n  },\n\n  /**\n   * Modifier used to make the popper flow toward the inner of the reference element.\n   * By default, when this modifier is disabled, the popper will be placed outside\n   * the reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  inner: {\n    /** @prop {number} order=700 - Index used to define the order of execution */\n    order: 700,\n    /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */\n    enabled: false,\n    /** @prop {ModifierFn} */\n    fn: inner\n  },\n\n  /**\n   * Modifier used to hide the popper when its reference element is outside of the\n   * popper boundaries. It will set a `x-out-of-boundaries` attribute which can\n   * be used to hide with a CSS selector the popper when its reference is\n   * out of boundaries.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   * @memberof modifiers\n   * @inner\n   */\n  hide: {\n    /** @prop {number} order=800 - Index used to define the order of execution */\n    order: 800,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: hide\n  },\n\n  /**\n   * Computes the style that will be applied to the popper element to gets\n   * properly positioned.\n   *\n   * Note that this modifier will not touch the DOM, it just prepares the styles\n   * so that `applyStyle` modifier can apply it. This separation is useful\n   * in case you need to replace `applyStyle` with a custom implementation.\n   *\n   * This modifier has `850` as `order` value to maintain backward compatibility\n   * with previous versions of Popper.js. Expect the modifiers ordering method\n   * to change in future major versions of the library.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  computeStyle: {\n    /** @prop {number} order=850 - Index used to define the order of execution */\n    order: 850,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: computeStyle,\n    /**\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: true,\n    /**\n     * @prop {string} [x='bottom']\n     * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.\n     * Change this if your popper should grow in a direction different from `bottom`\n     */\n    x: 'bottom',\n    /**\n     * @prop {string} [x='left']\n     * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.\n     * Change this if your popper should grow in a direction different from `right`\n     */\n    y: 'right'\n  },\n\n  /**\n   * Applies the computed styles to the popper element.\n   *\n   * All the DOM manipulations are limited to this modifier. This is useful in case\n   * you want to integrate Popper.js inside a framework or view library and you\n   * want to delegate all the DOM manipulations to it.\n   *\n   * Note that if you disable this modifier, you must make sure the popper element\n   * has its position set to `absolute` before Popper.js can do its work!\n   *\n   * Just disable this modifier and define your own to achieve the desired effect.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  applyStyle: {\n    /** @prop {number} order=900 - Index used to define the order of execution */\n    order: 900,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: applyStyle,\n    /** @prop {Function} */\n    onLoad: applyStyleOnLoad,\n    /**\n     * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: undefined\n  }\n};\n\n/**\n * The `dataObject` is an object containing all the information used by Popper.js.\n * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.\n * @name dataObject\n * @property {Object} data.instance The Popper.js instance\n * @property {String} data.placement Placement applied to popper\n * @property {String} data.originalPlacement Placement originally defined on init\n * @property {Boolean} data.flipped True if popper has been flipped by flip modifier\n * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper\n * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier\n * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.boundaries Offsets of the popper boundaries\n * @property {Object} data.offsets The measurements of popper, reference and arrow elements\n * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0\n */\n\n/**\n * Default options provided to Popper.js constructor.<br />\n * These can be overridden using the `options` argument of Popper.js.<br />\n * To override an option, simply pass an object with the same\n * structure of the `options` object, as the 3rd argument. For example:\n * ```\n * new Popper(ref, pop, {\n *   modifiers: {\n *     preventOverflow: { enabled: false }\n *   }\n * })\n * ```\n * @type {Object}\n * @static\n * @memberof Popper\n */\nvar Defaults = {\n  /**\n   * Popper's placement.\n   * @prop {Popper.placements} placement='bottom'\n   */\n  placement: 'bottom',\n\n  /**\n   * Set this to true if you want popper to position it self in 'fixed' mode\n   * @prop {Boolean} positionFixed=false\n   */\n  positionFixed: false,\n\n  /**\n   * Whether events (resize, scroll) are initially enabled.\n   * @prop {Boolean} eventsEnabled=true\n   */\n  eventsEnabled: true,\n\n  /**\n   * Set to true if you want to automatically remove the popper when\n   * you call the `destroy` method.\n   * @prop {Boolean} removeOnDestroy=false\n   */\n  removeOnDestroy: false,\n\n  /**\n   * Callback called when the popper is created.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onCreate}\n   */\n  onCreate: function onCreate() {},\n\n  /**\n   * Callback called when the popper is updated. This callback is not called\n   * on the initialization/creation of the popper, but only on subsequent\n   * updates.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onUpdate}\n   */\n  onUpdate: function onUpdate() {},\n\n  /**\n   * List of modifiers used to modify the offsets before they are applied to the popper.\n   * They provide most of the functionalities of Popper.js.\n   * @prop {modifiers}\n   */\n  modifiers: modifiers\n};\n\n/**\n * @callback onCreate\n * @param {dataObject} data\n */\n\n/**\n * @callback onUpdate\n * @param {dataObject} data\n */\n\n// Utils\n// Methods\nvar Popper = function () {\n  /**\n   * Creates a new Popper.js instance.\n   * @class Popper\n   * @param {Element|referenceObject} reference - The reference element used to position the popper\n   * @param {Element} popper - The HTML / XML element used as the popper\n   * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)\n   * @return {Object} instance - The generated Popper.js instance\n   */\n  function Popper(reference, popper) {\n    var _this = this;\n\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    classCallCheck(this, Popper);\n\n    this.scheduleUpdate = function () {\n      return requestAnimationFrame(_this.update);\n    };\n\n    // make update() debounced, so that it only runs at most once-per-tick\n    this.update = debounce(this.update.bind(this));\n\n    // with {} we create a new object with the options inside it\n    this.options = _extends({}, Popper.Defaults, options);\n\n    // init state\n    this.state = {\n      isDestroyed: false,\n      isCreated: false,\n      scrollParents: []\n    };\n\n    // get reference and popper elements (allow jQuery wrappers)\n    this.reference = reference && reference.jquery ? reference[0] : reference;\n    this.popper = popper && popper.jquery ? popper[0] : popper;\n\n    // Deep merge modifiers options\n    this.options.modifiers = {};\n    Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {\n      _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});\n    });\n\n    // Refactoring modifiers' list (Object => Array)\n    this.modifiers = Object.keys(this.options.modifiers).map(function (name) {\n      return _extends({\n        name: name\n      }, _this.options.modifiers[name]);\n    })\n    // sort the modifiers by order\n    .sort(function (a, b) {\n      return a.order - b.order;\n    });\n\n    // modifiers have the ability to execute arbitrary code when Popper.js get inited\n    // such code is executed in the same order of its modifier\n    // they could add new properties to their options configuration\n    // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!\n    this.modifiers.forEach(function (modifierOptions) {\n      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {\n        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);\n      }\n    });\n\n    // fire the first update to position the popper in the right place\n    this.update();\n\n    var eventsEnabled = this.options.eventsEnabled;\n    if (eventsEnabled) {\n      // setup event listeners, they will take care of update the position in specific situations\n      this.enableEventListeners();\n    }\n\n    this.state.eventsEnabled = eventsEnabled;\n  }\n\n  // We can't use class properties because they don't get listed in the\n  // class prototype and break stuff like Sinon stubs\n\n\n  createClass(Popper, [{\n    key: 'update',\n    value: function update$$1() {\n      return update.call(this);\n    }\n  }, {\n    key: 'destroy',\n    value: function destroy$$1() {\n      return destroy.call(this);\n    }\n  }, {\n    key: 'enableEventListeners',\n    value: function enableEventListeners$$1() {\n      return enableEventListeners.call(this);\n    }\n  }, {\n    key: 'disableEventListeners',\n    value: function disableEventListeners$$1() {\n      return disableEventListeners.call(this);\n    }\n\n    /**\n     * Schedules an update. It will run on the next UI update available.\n     * @method scheduleUpdate\n     * @memberof Popper\n     */\n\n\n    /**\n     * Collection of utilities useful when writing custom modifiers.\n     * Starting from version 1.7, this method is available only if you\n     * include `popper-utils.js` before `popper.js`.\n     *\n     * **DEPRECATION**: This way to access PopperUtils is deprecated\n     * and will be removed in v2! Use the PopperUtils module directly instead.\n     * Due to the high instability of the methods contained in Utils, we can't\n     * guarantee them to follow semver. Use them at your own risk!\n     * @static\n     * @private\n     * @type {Object}\n     * @deprecated since version 1.8\n     * @member Utils\n     * @memberof Popper\n     */\n\n  }]);\n  return Popper;\n}();\n\n/**\n * The `referenceObject` is an object that provides an interface compatible with Popper.js\n * and lets you use it as replacement of a real DOM node.<br />\n * You can use this method to position a popper relatively to a set of coordinates\n * in case you don't have a DOM node to use as reference.\n *\n * ```\n * new Popper(referenceObject, popperNode);\n * ```\n *\n * NB: This feature isn't supported in Internet Explorer 10.\n * @name referenceObject\n * @property {Function} data.getBoundingClientRect\n * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.\n * @property {number} data.clientWidth\n * An ES6 getter that will return the width of the virtual reference element.\n * @property {number} data.clientHeight\n * An ES6 getter that will return the height of the virtual reference element.\n */\n\n\nPopper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;\nPopper.placements = placements;\nPopper.Defaults = Defaults;\n\nexport default Popper;\n//# sourceMappingURL=popper.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/popper.js/dist/esm/popper.js\n// module id = 421\n// module chunks = 0","export { default as calendar } from './calendar';\r\nexport { default as select } from './select';\r\nexport { default as tooltip } from './tooltip';\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/core/components/index.js","/* eslint-disable no-unused-vars */\r\nimport $ from 'jquery';\r\nimport Pikaday from 'pikaday';\r\n\r\nconst defaults = {\r\n  firstDay: 1,\r\n  position: 'bottom right',\r\n  theme: 'netc-calendar-theme',\r\n};\r\n\r\nexport default function calendar(fieldSelector, triggerSelector, options = {}) {\r\n  const $date = $(selector); // eslint-disable-line\r\n  const $trigger = $(triggerSelector);\r\n\r\n  const locals = {\r\n    ...defaults,\r\n    ...options,\r\n  };\r\n\r\n  locals.field = $date[0];\r\n  locals.trigger = $trigger[0];\r\n\r\n  if (!$date.length) {\r\n    return;\r\n  }\r\n\r\n  if (!Modernizr.mq('(min-width: 1025px)')) {\r\n    return;\r\n  }\r\n\r\n  return new Pikaday(locals); // eslint-disable-line\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/core/components/calendar.js","/*!\n * Pikaday\n *\n * Copyright © 2014 David Bushell | BSD & MIT license | https://github.com/Pikaday/Pikaday\n */\n\n(function (root, factory)\n{\n    'use strict';\n\n    var moment;\n    if (typeof exports === 'object') {\n        // CommonJS module\n        // Load moment.js as an optional dependency\n        try { moment = require('moment'); } catch (e) {}\n        module.exports = factory(moment);\n    } else if (typeof define === 'function' && define.amd) {\n        // AMD. Register as an anonymous module.\n        define(function (req)\n        {\n            // Load moment.js as an optional dependency\n            var id = 'moment';\n            try { moment = req(id); } catch (e) {}\n            return factory(moment);\n        });\n    } else {\n        root.Pikaday = factory(root.moment);\n    }\n}(this, function (moment)\n{\n    'use strict';\n\n    /**\n     * feature detection and helper functions\n     */\n    var hasMoment = typeof moment === 'function',\n\n    hasEventListeners = !!window.addEventListener,\n\n    document = window.document,\n\n    sto = window.setTimeout,\n\n    addEvent = function(el, e, callback, capture)\n    {\n        if (hasEventListeners) {\n            el.addEventListener(e, callback, !!capture);\n        } else {\n            el.attachEvent('on' + e, callback);\n        }\n    },\n\n    removeEvent = function(el, e, callback, capture)\n    {\n        if (hasEventListeners) {\n            el.removeEventListener(e, callback, !!capture);\n        } else {\n            el.detachEvent('on' + e, callback);\n        }\n    },\n\n    trim = function(str)\n    {\n        return str.trim ? str.trim() : str.replace(/^\\s+|\\s+$/g,'');\n    },\n\n    hasClass = function(el, cn)\n    {\n        return (' ' + el.className + ' ').indexOf(' ' + cn + ' ') !== -1;\n    },\n\n    addClass = function(el, cn)\n    {\n        if (!hasClass(el, cn)) {\n            el.className = (el.className === '') ? cn : el.className + ' ' + cn;\n        }\n    },\n\n    removeClass = function(el, cn)\n    {\n        el.className = trim((' ' + el.className + ' ').replace(' ' + cn + ' ', ' '));\n    },\n\n    isArray = function(obj)\n    {\n        return (/Array/).test(Object.prototype.toString.call(obj));\n    },\n\n    isDate = function(obj)\n    {\n        return (/Date/).test(Object.prototype.toString.call(obj)) && !isNaN(obj.getTime());\n    },\n\n    isWeekend = function(date)\n    {\n        var day = date.getDay();\n        return day === 0 || day === 6;\n    },\n\n    isLeapYear = function(year)\n    {\n        // solution by Matti Virkkunen: http://stackoverflow.com/a/4881951\n        return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n    },\n\n    getDaysInMonth = function(year, month)\n    {\n        return [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];\n    },\n\n    setToStartOfDay = function(date)\n    {\n        if (isDate(date)) date.setHours(0,0,0,0);\n    },\n\n    compareDates = function(a,b)\n    {\n        // weak date comparison (use setToStartOfDay(date) to ensure correct result)\n        return a.getTime() === b.getTime();\n    },\n\n    extend = function(to, from, overwrite)\n    {\n        var prop, hasProp;\n        for (prop in from) {\n            hasProp = to[prop] !== undefined;\n            if (hasProp && typeof from[prop] === 'object' && from[prop] !== null && from[prop].nodeName === undefined) {\n                if (isDate(from[prop])) {\n                    if (overwrite) {\n                        to[prop] = new Date(from[prop].getTime());\n                    }\n                }\n                else if (isArray(from[prop])) {\n                    if (overwrite) {\n                        to[prop] = from[prop].slice(0);\n                    }\n                } else {\n                    to[prop] = extend({}, from[prop], overwrite);\n                }\n            } else if (overwrite || !hasProp) {\n                to[prop] = from[prop];\n            }\n        }\n        return to;\n    },\n\n    fireEvent = function(el, eventName, data)\n    {\n        var ev;\n\n        if (document.createEvent) {\n            ev = document.createEvent('HTMLEvents');\n            ev.initEvent(eventName, true, false);\n            ev = extend(ev, data);\n            el.dispatchEvent(ev);\n        } else if (document.createEventObject) {\n            ev = document.createEventObject();\n            ev = extend(ev, data);\n            el.fireEvent('on' + eventName, ev);\n        }\n    },\n\n    adjustCalendar = function(calendar) {\n        if (calendar.month < 0) {\n            calendar.year -= Math.ceil(Math.abs(calendar.month)/12);\n            calendar.month += 12;\n        }\n        if (calendar.month > 11) {\n            calendar.year += Math.floor(Math.abs(calendar.month)/12);\n            calendar.month -= 12;\n        }\n        return calendar;\n    },\n\n    /**\n     * defaults and localisation\n     */\n    defaults = {\n\n        // bind the picker to a form field\n        field: null,\n\n        // automatically show/hide the picker on `field` focus (default `true` if `field` is set)\n        bound: undefined,\n\n        // data-attribute on the input field with an aria assistance tekst (only applied when `bound` is set)\n        ariaLabel: 'Use the arrow keys to pick a date',\n\n        // position of the datepicker, relative to the field (default to bottom & left)\n        // ('bottom' & 'left' keywords are not used, 'top' & 'right' are modifier on the bottom/left position)\n        position: 'bottom left',\n\n        // automatically fit in the viewport even if it means repositioning from the position option\n        reposition: true,\n\n        // the default output format for `.toString()` and `field` value\n        format: 'YYYY-MM-DD',\n\n        // the toString function which gets passed a current date object and format\n        // and returns a string\n        toString: null,\n\n        // used to create date object from current input string\n        parse: null,\n\n        // the initial date to view when first opened\n        defaultDate: null,\n\n        // make the `defaultDate` the initial selected value\n        setDefaultDate: false,\n\n        // first day of week (0: Sunday, 1: Monday etc)\n        firstDay: 0,\n\n        // the default flag for moment's strict date parsing\n        formatStrict: false,\n\n        // the minimum/earliest date that can be selected\n        minDate: null,\n        // the maximum/latest date that can be selected\n        maxDate: null,\n\n        // number of years either side, or array of upper/lower range\n        yearRange: 10,\n\n        // show week numbers at head of row\n        showWeekNumber: false,\n\n        // Week picker mode\n        pickWholeWeek: false,\n\n        // used internally (don't config outside)\n        minYear: 0,\n        maxYear: 9999,\n        minMonth: undefined,\n        maxMonth: undefined,\n\n        startRange: null,\n        endRange: null,\n\n        isRTL: false,\n\n        // Additional text to append to the year in the calendar title\n        yearSuffix: '',\n\n        // Render the month after year in the calendar title\n        showMonthAfterYear: false,\n\n        // Render days of the calendar grid that fall in the next or previous month\n        showDaysInNextAndPreviousMonths: false,\n\n        // Allows user to select days that fall in the next or previous month\n        enableSelectionDaysInNextAndPreviousMonths: false,\n\n        // how many months are visible\n        numberOfMonths: 1,\n\n        // when numberOfMonths is used, this will help you to choose where the main calendar will be (default `left`, can be set to `right`)\n        // only used for the first display or when a selected date is not visible\n        mainCalendar: 'left',\n\n        // Specify a DOM element to render the calendar in\n        container: undefined,\n\n        // Blur field when date is selected\n        blurFieldOnSelect : true,\n\n        // internationalization\n        i18n: {\n            previousMonth : 'Previous Month',\n            nextMonth     : 'Next Month',\n            months        : ['January','February','March','April','May','June','July','August','September','October','November','December'],\n            weekdays      : ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],\n            weekdaysShort : ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']\n        },\n\n        // Theme Classname\n        theme: null,\n\n        // events array\n        events: [],\n\n        // callback function\n        onSelect: null,\n        onOpen: null,\n        onClose: null,\n        onDraw: null,\n\n        // Enable keyboard input\n        keyboardInput: true\n    },\n\n\n    /**\n     * templating functions to abstract HTML rendering\n     */\n    renderDayName = function(opts, day, abbr)\n    {\n        day += opts.firstDay;\n        while (day >= 7) {\n            day -= 7;\n        }\n        return abbr ? opts.i18n.weekdaysShort[day] : opts.i18n.weekdays[day];\n    },\n\n    renderDay = function(opts)\n    {\n        var arr = [];\n        var ariaSelected = 'false';\n        if (opts.isEmpty) {\n            if (opts.showDaysInNextAndPreviousMonths) {\n                arr.push('is-outside-current-month');\n\n                if(!opts.enableSelectionDaysInNextAndPreviousMonths) {\n                    arr.push('is-selection-disabled');\n                }\n\n            } else {\n                return '<td class=\"is-empty\"></td>';\n            }\n        }\n        if (opts.isDisabled) {\n            arr.push('is-disabled');\n        }\n        if (opts.isToday) {\n            arr.push('is-today');\n        }\n        if (opts.isSelected) {\n            arr.push('is-selected');\n            ariaSelected = 'true';\n        }\n        if (opts.hasEvent) {\n            arr.push('has-event');\n        }\n        if (opts.isInRange) {\n            arr.push('is-inrange');\n        }\n        if (opts.isStartRange) {\n            arr.push('is-startrange');\n        }\n        if (opts.isEndRange) {\n            arr.push('is-endrange');\n        }\n        return '<td data-day=\"' + opts.day + '\" class=\"' + arr.join(' ') + '\" aria-selected=\"' + ariaSelected + '\">' +\n                 '<button class=\"pika-button pika-day\" type=\"button\" ' +\n                    'data-pika-year=\"' + opts.year + '\" data-pika-month=\"' + opts.month + '\" data-pika-day=\"' + opts.day + '\">' +\n                        opts.day +\n                 '</button>' +\n               '</td>';\n    },\n\n    renderWeek = function (d, m, y) {\n        // Lifted from http://javascript.about.com/library/blweekyear.htm, lightly modified.\n        var onejan = new Date(y, 0, 1),\n            weekNum = Math.ceil((((new Date(y, m, d) - onejan) / 86400000) + onejan.getDay()+1)/7);\n        return '<td class=\"pika-week\">' + weekNum + '</td>';\n    },\n\n    renderRow = function(days, isRTL, pickWholeWeek, isRowSelected)\n    {\n        return '<tr class=\"pika-row' + (pickWholeWeek ? ' pick-whole-week' : '') + (isRowSelected ? ' is-selected' : '') + '\">' + (isRTL ? days.reverse() : days).join('') + '</tr>';\n    },\n\n    renderBody = function(rows)\n    {\n        return '<tbody>' + rows.join('') + '</tbody>';\n    },\n\n    renderHead = function(opts)\n    {\n        var i, arr = [];\n        if (opts.showWeekNumber) {\n            arr.push('<th></th>');\n        }\n        for (i = 0; i < 7; i++) {\n            arr.push('<th scope=\"col\"><abbr title=\"' + renderDayName(opts, i) + '\">' + renderDayName(opts, i, true) + '</abbr></th>');\n        }\n        return '<thead><tr>' + (opts.isRTL ? arr.reverse() : arr).join('') + '</tr></thead>';\n    },\n\n    renderTitle = function(instance, c, year, month, refYear, randId)\n    {\n        var i, j, arr,\n            opts = instance._o,\n            isMinYear = year === opts.minYear,\n            isMaxYear = year === opts.maxYear,\n            html = '<div id=\"' + randId + '\" class=\"pika-title\" role=\"heading\" aria-live=\"assertive\">',\n            monthHtml,\n            yearHtml,\n            prev = true,\n            next = true;\n\n        for (arr = [], i = 0; i < 12; i++) {\n            arr.push('<option value=\"' + (year === refYear ? i - c : 12 + i - c) + '\"' +\n                (i === month ? ' selected=\"selected\"': '') +\n                ((isMinYear && i < opts.minMonth) || (isMaxYear && i > opts.maxMonth) ? 'disabled=\"disabled\"' : '') + '>' +\n                opts.i18n.months[i] + '</option>');\n        }\n\n        monthHtml = '<div class=\"pika-label\">' + opts.i18n.months[month] + '<select class=\"pika-select pika-select-month\" tabindex=\"-1\">' + arr.join('') + '</select></div>';\n\n        if (isArray(opts.yearRange)) {\n            i = opts.yearRange[0];\n            j = opts.yearRange[1] + 1;\n        } else {\n            i = year - opts.yearRange;\n            j = 1 + year + opts.yearRange;\n        }\n\n        for (arr = []; i < j && i <= opts.maxYear; i++) {\n            if (i >= opts.minYear) {\n                arr.push('<option value=\"' + i + '\"' + (i === year ? ' selected=\"selected\"': '') + '>' + (i) + '</option>');\n            }\n        }\n        yearHtml = '<div class=\"pika-label\">' + year + opts.yearSuffix + '<select class=\"pika-select pika-select-year\" tabindex=\"-1\">' + arr.join('') + '</select></div>';\n\n        if (opts.showMonthAfterYear) {\n            html += yearHtml + monthHtml;\n        } else {\n            html += monthHtml + yearHtml;\n        }\n\n        if (isMinYear && (month === 0 || opts.minMonth >= month)) {\n            prev = false;\n        }\n\n        if (isMaxYear && (month === 11 || opts.maxMonth <= month)) {\n            next = false;\n        }\n\n        if (c === 0) {\n            html += '<button class=\"pika-prev' + (prev ? '' : ' is-disabled') + '\" type=\"button\">' + opts.i18n.previousMonth + '</button>';\n        }\n        if (c === (instance._o.numberOfMonths - 1) ) {\n            html += '<button class=\"pika-next' + (next ? '' : ' is-disabled') + '\" type=\"button\">' + opts.i18n.nextMonth + '</button>';\n        }\n\n        return html += '</div>';\n    },\n\n    renderTable = function(opts, data, randId)\n    {\n        return '<table cellpadding=\"0\" cellspacing=\"0\" class=\"pika-table\" role=\"grid\" aria-labelledby=\"' + randId + '\">' + renderHead(opts) + renderBody(data) + '</table>';\n    },\n\n\n    /**\n     * Pikaday constructor\n     */\n    Pikaday = function(options)\n    {\n        var self = this,\n            opts = self.config(options);\n\n        self._onMouseDown = function(e)\n        {\n            if (!self._v) {\n                return;\n            }\n            e = e || window.event;\n            var target = e.target || e.srcElement;\n            if (!target) {\n                return;\n            }\n\n            if (!hasClass(target, 'is-disabled')) {\n                if (hasClass(target, 'pika-button') && !hasClass(target, 'is-empty') && !hasClass(target.parentNode, 'is-disabled')) {\n                    self.setDate(new Date(target.getAttribute('data-pika-year'), target.getAttribute('data-pika-month'), target.getAttribute('data-pika-day')));\n                    if (opts.bound) {\n                        sto(function() {\n                            self.hide();\n                            if (opts.blurFieldOnSelect && opts.field) {\n                                opts.field.blur();\n                            }\n                        }, 100);\n                    }\n                }\n                else if (hasClass(target, 'pika-prev')) {\n                    self.prevMonth();\n                }\n                else if (hasClass(target, 'pika-next')) {\n                    self.nextMonth();\n                }\n            }\n            if (!hasClass(target, 'pika-select')) {\n                // if this is touch event prevent mouse events emulation\n                if (e.preventDefault) {\n                    e.preventDefault();\n                } else {\n                    e.returnValue = false;\n                    return false;\n                }\n            } else {\n                self._c = true;\n            }\n        };\n\n        self._onChange = function(e)\n        {\n            e = e || window.event;\n            var target = e.target || e.srcElement;\n            if (!target) {\n                return;\n            }\n            if (hasClass(target, 'pika-select-month')) {\n                self.gotoMonth(target.value);\n            }\n            else if (hasClass(target, 'pika-select-year')) {\n                self.gotoYear(target.value);\n            }\n        };\n\n        self._onKeyChange = function(e)\n        {\n            e = e || window.event;\n\n            if (self.isVisible()) {\n\n                switch(e.keyCode){\n                    case 13:\n                    case 27:\n                        if (opts.field) {\n                            opts.field.blur();\n                        }\n                        break;\n                    case 37:\n                        e.preventDefault();\n                        self.adjustDate('subtract', 1);\n                        break;\n                    case 38:\n                        self.adjustDate('subtract', 7);\n                        break;\n                    case 39:\n                        self.adjustDate('add', 1);\n                        break;\n                    case 40:\n                        self.adjustDate('add', 7);\n                        break;\n                }\n            }\n        };\n\n        self._onInputChange = function(e)\n        {\n            var date;\n\n            if (e.firedBy === self) {\n                return;\n            }\n            if (opts.parse) {\n                date = opts.parse(opts.field.value, opts.format);\n            } else if (hasMoment) {\n                date = moment(opts.field.value, opts.format, opts.formatStrict);\n                date = (date && date.isValid()) ? date.toDate() : null;\n            }\n            else {\n                date = new Date(Date.parse(opts.field.value));\n            }\n            if (isDate(date)) {\n              self.setDate(date);\n            }\n            if (!self._v) {\n                self.show();\n            }\n        };\n\n        self._onInputFocus = function()\n        {\n            self.show();\n        };\n\n        self._onInputClick = function()\n        {\n            self.show();\n        };\n\n        self._onInputBlur = function()\n        {\n            // IE allows pika div to gain focus; catch blur the input field\n            var pEl = document.activeElement;\n            do {\n                if (hasClass(pEl, 'pika-single')) {\n                    return;\n                }\n            }\n            while ((pEl = pEl.parentNode));\n\n            if (!self._c) {\n                self._b = sto(function() {\n                    self.hide();\n                }, 50);\n            }\n            self._c = false;\n        };\n\n        self._onClick = function(e)\n        {\n            e = e || window.event;\n            var target = e.target || e.srcElement,\n                pEl = target;\n            if (!target) {\n                return;\n            }\n            if (!hasEventListeners && hasClass(target, 'pika-select')) {\n                if (!target.onchange) {\n                    target.setAttribute('onchange', 'return;');\n                    addEvent(target, 'change', self._onChange);\n                }\n            }\n            do {\n                if (hasClass(pEl, 'pika-single') || pEl === opts.trigger) {\n                    return;\n                }\n            }\n            while ((pEl = pEl.parentNode));\n            if (self._v && target !== opts.trigger && pEl !== opts.trigger) {\n                self.hide();\n            }\n        };\n\n        self.el = document.createElement('div');\n        self.el.className = 'pika-single' + (opts.isRTL ? ' is-rtl' : '') + (opts.theme ? ' ' + opts.theme : '');\n\n        addEvent(self.el, 'mousedown', self._onMouseDown, true);\n        addEvent(self.el, 'touchend', self._onMouseDown, true);\n        addEvent(self.el, 'change', self._onChange);\n\n        if (opts.keyboardInput) {\n            addEvent(document, 'keydown', self._onKeyChange);\n        }\n\n        if (opts.field) {\n            if (opts.container) {\n                opts.container.appendChild(self.el);\n            } else if (opts.bound) {\n                document.body.appendChild(self.el);\n            } else {\n                opts.field.parentNode.insertBefore(self.el, opts.field.nextSibling);\n            }\n            addEvent(opts.field, 'change', self._onInputChange);\n\n            if (!opts.defaultDate) {\n                if (hasMoment && opts.field.value) {\n                    opts.defaultDate = moment(opts.field.value, opts.format).toDate();\n                } else {\n                    opts.defaultDate = new Date(Date.parse(opts.field.value));\n                }\n                opts.setDefaultDate = true;\n            }\n        }\n\n        var defDate = opts.defaultDate;\n\n        if (isDate(defDate)) {\n            if (opts.setDefaultDate) {\n                self.setDate(defDate, true);\n            } else {\n                self.gotoDate(defDate);\n            }\n        } else {\n            self.gotoDate(new Date());\n        }\n\n        if (opts.bound) {\n            this.hide();\n            self.el.className += ' is-bound';\n            addEvent(opts.trigger, 'click', self._onInputClick);\n            addEvent(opts.trigger, 'focus', self._onInputFocus);\n            addEvent(opts.trigger, 'blur', self._onInputBlur);\n        } else {\n            this.show();\n        }\n    };\n\n\n    /**\n     * public Pikaday API\n     */\n    Pikaday.prototype = {\n\n\n        /**\n         * configure functionality\n         */\n        config: function(options)\n        {\n            if (!this._o) {\n                this._o = extend({}, defaults, true);\n            }\n\n            var opts = extend(this._o, options, true);\n\n            opts.isRTL = !!opts.isRTL;\n\n            opts.field = (opts.field && opts.field.nodeName) ? opts.field : null;\n\n            opts.theme = (typeof opts.theme) === 'string' && opts.theme ? opts.theme : null;\n\n            opts.bound = !!(opts.bound !== undefined ? opts.field && opts.bound : opts.field);\n\n            opts.trigger = (opts.trigger && opts.trigger.nodeName) ? opts.trigger : opts.field;\n\n            opts.disableWeekends = !!opts.disableWeekends;\n\n            opts.disableDayFn = (typeof opts.disableDayFn) === 'function' ? opts.disableDayFn : null;\n\n            var nom = parseInt(opts.numberOfMonths, 10) || 1;\n            opts.numberOfMonths = nom > 4 ? 4 : nom;\n\n            if (!isDate(opts.minDate)) {\n                opts.minDate = false;\n            }\n            if (!isDate(opts.maxDate)) {\n                opts.maxDate = false;\n            }\n            if ((opts.minDate && opts.maxDate) && opts.maxDate < opts.minDate) {\n                opts.maxDate = opts.minDate = false;\n            }\n            if (opts.minDate) {\n                this.setMinDate(opts.minDate);\n            }\n            if (opts.maxDate) {\n                this.setMaxDate(opts.maxDate);\n            }\n\n            if (isArray(opts.yearRange)) {\n                var fallback = new Date().getFullYear() - 10;\n                opts.yearRange[0] = parseInt(opts.yearRange[0], 10) || fallback;\n                opts.yearRange[1] = parseInt(opts.yearRange[1], 10) || fallback;\n            } else {\n                opts.yearRange = Math.abs(parseInt(opts.yearRange, 10)) || defaults.yearRange;\n                if (opts.yearRange > 100) {\n                    opts.yearRange = 100;\n                }\n            }\n\n            return opts;\n        },\n\n        /**\n         * return a formatted string of the current selection (using Moment.js if available)\n         */\n        toString: function(format)\n        {\n            format = format || this._o.format;\n            if (!isDate(this._d)) {\n                return '';\n            }\n            if (this._o.toString) {\n              return this._o.toString(this._d, format);\n            }\n            if (hasMoment) {\n              return moment(this._d).format(format);\n            }\n            return this._d.toDateString();\n        },\n\n        /**\n         * return a Moment.js object of the current selection (if available)\n         */\n        getMoment: function()\n        {\n            return hasMoment ? moment(this._d) : null;\n        },\n\n        /**\n         * set the current selection from a Moment.js object (if available)\n         */\n        setMoment: function(date, preventOnSelect)\n        {\n            if (hasMoment && moment.isMoment(date)) {\n                this.setDate(date.toDate(), preventOnSelect);\n            }\n        },\n\n        /**\n         * return a Date object of the current selection\n         */\n        getDate: function()\n        {\n            return isDate(this._d) ? new Date(this._d.getTime()) : null;\n        },\n\n        /**\n         * set the current selection\n         */\n        setDate: function(date, preventOnSelect)\n        {\n            if (!date) {\n                this._d = null;\n\n                if (this._o.field) {\n                    this._o.field.value = '';\n                    fireEvent(this._o.field, 'change', { firedBy: this });\n                }\n\n                return this.draw();\n            }\n            if (typeof date === 'string') {\n                date = new Date(Date.parse(date));\n            }\n            if (!isDate(date)) {\n                return;\n            }\n\n            var min = this._o.minDate,\n                max = this._o.maxDate;\n\n            if (isDate(min) && date < min) {\n                date = min;\n            } else if (isDate(max) && date > max) {\n                date = max;\n            }\n\n            this._d = new Date(date.getTime());\n            setToStartOfDay(this._d);\n            this.gotoDate(this._d);\n\n            if (this._o.field) {\n                this._o.field.value = this.toString();\n                fireEvent(this._o.field, 'change', { firedBy: this });\n            }\n            if (!preventOnSelect && typeof this._o.onSelect === 'function') {\n                this._o.onSelect.call(this, this.getDate());\n            }\n        },\n\n        /**\n         * change view to a specific date\n         */\n        gotoDate: function(date)\n        {\n            var newCalendar = true;\n\n            if (!isDate(date)) {\n                return;\n            }\n\n            if (this.calendars) {\n                var firstVisibleDate = new Date(this.calendars[0].year, this.calendars[0].month, 1),\n                    lastVisibleDate = new Date(this.calendars[this.calendars.length-1].year, this.calendars[this.calendars.length-1].month, 1),\n                    visibleDate = date.getTime();\n                // get the end of the month\n                lastVisibleDate.setMonth(lastVisibleDate.getMonth()+1);\n                lastVisibleDate.setDate(lastVisibleDate.getDate()-1);\n                newCalendar = (visibleDate < firstVisibleDate.getTime() || lastVisibleDate.getTime() < visibleDate);\n            }\n\n            if (newCalendar) {\n                this.calendars = [{\n                    month: date.getMonth(),\n                    year: date.getFullYear()\n                }];\n                if (this._o.mainCalendar === 'right') {\n                    this.calendars[0].month += 1 - this._o.numberOfMonths;\n                }\n            }\n\n            this.adjustCalendars();\n        },\n\n        adjustDate: function(sign, days) {\n\n            var day = this.getDate() || new Date();\n            var difference = parseInt(days)*24*60*60*1000;\n\n            var newDay;\n\n            if (sign === 'add') {\n                newDay = new Date(day.valueOf() + difference);\n            } else if (sign === 'subtract') {\n                newDay = new Date(day.valueOf() - difference);\n            }\n\n            this.setDate(newDay);\n        },\n\n        adjustCalendars: function() {\n            this.calendars[0] = adjustCalendar(this.calendars[0]);\n            for (var c = 1; c < this._o.numberOfMonths; c++) {\n                this.calendars[c] = adjustCalendar({\n                    month: this.calendars[0].month + c,\n                    year: this.calendars[0].year\n                });\n            }\n            this.draw();\n        },\n\n        gotoToday: function()\n        {\n            this.gotoDate(new Date());\n        },\n\n        /**\n         * change view to a specific month (zero-index, e.g. 0: January)\n         */\n        gotoMonth: function(month)\n        {\n            if (!isNaN(month)) {\n                this.calendars[0].month = parseInt(month, 10);\n                this.adjustCalendars();\n            }\n        },\n\n        nextMonth: function()\n        {\n            this.calendars[0].month++;\n            this.adjustCalendars();\n        },\n\n        prevMonth: function()\n        {\n            this.calendars[0].month--;\n            this.adjustCalendars();\n        },\n\n        /**\n         * change view to a specific full year (e.g. \"2012\")\n         */\n        gotoYear: function(year)\n        {\n            if (!isNaN(year)) {\n                this.calendars[0].year = parseInt(year, 10);\n                this.adjustCalendars();\n            }\n        },\n\n        /**\n         * change the minDate\n         */\n        setMinDate: function(value)\n        {\n            if(value instanceof Date) {\n                setToStartOfDay(value);\n                this._o.minDate = value;\n                this._o.minYear  = value.getFullYear();\n                this._o.minMonth = value.getMonth();\n            } else {\n                this._o.minDate = defaults.minDate;\n                this._o.minYear  = defaults.minYear;\n                this._o.minMonth = defaults.minMonth;\n                this._o.startRange = defaults.startRange;\n            }\n\n            this.draw();\n        },\n\n        /**\n         * change the maxDate\n         */\n        setMaxDate: function(value)\n        {\n            if(value instanceof Date) {\n                setToStartOfDay(value);\n                this._o.maxDate = value;\n                this._o.maxYear = value.getFullYear();\n                this._o.maxMonth = value.getMonth();\n            } else {\n                this._o.maxDate = defaults.maxDate;\n                this._o.maxYear = defaults.maxYear;\n                this._o.maxMonth = defaults.maxMonth;\n                this._o.endRange = defaults.endRange;\n            }\n\n            this.draw();\n        },\n\n        setStartRange: function(value)\n        {\n            this._o.startRange = value;\n        },\n\n        setEndRange: function(value)\n        {\n            this._o.endRange = value;\n        },\n\n        /**\n         * refresh the HTML\n         */\n        draw: function(force)\n        {\n            if (!this._v && !force) {\n                return;\n            }\n            var opts = this._o,\n                minYear = opts.minYear,\n                maxYear = opts.maxYear,\n                minMonth = opts.minMonth,\n                maxMonth = opts.maxMonth,\n                html = '',\n                randId;\n\n            if (this._y <= minYear) {\n                this._y = minYear;\n                if (!isNaN(minMonth) && this._m < minMonth) {\n                    this._m = minMonth;\n                }\n            }\n            if (this._y >= maxYear) {\n                this._y = maxYear;\n                if (!isNaN(maxMonth) && this._m > maxMonth) {\n                    this._m = maxMonth;\n                }\n            }\n\n            randId = 'pika-title-' + Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 2);\n\n            for (var c = 0; c < opts.numberOfMonths; c++) {\n                html += '<div class=\"pika-lendar\">' + renderTitle(this, c, this.calendars[c].year, this.calendars[c].month, this.calendars[0].year, randId) + this.render(this.calendars[c].year, this.calendars[c].month, randId) + '</div>';\n            }\n\n            this.el.innerHTML = html;\n\n            if (opts.bound) {\n                if(opts.field.type !== 'hidden') {\n                    sto(function() {\n                        opts.trigger.focus();\n                    }, 1);\n                }\n            }\n\n            if (typeof this._o.onDraw === 'function') {\n                this._o.onDraw(this);\n            }\n\n            if (opts.bound) {\n                // let the screen reader user know to use arrow keys\n                opts.field.setAttribute('aria-label', opts.ariaLabel);\n            }\n        },\n\n        adjustPosition: function()\n        {\n            var field, pEl, width, height, viewportWidth, viewportHeight, scrollTop, left, top, clientRect, leftAligned, bottomAligned;\n\n            if (this._o.container) return;\n\n            this.el.style.position = 'absolute';\n\n            field = this._o.trigger;\n            pEl = field;\n            width = this.el.offsetWidth;\n            height = this.el.offsetHeight;\n            viewportWidth = window.innerWidth || document.documentElement.clientWidth;\n            viewportHeight = window.innerHeight || document.documentElement.clientHeight;\n            scrollTop = window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop;\n            leftAligned = true;\n            bottomAligned = true;\n\n            if (typeof field.getBoundingClientRect === 'function') {\n                clientRect = field.getBoundingClientRect();\n                left = clientRect.left + window.pageXOffset;\n                top = clientRect.bottom + window.pageYOffset;\n            } else {\n                left = pEl.offsetLeft;\n                top  = pEl.offsetTop + pEl.offsetHeight;\n                while((pEl = pEl.offsetParent)) {\n                    left += pEl.offsetLeft;\n                    top  += pEl.offsetTop;\n                }\n            }\n\n            // default position is bottom & left\n            if ((this._o.reposition && left + width > viewportWidth) ||\n                (\n                    this._o.position.indexOf('right') > -1 &&\n                    left - width + field.offsetWidth > 0\n                )\n            ) {\n                left = left - width + field.offsetWidth;\n                leftAligned = false;\n            }\n            if ((this._o.reposition && top + height > viewportHeight + scrollTop) ||\n                (\n                    this._o.position.indexOf('top') > -1 &&\n                    top - height - field.offsetHeight > 0\n                )\n            ) {\n                top = top - height - field.offsetHeight;\n                bottomAligned = false;\n            }\n\n            this.el.style.left = left + 'px';\n            this.el.style.top = top + 'px';\n\n            addClass(this.el, leftAligned ? 'left-aligned' : 'right-aligned');\n            addClass(this.el, bottomAligned ? 'bottom-aligned' : 'top-aligned');\n            removeClass(this.el, !leftAligned ? 'left-aligned' : 'right-aligned');\n            removeClass(this.el, !bottomAligned ? 'bottom-aligned' : 'top-aligned');\n        },\n\n        /**\n         * render HTML for a particular month\n         */\n        render: function(year, month, randId)\n        {\n            var opts   = this._o,\n                now    = new Date(),\n                days   = getDaysInMonth(year, month),\n                before = new Date(year, month, 1).getDay(),\n                data   = [],\n                row    = [];\n            setToStartOfDay(now);\n            if (opts.firstDay > 0) {\n                before -= opts.firstDay;\n                if (before < 0) {\n                    before += 7;\n                }\n            }\n            var previousMonth = month === 0 ? 11 : month - 1,\n                nextMonth = month === 11 ? 0 : month + 1,\n                yearOfPreviousMonth = month === 0 ? year - 1 : year,\n                yearOfNextMonth = month === 11 ? year + 1 : year,\n                daysInPreviousMonth = getDaysInMonth(yearOfPreviousMonth, previousMonth);\n            var cells = days + before,\n                after = cells;\n            while(after > 7) {\n                after -= 7;\n            }\n            cells += 7 - after;\n            var isWeekSelected = false;\n            for (var i = 0, r = 0; i < cells; i++)\n            {\n                var day = new Date(year, month, 1 + (i - before)),\n                    isSelected = isDate(this._d) ? compareDates(day, this._d) : false,\n                    isToday = compareDates(day, now),\n                    hasEvent = opts.events.indexOf(day.toDateString()) !== -1 ? true : false,\n                    isEmpty = i < before || i >= (days + before),\n                    dayNumber = 1 + (i - before),\n                    monthNumber = month,\n                    yearNumber = year,\n                    isStartRange = opts.startRange && compareDates(opts.startRange, day),\n                    isEndRange = opts.endRange && compareDates(opts.endRange, day),\n                    isInRange = opts.startRange && opts.endRange && opts.startRange < day && day < opts.endRange,\n                    isDisabled = (opts.minDate && day < opts.minDate) ||\n                                 (opts.maxDate && day > opts.maxDate) ||\n                                 (opts.disableWeekends && isWeekend(day)) ||\n                                 (opts.disableDayFn && opts.disableDayFn(day));\n\n                if (isEmpty) {\n                    if (i < before) {\n                        dayNumber = daysInPreviousMonth + dayNumber;\n                        monthNumber = previousMonth;\n                        yearNumber = yearOfPreviousMonth;\n                    } else {\n                        dayNumber = dayNumber - days;\n                        monthNumber = nextMonth;\n                        yearNumber = yearOfNextMonth;\n                    }\n                }\n\n                var dayConfig = {\n                        day: dayNumber,\n                        month: monthNumber,\n                        year: yearNumber,\n                        hasEvent: hasEvent,\n                        isSelected: isSelected,\n                        isToday: isToday,\n                        isDisabled: isDisabled,\n                        isEmpty: isEmpty,\n                        isStartRange: isStartRange,\n                        isEndRange: isEndRange,\n                        isInRange: isInRange,\n                        showDaysInNextAndPreviousMonths: opts.showDaysInNextAndPreviousMonths,\n                        enableSelectionDaysInNextAndPreviousMonths: opts.enableSelectionDaysInNextAndPreviousMonths\n                    };\n\n                if (opts.pickWholeWeek && isSelected) {\n                    isWeekSelected = true;\n                }\n\n                row.push(renderDay(dayConfig));\n\n                if (++r === 7) {\n                    if (opts.showWeekNumber) {\n                        row.unshift(renderWeek(i - before, month, year));\n                    }\n                    data.push(renderRow(row, opts.isRTL, opts.pickWholeWeek, isWeekSelected));\n                    row = [];\n                    r = 0;\n                    isWeekSelected = false;\n                }\n            }\n            return renderTable(opts, data, randId);\n        },\n\n        isVisible: function()\n        {\n            return this._v;\n        },\n\n        show: function()\n        {\n            if (!this.isVisible()) {\n                this._v = true;\n                this.draw();\n                removeClass(this.el, 'is-hidden');\n                if (this._o.bound) {\n                    addEvent(document, 'click', this._onClick);\n                    this.adjustPosition();\n                }\n                if (typeof this._o.onOpen === 'function') {\n                    this._o.onOpen.call(this);\n                }\n            }\n        },\n\n        hide: function()\n        {\n            var v = this._v;\n            if (v !== false) {\n                if (this._o.bound) {\n                    removeEvent(document, 'click', this._onClick);\n                }\n                this.el.style.position = 'static'; // reset\n                this.el.style.left = 'auto';\n                this.el.style.top = 'auto';\n                addClass(this.el, 'is-hidden');\n                this._v = false;\n                if (v !== undefined && typeof this._o.onClose === 'function') {\n                    this._o.onClose.call(this);\n                }\n            }\n        },\n\n        /**\n         * GAME OVER\n         */\n        destroy: function()\n        {\n            var opts = this._o;\n\n            this.hide();\n            removeEvent(this.el, 'mousedown', this._onMouseDown, true);\n            removeEvent(this.el, 'touchend', this._onMouseDown, true);\n            removeEvent(this.el, 'change', this._onChange);\n            if (opts.keyboardInput) {\n                removeEvent(document, 'keydown', this._onKeyChange);\n            }\n            if (opts.field) {\n                removeEvent(opts.field, 'change', this._onInputChange);\n                if (opts.bound) {\n                    removeEvent(opts.trigger, 'click', this._onInputClick);\n                    removeEvent(opts.trigger, 'focus', this._onInputFocus);\n                    removeEvent(opts.trigger, 'blur', this._onInputBlur);\n                }\n            }\n            if (this.el.parentNode) {\n                this.el.parentNode.removeChild(this.el);\n            }\n        }\n\n    };\n\n    return Pikaday;\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/pikaday/pikaday.js\n// module id = 425\n// module chunks = 0","import $ from 'jquery';\r\nimport 'titon-toolkit';\r\n\r\nexport default function select(selector) {\r\n  const $select = $(selector);\r\n\r\n  if ($select.length) {\r\n    $('select').inputSelect({\r\n      arrowTemplate: '<i aria-hidden=\"true\"></i>',\r\n    });\r\n  }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/core/components/select.js","import $ from 'jquery';\r\nimport Tooltip from 'tether-tooltip';\r\n\r\nexport default function tooltip(selector) {\r\n  const $tooltip = $(selector);\r\n\r\n  $tooltip.each((index, element) => {\r\n    const $item = $(element);\r\n    const content = $item.data('tooltip') || $item.attr('title');\r\n\r\n    // to stop the page to error if no attribut is found\r\n    if (!content) {\r\n      return;\r\n    }\r\n\r\n    $item.removeAttr('title');\r\n\r\n    // eslint-disable-next-line no-new\r\n    const instance = new Tooltip({\r\n      classes: 'netc-tooltip-theme',\r\n      constrainToWindow: true,\r\n      content,\r\n      position: 'top right',\r\n      target: $item[0],\r\n      openOn: 'focus',\r\n      tetherOptions: {\r\n        constraints: [\r\n          {\r\n            to: 'scrollParent',\r\n            attachment: 'together',\r\n            pin: true,\r\n          },\r\n        ],\r\n      },\r\n    });\r\n\r\n    if ($item.is(':focus')) {\r\n      instance.open();\r\n    }\r\n  });\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/core/components/tooltip.js","/*! tether-tooltip 1.1.0 */\n\n(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define([\"tether-drop\",\"tether\"], factory);\n  } else if (typeof exports === 'object') {\n    module.exports = factory(require('tether-drop'), require('tether'));\n  } else {\n    root.Tooltip = factory(root.Drop, root.Tether);\n  }\n}(this, function(Drop, Tether) {\n\n/* global Tether Drop */\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 extend = Tether.Utils.extend;\n\nvar _Drop = Drop.createContext({\n  classPrefix: 'tooltip'\n});\n\nvar defaults = {\n  position: 'top center',\n  openOn: 'hover',\n  classes: 'tooltip-theme-arrows',\n  constrainToWindow: true,\n  constrainToScrollParent: false\n};\n\nvar tooltipCount = 0;\n\nvar Tooltip = (function () {\n  function Tooltip(options) {\n    _classCallCheck(this, Tooltip);\n\n    this.options = options;\n\n    if (!this.options.target) {\n      throw new Error('Tooltip Error: You must provide a target for Tooltip to attach to');\n    }\n\n    var position = this.options.target.getAttribute('data-tooltip-position');\n    if (position) {\n      if (typeof this.options.position === 'undefined') {\n        this.options.position = position;\n      }\n    }\n\n    var content = this.options.target.getAttribute('data-tooltip');\n\n    if (content) {\n      if (typeof this.options.content === 'undefined') {\n        var contentEl = document.createElement('div');\n        contentEl.innerHTML = content;\n\n        // Add ARIA attributes (see #50)\n        contentEl.setAttribute('role', 'tooltip');\n        contentEl.id = 'drop-tooltip-' + tooltipCount;\n        this.options.target.setAttribute('aria-describedby', contentEl.id);\n        tooltipCount += 1;\n\n        this.options.content = contentEl;\n      }\n    }\n\n    if (!this.options.content) {\n      throw new Error('Tooltip Error: You must provide content for Tooltip to display');\n    }\n\n    this.options = extend({}, defaults, this.options);\n\n    this.drop = new _Drop(this.options);\n  }\n\n  _createClass(Tooltip, [{\n    key: 'close',\n    value: function close() {\n      this.drop.close();\n    }\n  }, {\n    key: 'open',\n    value: function open() {\n      this.drop.open();\n    }\n  }, {\n    key: 'toggle',\n    value: function toggle() {\n      this.drop.toggle();\n    }\n  }, {\n    key: 'remove',\n    value: function remove() {\n      this.drop.remove();\n    }\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      this.drop.destroy();\n    }\n  }, {\n    key: 'position',\n    value: function position() {\n      this.drop.position();\n    }\n  }]);\n\n  return Tooltip;\n})();\n\nvar initialized = [];\n\nTooltip.init = function () {\n  var tooltipElements = document.querySelectorAll('[data-tooltip]');\n  var len = tooltipElements.length;\n  for (var i = 0; i < len; ++i) {\n    var el = tooltipElements[i];\n    if (initialized.indexOf(el) === -1) {\n      new Tooltip({\n        target: el\n      });\n      initialized.push(el);\n    }\n  }\n};\n\ndocument.addEventListener('DOMContentLoaded', function () {\n  if (Tooltip.autoinit !== false) {\n    Tooltip.init();\n  }\n});\nreturn Tooltip;\n\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/tether-tooltip/dist/js/tooltip.js\n// module id = 454\n// module chunks = 0","/*! tether-drop 1.4.1 */\n\n(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define([\"tether\"], factory);\n  } else if (typeof exports === 'object') {\n    module.exports = factory(require('tether'));\n  } else {\n    root.Drop = factory(root.Tether);\n  }\n}(this, function(Tether) {\n\n/* global Tether */\n'use strict';\n\nvar _bind = Function.prototype.bind;\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(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _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 { _x2 = parent; _x3 = property; _x4 = 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\nvar _Tether$Utils = Tether.Utils;\nvar extend = _Tether$Utils.extend;\nvar addClass = _Tether$Utils.addClass;\nvar removeClass = _Tether$Utils.removeClass;\nvar hasClass = _Tether$Utils.hasClass;\nvar Evented = _Tether$Utils.Evented;\n\nfunction sortAttach(str) {\n  var _str$split = str.split(' ');\n\n  var _str$split2 = _slicedToArray(_str$split, 2);\n\n  var first = _str$split2[0];\n  var second = _str$split2[1];\n\n  if (['left', 'right'].indexOf(first) >= 0) {\n    var _ref = [second, first];\n    first = _ref[0];\n    second = _ref[1];\n  }\n  return [first, second].join(' ');\n}\n\nfunction removeFromArray(arr, item) {\n  var index = undefined;\n  var results = [];\n  while ((index = arr.indexOf(item)) !== -1) {\n    results.push(arr.splice(index, 1));\n  }\n  return results;\n}\n\nvar clickEvents = ['click'];\nif ('ontouchstart' in document.documentElement) {\n  clickEvents.push('touchstart');\n}\n\nvar transitionEndEvents = {\n  'WebkitTransition': 'webkitTransitionEnd',\n  'MozTransition': 'transitionend',\n  'OTransition': 'otransitionend',\n  'transition': 'transitionend'\n};\n\nvar transitionEndEvent = '';\nfor (var _name in transitionEndEvents) {\n  if (({}).hasOwnProperty.call(transitionEndEvents, _name)) {\n    var tempEl = document.createElement('p');\n    if (typeof tempEl.style[_name] !== 'undefined') {\n      transitionEndEvent = transitionEndEvents[_name];\n    }\n  }\n}\n\nvar MIRROR_ATTACH = {\n  left: 'right',\n  right: 'left',\n  top: 'bottom',\n  bottom: 'top',\n  middle: 'middle',\n  center: 'center'\n};\n\nvar allDrops = {};\n\n// Drop can be included in external libraries.  Calling createContext gives you a fresh\n// copy of drop which won't interact with other copies on the page (beyond calling the document events).\n\nfunction createContext() {\n  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n  var drop = function drop() {\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return new (_bind.apply(DropInstance, [null].concat(args)))();\n  };\n\n  extend(drop, {\n    createContext: createContext,\n    drops: [],\n    defaults: {}\n  });\n\n  var defaultOptions = {\n    classPrefix: 'drop',\n    defaults: {\n      position: 'bottom left',\n      openOn: 'click',\n      beforeClose: null,\n      constrainToScrollParent: true,\n      constrainToWindow: true,\n      classes: '',\n      remove: false,\n      openDelay: 0,\n      closeDelay: 50,\n      // inherited from openDelay and closeDelay if not explicitly defined\n      focusDelay: null,\n      blurDelay: null,\n      hoverOpenDelay: null,\n      hoverCloseDelay: null,\n      tetherOptions: {}\n    }\n  };\n\n  extend(drop, defaultOptions, options);\n  extend(drop.defaults, defaultOptions.defaults, options.defaults);\n\n  if (typeof allDrops[drop.classPrefix] === 'undefined') {\n    allDrops[drop.classPrefix] = [];\n  }\n\n  drop.updateBodyClasses = function () {\n    // There is only one body, so despite the context concept, we still iterate through all\n    // drops which share our classPrefix.\n\n    var anyOpen = false;\n    var drops = allDrops[drop.classPrefix];\n    var len = drops.length;\n    for (var i = 0; i < len; ++i) {\n      if (drops[i].isOpened()) {\n        anyOpen = true;\n        break;\n      }\n    }\n\n    if (anyOpen) {\n      addClass(document.body, drop.classPrefix + '-open');\n    } else {\n      removeClass(document.body, drop.classPrefix + '-open');\n    }\n  };\n\n  var DropInstance = (function (_Evented) {\n    _inherits(DropInstance, _Evented);\n\n    function DropInstance(opts) {\n      _classCallCheck(this, DropInstance);\n\n      _get(Object.getPrototypeOf(DropInstance.prototype), 'constructor', this).call(this);\n      this.options = extend({}, drop.defaults, opts);\n      this.target = this.options.target;\n\n      if (typeof this.target === 'undefined') {\n        throw new Error('Drop Error: You must provide a target.');\n      }\n\n      var dataPrefix = 'data-' + drop.classPrefix;\n\n      var contentAttr = this.target.getAttribute(dataPrefix);\n      if (contentAttr && this.options.content == null) {\n        this.options.content = contentAttr;\n      }\n\n      var attrsOverride = ['position', 'openOn'];\n      for (var i = 0; i < attrsOverride.length; ++i) {\n\n        var override = this.target.getAttribute(dataPrefix + '-' + attrsOverride[i]);\n        if (override && this.options[attrsOverride[i]] == null) {\n          this.options[attrsOverride[i]] = override;\n        }\n      }\n\n      if (this.options.classes && this.options.addTargetClasses !== false) {\n        addClass(this.target, this.options.classes);\n      }\n\n      drop.drops.push(this);\n      allDrops[drop.classPrefix].push(this);\n\n      this._boundEvents = [];\n      this.bindMethods();\n      this.setupElements();\n      this.setupEvents();\n      this.setupTether();\n    }\n\n    _createClass(DropInstance, [{\n      key: '_on',\n      value: function _on(element, event, handler) {\n        this._boundEvents.push({ element: element, event: event, handler: handler });\n        element.addEventListener(event, handler);\n      }\n    }, {\n      key: 'bindMethods',\n      value: function bindMethods() {\n        this.transitionEndHandler = this._transitionEndHandler.bind(this);\n      }\n    }, {\n      key: 'setupElements',\n      value: function setupElements() {\n        var _this = this;\n\n        this.drop = document.createElement('div');\n        addClass(this.drop, drop.classPrefix);\n\n        if (this.options.classes) {\n          addClass(this.drop, this.options.classes);\n        }\n\n        this.content = document.createElement('div');\n        addClass(this.content, drop.classPrefix + '-content');\n\n        if (typeof this.options.content === 'function') {\n          var generateAndSetContent = function generateAndSetContent() {\n            // content function might return a string or an element\n            var contentElementOrHTML = _this.options.content.call(_this, _this);\n\n            if (typeof contentElementOrHTML === 'string') {\n              _this.content.innerHTML = contentElementOrHTML;\n            } else if (typeof contentElementOrHTML === 'object') {\n              _this.content.innerHTML = '';\n              _this.content.appendChild(contentElementOrHTML);\n            } else {\n              throw new Error('Drop Error: Content function should return a string or HTMLElement.');\n            }\n          };\n\n          generateAndSetContent();\n          this.on('open', generateAndSetContent.bind(this));\n        } else if (typeof this.options.content === 'object') {\n          this.content.appendChild(this.options.content);\n        } else {\n          this.content.innerHTML = this.options.content;\n        }\n\n        this.drop.appendChild(this.content);\n      }\n    }, {\n      key: 'setupTether',\n      value: function setupTether() {\n        // Tether expects two attachment points, one in the target element, one in the\n        // drop.  We use a single one, and use the order as well, to allow us to put\n        // the drop on either side of any of the four corners.  This magic converts between\n        // the two:\n        var dropAttach = this.options.position.split(' ');\n        dropAttach[0] = MIRROR_ATTACH[dropAttach[0]];\n        dropAttach = dropAttach.join(' ');\n\n        var constraints = [];\n        if (this.options.constrainToScrollParent) {\n          constraints.push({\n            to: 'scrollParent',\n            pin: 'top, bottom',\n            attachment: 'together none'\n          });\n        } else {\n          // To get 'out of bounds' classes\n          constraints.push({\n            to: 'scrollParent'\n          });\n        }\n\n        if (this.options.constrainToWindow !== false) {\n          constraints.push({\n            to: 'window',\n            attachment: 'together'\n          });\n        } else {\n          // To get 'out of bounds' classes\n          constraints.push({\n            to: 'window'\n          });\n        }\n\n        var opts = {\n          element: this.drop,\n          target: this.target,\n          attachment: sortAttach(dropAttach),\n          targetAttachment: sortAttach(this.options.position),\n          classPrefix: drop.classPrefix,\n          offset: '0 0',\n          targetOffset: '0 0',\n          enabled: false,\n          constraints: constraints,\n          addTargetClasses: this.options.addTargetClasses\n        };\n\n        if (this.options.tetherOptions !== false) {\n          this.tether = new Tether(extend({}, opts, this.options.tetherOptions));\n        }\n      }\n    }, {\n      key: 'setupEvents',\n      value: function setupEvents() {\n        var _this2 = this;\n\n        if (!this.options.openOn) {\n          return;\n        }\n\n        if (this.options.openOn === 'always') {\n          setTimeout(this.open.bind(this));\n          return;\n        }\n\n        var events = this.options.openOn.split(' ');\n\n        if (events.indexOf('click') >= 0) {\n          var openHandler = function openHandler(event) {\n            _this2.toggle(event);\n            event.preventDefault();\n          };\n\n          var closeHandler = function closeHandler(event) {\n            if (!_this2.isOpened()) {\n              return;\n            }\n\n            // Clicking inside dropdown\n            if (event.target === _this2.drop || _this2.drop.contains(event.target)) {\n              return;\n            }\n\n            // Clicking target\n            if (event.target === _this2.target || _this2.target.contains(event.target)) {\n              return;\n            }\n\n            _this2.close(event);\n          };\n\n          for (var i = 0; i < clickEvents.length; ++i) {\n            var clickEvent = clickEvents[i];\n            this._on(this.target, clickEvent, openHandler);\n            this._on(document, clickEvent, closeHandler);\n          }\n        }\n\n        var inTimeout = null;\n        var outTimeout = null;\n\n        var inHandler = function inHandler(event) {\n          if (outTimeout !== null) {\n            clearTimeout(outTimeout);\n          } else {\n            inTimeout = setTimeout(function () {\n              _this2.open(event);\n              inTimeout = null;\n            }, (event.type === 'focus' ? _this2.options.focusDelay : _this2.options.hoverOpenDelay) || _this2.options.openDelay);\n          }\n        };\n\n        var outHandler = function outHandler(event) {\n          if (inTimeout !== null) {\n            clearTimeout(inTimeout);\n          } else {\n            outTimeout = setTimeout(function () {\n              _this2.close(event);\n              outTimeout = null;\n            }, (event.type === 'blur' ? _this2.options.blurDelay : _this2.options.hoverCloseDelay) || _this2.options.closeDelay);\n          }\n        };\n\n        if (events.indexOf('hover') >= 0) {\n          this._on(this.target, 'mouseover', inHandler);\n          this._on(this.drop, 'mouseover', inHandler);\n          this._on(this.target, 'mouseout', outHandler);\n          this._on(this.drop, 'mouseout', outHandler);\n        }\n\n        if (events.indexOf('focus') >= 0) {\n          this._on(this.target, 'focus', inHandler);\n          this._on(this.drop, 'focus', inHandler);\n          this._on(this.target, 'blur', outHandler);\n          this._on(this.drop, 'blur', outHandler);\n        }\n      }\n    }, {\n      key: 'isOpened',\n      value: function isOpened() {\n        if (this.drop) {\n          return hasClass(this.drop, drop.classPrefix + '-open');\n        }\n      }\n    }, {\n      key: 'toggle',\n      value: function toggle(event) {\n        if (this.isOpened()) {\n          this.close(event);\n        } else {\n          this.open(event);\n        }\n      }\n    }, {\n      key: 'open',\n      value: function open(event) {\n        var _this3 = this;\n\n        /* eslint no-unused-vars: 0 */\n        if (this.isOpened()) {\n          return;\n        }\n\n        if (!this.drop.parentNode) {\n          document.body.appendChild(this.drop);\n        }\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.enable();\n        }\n\n        addClass(this.drop, drop.classPrefix + '-open');\n        addClass(this.drop, drop.classPrefix + '-open-transitionend');\n\n        setTimeout(function () {\n          if (_this3.drop) {\n            addClass(_this3.drop, drop.classPrefix + '-after-open');\n          }\n        });\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.position();\n        }\n\n        this.trigger('open');\n\n        drop.updateBodyClasses();\n      }\n    }, {\n      key: '_transitionEndHandler',\n      value: function _transitionEndHandler(e) {\n        if (e.target !== e.currentTarget) {\n          return;\n        }\n\n        if (!hasClass(this.drop, drop.classPrefix + '-open')) {\n          removeClass(this.drop, drop.classPrefix + '-open-transitionend');\n        }\n        this.drop.removeEventListener(transitionEndEvent, this.transitionEndHandler);\n      }\n    }, {\n      key: 'beforeCloseHandler',\n      value: function beforeCloseHandler(event) {\n        var shouldClose = true;\n\n        if (!this.isClosing && typeof this.options.beforeClose === 'function') {\n          this.isClosing = true;\n          shouldClose = this.options.beforeClose(event, this) !== false;\n        }\n\n        this.isClosing = false;\n\n        return shouldClose;\n      }\n    }, {\n      key: 'close',\n      value: function close(event) {\n        if (!this.isOpened()) {\n          return;\n        }\n\n        if (!this.beforeCloseHandler(event)) {\n          return;\n        }\n\n        removeClass(this.drop, drop.classPrefix + '-open');\n        removeClass(this.drop, drop.classPrefix + '-after-open');\n\n        this.drop.addEventListener(transitionEndEvent, this.transitionEndHandler);\n\n        this.trigger('close');\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.disable();\n        }\n\n        drop.updateBodyClasses();\n\n        if (this.options.remove) {\n          this.remove(event);\n        }\n      }\n    }, {\n      key: 'remove',\n      value: function remove(event) {\n        this.close(event);\n        if (this.drop.parentNode) {\n          this.drop.parentNode.removeChild(this.drop);\n        }\n      }\n    }, {\n      key: 'position',\n      value: function position() {\n        if (this.isOpened() && typeof this.tether !== 'undefined') {\n          this.tether.position();\n        }\n      }\n    }, {\n      key: 'destroy',\n      value: function destroy() {\n        this.remove();\n\n        if (typeof this.tether !== 'undefined') {\n          this.tether.destroy();\n        }\n\n        for (var i = 0; i < this._boundEvents.length; ++i) {\n          var _boundEvents$i = this._boundEvents[i];\n          var element = _boundEvents$i.element;\n          var _event = _boundEvents$i.event;\n          var handler = _boundEvents$i.handler;\n\n          element.removeEventListener(_event, handler);\n        }\n\n        this._boundEvents = [];\n\n        this.tether = null;\n        this.drop = null;\n        this.content = null;\n        this.target = null;\n\n        removeFromArray(allDrops[drop.classPrefix], this);\n        removeFromArray(drop.drops, this);\n      }\n    }]);\n\n    return DropInstance;\n  })(Evented);\n\n  return drop;\n}\n\nvar Drop = createContext();\n\ndocument.addEventListener('DOMContentLoaded', function () {\n  Drop.updateBodyClasses();\n});\nreturn Drop;\n\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/tether-drop/dist/js/drop.js\n// module id = 455\n// module chunks = 0","import 'titon-toolkit';\r\n\r\nToolkit.namespace = 'netc-';\r\n\n\n\n// WEBPACK FOOTER //\n// ./js/core/titon.js"],"sourceRoot":""}