{"version":3,"sources":["webpack://@flarum/core/webpack/bootstrap","webpack://@flarum/core/./src/common/Component.ts","webpack://@flarum/core/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://@flarum/core/(webpack)/buildin/global.js","webpack://@flarum/core/./node_modules/mithril/render/vnode.js","webpack://@flarum/core/external \"m\"","webpack://@flarum/core/./node_modules/mithril/mount-redraw.js","webpack://@flarum/core/./node_modules/mithril/pathname/build.js","webpack://@flarum/core/./node_modules/mithril/pathname/parse.js","webpack://@flarum/core/./src/common/utils/patchMithril.ts","webpack://@flarum/core/./node_modules/mithril/render/hyperscript.js","webpack://@flarum/core/./node_modules/mithril/render/hyperscriptVnode.js","webpack://@flarum/core/./node_modules/mithril/promise/promise.js","webpack://@flarum/core/./node_modules/mithril/promise/polyfill.js","webpack://@flarum/core/./node_modules/timers-browserify/main.js","webpack://@flarum/core/./node_modules/mithril/render.js","webpack://@flarum/core/./node_modules/mithril/querystring/build.js","webpack://@flarum/core/./node_modules/mithril/pathname/assign.js","webpack://@flarum/core/./node_modules/mithril/querystring/parse.js","webpack://@flarum/core/./node_modules/jump.js/dist/jump.module.js","webpack://@flarum/core/../../src/index.js","webpack://@flarum/core/../../../popper/src/utils/isFunction.js","webpack://@flarum/core/./src/common/utils/patchZepto.ts","webpack://@flarum/core/./src/common/index.ts","webpack://@flarum/core/../../src/utils/isBrowser.js","webpack://@flarum/core/../../src/utils/debounce.js","webpack://@flarum/core/../../src/utils/isFunction.js","webpack://@flarum/core/../../src/utils/getStyleComputedProperty.js","webpack://@flarum/core/../../src/utils/getParentNode.js","webpack://@flarum/core/../../src/utils/getScrollParent.js","webpack://@flarum/core/../../src/utils/getReferenceNode.js","webpack://@flarum/core/../../src/utils/isIE.js","webpack://@flarum/core/../../src/utils/getOffsetParent.js","webpack://@flarum/core/../../src/utils/getRoot.js","webpack://@flarum/core/../../src/utils/findCommonOffsetParent.js","webpack://@flarum/core/../../src/utils/isOffsetContainer.js","webpack://@flarum/core/../../src/utils/getScroll.js","webpack://@flarum/core/../../src/utils/includeScroll.js","webpack://@flarum/core/../../src/utils/getBordersSize.js","webpack://@flarum/core/../../src/utils/getWindowSizes.js","webpack://@flarum/core/../../src/utils/getClientRect.js","webpack://@flarum/core/../../src/utils/getBoundingClientRect.js","webpack://@flarum/core/../../src/utils/getOffsetRectRelativeToArbitraryNode.js","webpack://@flarum/core/../../src/utils/getViewportOffsetRectRelativeToArtbitraryNode.js","webpack://@flarum/core/../../src/utils/isFixed.js","webpack://@flarum/core/../../src/utils/getFixedPositionOffsetParent.js","webpack://@flarum/core/../../src/utils/getBoundaries.js","webpack://@flarum/core/../../src/utils/computeAutoPlacement.js","webpack://@flarum/core/../../src/utils/getReferenceOffsets.js","webpack://@flarum/core/../../src/utils/getOuterSizes.js","webpack://@flarum/core/../../src/utils/getOppositePlacement.js","webpack://@flarum/core/../../src/utils/getPopperOffsets.js","webpack://@flarum/core/../../src/utils/find.js","webpack://@flarum/core/../../src/utils/runModifiers.js","webpack://@flarum/core/../../src/utils/findIndex.js","webpack://@flarum/core/../../src/methods/update.js","webpack://@flarum/core/../../src/utils/isModifierEnabled.js","webpack://@flarum/core/../../src/utils/getSupportedPropertyName.js","webpack://@flarum/core/../../src/methods/destroy.js","webpack://@flarum/core/../../src/utils/getWindow.js","webpack://@flarum/core/../../src/utils/setupEventListeners.js","webpack://@flarum/core/../../src/methods/enableEventListeners.js","webpack://@flarum/core/../../src/methods/disableEventListeners.js","webpack://@flarum/core/../../src/utils/removeEventListeners.js","webpack://@flarum/core/../../src/utils/isNumeric.js","webpack://@flarum/core/../../src/utils/setStyles.js","webpack://@flarum/core/../../src/modifiers/computeStyle.js","webpack://@flarum/core/../../src/utils/isModifierRequired.js","webpack://@flarum/core/../../src/methods/placements.js","webpack://@flarum/core/../../src/utils/clockwise.js","webpack://@flarum/core/../../src/modifiers/flip.js","webpack://@flarum/core/../../src/modifiers/offset.js","webpack://@flarum/core/../../src/modifiers/index.js","webpack://@flarum/core/../../src/methods/defaults.js","webpack://@flarum/core/../../src/modifiers/shift.js","webpack://@flarum/core/../../src/modifiers/preventOverflow.js","webpack://@flarum/core/../../src/modifiers/keepTogether.js","webpack://@flarum/core/../../src/modifiers/arrow.js","webpack://@flarum/core/../../src/utils/getOppositeVariation.js","webpack://@flarum/core/../../src/modifiers/inner.js","webpack://@flarum/core/../../src/modifiers/hide.js","webpack://@flarum/core/../../src/utils/getRoundedOffsets.js","webpack://@flarum/core/../../src/modifiers/applyStyle.js","webpack://@flarum/core/../../src/utils/setAttributes.js","webpack://@flarum/core/./node_modules/dayjs/plugin/relativeTime.js","webpack://@flarum/core/./node_modules/dayjs/plugin/localizedFormat.js","webpack://@flarum/core/./node_modules/mithril/stream.js","webpack://@flarum/core/./node_modules/zepto/dist/zepto.js-exposed","webpack://@flarum/core/./node_modules/zepto/dist/zepto.js","webpack://@flarum/core/./node_modules/dayjs/dayjs.min.js-exposed?da0f","webpack://@flarum/core/./node_modules/dayjs/dayjs.min.js-exposed","webpack://@flarum/core/./node_modules/dayjs/dayjs.min.js","webpack://@flarum/core/./node_modules/mithril/index.js-exposed","webpack://@flarum/core/./node_modules/mithril/index.js","webpack://@flarum/core/./node_modules/mithril/hyperscript.js","webpack://@flarum/core/./node_modules/mithril/render/trust.js","webpack://@flarum/core/./node_modules/mithril/render/fragment.js","webpack://@flarum/core/./node_modules/mithril/request.js","webpack://@flarum/core/./node_modules/setimmediate/setImmediate.js","webpack://@flarum/core/./node_modules/process/browser.js","webpack://@flarum/core/./node_modules/mithril/render/render.js","webpack://@flarum/core/./node_modules/mithril/api/mount-redraw.js","webpack://@flarum/core/./node_modules/mithril/request/request.js","webpack://@flarum/core/./node_modules/mithril/route.js","webpack://@flarum/core/./node_modules/mithril/api/router.js","webpack://@flarum/core/./node_modules/mithril/pathname/compileTemplate.js","webpack://@flarum/core/./node_modules/m.attrs.bidi/bidi.js-exposed","webpack://@flarum/core/./node_modules/m.attrs.bidi/bidi.js","webpack://@flarum/core/./node_modules/mousetrap/mousetrap.js-exposed","webpack://@flarum/core/./node_modules/mousetrap/mousetrap.js","webpack://@flarum/core/./node_modules/classnames/index.js-exposed","webpack://@flarum/core/./node_modules/classnames/index.js","webpack://@flarum/core/./node_modules/zepto/src/selector.js","webpack://@flarum/core/./node_modules/zepto/src/data.js","webpack://@flarum/core/./node_modules/zepto/src/fx.js","webpack://@flarum/core/./node_modules/zepto/src/fx_methods.js","webpack://@flarum/core/./node_modules/hc-sticky/dist/hc-sticky.js","webpack://@flarum/core/(webpack)/buildin/harmony-module.js","webpack://@flarum/core/(webpack)/buildin/amd-options.js","webpack://@flarum/core/./node_modules/bootstrap/js/dropdown.js","webpack://@flarum/core/./node_modules/bootstrap/js/transition.js","webpack://@flarum/core/./node_modules/mithril/stream/stream.js","webpack://@flarum/core/./admin.ts"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","Component","props","element","this","tag","view","vnode","Error","oninit","setProps","oncreate","dom","onbeforeupdate","onupdate","onbeforeremove","onremove","$","selector","$element","find","render","constructor","component","children","componentProps","initProps","attrs","_extends","assign","target","arguments","length","source","apply","g","Function","e","window","Vnode","text","domSize","undefined","state","events","instance","normalize","node","Array","isArray","normalizeChildren","String","input","isKeyed","TypeError","require","requestAnimationFrame","console","buildQueryString","template","params","test","SyntaxError","queryIndex","indexOf","hashIndex","queryEnd","pathEnd","path","slice","query","resolved","replace","variadic","encodeURIComponent","newQueryIndex","newHashIndex","newQueryEnd","newPathEnd","result","querystring","parseQueryString","url","mo","_m","comp","args","writable","bidi","route","href","Link","keys","forEach","withAttr","cb","getAttribute","prop","hyperscriptVnode","selectorParser","selectorCache","hasOwn","isEmpty","compileSelector","match","classes","exec","type","id","push","attrValue","className","join","execSelector","hasClass","class","newAttrs","start","PromisePolyfill","Promise","finally","global","executor","self","resolvers","rejectors","resolveCurrent","handler","rejectCurrent","_instance","callAsync","setImmediate","setTimeout","list","shouldAbsorb","execute","then","error","retry","executeOnce","runs","run","fn","onerror","onFulfilled","onRejection","resolveNext","rejectNext","handle","callback","next","promise","resolve","reject","catch","reason","all","total","count","values","consume","race","scope","Timeout","clearFn","_id","_clearFn","clearTimeout","setInterval","clearInterval","timeout","close","unref","ref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","clearImmediate","toString","destructure","string","charAt","entries","split","counters","data","entry","decodeURIComponent","levels","cursor","pop","j","level","nextLevel","isNumber","isNaN","parseInt","desc","getOwnPropertyDescriptor","easeInOutQuad","b","_typeof","iterator","obj","singleton","stop","offset","easing","a11y","distance","duration","timeStart","timeElapsed","location","scrollY","pageYOffset","top","getBoundingClientRect","loop","timeCurrent","scrollTo","setAttribute","focus","done","options","document","querySelector","jumper","DEFAULT_OPTIONS","Tooltip","reference","title","allowHtml","tooltipGenerator","tooltipNode","Math","titleNode","functionToCheck","getType","container","placement","arrowSelector","boundariesElement","func","event","directEvents","oppositeEvents","evt","popper","delay","computedDelay","lastTitle","show","hide","dispose","toggle","updateTitleContent","_events","_setTooltipNodeEvent","relatedreference","relatedreference2","evt2","tooltip","option","each","$this","attr","removeAttr","includes","dimension","Dimension","toUpperCase","margin","elem","size","width","height","side","css","expr","tagName","hover","leave","on","animateScrollTop","to","fx","speeds","_default","jump","slideUp","overflow","animate","extend","special","bindBeforeSpecialEvents","eventName","el","specialEvent","_init","originalHandler","$target","trigger","setup","dayjs","relativeTime","localizedFormat","patchMithril","navigator","timeoutDuration","longerTimeoutBrowsers","isBrowser","called","scheduled","isFunction","getStyleComputedProperty","getParentNode","getScrollParent","overflowX","overflowY","getReferenceNode","isIE11","isIE10","isIE","version","getOffsetParent","noOffsetParent","offsetParent","nodeName","getRoot","findCommonOffsetParent","element1","element2","order","Node","end","range","commonAncestorContainer","element1root","getScroll","upperSide","html","scrollingElement","includeScroll","rect","subtract","scrollTop","scrollLeft","modifier","getBordersSize","styles","axis","sideA","sideB","parseFloat","getSize","body","computedStyle","getWindowSizes","getComputedStyle","getClientRect","offsets","sizes","horizScrollbar","vertScrollbar","getOffsetRectRelativeToArbitraryNode","parent","fixedPosition","runIsIE","isHTML","childrenRect","parentRect","scrollParent","borderTopWidth","borderLeftWidth","marginTop","marginLeft","getViewportOffsetRectRelativeToArtbitraryNode","excludeScroll","relativeOffset","isFixed","parentNode","getFixedPositionOffsetParent","getBoundaries","boundaries","left","boundariesNode","isPaddingNumber","padding","getArea","computeAutoPlacement","rects","refRect","bottom","sortedAreas","a","filteredAreas","filter","computedPlacement","variation","getReferenceOffsets","commonOffsetParent","getOuterSizes","x","y","getOppositePlacement","hash","right","matched","getPopperOffsets","referenceOffsets","popperRect","popperOffsets","isHoriz","mainSide","secondarySide","measurement","secondaryMeasurement","arr","check","runModifiers","modifiers","ends","findIndex","cur","update","flip","positionFixed","isModifierEnabled","modifierName","some","getSupportedPropertyName","prefixes","upperProp","prefix","toCheck","destroy","getWindow","ownerDocument","setupEventListeners","passive","scrollElement","attachToScrollParents","scrollParents","isBody","enableEventListeners","disableEventListeners","removeEventListeners","isNumeric","isFinite","setStyles","unit","isFirefox","isModifierRequired","requesting","isRequired","requested","validPlacements","placements","clockwise","counter","index","BEHAVIORS","parseOffset","useHeight","basePlacement","fragments","map","frag","divider","splitRegex","ops","mergeWithPrevious","op","str","toValue","index2","shiftvariation","isVertical","shiftOffsets","transformProp","popperStyles","transform","floor","opSide","arrowElement","len","sideCapitalized","altSide","arrowElementSize","center","popperMarginSide","popperBorderSide","sideValue","placementOpposite","flipOrder","refOffsets","overlapsRef","overflowsLeft","overflowsRight","overflowsTop","overflowsBottom","overflowsBoundaries","flippedVariationByRef","flippedVariationByContent","flippedVariation","getOppositeVariation","subtractLength","bound","legacyGpuAccelerationOption","gpuAcceleration","offsetParentRect","position","shouldRound","round","noRound","v","referenceWidth","popperWidth","isVariation","horizontalToInteger","verticalToInteger","bothOddWidth","getRoundedOffsets","prefixedProperty","invertTop","invertLeft","attributes","Popper","debounce","modifierOptions","eventsEnabled","Utils","PopperUtils","Defaults","en","future","past","mm","h","hh","dd","M","MM","yy","u","$locale","f","diff","abs","from","$u","utc","toNow","fromNow","format","LTS","LT","L","LL","LLL","LLLL","formats","define","Zepto","classList","camelize","uniq","emptyArray","concat","elementDisplay","classCache","cssNumber","fragmentRE","singleTagRE","tagExpanderRE","rootNodeRE","capitalRE","methodAttributes","table","createElement","tableRow","containers","readyRE","simpleSelectorRE","class2type","zepto","tempParent","propMap","isWindow","isDocument","nodeType","DOCUMENT_NODE","isObject","isPlainObject","getPrototypeOf","likeArray","dasherize","toLowerCase","classRE","RegExp","maybeAddPx","childNodes","Z","deep","filtered","nodes","funcArg","context","arg","idx","payload","removeAttribute","klass","svg","baseVal","deserializeValue","parseJSON","traverseNode","fun","matches","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","temp","appendChild","qsa","removeChild","chr","array","fragment","properties","$1","innerHTML","isZ","init","trim","ready","shift","found","maybeID","maybeClass","nameOnly","isSimple","getElementById","getElementsByClassName","getElementsByTagName","querySelectorAll","contains","documentElement","isEmptyObject","val","num","Number","inArray","camelCase","uuid","support","noop","elements","grep","JSON","parse","reduce","sort","splice","toArray","readyState","addEventListener","remove","every","not","add","is","excludes","has","eq","first","last","closest","collection","_","parents","ancestors","pluck","contents","contentDocument","siblings","child","empty","display","style","getPropertyValue","replaceWith","newContent","before","wrap","structure","clone","wrapAll","cloneNode","append","wrapInner","unwrap","setting","prev","originHtml","newText","textContent","attribute","removeProp","attrName","multiple","selected","coordinates","coords","parentOffset","pageXOffset","removeProperty","cssText","addClass","cls","removeClass","toggleClass","when","hasScrollTop","scrollX","hasScrollLeft","detach","dimensionProperty","operator","operatorIndex","inside","argType","copyByClone","nextSibling","firstChild","parentInDocument","insertBefore","src","defaultView","_zid","isString","handlers","specialEvents","focusinSupported","blur","mouseenter","mouseleave","zid","findHandlers","matcher","sel","parts","eventCapture","captureSetting","del","realEvent","delegator","capture","set","related","relatedTarget","proxy","compatible","isImmediatePropagationStopped","_args","preventDefault","stopPropagation","removeEventListener","click","mousedown","mouseup","mousemove","proxyFn","unshift","unbind","off","one","returnTrue","returnFalse","ignoreProperties","eventMethods","stopImmediatePropagation","isDefaultPrevented","predicate","sourceMethod","timeStamp","Date","now","defaultPrevented","returnValue","getPreventDefault","createProxy","originalEvent","delegate","undelegate","live","die","autoRemove","currentTarget","liveFired","Event","dispatchEvent","triggerHandler","createEvent","bubbles","initEvent","jsonpID","rscript","scriptTypeRE","xmlTypeRE","blankRE","originAnchor","triggerGlobal","settings","triggerAndReturn","ajaxBeforeSend","xhr","beforeSend","ajaxSuccess","deferred","success","resolveWith","ajaxComplete","ajaxError","rejectWith","status","complete","ajaxStop","appendQuery","parseArguments","dataType","ajaxJSONP","ajax","responseData","abortTimeout","_callbackName","jsonpCallback","callbackName","script","originalCallback","abort","errorType","head","ajaxSettings","XMLHttpRequest","accepts","json","xml","crossDomain","processData","cache","dataFilter","urlAnchor","Deferred","ajaxStart","protocol","host","param","traditional","serializeData","hasPlaceholder","jsonp","mime","headers","setHeader","nativeSetHeader","setRequestHeader","mimeType","overrideMimeType","contentType","onreadystatechange","mimeToDataType","getResponseHeader","responseType","response","responseText","ajaxDataFilter","eval","responseXML","statusText","async","open","username","password","xhrFields","send","post","getJSON","load","escape","serialize","serializeArray","field","disabled","checked","elm","submit","nativeGetComputedStyle","pseudoElement","factory","z","utcOffset","year","month","ceil","w","D","ms","Q","weekdays","months","pl","date","locale","$L","$offset","$d","NaN","UTC","$y","getFullYear","$M","getMonth","$D","getDate","$W","getDay","$H","getHours","$m","getMinutes","$s","getSeconds","$ms","getMilliseconds","$utils","isValid","isSame","startOf","endOf","isAfter","isBefore","$g","day","hour","minute","second","millisecond","unix","valueOf","getTime","toDate","weekStart","$set","min","daysInMonth","substr","meridiem","YY","YYYY","MMM","monthsShort","MMMM","DD","weekdaysMin","ddd","weekdaysShort","dddd","H","HH","A","ss","SSS","getTimezoneOffset","toJSON","toISOString","toUTCString","isDayjs","Ls","hyperscript","request","mountRedraw","trust","mount","redraw","parsePathname","buildPathname","registerImmediate","channel","messagePrefix","onGlobalMessage","nextHandle","tasksByHandle","currentlyRunningATask","doc","attachTo","process","nextTick","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","canUsePostMessage","MessageChannel","port1","port2","random","attachEvent","task","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","marker","runClearTimeout","Item","browser","env","argv","versions","addListener","once","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","$window","currentRedraw","$doc","nameSpace","math","getNameSpace","xmlns","checkState","original","callHook","activeElement","createNodes","vnodes","hooks","createNode","initLifecycle","createTextNode","insertNode","createText","createHTML","createDocumentFragment","createFragment","createElementNS","setAttr","setAttrs","maybeSetContentEditable","selectedIndex","normalized","setLateSelectAttrs","sentinel","$$reentrantLock$$","initComponent","createComponent","possibleParents","caption","thead","tbody","tfoot","tr","th","td","colgroup","col","updateNodes","old","removeNodes","isOldKeyed","oldStart","oe","ve","topSibling","oldEnd","updateNode","getNextSibling","moveNodes","lisIndices","originalNextSibling","vnodesLength","oldIndices","li","pos","getKeyMap","oldIndex","il","lisTemp","makeLisIndices","commonLength","removeNode","oldTag","force","shouldNotUpdate","updateLifecycle","nodeValue","updateText","removeHTML","updateHTML","updateFragment","updateAttrs","updateElement","updateComponent","moveChildToFrag","contenteditable","contentEditable","content","stateResult","attrsResult","mask","reallyRemove","isLifecycleMethod","isFormAttribute","updateEvent","setAttributeNS","updateStyle","hasPropertyKey","nsLastIndex","uppercaseRegex","capital","normalizeKey","setProperty","EventDict","handleEvent","ev","namespace","namespaceURI","prevRedraw","schedule","subscriptions","rendering","pending","sync","root","oncompletion","callbackCount","PromiseProxy","makeRequest","background","hasHeader","__proto__","replacedAbort","method","assumeJSON","FormData","extract","aborted","user","deserialize","withCredentials","message","code","config","stringify","callbackKey","compileTemplate","fireAsync","setPath","history","replaceState","pushState","currentPath","lastUpdate","currentResolver","SKIP","defaultRoute","routes","compiled","defaultData","ReferenceError","resolveRoute","search","pathname","fail","matchedRoute","localComp","onmatch","onclick","Boolean","button","which","ctrlKey","metaKey","shiftKey","altKey","templateData","templateKeys","regexp","extra","k","multi","onchange","selectedOptions","oninput","ctrl","_REVERSE_MAP","_MAP","8","9","13","16","17","18","20","27","32","33","34","35","36","37","38","39","40","45","46","91","93","224","_KEYCODE_MAP","106","107","109","110","111","186","187","188","189","190","191","192","219","220","221","222","_SHIFT_MAP","_SPECIAL_ALIASES","platform","Mousetrap","action","_bindMultiple","_directMap","reset","_callbacks","stopCallback","_belongsTo","ancestor","composedPath","initialEventTarget","isContentEditable","handleKey","_handleKey","addKeycodes","documentMousetrap","_addEvent","_characterFromEvent","character","fromCharCode","_isModifier","_pickBestAction","_getReverseMap","_getKeyInfo","combination","_keysFromString","targetElement","_resetTimer","_sequenceLevels","_ignoreNextKeyup","_ignoreNextKeypress","_nextExpectedAction","_resetSequences","doNotReset","activeSequences","_getMatches","sequenceName","modifiers1","modifiers2","seq","deleteCombo","combo","deleteSequence","_fireCallback","sequence","srcElement","_preventDefault","cancelBubble","_stopPropagation","_handleKeyEvent","keyCode","_eventModifiers","_bindSequence","_increaseSequence","nextAction","_callbackAndReset","wrappedCallback","_bindSingle","info","callbacks","maxLevel","processedSequenceCallback","max","ignoreThisKeypress","combinations","classNames","inner","default","oldQsa","oldMatches","visible","filters","hidden","filterRe","childRe","classTag","taggedParent","dataAttr","exp","expando","setData","store","attributeData","camelName","getData","hasData","removeData","names","methodName","origFn","eventPrefix","transitionProperty","transitionDuration","transitionTiming","transitionDelay","animationName","animationDuration","animationTiming","animationDelay","testEl","supportedTransforms","cssReset","normalizeEvent","Webkit","Moz","O","vendor","fast","slow","cssPrefix","transitionEnd","animationEnd","ease","anim","cssProperties","cssValues","transforms","that","endEvent","fired","clientLeft","origShow","origHide","origToggle","speed","opacity","scale","fadeTo","fadeIn","fadeOut","fadeToggle","U","Y","bottomEnd","innerTop","innerSticker","stickyClass","stickTo","followScroll","responsive","mobileFirst","onStart","onStop","onBeforeResize","onResize","resizeDebounce","disable","queries","queryFlow","log","X","Helpers","getStyle","innerWidth","stick","isAttached","attach","offsetLeft","release","positionLeft","S","E","T","C","N","R","offsetHeight","B","I","q","getCascadedStyle","verticalAlign","boxSizing","marginRight","marginBottom","paddingLeft","paddingRight","float","cssFloat","MozBoxSizing","offsetWidth","HTMLDocument","Document","clientHeight","scrollHeight","innerHeight","offsetTop","F","P","W","V","refresh","triggerMethod","reinit","jQuery","hcSticky","configurable","detachEvent","currentStyle","originalModule","webpackPolyfill","__webpack_amd_options__","Dropdown","getParent","$parent","clearMenus","VERSION","isActive","insertAfter","keydown","$items","dropdown","Constructor","noConflict","emulateTransitionEnd","$el","transition","transEndEventNames","WebkitTransition","MozTransition","OTransition","bsTransitionEnd","bindType","delegateType","handleObj","Stream","lift","streams","merge","scan","acc","origin","stream","combine","scanMerge","tuples","seed","tuple","changed","warnedHalt","dependentStreams","dependentFns","_changing","_state","createEnd","_parents","_unregisterChild","_map","ignoreInitial","s1","s2","childIndex","mappers","endStream","mapper"],"mappings":"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","file":"admin.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/dist/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 75);\n","import Mithril, { ClassComponent, Vnode } from 'mithril';\r\n\r\nexport type ComponentProps = {\r\n    children?: Mithril.Children;\r\n\r\n    className?: string;\r\n\r\n    [key: string]: any;\r\n};\r\n\r\nexport default class Component<T extends ComponentProps = any> implements ClassComponent {\r\n    element!: HTMLElement;\r\n\r\n    props: T;\r\n\r\n    constructor(props: T = <T>{}) {\r\n        this.props = props.tag ? <T>{} : props;\r\n    }\r\n\r\n    view(vnode) {\r\n        throw new Error('Component#view must be implemented by subclass');\r\n    }\r\n\r\n    oninit(vnode) {\r\n        this.setProps(vnode);\r\n    }\r\n\r\n    oncreate(vnode) {\r\n        this.setProps(vnode);\r\n        this.element = vnode.dom;\r\n    }\r\n\r\n    onbeforeupdate(vnode) {\r\n        this.setProps(vnode);\r\n    }\r\n\r\n    onupdate(vnode) {\r\n        this.setProps(vnode);\r\n    }\r\n\r\n    onbeforeremove(vnode) {\r\n        this.setProps(vnode);\r\n    }\r\n\r\n    onremove(vnode) {\r\n        this.setProps(vnode);\r\n    }\r\n\r\n    /**\r\n     * Returns a jQuery object for this component's element. If you pass in a\r\n     * selector string, this method will return a jQuery object, using the current\r\n     * element as its buffer.\r\n     *\r\n     * For example, calling `component.$('li')` will return a jQuery object\r\n     * containing all of the `li` elements inside the DOM element of this\r\n     * component.\r\n     *\r\n     * @param selector a jQuery-compatible selector string\r\n     * @final\r\n     */\r\n    $(selector?: string): ZeptoCollection {\r\n        const $element = $(this.element);\r\n\r\n        return selector ? $element.find(selector) : $element;\r\n    }\r\n\r\n    render() {\r\n        return m(this.constructor as typeof Component, this.props);\r\n    }\r\n\r\n    static component(props: ComponentProps | any = {}, children?: Mithril.Children) {\r\n        const componentProps: ComponentProps = Object.assign({}, props);\r\n\r\n        if (children) componentProps.children = children;\r\n\r\n        return m(this, componentProps);\r\n    }\r\n\r\n    static initProps(props: ComponentProps = {}) {}\r\n\r\n    private setProps(vnode: Vnode<T, this>) {\r\n        const props = vnode.attrs || {};\r\n\r\n        (this.constructor as typeof Component).initProps(props);\r\n\r\n        if (!props.children) props.children = vnode.children;\r\n\r\n        this.props = props;\r\n    }\r\n}\r\n","export default function _extends() {\n  _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  return _extends.apply(this, arguments);\n}","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","\"use strict\"\n\nfunction Vnode(tag, key, attrs, children, text, dom) {\n\treturn {tag: tag, key: key, attrs: attrs, children: children, text: text, dom: dom, domSize: undefined, state: undefined, events: undefined, instance: undefined}\n}\nVnode.normalize = function(node) {\n\tif (Array.isArray(node)) return Vnode(\"[\", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)\n\tif (node == null || typeof node === \"boolean\") return null\n\tif (typeof node === \"object\") return node\n\treturn Vnode(\"#\", undefined, undefined, String(node), undefined, undefined)\n}\nVnode.normalizeChildren = function(input) {\n\tvar children = []\n\tif (input.length) {\n\t\tvar isKeyed = input[0] != null && input[0].key != null\n\t\t// Note: this is a *very* perf-sensitive check.\n\t\t// Fun fact: merging the loop like this is somehow faster than splitting\n\t\t// it, noticeably so.\n\t\tfor (var i = 1; i < input.length; i++) {\n\t\t\tif ((input[i] != null && input[i].key != null) !== isKeyed) {\n\t\t\t\tthrow new TypeError(\"Vnodes must either always have keys or never have keys!\")\n\t\t\t}\n\t\t}\n\t\tfor (var i = 0; i < input.length; i++) {\n\t\t\tchildren[i] = Vnode.normalize(input[i])\n\t\t}\n\t}\n\treturn children\n}\n\nmodule.exports = Vnode\n","module.exports = m;","\"use strict\"\n\nvar render = require(\"./render\")\n\nmodule.exports = require(\"./api/mount-redraw\")(render, requestAnimationFrame, console)\n","\"use strict\"\n\nvar buildQueryString = require(\"../querystring/build\")\nvar assign = require(\"./assign\")\n\n// Returns `path` from `template` + `params`\nmodule.exports = function(template, params) {\n\tif ((/:([^\\/\\.-]+)(\\.{3})?:/).test(template)) {\n\t\tthrow new SyntaxError(\"Template parameter names *must* be separated\")\n\t}\n\tif (params == null) return template\n\tvar queryIndex = template.indexOf(\"?\")\n\tvar hashIndex = template.indexOf(\"#\")\n\tvar queryEnd = hashIndex < 0 ? template.length : hashIndex\n\tvar pathEnd = queryIndex < 0 ? queryEnd : queryIndex\n\tvar path = template.slice(0, pathEnd)\n\tvar query = {}\n\n\tassign(query, params)\n\n\tvar resolved = path.replace(/:([^\\/\\.-]+)(\\.{3})?/g, function(m, key, variadic) {\n\t\tdelete query[key]\n\t\t// If no such parameter exists, don't interpolate it.\n\t\tif (params[key] == null) return m\n\t\t// Escape normal parameters, but not variadic ones.\n\t\treturn variadic ? params[key] : encodeURIComponent(String(params[key]))\n\t})\n\n\t// In case the template substitution adds new query/hash parameters.\n\tvar newQueryIndex = resolved.indexOf(\"?\")\n\tvar newHashIndex = resolved.indexOf(\"#\")\n\tvar newQueryEnd = newHashIndex < 0 ? resolved.length : newHashIndex\n\tvar newPathEnd = newQueryIndex < 0 ? newQueryEnd : newQueryIndex\n\tvar result = resolved.slice(0, newPathEnd)\n\n\tif (queryIndex >= 0) result += template.slice(queryIndex, queryEnd)\n\tif (newQueryIndex >= 0) result += (queryIndex < 0 ? \"?\" : \"&\") + resolved.slice(newQueryIndex, newQueryEnd)\n\tvar querystring = buildQueryString(query)\n\tif (querystring) result += (queryIndex < 0 && newQueryIndex < 0 ? \"?\" : \"&\") + querystring\n\tif (hashIndex >= 0) result += template.slice(hashIndex)\n\tif (newHashIndex >= 0) result += (hashIndex < 0 ? \"\" : \"&\") + resolved.slice(newHashIndex)\n\treturn result\n}\n","\"use strict\"\n\nvar parseQueryString = require(\"../querystring/parse\")\n\n// Returns `{path, params}` from `url`\nmodule.exports = function(url) {\n\tvar queryIndex = url.indexOf(\"?\")\n\tvar hashIndex = url.indexOf(\"#\")\n\tvar queryEnd = hashIndex < 0 ? url.length : hashIndex\n\tvar pathEnd = queryIndex < 0 ? queryEnd : queryIndex\n\tvar path = url.slice(0, pathEnd).replace(/\\/{2,}/g, \"/\")\n\n\tif (!path) path = \"/\"\n\telse {\n\t\tif (path[0] !== \"/\") path = \"/\" + path\n\t\tif (path.length > 1 && path[path.length - 1] === \"/\") path = path.slice(0, -1)\n\t}\n\treturn {\n\t\tpath: path,\n\t\tparams: queryIndex < 0\n\t\t\t? {}\n\t\t\t: parseQueryString(url.slice(queryIndex + 1, queryEnd)),\n\t}\n}\n","import m from 'mithril';\r\nimport prop from 'mithril/stream';\r\n\r\nimport Component from '../Component';\r\n\r\nexport default () => {\r\n    const mo = window['m'];\r\n\r\n    const _m = function (comp, ...args) {\r\n        if (!arguments[1]) arguments[1] = {};\r\n\r\n        if (comp.prototype && comp.prototype instanceof Component) {\r\n            // allow writing to children attribute\r\n            Object.defineProperty(arguments[1], 'children', {\r\n                writable: true,\r\n            });\r\n        }\r\n\r\n        const node = mo.apply(this, arguments);\r\n\r\n        if (!node.attrs) node.attrs = {};\r\n\r\n        if (node.attrs.bidi) {\r\n            m.bidi(node, node.attrs.bidi);\r\n        }\r\n\r\n        if (node.attrs.route) {\r\n            node.attrs.href = node.attrs.route;\r\n            node.attrs.tag = m.route.Link;\r\n\r\n            delete node.attrs.route;\r\n        }\r\n\r\n        return node;\r\n    };\r\n\r\n    Object.keys(mo).forEach((key) => (_m[key] = mo[key]));\r\n\r\n    _m.withAttr = (key: string, cb: Function) =>\r\n        function () {\r\n            cb(this.getAttribute(key) || this[key]);\r\n        };\r\n\r\n    _m.prop = prop;\r\n\r\n    window['m'] = _m;\r\n};\r\n","\"use strict\"\n\nvar Vnode = require(\"../render/vnode\")\nvar hyperscriptVnode = require(\"./hyperscriptVnode\")\n\nvar selectorParser = /(?:(^|#|\\.)([^#\\.\\[\\]]+))|(\\[(.+?)(?:\\s*=\\s*(\"|'|)((?:\\\\[\"'\\]]|.)*?)\\5)?\\])/g\nvar selectorCache = {}\nvar hasOwn = {}.hasOwnProperty\n\nfunction isEmpty(object) {\n\tfor (var key in object) if (hasOwn.call(object, key)) return false\n\treturn true\n}\n\nfunction compileSelector(selector) {\n\tvar match, tag = \"div\", classes = [], attrs = {}\n\twhile (match = selectorParser.exec(selector)) {\n\t\tvar type = match[1], value = match[2]\n\t\tif (type === \"\" && value !== \"\") tag = value\n\t\telse if (type === \"#\") attrs.id = value\n\t\telse if (type === \".\") classes.push(value)\n\t\telse if (match[3][0] === \"[\") {\n\t\t\tvar attrValue = match[6]\n\t\t\tif (attrValue) attrValue = attrValue.replace(/\\\\([\"'])/g, \"$1\").replace(/\\\\\\\\/g, \"\\\\\")\n\t\t\tif (match[4] === \"class\") classes.push(attrValue)\n\t\t\telse attrs[match[4]] = attrValue === \"\" ? attrValue : attrValue || true\n\t\t}\n\t}\n\tif (classes.length > 0) attrs.className = classes.join(\" \")\n\treturn selectorCache[selector] = {tag: tag, attrs: attrs}\n}\n\nfunction execSelector(state, vnode) {\n\tvar attrs = vnode.attrs\n\tvar children = Vnode.normalizeChildren(vnode.children)\n\tvar hasClass = hasOwn.call(attrs, \"class\")\n\tvar className = hasClass ? attrs.class : attrs.className\n\n\tvnode.tag = state.tag\n\tvnode.attrs = null\n\tvnode.children = undefined\n\n\tif (!isEmpty(state.attrs) && !isEmpty(attrs)) {\n\t\tvar newAttrs = {}\n\n\t\tfor (var key in attrs) {\n\t\t\tif (hasOwn.call(attrs, key)) newAttrs[key] = attrs[key]\n\t\t}\n\n\t\tattrs = newAttrs\n\t}\n\n\tfor (var key in state.attrs) {\n\t\tif (hasOwn.call(state.attrs, key) && key !== \"className\" && !hasOwn.call(attrs, key)){\n\t\t\tattrs[key] = state.attrs[key]\n\t\t}\n\t}\n\tif (className != null || state.attrs.className != null) attrs.className =\n\t\tclassName != null\n\t\t\t? state.attrs.className != null\n\t\t\t\t? String(state.attrs.className) + \" \" + String(className)\n\t\t\t\t: className\n\t\t\t: state.attrs.className != null\n\t\t\t\t? state.attrs.className\n\t\t\t\t: null\n\n\tif (hasClass) attrs.class = null\n\n\tfor (var key in attrs) {\n\t\tif (hasOwn.call(attrs, key) && key !== \"key\") {\n\t\t\tvnode.attrs = attrs\n\t\t\tbreak\n\t\t}\n\t}\n\n\tif (Array.isArray(children) && children.length === 1 && children[0] != null && children[0].tag === \"#\") {\n\t\tvnode.text = children[0].children\n\t} else {\n\t\tvnode.children = children\n\t}\n\n\treturn vnode\n}\n\nfunction hyperscript(selector) {\n\tif (selector == null || typeof selector !== \"string\" && typeof selector !== \"function\" && typeof selector.view !== \"function\") {\n\t\tthrow Error(\"The selector must be either a string or a component.\");\n\t}\n\n\tvar vnode = hyperscriptVnode.apply(1, arguments)\n\n\tif (typeof selector === \"string\") {\n\t\tvnode.children = Vnode.normalizeChildren(vnode.children)\n\t\tif (selector !== \"[\") return execSelector(selectorCache[selector] || compileSelector(selector), vnode)\n\t}\n\n\tvnode.tag = selector\n\treturn vnode\n}\n\nmodule.exports = hyperscript\n","\"use strict\"\n\nvar Vnode = require(\"../render/vnode\")\n\n// Call via `hyperscriptVnode.apply(startOffset, arguments)`\n//\n// The reason I do it this way, forwarding the arguments and passing the start\n// offset in `this`, is so I don't have to create a temporary array in a\n// performance-critical path.\n//\n// In native ES6, I'd instead add a final `...args` parameter to the\n// `hyperscript` and `fragment` factories and define this as\n// `hyperscriptVnode(...args)`, since modern engines do optimize that away. But\n// ES5 (what Mithril requires thanks to IE support) doesn't give me that luxury,\n// and engines aren't nearly intelligent enough to do either of these:\n//\n// 1. Elide the allocation for `[].slice.call(arguments, 1)` when it's passed to\n//    another function only to be indexed.\n// 2. Elide an `arguments` allocation when it's passed to any function other\n//    than `Function.prototype.apply` or `Reflect.apply`.\n//\n// In ES6, it'd probably look closer to this (I'd need to profile it, though):\n// module.exports = function(attrs, ...children) {\n//     if (attrs == null || typeof attrs === \"object\" && attrs.tag == null && !Array.isArray(attrs)) {\n//         if (children.length === 1 && Array.isArray(children[0])) children = children[0]\n//     } else {\n//         children = children.length === 0 && Array.isArray(attrs) ? attrs : [attrs, ...children]\n//         attrs = undefined\n//     }\n//\n//     if (attrs == null) attrs = {}\n//     return Vnode(\"\", attrs.key, attrs, children)\n// }\nmodule.exports = function() {\n\tvar attrs = arguments[this], start = this + 1, children\n\n\tif (attrs == null) {\n\t\tattrs = {}\n\t} else if (typeof attrs !== \"object\" || attrs.tag != null || Array.isArray(attrs)) {\n\t\tattrs = {}\n\t\tstart = this\n\t}\n\n\tif (arguments.length === start + 1) {\n\t\tchildren = arguments[start]\n\t\tif (!Array.isArray(children)) children = [children]\n\t} else {\n\t\tchildren = []\n\t\twhile (start < arguments.length) children.push(arguments[start++])\n\t}\n\n\treturn Vnode(\"\", attrs.key, attrs, children)\n}\n","\"use strict\"\n\nvar PromisePolyfill = require(\"./polyfill\")\n\nif (typeof window !== \"undefined\") {\n\tif (typeof window.Promise === \"undefined\") {\n\t\twindow.Promise = PromisePolyfill\n\t} else if (!window.Promise.prototype.finally) {\n\t\twindow.Promise.prototype.finally = PromisePolyfill.prototype.finally\n\t}\n\tmodule.exports = window.Promise\n} else if (typeof global !== \"undefined\") {\n\tif (typeof global.Promise === \"undefined\") {\n\t\tglobal.Promise = PromisePolyfill\n\t} else if (!global.Promise.prototype.finally) {\n\t\tglobal.Promise.prototype.finally = PromisePolyfill.prototype.finally\n\t}\n\tmodule.exports = global.Promise\n} else {\n\tmodule.exports = PromisePolyfill\n}\n","\"use strict\"\n/** @constructor */\nvar PromisePolyfill = function(executor) {\n\tif (!(this instanceof PromisePolyfill)) throw new Error(\"Promise must be called with `new`\")\n\tif (typeof executor !== \"function\") throw new TypeError(\"executor must be a function\")\n\n\tvar self = this, resolvers = [], rejectors = [], resolveCurrent = handler(resolvers, true), rejectCurrent = handler(rejectors, false)\n\tvar instance = self._instance = {resolvers: resolvers, rejectors: rejectors}\n\tvar callAsync = typeof setImmediate === \"function\" ? setImmediate : setTimeout\n\tfunction handler(list, shouldAbsorb) {\n\t\treturn function execute(value) {\n\t\t\tvar then\n\t\t\ttry {\n\t\t\t\tif (shouldAbsorb && value != null && (typeof value === \"object\" || typeof value === \"function\") && typeof (then = value.then) === \"function\") {\n\t\t\t\t\tif (value === self) throw new TypeError(\"Promise can't be resolved w/ itself\")\n\t\t\t\t\texecuteOnce(then.bind(value))\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tcallAsync(function() {\n\t\t\t\t\t\tif (!shouldAbsorb && list.length === 0) console.error(\"Possible unhandled promise rejection:\", value)\n\t\t\t\t\t\tfor (var i = 0; i < list.length; i++) list[i](value)\n\t\t\t\t\t\tresolvers.length = 0, rejectors.length = 0\n\t\t\t\t\t\tinstance.state = shouldAbsorb\n\t\t\t\t\t\tinstance.retry = function() {execute(value)}\n\t\t\t\t\t})\n\t\t\t\t}\n\t\t\t}\n\t\t\tcatch (e) {\n\t\t\t\trejectCurrent(e)\n\t\t\t}\n\t\t}\n\t}\n\tfunction executeOnce(then) {\n\t\tvar runs = 0\n\t\tfunction run(fn) {\n\t\t\treturn function(value) {\n\t\t\t\tif (runs++ > 0) return\n\t\t\t\tfn(value)\n\t\t\t}\n\t\t}\n\t\tvar onerror = run(rejectCurrent)\n\t\ttry {then(run(resolveCurrent), onerror)} catch (e) {onerror(e)}\n\t}\n\n\texecuteOnce(executor)\n}\nPromisePolyfill.prototype.then = function(onFulfilled, onRejection) {\n\tvar self = this, instance = self._instance\n\tfunction handle(callback, list, next, state) {\n\t\tlist.push(function(value) {\n\t\t\tif (typeof callback !== \"function\") next(value)\n\t\t\telse try {resolveNext(callback(value))} catch (e) {if (rejectNext) rejectNext(e)}\n\t\t})\n\t\tif (typeof instance.retry === \"function\" && state === instance.state) instance.retry()\n\t}\n\tvar resolveNext, rejectNext\n\tvar promise = new PromisePolyfill(function(resolve, reject) {resolveNext = resolve, rejectNext = reject})\n\thandle(onFulfilled, instance.resolvers, resolveNext, true), handle(onRejection, instance.rejectors, rejectNext, false)\n\treturn promise\n}\nPromisePolyfill.prototype.catch = function(onRejection) {\n\treturn this.then(null, onRejection)\n}\nPromisePolyfill.prototype.finally = function(callback) {\n\treturn this.then(\n\t\tfunction(value) {\n\t\t\treturn PromisePolyfill.resolve(callback()).then(function() {\n\t\t\t\treturn value\n\t\t\t})\n\t\t},\n\t\tfunction(reason) {\n\t\t\treturn PromisePolyfill.resolve(callback()).then(function() {\n\t\t\t\treturn PromisePolyfill.reject(reason);\n\t\t\t})\n\t\t}\n\t)\n}\nPromisePolyfill.resolve = function(value) {\n\tif (value instanceof PromisePolyfill) return value\n\treturn new PromisePolyfill(function(resolve) {resolve(value)})\n}\nPromisePolyfill.reject = function(value) {\n\treturn new PromisePolyfill(function(resolve, reject) {reject(value)})\n}\nPromisePolyfill.all = function(list) {\n\treturn new PromisePolyfill(function(resolve, reject) {\n\t\tvar total = list.length, count = 0, values = []\n\t\tif (list.length === 0) resolve([])\n\t\telse for (var i = 0; i < list.length; i++) {\n\t\t\t(function(i) {\n\t\t\t\tfunction consume(value) {\n\t\t\t\t\tcount++\n\t\t\t\t\tvalues[i] = value\n\t\t\t\t\tif (count === total) resolve(values)\n\t\t\t\t}\n\t\t\t\tif (list[i] != null && (typeof list[i] === \"object\" || typeof list[i] === \"function\") && typeof list[i].then === \"function\") {\n\t\t\t\t\tlist[i].then(consume, reject)\n\t\t\t\t}\n\t\t\t\telse consume(list[i])\n\t\t\t})(i)\n\t\t}\n\t})\n}\nPromisePolyfill.race = function(list) {\n\treturn new PromisePolyfill(function(resolve, reject) {\n\t\tfor (var i = 0; i < list.length; i++) {\n\t\t\tlist[i].then(resolve, reject)\n\t\t}\n\t})\n}\n\nmodule.exports = PromisePolyfill\n","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","\"use strict\"\n\nmodule.exports = require(\"./render/render\")(window)\n","\"use strict\"\n\nmodule.exports = function(object) {\n\tif (Object.prototype.toString.call(object) !== \"[object Object]\") return \"\"\n\n\tvar args = []\n\tfor (var key in object) {\n\t\tdestructure(key, object[key])\n\t}\n\n\treturn args.join(\"&\")\n\n\tfunction destructure(key, value) {\n\t\tif (Array.isArray(value)) {\n\t\t\tfor (var i = 0; i < value.length; i++) {\n\t\t\t\tdestructure(key + \"[\" + i + \"]\", value[i])\n\t\t\t}\n\t\t}\n\t\telse if (Object.prototype.toString.call(value) === \"[object Object]\") {\n\t\t\tfor (var i in value) {\n\t\t\t\tdestructure(key + \"[\" + i + \"]\", value[i])\n\t\t\t}\n\t\t}\n\t\telse args.push(encodeURIComponent(key) + (value != null && value !== \"\" ? \"=\" + encodeURIComponent(value) : \"\"))\n\t}\n}\n","\"use strict\"\n\nmodule.exports = Object.assign || function(target, source) {\n\tif(source) Object.keys(source).forEach(function(key) { target[key] = source[key] })\n}\n","\"use strict\"\n\nmodule.exports = function(string) {\n\tif (string === \"\" || string == null) return {}\n\tif (string.charAt(0) === \"?\") string = string.slice(1)\n\n\tvar entries = string.split(\"&\"), counters = {}, data = {}\n\tfor (var i = 0; i < entries.length; i++) {\n\t\tvar entry = entries[i].split(\"=\")\n\t\tvar key = decodeURIComponent(entry[0])\n\t\tvar value = entry.length === 2 ? decodeURIComponent(entry[1]) : \"\"\n\n\t\tif (value === \"true\") value = true\n\t\telse if (value === \"false\") value = false\n\n\t\tvar levels = key.split(/\\]\\[?|\\[/)\n\t\tvar cursor = data\n\t\tif (key.indexOf(\"[\") > -1) levels.pop()\n\t\tfor (var j = 0; j < levels.length; j++) {\n\t\t\tvar level = levels[j], nextLevel = levels[j + 1]\n\t\t\tvar isNumber = nextLevel == \"\" || !isNaN(parseInt(nextLevel, 10))\n\t\t\tif (level === \"\") {\n\t\t\t\tvar key = levels.slice(0, j).join()\n\t\t\t\tif (counters[key] == null) {\n\t\t\t\t\tcounters[key] = Array.isArray(cursor) ? cursor.length : 0\n\t\t\t\t}\n\t\t\t\tlevel = counters[key]++\n\t\t\t}\n\t\t\t// Disallow direct prototype pollution\n\t\t\telse if (level === \"__proto__\") break\n\t\t\tif (j === levels.length - 1) cursor[level] = value\n\t\t\telse {\n\t\t\t\t// Read own properties exclusively to disallow indirect\n\t\t\t\t// prototype pollution\n\t\t\t\tvar desc = Object.getOwnPropertyDescriptor(cursor, level)\n\t\t\t\tif (desc != null) desc = desc.value\n\t\t\t\tif (desc == null) cursor[level] = desc = isNumber ? [] : {}\n\t\t\t\tcursor = desc\n\t\t\t}\n\t\t}\n\t}\n\treturn data\n}\n","// Robert Penner's easeInOutQuad\n\n// find the rest of his easing functions here: http://robertpenner.com/easing/\n// find them exported for ES6 consumption here: https://github.com/jaxgeller/ez.js\n\nvar easeInOutQuad = function easeInOutQuad(t, b, c, d) {\n  t /= d / 2;\n  if (t < 1) return c / 2 * t * t + b;\n  t--;\n  return -c / 2 * (t * (t - 2) - 1) + b;\n};\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar jumper = function jumper() {\n  // private variable cache\n  // no variables are created during a jump, preventing memory leaks\n\n  var element = void 0; // element to scroll to                   (node)\n\n  var start = void 0; // where scroll starts                    (px)\n  var stop = void 0; // where scroll stops                     (px)\n\n  var offset = void 0; // adjustment from the stop position      (px)\n  var easing = void 0; // easing function                        (function)\n  var a11y = void 0; // accessibility support flag             (boolean)\n\n  var distance = void 0; // distance of scroll                     (px)\n  var duration = void 0; // scroll duration                        (ms)\n\n  var timeStart = void 0; // time scroll started                    (ms)\n  var timeElapsed = void 0; // time spent scrolling thus far          (ms)\n\n  var next = void 0; // next scroll position                   (px)\n\n  var callback = void 0; // to call when done scrolling            (function)\n\n  // scroll position helper\n\n  function location() {\n    return window.scrollY || window.pageYOffset;\n  }\n\n  // element offset helper\n\n  function top(element) {\n    return element.getBoundingClientRect().top + start;\n  }\n\n  // rAF loop helper\n\n  function loop(timeCurrent) {\n    // store time scroll started, if not started already\n    if (!timeStart) {\n      timeStart = timeCurrent;\n    }\n\n    // determine time spent scrolling so far\n    timeElapsed = timeCurrent - timeStart;\n\n    // calculate next scroll position\n    next = easing(timeElapsed, start, distance, duration);\n\n    // scroll to it\n    window.scrollTo(0, next);\n\n    // check progress\n    timeElapsed < duration ? window.requestAnimationFrame(loop) // continue scroll loop\n    : done(); // scrolling is done\n  }\n\n  // scroll finished helper\n\n  function done() {\n    // account for rAF time rounding inaccuracies\n    window.scrollTo(0, start + distance);\n\n    // if scrolling to an element, and accessibility is enabled\n    if (element && a11y) {\n      // add tabindex indicating programmatic focus\n      element.setAttribute('tabindex', '-1');\n\n      // focus the element\n      element.focus();\n    }\n\n    // if it exists, fire the callback\n    if (typeof callback === 'function') {\n      callback();\n    }\n\n    // reset time for next jump\n    timeStart = false;\n  }\n\n  // API\n\n  function jump(target) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    // resolve options, or use defaults\n    duration = options.duration || 1000;\n    offset = options.offset || 0;\n    callback = options.callback; // \"undefined\" is a suitable default, and won't be called\n    easing = options.easing || easeInOutQuad;\n    a11y = options.a11y || false;\n\n    // cache starting position\n    start = location();\n\n    // resolve target\n    switch (typeof target === 'undefined' ? 'undefined' : _typeof(target)) {\n      // scroll from current position\n      case 'number':\n        element = undefined; // no element to scroll to\n        a11y = false; // make sure accessibility is off\n        stop = start + target;\n        break;\n\n      // scroll to element (node)\n      // bounding rect is relative to the viewport\n      case 'object':\n        element = target;\n        stop = top(element);\n        break;\n\n      // scroll to element (selector)\n      // bounding rect is relative to the viewport\n      case 'string':\n        element = document.querySelector(target);\n        stop = top(element);\n        break;\n    }\n\n    // resolve scroll distance, accounting for offset\n    distance = stop - start + offset;\n\n    // resolve duration\n    switch (_typeof(options.duration)) {\n      // number in ms\n      case 'number':\n        duration = options.duration;\n        break;\n\n      // function passed the distance of the scroll\n      case 'function':\n        duration = options.duration(distance);\n        break;\n    }\n\n    // start the loop\n    window.requestAnimationFrame(loop);\n  }\n\n  // expose only the jump method\n  return jump;\n};\n\n// export singleton\n\nvar singleton = jumper();\n\nexport default singleton;\n","// Utils\nimport debounce from './utils/debounce';\nimport isFunction from './utils/isFunction';\n\n// Methods\nimport update from './methods/update';\nimport destroy from './methods/destroy';\nimport enableEventListeners from './methods/enableEventListeners';\nimport disableEventListeners from './methods/disableEventListeners';\nimport Defaults from './methods/defaults';\nimport placements from './methods/placements';\n\nexport default class Popper {\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  constructor(reference, popper, options = {}) {\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 = { ...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({\n      ...Popper.Defaults.modifiers,\n      ...options.modifiers,\n    }).forEach(name => {\n      this.options.modifiers[name] = {\n        // If it's a built-in modifier, use it as base\n        ...(Popper.Defaults.modifiers[name] || {}),\n        // If there are custom options, override and merge with default ones\n        ...(options.modifiers ? options.modifiers[name] : {}),\n      };\n    });\n\n    // Refactoring modifiers' list (Object => Array)\n    this.modifiers = Object.keys(this.options.modifiers)\n      .map(name => ({\n        name,\n        ...this.options.modifiers[name],\n      }))\n      // sort the modifiers by order\n      .sort((a, b) => a.order - b.order);\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(modifierOptions => {\n      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {\n        modifierOptions.onLoad(\n          this.reference,\n          this.popper,\n          this.options,\n          modifierOptions,\n          this.state\n        );\n      }\n    });\n\n    // fire the first update to position the popper in the right place\n    this.update();\n\n    const 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  update() {\n    return update.call(this);\n  }\n  destroy() {\n    return destroy.call(this);\n  }\n  enableEventListeners() {\n    return enableEventListeners.call(this);\n  }\n  disableEventListeners() {\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  scheduleUpdate = () => requestAnimationFrame(this.update);\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  static Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;\n\n  static placements = placements;\n\n  static Defaults = Defaults;\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 * 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 */\nexport default function isFunction(functionToCheck) {\n  const getType = {};\n  return (\n    functionToCheck &&\n    getType.toString.call(functionToCheck) === '[object Function]'\n  );\n}\n","import jump from 'jump.js';\r\nimport Tooltip from 'tooltip.js';\r\n\r\n// add $.fn.tooltip\r\n$.fn.tooltip = function (option) {\r\n    return this.each(function (this: HTMLElement) {\r\n        const $this = $(this);\r\n        let data = $this.data('bs.tooltip');\r\n        const options = (typeof option === 'object' && option) || {};\r\n\r\n        if ($this.attr('title')) {\r\n            options.title = $this.attr('title');\r\n            $this.removeAttr('title');\r\n            $this.attr('data-original-title', options.title);\r\n        }\r\n\r\n        if (option === 'destroy') option = 'dispose';\r\n\r\n        if (!data && ['dispose', 'hide'].includes(option)) return;\r\n\r\n        if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)));\r\n        if (typeof option === 'string' && data[option]) data[option]();\r\n    });\r\n};\r\n\r\n// add $.fn.outerWidth and $.fn.outerHeight\r\n['width', 'height'].forEach(function (dimension) {\r\n    const Dimension = dimension.replace(/./, function (m) {\r\n        return m[0].toUpperCase();\r\n    });\r\n\r\n    $.fn[`outer${Dimension}`] = function (margin) {\r\n        const elem = this;\r\n\r\n        if (elem) {\r\n            const sides = { width: ['left', 'right'], height: ['top', 'bottom'] };\r\n            let size = elem[dimension]();\r\n\r\n            sides[dimension].forEach(function (side) {\r\n                if (margin) size += parseInt(elem.css('margin-' + side), 10);\r\n            });\r\n\r\n            return size;\r\n        } else {\r\n            return null;\r\n        }\r\n    };\r\n});\r\n\r\n// allow use of $(':input')\r\n// @ts-ignore\r\n$.expr[':']['input'] = function () {\r\n    if ('disabled' in this || ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON'].includes(this.tagName)) return this;\r\n};\r\n\r\n// add $().hover() method\r\n$.fn.hover = function (hover, leave) {\r\n    return this.on('mouseenter', hover).on('mouseleave', leave || hover);\r\n};\r\n\r\n// add animated scroll\r\n$.fn.animateScrollTop = function (to, duration = $.fx.speeds._default, callback) {\r\n    if (typeof to === 'number') to -= window.scrollY || window.pageYOffset;\r\n\r\n    jump(to, {\r\n        duration: $.fx.speeds[duration] || duration,\r\n        callback,\r\n    });\r\n\r\n    return this;\r\n};\r\n\r\n// add basic $().slideUp() function\r\n$.fn.slideUp = function (duration = $.fx.speeds._default, easing?, callback?) {\r\n    this.css({ overflow: 'hidden', height: this.height() });\r\n\r\n    this.animate(\r\n        {\r\n            height: 0,\r\n        },\r\n        duration,\r\n        easing,\r\n        callback\r\n    );\r\n\r\n    return this;\r\n};\r\n\r\n// required for compatibility with jquery plugins\r\n// ex: bootstrap plugins\r\n$.fn.extend = $.extend.bind($);\r\n\r\n/**\r\n * Enable special events on Zepto\r\n * @license Original Copyright 2013 Enideo. Released under dual MIT and GPL licenses.\r\n */\r\n$.event.special = $.event.special || {};\r\n\r\nconst bindBeforeSpecialEvents = $.fn.bind;\r\n\r\n$.fn.bind = function (eventName, data, callback) {\r\n    const el = this;\r\n\r\n    if (!callback) {\r\n        callback = data;\r\n        data = null;\r\n    }\r\n\r\n    $.each(eventName.split(/\\s/), (key: string, value: any): boolean => {\r\n        value = value.split(/\\./)[0];\r\n\r\n        if (value in $.event.special) {\r\n            let specialEvent = $.event.special[value];\r\n\r\n            /// init enable special events on Zepto\r\n            if (!specialEvent._init) {\r\n                specialEvent._init = true;\r\n\r\n                /// intercept and replace the special event handler to add functionality\r\n                specialEvent.originalHandler = specialEvent.handler;\r\n                specialEvent.handler = function () {\r\n                    /// make event argument writable, like on jQuery\r\n                    const args = Array.prototype.slice.call(arguments);\r\n\r\n                    args[0] = $.extend({}, args[0]);\r\n\r\n                    /// define the event handle, $.event.dispatch is only for newer versions of jQuery\r\n                    $.event.handle = function () {\r\n                        /// make context of trigger the event element\r\n                        const args = Array.prototype.slice.call(arguments);\r\n                        const event = args[0];\r\n                        const $target = $(event.target);\r\n\r\n                        $target.trigger.apply($target, arguments);\r\n                    };\r\n\r\n                    specialEvent.originalHandler.apply(this, args);\r\n                };\r\n            }\r\n\r\n            /// setup special events on Zepto\r\n            specialEvent.setup.apply(el, [data]);\r\n        }\r\n\r\n        return true;\r\n    });\r\n\r\n    return bindBeforeSpecialEvents.apply(this, [eventName, callback]);\r\n};\r\n","import 'expose-loader?jQuery!zepto';\r\nimport 'expose-loader?moment!expose-loader?dayjs!dayjs';\r\nimport 'expose-loader?m!mithril';\r\nimport 'expose-loader?m.bidi!m.attrs.bidi';\r\nimport 'expose-loader?Mousetrap!mousetrap';\r\nimport 'expose-loader?classNames!classnames';\r\n\r\nimport 'zepto/src/selector';\r\nimport 'zepto/src/data';\r\nimport 'zepto/src/fx';\r\nimport 'zepto/src/fx_methods';\r\n\r\nimport './utils/patchZepto';\r\n\r\nimport 'hc-sticky';\r\nimport 'bootstrap/js/dropdown';\r\nimport 'bootstrap/js/transition';\r\n\r\nimport relativeTime from 'dayjs/plugin/relativeTime';\r\nimport localizedFormat from 'dayjs/plugin/localizedFormat';\r\n\r\ndayjs.extend(relativeTime);\r\ndayjs.extend(localizedFormat);\r\n\r\nimport patchMithril from './utils/patchMithril';\r\n\r\npatchMithril();\r\n\r\n// import * as Extend from './extend/index';\r\n\r\n// export { Extend };\r\n","export default typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';\n","import isBrowser from './isBrowser';\n\nconst timeoutDuration = (function(){\n  const longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];\n  for (let 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\nexport function microtaskDebounce(fn) {\n  let called = false\n  return () => {\n    if (called) {\n      return\n    }\n    called = true\n    window.Promise.resolve().then(() => {\n      called = false\n      fn()\n    })\n  }\n}\n\nexport function taskDebounce(fn) {\n  let scheduled = false;\n  return () => {\n    if (!scheduled) {\n      scheduled = true;\n      setTimeout(() => {\n        scheduled = false;\n        fn();\n      }, timeoutDuration);\n    }\n  };\n}\n\nconst supportsMicroTasks = isBrowser && window.Promise\n\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*/\nexport default (supportsMicroTasks\n  ? microtaskDebounce\n  : taskDebounce);\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 */\nexport default function isFunction(functionToCheck) {\n  const getType = {};\n  return (\n    functionToCheck &&\n    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 */\nexport default function getStyleComputedProperty(element, property) {\n  if (element.nodeType !== 1) {\n    return [];\n  }\n  // NOTE: 1 DOM access here\n  const window = element.ownerDocument.defaultView;\n  const css = window.getComputedStyle(element, null);\n  return property ? css[property] : css;\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 */\nexport default function getParentNode(element) {\n  if (element.nodeName === 'HTML') {\n    return element;\n  }\n  return element.parentNode || element.host;\n}\n","import getStyleComputedProperty from './getStyleComputedProperty';\nimport getParentNode from './getParentNode';\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 */\nexport default function 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  const { overflow, overflowX, overflowY } = getStyleComputedProperty(element);\n  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {\n    return element;\n  }\n\n  return getScrollParent(getParentNode(element));\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 */\nexport default function getReferenceNode(reference) {\n  return reference && reference.referenceNode ? reference.referenceNode : reference;\n}\n","import isBrowser from './isBrowser';\n\nconst isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);\nconst 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 */\nexport default function isIE(version) {\n  if (version === 11) {\n    return isIE11;\n  }\n  if (version === 10) {\n    return isIE10;\n  }\n  return isIE11 || isIE10;\n}\n","import getStyleComputedProperty from './getStyleComputedProperty';\nimport isIE from './isIE';\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 */\nexport default function getOffsetParent(element) {\n  if (!element) {\n    return document.documentElement;\n  }\n\n  const noOffsetParent = isIE(10) ? document.body : null;\n\n  // NOTE: 1 DOM access here\n  let 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  const 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 (\n    ['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 &&\n    getStyleComputedProperty(offsetParent, 'position') === 'static'\n  ) {\n    return getOffsetParent(offsetParent);\n  }\n\n  return offsetParent;\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 */\nexport default function getRoot(node) {\n  if (node.parentNode !== null) {\n    return getRoot(node.parentNode);\n  }\n\n  return node;\n}\n","import isOffsetContainer from './isOffsetContainer';\nimport getRoot from './getRoot';\nimport getOffsetParent from './getOffsetParent';\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 */\nexport default function 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  const order =\n    element1.compareDocumentPosition(element2) &\n    Node.DOCUMENT_POSITION_FOLLOWING;\n  const start = order ? element1 : element2;\n  const end = order ? element2 : element1;\n\n  // Get common ancestor container\n  const range = document.createRange();\n  range.setStart(start, 0);\n  range.setEnd(end, 0);\n  const { commonAncestorContainer } = range;\n\n  // Both nodes are inside #document\n  if (\n    (element1 !== commonAncestorContainer &&\n      element2 !== commonAncestorContainer) ||\n    start.contains(end)\n  ) {\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  const 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","import getOffsetParent from './getOffsetParent';\n\nexport default function isOffsetContainer(element) {\n  const { nodeName } = element;\n  if (nodeName === 'BODY') {\n    return false;\n  }\n  return (\n    nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element\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 */\nexport default function getScroll(element, side = 'top') {\n  const upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';\n  const nodeName = element.nodeName;\n\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    const html = element.ownerDocument.documentElement;\n    const scrollingElement = element.ownerDocument.scrollingElement || html;\n    return scrollingElement[upperSide];\n  }\n\n  return element[upperSide];\n}\n","import getScroll from './getScroll';\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 */\nexport default function includeScroll(rect, element, subtract = false) {\n  const scrollTop = getScroll(element, 'top');\n  const scrollLeft = getScroll(element, 'left');\n  const 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 * 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\nexport default function getBordersSize(styles, axis) {\n  const sideA = axis === 'x' ? 'Left' : 'Top';\n  const sideB = sideA === 'Left' ? 'Right' : 'Bottom';\n\n  return (\n    parseFloat(styles[`border${sideA}Width`]) +\n    parseFloat(styles[`border${sideB}Width`])\n  );\n}\n","import isIE from './isIE';\n\nfunction getSize(axis, body, html, computedStyle) {\n  return Math.max(\n    body[`offset${axis}`],\n    body[`scroll${axis}`],\n    html[`client${axis}`],\n    html[`offset${axis}`],\n    html[`scroll${axis}`],\n    isIE(10)\n      ? (parseInt(html[`offset${axis}`]) + \n      parseInt(computedStyle[`margin${axis === 'Height' ? 'Top' : 'Left'}`]) + \n      parseInt(computedStyle[`margin${axis === 'Height' ? 'Bottom' : 'Right'}`]))\n    : 0 \n  );\n}\n\nexport default function getWindowSizes(document) {\n  const body = document.body;\n  const html = document.documentElement;\n  const 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","/**\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 */\nexport default function getClientRect(offsets) {\n  return {\n    ...offsets,\n    right: offsets.left + offsets.width,\n    bottom: offsets.top + offsets.height,\n  };\n}\n","import getStyleComputedProperty from './getStyleComputedProperty';\nimport getBordersSize from './getBordersSize';\nimport getWindowSizes from './getWindowSizes';\nimport getScroll from './getScroll';\nimport getClientRect from './getClientRect';\nimport isIE from './isIE';\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 */\nexport default function getBoundingClientRect(element) {\n  let 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      const scrollTop = getScroll(element, 'top');\n      const scrollLeft = getScroll(element, 'left');\n      rect.top += scrollTop;\n      rect.left += scrollLeft;\n      rect.bottom += scrollTop;\n      rect.right += scrollLeft;\n    }\n    else {\n      rect = element.getBoundingClientRect();\n    }\n  }\n  catch(e){}\n\n  const 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  const sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};\n  const width =\n    sizes.width || element.clientWidth || result.width;\n  const height =\n    sizes.height || element.clientHeight || result.height;\n\n  let horizScrollbar = element.offsetWidth - width;\n  let 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    const 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","import getStyleComputedProperty from './getStyleComputedProperty';\nimport includeScroll from './includeScroll';\nimport getScrollParent from './getScrollParent';\nimport getBoundingClientRect from './getBoundingClientRect';\nimport runIsIE from './isIE';\nimport getClientRect from './getClientRect';\n\nexport default function getOffsetRectRelativeToArbitraryNode(children, parent, fixedPosition = false) {\n  const isIE10 = runIsIE(10);\n  const isHTML = parent.nodeName === 'HTML';\n  const childrenRect = getBoundingClientRect(children);\n  const parentRect = getBoundingClientRect(parent);\n  const scrollParent = getScrollParent(children);\n\n  const styles = getStyleComputedProperty(parent);\n  const borderTopWidth = parseFloat(styles.borderTopWidth);\n  const 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  let 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    const marginTop = parseFloat(styles.marginTop);\n    const 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 (\n    isIE10 && !fixedPosition\n      ? parent.contains(scrollParent)\n      : parent === scrollParent && scrollParent.nodeName !== 'BODY'\n  ) {\n    offsets = includeScroll(offsets, parent);\n  }\n\n  return offsets;\n}\n","import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode';\nimport getScroll from './getScroll';\nimport getClientRect from './getClientRect';\n\nexport default function getViewportOffsetRectRelativeToArtbitraryNode(element, excludeScroll = false) {\n  const html = element.ownerDocument.documentElement;\n  const relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);\n  const width = Math.max(html.clientWidth, window.innerWidth || 0);\n  const height = Math.max(html.clientHeight, window.innerHeight || 0);\n\n  const scrollTop = !excludeScroll ? getScroll(html) : 0;\n  const scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;\n\n  const offset = {\n    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,\n    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,\n    width,\n    height,\n  };\n\n  return getClientRect(offset);\n}\n","import getStyleComputedProperty from './getStyleComputedProperty';\nimport getParentNode from './getParentNode';\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 */\nexport default function isFixed(element) {\n  const nodeName = element.nodeName;\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    return false;\n  }\n  if (getStyleComputedProperty(element, 'position') === 'fixed') {\n    return true;\n  }\n  const parentNode = getParentNode(element);\n  if (!parentNode) {\n    return false;\n  }\n  return isFixed(parentNode);\n}\n","import getStyleComputedProperty from './getStyleComputedProperty';\nimport isIE from './isIE';\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\nexport default function 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  let el = element.parentElement;\n  while (el && getStyleComputedProperty(el, 'transform') === 'none') {\n    el = el.parentElement;\n  }\n  return el || document.documentElement;\n\n}\n","import getScrollParent from './getScrollParent';\nimport getParentNode from './getParentNode';\nimport getReferenceNode from './getReferenceNode';\nimport findCommonOffsetParent from './findCommonOffsetParent';\nimport getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode';\nimport getViewportOffsetRectRelativeToArtbitraryNode from './getViewportOffsetRectRelativeToArtbitraryNode';\nimport getWindowSizes from './getWindowSizes';\nimport isFixed from './isFixed';\nimport getFixedPositionOffsetParent from './getFixedPositionOffsetParent';\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 */\nexport default function getBoundaries(\n  popper,\n  reference,\n  padding,\n  boundariesElement,\n  fixedPosition = false\n) {\n  // NOTE: 1 DOM access here\n\n  let boundaries = { top: 0, left: 0 };\n  const offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n\n  // Handle viewport case\n  if (boundariesElement === 'viewport' ) {\n    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);\n  }\n\n  else {\n    // Handle other cases based on DOM element used as boundaries\n    let boundariesNode;\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    const offsets = getOffsetRectRelativeToArbitraryNode(\n      boundariesNode,\n      offsetParent,\n      fixedPosition\n    );\n\n    // In case of HTML, we need a different computation\n    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {\n      const { height, width } = getWindowSizes(popper.ownerDocument);\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  const 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","import getBoundaries from '../utils/getBoundaries';\n\nfunction getArea({ width, height }) {\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 */\nexport default function computeAutoPlacement(\n  placement,\n  refRect,\n  popper,\n  reference,\n  boundariesElement,\n  padding = 0\n) {\n  if (placement.indexOf('auto') === -1) {\n    return placement;\n  }\n\n  const boundaries = getBoundaries(\n    popper,\n    reference,\n    padding,\n    boundariesElement\n  );\n\n  const 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  const sortedAreas = Object.keys(rects)\n    .map(key => ({\n      key,\n      ...rects[key],\n      area: getArea(rects[key]),\n    }))\n    .sort((a, b) => b.area - a.area);\n\n  const filteredAreas = sortedAreas.filter(\n    ({ width, height }) =>\n      width >= popper.clientWidth && height >= popper.clientHeight\n  );\n\n  const computedPlacement = filteredAreas.length > 0\n    ? filteredAreas[0].key\n    : sortedAreas[0].key;\n\n  const variation = placement.split('-')[1];\n\n  return computedPlacement + (variation ? `-${variation}` : '');\n}\n","import findCommonOffsetParent from './findCommonOffsetParent';\nimport getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode';\nimport getFixedPositionOffsetParent from './getFixedPositionOffsetParent';\nimport getReferenceNode from './getReferenceNode';\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 */\nexport default function getReferenceOffsets(state, popper, reference, fixedPosition = null) {\n  const commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));\n  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);\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 */\nexport default function getOuterSizes(element) {\n  const window = element.ownerDocument.defaultView;\n  const styles = window.getComputedStyle(element);\n  const x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);\n  const y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);\n  const result = {\n    width: element.offsetWidth + y,\n    height: element.offsetHeight + x,\n  };\n  return result;\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 */\nexport default function getOppositePlacement(placement) {\n  const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };\n  return placement.replace(/left|right|bottom|top/g, matched => hash[matched]);\n}\n","import getOuterSizes from './getOuterSizes';\nimport getOppositePlacement from './getOppositePlacement';\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 */\nexport default function getPopperOffsets(popper, referenceOffsets, placement) {\n  placement = placement.split('-')[0];\n\n  // Get popper node sizes\n  const popperRect = getOuterSizes(popper);\n\n  // Add position, width and height to our offsets object\n  const 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  const isHoriz = ['right', 'left'].indexOf(placement) !== -1;\n  const mainSide = isHoriz ? 'top' : 'left';\n  const secondarySide = isHoriz ? 'left' : 'top';\n  const measurement = isHoriz ? 'height' : 'width';\n  const secondaryMeasurement = !isHoriz ? 'height' : 'width';\n\n  popperOffsets[mainSide] =\n    referenceOffsets[mainSide] +\n    referenceOffsets[measurement] / 2 -\n    popperRect[measurement] / 2;\n  if (placement === secondarySide) {\n    popperOffsets[secondarySide] =\n      referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];\n  } else {\n    popperOffsets[secondarySide] =\n      referenceOffsets[getOppositePlacement(secondarySide)];\n  }\n\n  return popperOffsets;\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 */\nexport default function 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","import isFunction from './isFunction';\nimport findIndex from './findIndex';\nimport getClientRect from '../utils/getClientRect';\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 */\nexport default function runModifiers(modifiers, data, ends) {\n  const modifiersToRun = ends === undefined\n    ? modifiers\n    : modifiers.slice(0, findIndex(modifiers, 'name', ends));\n\n  modifiersToRun.forEach(modifier => {\n    if (modifier['function']) { // eslint-disable-line dot-notation\n      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');\n    }\n    const 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","import find from './find';\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 */\nexport default function findIndex(arr, prop, value) {\n  // use native findIndex if supported\n  if (Array.prototype.findIndex) {\n    return arr.findIndex(cur => cur[prop] === value);\n  }\n\n  // use `find` + `indexOf` if `findIndex` isn't supported\n  const match = find(arr, obj => obj[prop] === value);\n  return arr.indexOf(match);\n}\n","import computeAutoPlacement from '../utils/computeAutoPlacement';\nimport getReferenceOffsets from '../utils/getReferenceOffsets';\nimport getPopperOffsets from '../utils/getPopperOffsets';\nimport runModifiers from '../utils/runModifiers';\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 */\nexport default function update() {\n  // if popper is destroyed, don't perform any further update\n  if (this.state.isDestroyed) {\n    return;\n  }\n\n  let 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(\n    this.state,\n    this.popper,\n    this.reference,\n    this.options.positionFixed\n  );\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(\n    this.options.placement,\n    data.offsets.reference,\n    this.popper,\n    this.reference,\n    this.options.modifiers.flip.boundariesElement,\n    this.options.modifiers.flip.padding\n  );\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(\n    this.popper,\n    data.offsets.reference,\n    data.placement\n  );\n\n  data.offsets.popper.position = this.options.positionFixed\n    ? 'fixed'\n    : '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 * Helper used to know if the given modifier is enabled.\n * @method\n * @memberof Popper.Utils\n * @returns {Boolean}\n */\nexport default function isModifierEnabled(modifiers, modifierName) {\n  return modifiers.some(\n    ({ name, enabled }) => enabled && name === modifierName\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 */\nexport default function getSupportedPropertyName(property) {\n  const prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];\n  const upperProp = property.charAt(0).toUpperCase() + property.slice(1);\n\n  for (let i = 0; i < prefixes.length; i++) {\n    const prefix = prefixes[i];\n    const toCheck = prefix ? `${prefix}${upperProp}` : property;\n    if (typeof document.body.style[toCheck] !== 'undefined') {\n      return toCheck;\n    }\n  }\n  return null;\n}\n","import isModifierEnabled from '../utils/isModifierEnabled';\nimport getSupportedPropertyName from '../utils/getSupportedPropertyName';\n\n/**\n * Destroys the popper.\n * @method\n * @memberof Popper\n */\nexport default function 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 * Get the window associated with the element\n * @argument {Element} element\n * @returns {Window}\n */\nexport default function getWindow(element) {\n  const ownerDocument = element.ownerDocument;\n  return ownerDocument ? ownerDocument.defaultView : window;\n}\n","import getScrollParent from './getScrollParent';\nimport getWindow from './getWindow';\n\nfunction attachToScrollParents(scrollParent, event, callback, scrollParents) {\n  const isBody = scrollParent.nodeName === 'BODY';\n  const target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;\n  target.addEventListener(event, callback, { passive: true });\n\n  if (!isBody) {\n    attachToScrollParents(\n      getScrollParent(target.parentNode),\n      event,\n      callback,\n      scrollParents\n    );\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 */\nexport default function setupEventListeners(\n  reference,\n  options,\n  state,\n  updateBound\n) {\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  const scrollElement = getScrollParent(reference);\n  attachToScrollParents(\n    scrollElement,\n    'scroll',\n    state.updateBound,\n    state.scrollParents\n  );\n  state.scrollElement = scrollElement;\n  state.eventsEnabled = true;\n\n  return state;\n}\n","import setupEventListeners from '../utils/setupEventListeners';\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 */\nexport default function enableEventListeners() {\n  if (!this.state.eventsEnabled) {\n    this.state = setupEventListeners(\n      this.reference,\n      this.options,\n      this.state,\n      this.scheduleUpdate\n    );\n  }\n}\n","import removeEventListeners from '../utils/removeEventListeners';\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 */\nexport default function disableEventListeners() {\n  if (this.state.eventsEnabled) {\n    cancelAnimationFrame(this.scheduleUpdate);\n    this.state = removeEventListeners(this.reference, this.state);\n  }\n}\n","import getWindow from './getWindow';\n\n/**\n * Remove event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nexport default function 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(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 * Tells if a given input is a number\n * @method\n * @memberof Popper.Utils\n * @param {*} input to check\n * @return {Boolean}\n */\nexport default function isNumeric(n) {\n  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);\n}\n","import isNumeric from './isNumeric';\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 */\nexport default function setStyles(element, styles) {\n  Object.keys(styles).forEach(prop => {\n    let unit = '';\n    // add unit if the value is numeric and is one of the following\n    if (\n      ['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !==\n        -1 &&\n      isNumeric(styles[prop])\n    ) {\n      unit = 'px';\n    }\n    element.style[prop] = styles[prop] + unit;\n  });\n}\n","import getSupportedPropertyName from '../utils/getSupportedPropertyName';\nimport find from '../utils/find';\nimport getOffsetParent from '../utils/getOffsetParent';\nimport getBoundingClientRect from '../utils/getBoundingClientRect';\nimport getRoundedOffsets from '../utils/getRoundedOffsets';\nimport isBrowser from '../utils/isBrowser';\n\nconst 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 */\nexport default function computeStyle(data, options) {\n  const { x, y } = options;\n  const { popper } = data.offsets;\n\n  // Remove this legacy support in Popper.js v2\n  const legacyGpuAccelerationOption = find(\n    data.instance.modifiers,\n    modifier => modifier.name === 'applyStyle'\n  ).gpuAcceleration;\n  if (legacyGpuAccelerationOption !== undefined) {\n    console.warn(\n      'WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!'\n    );\n  }\n  const gpuAcceleration =\n    legacyGpuAccelerationOption !== undefined\n      ? legacyGpuAccelerationOption\n      : options.gpuAcceleration;\n\n  const offsetParent = getOffsetParent(data.instance.popper);\n  const offsetParentRect = getBoundingClientRect(offsetParent);\n\n  // Styles\n  const styles = {\n    position: popper.position,\n  };\n\n  const offsets = getRoundedOffsets(\n    data,\n    window.devicePixelRatio < 2 || !isFirefox\n  );\n\n  const sideA = x === 'bottom' ? 'top' : 'bottom';\n  const 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  const 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  let left, top;\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    const invertTop = sideA === 'bottom' ? -1 : 1;\n    const 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  const attributes = {\n    'x-placement': data.placement,\n  };\n\n  // Update `data` attributes, styles and arrowStyles\n  data.attributes = { ...attributes, ...data.attributes };\n  data.styles = { ...styles, ...data.styles };\n  data.arrowStyles = { ...data.offsets.arrow, ...data.arrowStyles };\n\n  return data;\n}\n","import find from './find';\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 */\nexport default function isModifierRequired(\n  modifiers,\n  requestingName,\n  requestedName\n) {\n  const requesting = find(modifiers, ({ name }) => name === requestingName);\n\n  const isRequired =\n    !!requesting &&\n    modifiers.some(modifier => {\n      return (\n        modifier.name === requestedName &&\n        modifier.enabled &&\n        modifier.order < requesting.order\n      );\n    });\n\n  if (!isRequired) {\n    const requesting = `\\`${requestingName}\\``;\n    const requested = `\\`${requestedName}\\``;\n    console.warn(\n      `${requested} modifier is required by ${requesting} modifier in order to work, be sure to include it before ${requesting}!`\n    );\n  }\n  return isRequired;\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 */\nexport default [\n  'auto-start',\n  'auto',\n  'auto-end',\n  'top-start',\n  'top',\n  'top-end',\n  'right-start',\n  'right',\n  'right-end',\n  'bottom-end',\n  'bottom',\n  'bottom-start',\n  'left-end',\n  'left',\n  'left-start',\n];\n","import placements from '../methods/placements';\n\n// Get rid of `auto` `auto-start` and `auto-end`\nconst 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 */\nexport default function clockwise(placement, counter = false) {\n  const index = validPlacements.indexOf(placement);\n  const arr = validPlacements\n    .slice(index + 1)\n    .concat(validPlacements.slice(0, index));\n  return counter ? arr.reverse() : arr;\n}\n","import getOppositePlacement from '../utils/getOppositePlacement';\nimport getOppositeVariation from '../utils/getOppositeVariation';\nimport getPopperOffsets from '../utils/getPopperOffsets';\nimport runModifiers from '../utils/runModifiers';\nimport getBoundaries from '../utils/getBoundaries';\nimport isModifierEnabled from '../utils/isModifierEnabled';\nimport clockwise from '../utils/clockwise';\n\nconst 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 */\nexport default function 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  const boundaries = getBoundaries(\n    data.instance.popper,\n    data.instance.reference,\n    options.padding,\n    options.boundariesElement,\n    data.positionFixed\n  );\n\n  let placement = data.placement.split('-')[0];\n  let placementOpposite = getOppositePlacement(placement);\n  let variation = data.placement.split('-')[1] || '';\n\n  let 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((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    const popperOffsets = data.offsets.popper;\n    const refOffsets = data.offsets.reference;\n\n    // using floor because the reference offsets may contain decimals we are not going to consider here\n    const floor = Math.floor;\n    const overlapsRef =\n      (placement === 'left' &&\n        floor(popperOffsets.right) > floor(refOffsets.left)) ||\n      (placement === 'right' &&\n        floor(popperOffsets.left) < floor(refOffsets.right)) ||\n      (placement === 'top' &&\n        floor(popperOffsets.bottom) > floor(refOffsets.top)) ||\n      (placement === 'bottom' &&\n        floor(popperOffsets.top) < floor(refOffsets.bottom));\n\n    const overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);\n    const overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);\n    const overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);\n    const overflowsBottom =\n      floor(popperOffsets.bottom) > floor(boundaries.bottom);\n\n    const overflowsBoundaries =\n      (placement === 'left' && overflowsLeft) ||\n      (placement === 'right' && overflowsRight) ||\n      (placement === 'top' && overflowsTop) ||\n      (placement === 'bottom' && overflowsBottom);\n\n    // flip the variation if required\n    const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n\n    // flips variation if reference element overflows boundaries\n    const flippedVariationByRef =\n      !!options.flipVariations &&\n      ((isVertical && variation === 'start' && overflowsLeft) ||\n        (isVertical && variation === 'end' && overflowsRight) ||\n        (!isVertical && variation === 'start' && overflowsTop) ||\n        (!isVertical && variation === 'end' && overflowsBottom));\n\n    // flips variation if popper content overflows boundaries\n    const flippedVariationByContent =\n      !!options.flipVariationsByContent &&\n      ((isVertical && variation === 'start' && overflowsRight) ||\n        (isVertical && variation === 'end' && overflowsLeft) ||\n        (!isVertical && variation === 'start' && overflowsBottom) ||\n        (!isVertical && variation === 'end' && overflowsTop));\n\n    const 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 = {\n        ...data.offsets.popper,\n        ...getPopperOffsets(\n          data.instance.popper,\n          data.offsets.reference,\n          data.placement\n        ),\n      };\n\n      data = runModifiers(data.instance.modifiers, data, 'flip');\n    }\n  });\n  return data;\n}\n","import isNumeric from '../utils/isNumeric';\nimport getClientRect from '../utils/getClientRect';\nimport find from '../utils/find';\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 */\nexport function toValue(str, measurement, popperOffsets, referenceOffsets) {\n  // separate value from unit\n  const split = str.match(/((?:\\-|\\+)?\\d*\\.?\\d*)(.*)/);\n  const value = +split[1];\n  const 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    let element;\n    switch (unit) {\n      case '%p':\n        element = popperOffsets;\n        break;\n      case '%':\n      case '%r':\n      default:\n        element = referenceOffsets;\n    }\n\n    const 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    let size;\n    if (unit === 'vh') {\n      size = Math.max(\n        document.documentElement.clientHeight,\n        window.innerHeight || 0\n      );\n    } else {\n      size = Math.max(\n        document.documentElement.clientWidth,\n        window.innerWidth || 0\n      );\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 */\nexport function parseOffset(\n  offset,\n  popperOffsets,\n  referenceOffsets,\n  basePlacement\n) {\n  const 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  const 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  const fragments = offset.split(/(\\+|\\-)/).map(frag => frag.trim());\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  const divider = fragments.indexOf(\n    find(fragments, frag => frag.search(/,|\\s/) !== -1)\n  );\n\n  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {\n    console.warn(\n      'Offsets separated by white space(s) are deprecated, use a comma (,) instead.'\n    );\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  const splitRegex = /\\s*,\\s*|\\s+/;\n  let ops = divider !== -1\n    ? [\n        fragments\n          .slice(0, divider)\n          .concat([fragments[divider].split(splitRegex)[0]]),\n        [fragments[divider].split(splitRegex)[1]].concat(\n          fragments.slice(divider + 1)\n        ),\n      ]\n    : [fragments];\n\n  // Convert the values with units to absolute pixels to allow our computations\n  ops = ops.map((op, index) => {\n    // Most of the units rely on the orientation of the popper\n    const measurement = (index === 1 ? !useHeight : useHeight)\n      ? 'height'\n      : 'width';\n    let mergeWithPrevious = false;\n    return (\n      op\n        // This aggregates any `+` or `-` sign that aren't considered operators\n        // e.g.: 10 + +5 => [10, +, +5]\n        .reduce((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(str => toValue(str, measurement, popperOffsets, referenceOffsets))\n    );\n  });\n\n  // Loop trough the offsets arrays and execute the operations\n  ops.forEach((op, index) => {\n    op.forEach((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 */\nexport default function offset(data, { offset }) {\n  const { placement, offsets: { popper, reference } } = data;\n  const basePlacement = placement.split('-')[0];\n\n  let offsets;\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","import applyStyle, { applyStyleOnLoad } from './applyStyle';\nimport computeStyle from './computeStyle';\nimport arrow from './arrow';\nimport flip from './flip';\nimport keepTogether from './keepTogether';\nimport offset from './offset';\nimport preventOverflow from './preventOverflow';\nimport shift from './shift';\nimport hide from './hide';\nimport inner from './inner';\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 */\nexport default {\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","import modifiers from '../modifiers/index';\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 */\nexport default {\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: () => {},\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: () => {},\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,\n};\n\n/**\n * @callback onCreate\n * @param {dataObject} data\n */\n\n/**\n * @callback onUpdate\n * @param {dataObject} data\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 */\nexport default function shift(data) {\n  const placement = data.placement;\n  const basePlacement = placement.split('-')[0];\n  const shiftvariation = placement.split('-')[1];\n\n  // if shift shiftvariation is specified, run the modifier\n  if (shiftvariation) {\n    const { reference, popper } = data.offsets;\n    const isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;\n    const side = isVertical ? 'left' : 'top';\n    const measurement = isVertical ? 'width' : 'height';\n\n    const shiftOffsets = {\n      start: { [side]: reference[side] },\n      end: {\n        [side]: reference[side] + reference[measurement] - popper[measurement],\n      },\n    };\n\n    data.offsets.popper = { ...popper, ...shiftOffsets[shiftvariation] };\n  }\n\n  return data;\n}\n","import getOffsetParent from '../utils/getOffsetParent';\nimport getBoundaries from '../utils/getBoundaries';\nimport getSupportedPropertyName from '../utils/getSupportedPropertyName';\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 */\nexport default function preventOverflow(data, options) {\n  let boundariesElement =\n    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  const transformProp = getSupportedPropertyName('transform');\n  const popperStyles = data.instance.popper.style; // assignment to help minification\n  const { top, left, [transformProp]: transform } = popperStyles;\n  popperStyles.top = '';\n  popperStyles.left = '';\n  popperStyles[transformProp] = '';\n\n  const boundaries = getBoundaries(\n    data.instance.popper,\n    data.instance.reference,\n    options.padding,\n    boundariesElement,\n    data.positionFixed\n  );\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  const order = options.priority;\n  let popper = data.offsets.popper;\n\n  const check = {\n    primary(placement) {\n      let value = popper[placement];\n      if (\n        popper[placement] < boundaries[placement] &&\n        !options.escapeWithReference\n      ) {\n        value = Math.max(popper[placement], boundaries[placement]);\n      }\n      return { [placement]: value };\n    },\n    secondary(placement) {\n      const mainSide = placement === 'right' ? 'left' : 'top';\n      let value = popper[mainSide];\n      if (\n        popper[placement] > boundaries[placement] &&\n        !options.escapeWithReference\n      ) {\n        value = Math.min(\n          popper[mainSide],\n          boundaries[placement] -\n            (placement === 'right' ? popper.width : popper.height)\n        );\n      }\n      return { [mainSide]: value };\n    },\n  };\n\n  order.forEach(placement => {\n    const side =\n      ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';\n    popper = { ...popper, ...check[side](placement) };\n  });\n\n  data.offsets.popper = popper;\n\n  return data;\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 */\nexport default function keepTogether(data) {\n  const { popper, reference } = data.offsets;\n  const placement = data.placement.split('-')[0];\n  const floor = Math.floor;\n  const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n  const side = isVertical ? 'right' : 'bottom';\n  const opSide = isVertical ? 'left' : 'top';\n  const measurement = isVertical ? 'width' : 'height';\n\n  if (popper[side] < floor(reference[opSide])) {\n    data.offsets.popper[opSide] =\n      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","import getClientRect from '../utils/getClientRect';\nimport getOuterSizes from '../utils/getOuterSizes';\nimport isModifierRequired from '../utils/isModifierRequired';\nimport getStyleComputedProperty from '../utils/getStyleComputedProperty';\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 */\nexport default function arrow(data, options) {\n  // arrow depends on keepTogether in order to work\n  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {\n    return data;\n  }\n\n  let 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(\n        'WARNING: `arrow.element` must be child of its popper element!'\n      );\n      return data;\n    }\n  }\n\n  const placement = data.placement.split('-')[0];\n  const { popper, reference } = data.offsets;\n  const isVertical = ['left', 'right'].indexOf(placement) !== -1;\n\n  const len = isVertical ? 'height' : 'width';\n  const sideCapitalized = isVertical ? 'Top' : 'Left';\n  const side = sideCapitalized.toLowerCase();\n  const altSide = isVertical ? 'left' : 'top';\n  const opSide = isVertical ? 'bottom' : 'right';\n  const 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] -=\n      popper[side] - (reference[opSide] - arrowElementSize);\n  }\n  // bottom/right side\n  if (reference[side] + arrowElementSize > popper[opSide]) {\n    data.offsets.popper[side] +=\n      reference[side] + arrowElementSize - popper[opSide];\n  }\n  data.offsets.popper = getClientRect(data.offsets.popper);\n\n  // compute center of the popper\n  const 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  const css = getStyleComputedProperty(data.instance.popper);\n  const popperMarginSide = parseFloat(css[`margin${sideCapitalized}`]);\n  const popperBorderSide = parseFloat(css[`border${sideCapitalized}Width`]);\n  let sideValue =\n    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 = {\n    [side]: Math.round(sideValue),\n    [altSide]: '', // make sure to unset any eventual altSide value from the DOM node\n  };\n\n  return data;\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 */\nexport default function getOppositeVariation(variation) {\n  if (variation === 'end') {\n    return 'start';\n  } else if (variation === 'start') {\n    return 'end';\n  }\n  return variation;\n}\n","import getClientRect from '../utils/getClientRect';\nimport getOppositePlacement from '../utils/getOppositePlacement';\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 */\nexport default function inner(data) {\n  const placement = data.placement;\n  const basePlacement = placement.split('-')[0];\n  const { popper, reference } = data.offsets;\n  const isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;\n\n  const subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;\n\n  popper[isHoriz ? 'left' : 'top'] =\n    reference[basePlacement] -\n    (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);\n\n  data.placement = getOppositePlacement(placement);\n  data.offsets.popper = getClientRect(popper);\n\n  return data;\n}\n","import isModifierRequired from '../utils/isModifierRequired';\nimport find from '../utils/find';\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 */\nexport default function hide(data) {\n  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {\n    return data;\n  }\n\n  const refRect = data.offsets.reference;\n  const bound = find(\n    data.instance.modifiers,\n    modifier => modifier.name === 'preventOverflow'\n  ).boundaries;\n\n  if (\n    refRect.bottom < bound.top ||\n    refRect.left > bound.right ||\n    refRect.top > bound.bottom ||\n    refRect.right < bound.left\n  ) {\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 * @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 */\nexport default function getRoundedOffsets(data, shouldRound) {\n  const { popper, reference } = data.offsets;\n  const { round, floor } = Math;\n  const noRound = v => v;\n  \n  const referenceWidth = round(reference.width);\n  const popperWidth = round(popper.width);\n  \n  const isVertical = ['left', 'right'].indexOf(data.placement) !== -1;\n  const isVariation = data.placement.indexOf('-') !== -1;\n  const sameWidthParity = referenceWidth % 2 === popperWidth % 2;\n  const bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;\n\n  const horizontalToInteger = !shouldRound\n    ? noRound\n    : isVertical || isVariation || sameWidthParity\n    ? round\n    : floor;\n  const verticalToInteger = !shouldRound ? noRound : round;\n\n  return {\n    left: horizontalToInteger(\n      bothOddWidth && !isVariation && shouldRound\n        ? popper.left - 1\n        : popper.left\n    ),\n    top: verticalToInteger(popper.top),\n    bottom: verticalToInteger(popper.bottom),\n    right: horizontalToInteger(popper.right),\n  };\n}\n","import setStyles from '../utils/setStyles';\nimport setAttributes from '../utils/setAttributes';\nimport getReferenceOffsets from '../utils/getReferenceOffsets';\nimport computeAutoPlacement from '../utils/computeAutoPlacement';\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 */\nexport default function 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 */\nexport function applyStyleOnLoad(\n  reference,\n  popper,\n  options,\n  modifierOptions,\n  state\n) {\n  // compute reference element offsets\n  const 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  const placement = computeAutoPlacement(\n    options.placement,\n    referenceOffsets,\n    popper,\n    reference,\n    options.modifiers.flip.boundariesElement,\n    options.modifiers.flip.padding\n  );\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 * 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 */\nexport default function setAttributes(element, attributes) {\n  Object.keys(attributes).forEach(function(prop) {\n    const value = attributes[prop];\n    if (value !== false) {\n      element.setAttribute(prop, attributes[prop]);\n    } else {\n      element.removeAttribute(prop);\n    }\n  });\n}\n","!function(r,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):r.dayjs_plugin_relativeTime=t()}(this,function(){\"use strict\";return function(r,t,e){var n=t.prototype;e.en.relativeTime={future:\"in %s\",past:\"%s ago\",s:\"a few seconds\",m:\"a minute\",mm:\"%d minutes\",h:\"an hour\",hh:\"%d hours\",d:\"a day\",dd:\"%d days\",M:\"a month\",MM:\"%d months\",y:\"a year\",yy:\"%d years\"};var o=function(r,t,n,o){for(var d,i,u,a=n.$locale().relativeTime,f=[{l:\"s\",r:44,d:\"second\"},{l:\"m\",r:89},{l:\"mm\",r:44,d:\"minute\"},{l:\"h\",r:89},{l:\"hh\",r:21,d:\"hour\"},{l:\"d\",r:35},{l:\"dd\",r:25,d:\"day\"},{l:\"M\",r:45},{l:\"MM\",r:10,d:\"month\"},{l:\"y\",r:17},{l:\"yy\",d:\"year\"}],s=f.length,l=0;l<s;l+=1){var h=f[l];h.d&&(d=o?e(r).diff(n,h.d,!0):n.diff(r,h.d,!0));var m=Math.round(Math.abs(d));if(u=d>0,m<=h.r||!h.r){1===m&&l>0&&(h=f[l-1]);var c=a[h.l];i=\"string\"==typeof c?c.replace(\"%d\",m):c(m,t,h.l,u);break}}return t?i:(u?a.future:a.past).replace(\"%s\",i)};n.to=function(r,t){return o(r,t,this,!0)},n.from=function(r,t){return o(r,t,this)};var d=function(r){return r.$u?e.utc():e()};n.toNow=function(r){return this.to(d(this),r)},n.fromNow=function(r){return this.from(d(this),r)}}});\n","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):e.dayjs_plugin_localizedFormat=t()}(this,function(){\"use strict\";return function(e,t,o){var n=t.prototype,r=n.format,M={LTS:\"h:mm:ss A\",LT:\"h:mm A\",L:\"MM/DD/YYYY\",LL:\"MMMM D, YYYY\",LLL:\"MMMM D, YYYY h:mm A\",LLLL:\"dddd, MMMM D, YYYY h:mm A\"};o.en.formats=M;n.format=function(e){void 0===e&&(e=\"YYYY-MM-DDTHH:mm:ssZ\");var t=this.$locale().formats,o=void 0===t?{}:t,n=e.replace(/(\\[[^\\]]+])|(LTS?|l{1,4}|L{1,4})/g,function(e,t,n){var r=n&&n.toUpperCase();return t||o[n]||M[n]||o[r].replace(/(\\[[^\\]]+])|(MMMM|MM|DD|dddd)/g,function(e,t,o){return t||o.slice(1)})});return r.call(this,n)}}});\n","\"use strict\"\n\nmodule.exports = require(\"./stream/stream\")\n","module.exports = global[\"jQuery\"] = require(\"-!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\babel-loader\\\\lib\\\\index.js??ref--5!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\imports-loader\\\\index.js?this=>window!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\source-map-loader\\\\index.js!.\\\\zepto.js\");","/*** IMPORTS FROM imports-loader ***/\n(function() {\n\n/* Zepto v1.2.0 - zepto event ajax form ie - zeptojs.com/license */\n(function(global, factory) {\n  if (typeof define === 'function' && define.amd)\n    define(function() { return factory(global) })\n  else\n    factory(global)\n}(this, function(window) {\n  var Zepto = (function() {\n  var undefined, key, $, classList, emptyArray = [], concat = emptyArray.concat, filter = emptyArray.filter, slice = emptyArray.slice,\n    document = window.document,\n    elementDisplay = {}, classCache = {},\n    cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1,'opacity': 1, 'z-index': 1, 'zoom': 1 },\n    fragmentRE = /^\\s*<(\\w+|!)[^>]*>/,\n    singleTagRE = /^<(\\w+)\\s*\\/?>(?:<\\/\\1>|)$/,\n    tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\\w:]+)[^>]*)\\/>/ig,\n    rootNodeRE = /^(?:body|html)$/i,\n    capitalRE = /([A-Z])/g,\n\n    // special attributes that should be get/set via method calls\n    methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'],\n\n    adjacencyOperators = [ 'after', 'prepend', 'before', 'append' ],\n    table = document.createElement('table'),\n    tableRow = document.createElement('tr'),\n    containers = {\n      'tr': document.createElement('tbody'),\n      'tbody': table, 'thead': table, 'tfoot': table,\n      'td': tableRow, 'th': tableRow,\n      '*': document.createElement('div')\n    },\n    readyRE = /complete|loaded|interactive/,\n    simpleSelectorRE = /^[\\w-]*$/,\n    class2type = {},\n    toString = class2type.toString,\n    zepto = {},\n    camelize, uniq,\n    tempParent = document.createElement('div'),\n    propMap = {\n      'tabindex': 'tabIndex',\n      'readonly': 'readOnly',\n      'for': 'htmlFor',\n      'class': 'className',\n      'maxlength': 'maxLength',\n      'cellspacing': 'cellSpacing',\n      'cellpadding': 'cellPadding',\n      'rowspan': 'rowSpan',\n      'colspan': 'colSpan',\n      'usemap': 'useMap',\n      'frameborder': 'frameBorder',\n      'contenteditable': 'contentEditable'\n    },\n    isArray = Array.isArray ||\n      function(object){ return object instanceof Array }\n\n  zepto.matches = function(element, selector) {\n    if (!selector || !element || element.nodeType !== 1) return false\n    var matchesSelector = element.matches || element.webkitMatchesSelector ||\n                          element.mozMatchesSelector || element.oMatchesSelector ||\n                          element.matchesSelector\n    if (matchesSelector) return matchesSelector.call(element, selector)\n    // fall back to performing a selector:\n    var match, parent = element.parentNode, temp = !parent\n    if (temp) (parent = tempParent).appendChild(element)\n    match = ~zepto.qsa(parent, selector).indexOf(element)\n    temp && tempParent.removeChild(element)\n    return match\n  }\n\n  function type(obj) {\n    return obj == null ? String(obj) :\n      class2type[toString.call(obj)] || \"object\"\n  }\n\n  function isFunction(value) { return type(value) == \"function\" }\n  function isWindow(obj)     { return obj != null && obj == obj.window }\n  function isDocument(obj)   { return obj != null && obj.nodeType == obj.DOCUMENT_NODE }\n  function isObject(obj)     { return type(obj) == \"object\" }\n  function isPlainObject(obj) {\n    return isObject(obj) && !isWindow(obj) && Object.getPrototypeOf(obj) == Object.prototype\n  }\n\n  function likeArray(obj) {\n    var length = !!obj && 'length' in obj && obj.length,\n      type = $.type(obj)\n\n    return 'function' != type && !isWindow(obj) && (\n      'array' == type || length === 0 ||\n        (typeof length == 'number' && length > 0 && (length - 1) in obj)\n    )\n  }\n\n  function compact(array) { return filter.call(array, function(item){ return item != null }) }\n  function flatten(array) { return array.length > 0 ? $.fn.concat.apply([], array) : array }\n  camelize = function(str){ return str.replace(/-+(.)?/g, function(match, chr){ return chr ? chr.toUpperCase() : '' }) }\n  function dasherize(str) {\n    return str.replace(/::/g, '/')\n           .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')\n           .replace(/([a-z\\d])([A-Z])/g, '$1_$2')\n           .replace(/_/g, '-')\n           .toLowerCase()\n  }\n  uniq = function(array){ return filter.call(array, function(item, idx){ return array.indexOf(item) == idx }) }\n\n  function classRE(name) {\n    return name in classCache ?\n      classCache[name] : (classCache[name] = new RegExp('(^|\\\\s)' + name + '(\\\\s|$)'))\n  }\n\n  function maybeAddPx(name, value) {\n    return (typeof value == \"number\" && !cssNumber[dasherize(name)]) ? value + \"px\" : value\n  }\n\n  function defaultDisplay(nodeName) {\n    var element, display\n    if (!elementDisplay[nodeName]) {\n      element = document.createElement(nodeName)\n      document.body.appendChild(element)\n      display = getComputedStyle(element, '').getPropertyValue(\"display\")\n      element.parentNode.removeChild(element)\n      display == \"none\" && (display = \"block\")\n      elementDisplay[nodeName] = display\n    }\n    return elementDisplay[nodeName]\n  }\n\n  function children(element) {\n    return 'children' in element ?\n      slice.call(element.children) :\n      $.map(element.childNodes, function(node){ if (node.nodeType == 1) return node })\n  }\n\n  function Z(dom, selector) {\n    var i, len = dom ? dom.length : 0\n    for (i = 0; i < len; i++) this[i] = dom[i]\n    this.length = len\n    this.selector = selector || ''\n  }\n\n  // `$.zepto.fragment` takes a html string and an optional tag name\n  // to generate DOM nodes from the given html string.\n  // The generated DOM nodes are returned as an array.\n  // This function can be overridden in plugins for example to make\n  // it compatible with browsers that don't support the DOM fully.\n  zepto.fragment = function(html, name, properties) {\n    var dom, nodes, container\n\n    // A special case optimization for a single tag\n    if (singleTagRE.test(html)) dom = $(document.createElement(RegExp.$1))\n\n    if (!dom) {\n      if (html.replace) html = html.replace(tagExpanderRE, \"<$1></$2>\")\n      if (name === undefined) name = fragmentRE.test(html) && RegExp.$1\n      if (!(name in containers)) name = '*'\n\n      container = containers[name]\n      container.innerHTML = '' + html\n      dom = $.each(slice.call(container.childNodes), function(){\n        container.removeChild(this)\n      })\n    }\n\n    if (isPlainObject(properties)) {\n      nodes = $(dom)\n      $.each(properties, function(key, value) {\n        if (methodAttributes.indexOf(key) > -1) nodes[key](value)\n        else nodes.attr(key, value)\n      })\n    }\n\n    return dom\n  }\n\n  // `$.zepto.Z` swaps out the prototype of the given `dom` array\n  // of nodes with `$.fn` and thus supplying all the Zepto functions\n  // to the array. This method can be overridden in plugins.\n  zepto.Z = function(dom, selector) {\n    return new Z(dom, selector)\n  }\n\n  // `$.zepto.isZ` should return `true` if the given object is a Zepto\n  // collection. This method can be overridden in plugins.\n  zepto.isZ = function(object) {\n    return object instanceof zepto.Z\n  }\n\n  // `$.zepto.init` is Zepto's counterpart to jQuery's `$.fn.init` and\n  // takes a CSS selector and an optional context (and handles various\n  // special cases).\n  // This method can be overridden in plugins.\n  zepto.init = function(selector, context) {\n    var dom\n    // If nothing given, return an empty Zepto collection\n    if (!selector) return zepto.Z()\n    // Optimize for string selectors\n    else if (typeof selector == 'string') {\n      selector = selector.trim()\n      // If it's a html fragment, create nodes from it\n      // Note: In both Chrome 21 and Firefox 15, DOM error 12\n      // is thrown if the fragment doesn't begin with <\n      if (selector[0] == '<' && fragmentRE.test(selector))\n        dom = zepto.fragment(selector, RegExp.$1, context), selector = null\n      // If there's a context, create a collection on that context first, and select\n      // nodes from there\n      else if (context !== undefined) return $(context).find(selector)\n      // If it's a CSS selector, use it to select nodes.\n      else dom = zepto.qsa(document, selector)\n    }\n    // If a function is given, call it when the DOM is ready\n    else if (isFunction(selector)) return $(document).ready(selector)\n    // If a Zepto collection is given, just return it\n    else if (zepto.isZ(selector)) return selector\n    else {\n      // normalize array if an array of nodes is given\n      if (isArray(selector)) dom = compact(selector)\n      // Wrap DOM nodes.\n      else if (isObject(selector))\n        dom = [selector], selector = null\n      // If it's a html fragment, create nodes from it\n      else if (fragmentRE.test(selector))\n        dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null\n      // If there's a context, create a collection on that context first, and select\n      // nodes from there\n      else if (context !== undefined) return $(context).find(selector)\n      // And last but no least, if it's a CSS selector, use it to select nodes.\n      else dom = zepto.qsa(document, selector)\n    }\n    // create a new Zepto collection from the nodes found\n    return zepto.Z(dom, selector)\n  }\n\n  // `$` will be the base `Zepto` object. When calling this\n  // function just call `$.zepto.init, which makes the implementation\n  // details of selecting nodes and creating Zepto collections\n  // patchable in plugins.\n  $ = function(selector, context){\n    return zepto.init(selector, context)\n  }\n\n  function extend(target, source, deep) {\n    for (key in source)\n      if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {\n        if (isPlainObject(source[key]) && !isPlainObject(target[key]))\n          target[key] = {}\n        if (isArray(source[key]) && !isArray(target[key]))\n          target[key] = []\n        extend(target[key], source[key], deep)\n      }\n      else if (source[key] !== undefined) target[key] = source[key]\n  }\n\n  // Copy all but undefined properties from one or more\n  // objects to the `target` object.\n  $.extend = function(target){\n    var deep, args = slice.call(arguments, 1)\n    if (typeof target == 'boolean') {\n      deep = target\n      target = args.shift()\n    }\n    args.forEach(function(arg){ extend(target, arg, deep) })\n    return target\n  }\n\n  // `$.zepto.qsa` is Zepto's CSS selector implementation which\n  // uses `document.querySelectorAll` and optimizes for some special cases, like `#id`.\n  // This method can be overridden in plugins.\n  zepto.qsa = function(element, selector){\n    var found,\n        maybeID = selector[0] == '#',\n        maybeClass = !maybeID && selector[0] == '.',\n        nameOnly = maybeID || maybeClass ? selector.slice(1) : selector, // Ensure that a 1 char tag name still gets checked\n        isSimple = simpleSelectorRE.test(nameOnly)\n    return (element.getElementById && isSimple && maybeID) ? // Safari DocumentFragment doesn't have getElementById\n      ( (found = element.getElementById(nameOnly)) ? [found] : [] ) :\n      (element.nodeType !== 1 && element.nodeType !== 9 && element.nodeType !== 11) ? [] :\n      slice.call(\n        isSimple && !maybeID && element.getElementsByClassName ? // DocumentFragment doesn't have getElementsByClassName/TagName\n          maybeClass ? element.getElementsByClassName(nameOnly) : // If it's simple, it could be a class\n          element.getElementsByTagName(selector) : // Or a tag\n          element.querySelectorAll(selector) // Or it's not simple, and we need to query all\n      )\n  }\n\n  function filtered(nodes, selector) {\n    return selector == null ? $(nodes) : $(nodes).filter(selector)\n  }\n\n  $.contains = document.documentElement.contains ?\n    function(parent, node) {\n      return parent !== node && parent.contains(node)\n    } :\n    function(parent, node) {\n      while (node && (node = node.parentNode))\n        if (node === parent) return true\n      return false\n    }\n\n  function funcArg(context, arg, idx, payload) {\n    return isFunction(arg) ? arg.call(context, idx, payload) : arg\n  }\n\n  function setAttribute(node, name, value) {\n    value == null ? node.removeAttribute(name) : node.setAttribute(name, value)\n  }\n\n  // access className property while respecting SVGAnimatedString\n  function className(node, value){\n    var klass = node.className || '',\n        svg   = klass && klass.baseVal !== undefined\n\n    if (value === undefined) return svg ? klass.baseVal : klass\n    svg ? (klass.baseVal = value) : (node.className = value)\n  }\n\n  // \"true\"  => true\n  // \"false\" => false\n  // \"null\"  => null\n  // \"42\"    => 42\n  // \"42.5\"  => 42.5\n  // \"08\"    => \"08\"\n  // JSON    => parse if valid\n  // String  => self\n  function deserializeValue(value) {\n    try {\n      return value ?\n        value == \"true\" ||\n        ( value == \"false\" ? false :\n          value == \"null\" ? null :\n          +value + \"\" == value ? +value :\n          /^[\\[\\{]/.test(value) ? $.parseJSON(value) :\n          value )\n        : value\n    } catch(e) {\n      return value\n    }\n  }\n\n  $.type = type\n  $.isFunction = isFunction\n  $.isWindow = isWindow\n  $.isArray = isArray\n  $.isPlainObject = isPlainObject\n\n  $.isEmptyObject = function(obj) {\n    var name\n    for (name in obj) return false\n    return true\n  }\n\n  $.isNumeric = function(val) {\n    var num = Number(val), type = typeof val\n    return val != null && type != 'boolean' &&\n      (type != 'string' || val.length) &&\n      !isNaN(num) && isFinite(num) || false\n  }\n\n  $.inArray = function(elem, array, i){\n    return emptyArray.indexOf.call(array, elem, i)\n  }\n\n  $.camelCase = camelize\n  $.trim = function(str) {\n    return str == null ? \"\" : String.prototype.trim.call(str)\n  }\n\n  // plugin compatibility\n  $.uuid = 0\n  $.support = { }\n  $.expr = { }\n  $.noop = function() {}\n\n  $.map = function(elements, callback){\n    var value, values = [], i, key\n    if (likeArray(elements))\n      for (i = 0; i < elements.length; i++) {\n        value = callback(elements[i], i)\n        if (value != null) values.push(value)\n      }\n    else\n      for (key in elements) {\n        value = callback(elements[key], key)\n        if (value != null) values.push(value)\n      }\n    return flatten(values)\n  }\n\n  $.each = function(elements, callback){\n    var i, key\n    if (likeArray(elements)) {\n      for (i = 0; i < elements.length; i++)\n        if (callback.call(elements[i], i, elements[i]) === false) return elements\n    } else {\n      for (key in elements)\n        if (callback.call(elements[key], key, elements[key]) === false) return elements\n    }\n\n    return elements\n  }\n\n  $.grep = function(elements, callback){\n    return filter.call(elements, callback)\n  }\n\n  if (window.JSON) $.parseJSON = JSON.parse\n\n  // Populate the class2type map\n  $.each(\"Boolean Number String Function Array Date RegExp Object Error\".split(\" \"), function(i, name) {\n    class2type[ \"[object \" + name + \"]\" ] = name.toLowerCase()\n  })\n\n  // Define methods that will be available on all\n  // Zepto collections\n  $.fn = {\n    constructor: zepto.Z,\n    length: 0,\n\n    // Because a collection acts like an array\n    // copy over these useful array functions.\n    forEach: emptyArray.forEach,\n    reduce: emptyArray.reduce,\n    push: emptyArray.push,\n    sort: emptyArray.sort,\n    splice: emptyArray.splice,\n    indexOf: emptyArray.indexOf,\n    concat: function(){\n      var i, value, args = []\n      for (i = 0; i < arguments.length; i++) {\n        value = arguments[i]\n        args[i] = zepto.isZ(value) ? value.toArray() : value\n      }\n      return concat.apply(zepto.isZ(this) ? this.toArray() : this, args)\n    },\n\n    // `map` and `slice` in the jQuery API work differently\n    // from their array counterparts\n    map: function(fn){\n      return $($.map(this, function(el, i){ return fn.call(el, i, el) }))\n    },\n    slice: function(){\n      return $(slice.apply(this, arguments))\n    },\n\n    ready: function(callback){\n      // need to check if document.body exists for IE as that browser reports\n      // document ready when it hasn't yet created the body element\n      if (readyRE.test(document.readyState) && document.body) callback($)\n      else document.addEventListener('DOMContentLoaded', function(){ callback($) }, false)\n      return this\n    },\n    get: function(idx){\n      return idx === undefined ? slice.call(this) : this[idx >= 0 ? idx : idx + this.length]\n    },\n    toArray: function(){ return this.get() },\n    size: function(){\n      return this.length\n    },\n    remove: function(){\n      return this.each(function(){\n        if (this.parentNode != null)\n          this.parentNode.removeChild(this)\n      })\n    },\n    each: function(callback){\n      emptyArray.every.call(this, function(el, idx){\n        return callback.call(el, idx, el) !== false\n      })\n      return this\n    },\n    filter: function(selector){\n      if (isFunction(selector)) return this.not(this.not(selector))\n      return $(filter.call(this, function(element){\n        return zepto.matches(element, selector)\n      }))\n    },\n    add: function(selector,context){\n      return $(uniq(this.concat($(selector,context))))\n    },\n    is: function(selector){\n      return this.length > 0 && zepto.matches(this[0], selector)\n    },\n    not: function(selector){\n      var nodes=[]\n      if (isFunction(selector) && selector.call !== undefined)\n        this.each(function(idx){\n          if (!selector.call(this,idx)) nodes.push(this)\n        })\n      else {\n        var excludes = typeof selector == 'string' ? this.filter(selector) :\n          (likeArray(selector) && isFunction(selector.item)) ? slice.call(selector) : $(selector)\n        this.forEach(function(el){\n          if (excludes.indexOf(el) < 0) nodes.push(el)\n        })\n      }\n      return $(nodes)\n    },\n    has: function(selector){\n      return this.filter(function(){\n        return isObject(selector) ?\n          $.contains(this, selector) :\n          $(this).find(selector).size()\n      })\n    },\n    eq: function(idx){\n      return idx === -1 ? this.slice(idx) : this.slice(idx, + idx + 1)\n    },\n    first: function(){\n      var el = this[0]\n      return el && !isObject(el) ? el : $(el)\n    },\n    last: function(){\n      var el = this[this.length - 1]\n      return el && !isObject(el) ? el : $(el)\n    },\n    find: function(selector){\n      var result, $this = this\n      if (!selector) result = $()\n      else if (typeof selector == 'object')\n        result = $(selector).filter(function(){\n          var node = this\n          return emptyArray.some.call($this, function(parent){\n            return $.contains(parent, node)\n          })\n        })\n      else if (this.length == 1) result = $(zepto.qsa(this[0], selector))\n      else result = this.map(function(){ return zepto.qsa(this, selector) })\n      return result\n    },\n    closest: function(selector, context){\n      var nodes = [], collection = typeof selector == 'object' && $(selector)\n      this.each(function(_, node){\n        while (node && !(collection ? collection.indexOf(node) >= 0 : zepto.matches(node, selector)))\n          node = node !== context && !isDocument(node) && node.parentNode\n        if (node && nodes.indexOf(node) < 0) nodes.push(node)\n      })\n      return $(nodes)\n    },\n    parents: function(selector){\n      var ancestors = [], nodes = this\n      while (nodes.length > 0)\n        nodes = $.map(nodes, function(node){\n          if ((node = node.parentNode) && !isDocument(node) && ancestors.indexOf(node) < 0) {\n            ancestors.push(node)\n            return node\n          }\n        })\n      return filtered(ancestors, selector)\n    },\n    parent: function(selector){\n      return filtered(uniq(this.pluck('parentNode')), selector)\n    },\n    children: function(selector){\n      return filtered(this.map(function(){ return children(this) }), selector)\n    },\n    contents: function() {\n      return this.map(function() { return this.contentDocument || slice.call(this.childNodes) })\n    },\n    siblings: function(selector){\n      return filtered(this.map(function(i, el){\n        return filter.call(children(el.parentNode), function(child){ return child!==el })\n      }), selector)\n    },\n    empty: function(){\n      return this.each(function(){ this.innerHTML = '' })\n    },\n    // `pluck` is borrowed from Prototype.js\n    pluck: function(property){\n      return $.map(this, function(el){ return el[property] })\n    },\n    show: function(){\n      return this.each(function(){\n        this.style.display == \"none\" && (this.style.display = '')\n        if (getComputedStyle(this, '').getPropertyValue(\"display\") == \"none\")\n          this.style.display = defaultDisplay(this.nodeName)\n      })\n    },\n    replaceWith: function(newContent){\n      return this.before(newContent).remove()\n    },\n    wrap: function(structure){\n      var func = isFunction(structure)\n      if (this[0] && !func)\n        var dom   = $(structure).get(0),\n            clone = dom.parentNode || this.length > 1\n\n      return this.each(function(index){\n        $(this).wrapAll(\n          func ? structure.call(this, index) :\n            clone ? dom.cloneNode(true) : dom\n        )\n      })\n    },\n    wrapAll: function(structure){\n      if (this[0]) {\n        $(this[0]).before(structure = $(structure))\n        var children\n        // drill down to the inmost element\n        while ((children = structure.children()).length) structure = children.first()\n        $(structure).append(this)\n      }\n      return this\n    },\n    wrapInner: function(structure){\n      var func = isFunction(structure)\n      return this.each(function(index){\n        var self = $(this), contents = self.contents(),\n            dom  = func ? structure.call(this, index) : structure\n        contents.length ? contents.wrapAll(dom) : self.append(dom)\n      })\n    },\n    unwrap: function(){\n      this.parent().each(function(){\n        $(this).replaceWith($(this).children())\n      })\n      return this\n    },\n    clone: function(){\n      return this.map(function(){ return this.cloneNode(true) })\n    },\n    hide: function(){\n      return this.css(\"display\", \"none\")\n    },\n    toggle: function(setting){\n      return this.each(function(){\n        var el = $(this)\n        ;(setting === undefined ? el.css(\"display\") == \"none\" : setting) ? el.show() : el.hide()\n      })\n    },\n    prev: function(selector){ return $(this.pluck('previousElementSibling')).filter(selector || '*') },\n    next: function(selector){ return $(this.pluck('nextElementSibling')).filter(selector || '*') },\n    html: function(html){\n      return 0 in arguments ?\n        this.each(function(idx){\n          var originHtml = this.innerHTML\n          $(this).empty().append( funcArg(this, html, idx, originHtml) )\n        }) :\n        (0 in this ? this[0].innerHTML : null)\n    },\n    text: function(text){\n      return 0 in arguments ?\n        this.each(function(idx){\n          var newText = funcArg(this, text, idx, this.textContent)\n          this.textContent = newText == null ? '' : ''+newText\n        }) :\n        (0 in this ? this.pluck('textContent').join(\"\") : null)\n    },\n    attr: function(name, value){\n      var result\n      return (typeof name == 'string' && !(1 in arguments)) ?\n        (0 in this && this[0].nodeType == 1 && (result = this[0].getAttribute(name)) != null ? result : undefined) :\n        this.each(function(idx){\n          if (this.nodeType !== 1) return\n          if (isObject(name)) for (key in name) setAttribute(this, key, name[key])\n          else setAttribute(this, name, funcArg(this, value, idx, this.getAttribute(name)))\n        })\n    },\n    removeAttr: function(name){\n      return this.each(function(){ this.nodeType === 1 && name.split(' ').forEach(function(attribute){\n        setAttribute(this, attribute)\n      }, this)})\n    },\n    prop: function(name, value){\n      name = propMap[name] || name\n      return (1 in arguments) ?\n        this.each(function(idx){\n          this[name] = funcArg(this, value, idx, this[name])\n        }) :\n        (this[0] && this[0][name])\n    },\n    removeProp: function(name){\n      name = propMap[name] || name\n      return this.each(function(){ delete this[name] })\n    },\n    data: function(name, value){\n      var attrName = 'data-' + name.replace(capitalRE, '-$1').toLowerCase()\n\n      var data = (1 in arguments) ?\n        this.attr(attrName, value) :\n        this.attr(attrName)\n\n      return data !== null ? deserializeValue(data) : undefined\n    },\n    val: function(value){\n      if (0 in arguments) {\n        if (value == null) value = \"\"\n        return this.each(function(idx){\n          this.value = funcArg(this, value, idx, this.value)\n        })\n      } else {\n        return this[0] && (this[0].multiple ?\n           $(this[0]).find('option').filter(function(){ return this.selected }).pluck('value') :\n           this[0].value)\n      }\n    },\n    offset: function(coordinates){\n      if (coordinates) return this.each(function(index){\n        var $this = $(this),\n            coords = funcArg(this, coordinates, index, $this.offset()),\n            parentOffset = $this.offsetParent().offset(),\n            props = {\n              top:  coords.top  - parentOffset.top,\n              left: coords.left - parentOffset.left\n            }\n\n        if ($this.css('position') == 'static') props['position'] = 'relative'\n        $this.css(props)\n      })\n      if (!this.length) return null\n      if (document.documentElement !== this[0] && !$.contains(document.documentElement, this[0]))\n        return {top: 0, left: 0}\n      var obj = this[0].getBoundingClientRect()\n      return {\n        left: obj.left + window.pageXOffset,\n        top: obj.top + window.pageYOffset,\n        width: Math.round(obj.width),\n        height: Math.round(obj.height)\n      }\n    },\n    css: function(property, value){\n      if (arguments.length < 2) {\n        var element = this[0]\n        if (typeof property == 'string') {\n          if (!element) return\n          return element.style[camelize(property)] || getComputedStyle(element, '').getPropertyValue(property)\n        } else if (isArray(property)) {\n          if (!element) return\n          var props = {}\n          var computedStyle = getComputedStyle(element, '')\n          $.each(property, function(_, prop){\n            props[prop] = (element.style[camelize(prop)] || computedStyle.getPropertyValue(prop))\n          })\n          return props\n        }\n      }\n\n      var css = ''\n      if (type(property) == 'string') {\n        if (!value && value !== 0)\n          this.each(function(){ this.style.removeProperty(dasherize(property)) })\n        else\n          css = dasherize(property) + \":\" + maybeAddPx(property, value)\n      } else {\n        for (key in property)\n          if (!property[key] && property[key] !== 0)\n            this.each(function(){ this.style.removeProperty(dasherize(key)) })\n          else\n            css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';'\n      }\n\n      return this.each(function(){ this.style.cssText += ';' + css })\n    },\n    index: function(element){\n      return element ? this.indexOf($(element)[0]) : this.parent().children().indexOf(this[0])\n    },\n    hasClass: function(name){\n      if (!name) return false\n      return emptyArray.some.call(this, function(el){\n        return this.test(className(el))\n      }, classRE(name))\n    },\n    addClass: function(name){\n      if (!name) return this\n      return this.each(function(idx){\n        if (!('className' in this)) return\n        classList = []\n        var cls = className(this), newName = funcArg(this, name, idx, cls)\n        newName.split(/\\s+/g).forEach(function(klass){\n          if (!$(this).hasClass(klass)) classList.push(klass)\n        }, this)\n        classList.length && className(this, cls + (cls ? \" \" : \"\") + classList.join(\" \"))\n      })\n    },\n    removeClass: function(name){\n      return this.each(function(idx){\n        if (!('className' in this)) return\n        if (name === undefined) return className(this, '')\n        classList = className(this)\n        funcArg(this, name, idx, classList).split(/\\s+/g).forEach(function(klass){\n          classList = classList.replace(classRE(klass), \" \")\n        })\n        className(this, classList.trim())\n      })\n    },\n    toggleClass: function(name, when){\n      if (!name) return this\n      return this.each(function(idx){\n        var $this = $(this), names = funcArg(this, name, idx, className(this))\n        names.split(/\\s+/g).forEach(function(klass){\n          (when === undefined ? !$this.hasClass(klass) : when) ?\n            $this.addClass(klass) : $this.removeClass(klass)\n        })\n      })\n    },\n    scrollTop: function(value){\n      if (!this.length) return\n      var hasScrollTop = 'scrollTop' in this[0]\n      if (value === undefined) return hasScrollTop ? this[0].scrollTop : this[0].pageYOffset\n      return this.each(hasScrollTop ?\n        function(){ this.scrollTop = value } :\n        function(){ this.scrollTo(this.scrollX, value) })\n    },\n    scrollLeft: function(value){\n      if (!this.length) return\n      var hasScrollLeft = 'scrollLeft' in this[0]\n      if (value === undefined) return hasScrollLeft ? this[0].scrollLeft : this[0].pageXOffset\n      return this.each(hasScrollLeft ?\n        function(){ this.scrollLeft = value } :\n        function(){ this.scrollTo(value, this.scrollY) })\n    },\n    position: function() {\n      if (!this.length) return\n\n      var elem = this[0],\n        // Get *real* offsetParent\n        offsetParent = this.offsetParent(),\n        // Get correct offsets\n        offset       = this.offset(),\n        parentOffset = rootNodeRE.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset()\n\n      // Subtract element margins\n      // note: when an element has margin: auto the offsetLeft and marginLeft\n      // are the same in Safari causing offset.left to incorrectly be 0\n      offset.top  -= parseFloat( $(elem).css('margin-top') ) || 0\n      offset.left -= parseFloat( $(elem).css('margin-left') ) || 0\n\n      // Add offsetParent borders\n      parentOffset.top  += parseFloat( $(offsetParent[0]).css('border-top-width') ) || 0\n      parentOffset.left += parseFloat( $(offsetParent[0]).css('border-left-width') ) || 0\n\n      // Subtract the two offsets\n      return {\n        top:  offset.top  - parentOffset.top,\n        left: offset.left - parentOffset.left\n      }\n    },\n    offsetParent: function() {\n      return this.map(function(){\n        var parent = this.offsetParent || document.body\n        while (parent && !rootNodeRE.test(parent.nodeName) && $(parent).css(\"position\") == \"static\")\n          parent = parent.offsetParent\n        return parent\n      })\n    }\n  }\n\n  // for now\n  $.fn.detach = $.fn.remove\n\n  // Generate the `width` and `height` functions\n  ;['width', 'height'].forEach(function(dimension){\n    var dimensionProperty =\n      dimension.replace(/./, function(m){ return m[0].toUpperCase() })\n\n    $.fn[dimension] = function(value){\n      var offset, el = this[0]\n      if (value === undefined) return isWindow(el) ? el['inner' + dimensionProperty] :\n        isDocument(el) ? el.documentElement['scroll' + dimensionProperty] :\n        (offset = this.offset()) && offset[dimension]\n      else return this.each(function(idx){\n        el = $(this)\n        el.css(dimension, funcArg(this, value, idx, el[dimension]()))\n      })\n    }\n  })\n\n  function traverseNode(node, fun) {\n    fun(node)\n    for (var i = 0, len = node.childNodes.length; i < len; i++)\n      traverseNode(node.childNodes[i], fun)\n  }\n\n  // Generate the `after`, `prepend`, `before`, `append`,\n  // `insertAfter`, `insertBefore`, `appendTo`, and `prependTo` methods.\n  adjacencyOperators.forEach(function(operator, operatorIndex) {\n    var inside = operatorIndex % 2 //=> prepend, append\n\n    $.fn[operator] = function(){\n      // arguments can be nodes, arrays of nodes, Zepto objects and HTML strings\n      var argType, nodes = $.map(arguments, function(arg) {\n            var arr = []\n            argType = type(arg)\n            if (argType == \"array\") {\n              arg.forEach(function(el) {\n                if (el.nodeType !== undefined) return arr.push(el)\n                else if ($.zepto.isZ(el)) return arr = arr.concat(el.get())\n                arr = arr.concat(zepto.fragment(el))\n              })\n              return arr\n            }\n            return argType == \"object\" || arg == null ?\n              arg : zepto.fragment(arg)\n          }),\n          parent, copyByClone = this.length > 1\n      if (nodes.length < 1) return this\n\n      return this.each(function(_, target){\n        parent = inside ? target : target.parentNode\n\n        // convert all methods to a \"before\" operation\n        target = operatorIndex == 0 ? target.nextSibling :\n                 operatorIndex == 1 ? target.firstChild :\n                 operatorIndex == 2 ? target :\n                 null\n\n        var parentInDocument = $.contains(document.documentElement, parent)\n\n        nodes.forEach(function(node){\n          if (copyByClone) node = node.cloneNode(true)\n          else if (!parent) return $(node).remove()\n\n          parent.insertBefore(node, target)\n          if (parentInDocument) traverseNode(node, function(el){\n            if (el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' &&\n               (!el.type || el.type === 'text/javascript') && !el.src){\n              var target = el.ownerDocument ? el.ownerDocument.defaultView : window\n              target['eval'].call(target, el.innerHTML)\n            }\n          })\n        })\n      })\n    }\n\n    // after    => insertAfter\n    // prepend  => prependTo\n    // before   => insertBefore\n    // append   => appendTo\n    $.fn[inside ? operator+'To' : 'insert'+(operatorIndex ? 'Before' : 'After')] = function(html){\n      $(html)[operator](this)\n      return this\n    }\n  })\n\n  zepto.Z.prototype = Z.prototype = $.fn\n\n  // Export internal API functions in the `$.zepto` namespace\n  zepto.uniq = uniq\n  zepto.deserializeValue = deserializeValue\n  $.zepto = zepto\n\n  return $\n})()\n\nwindow.Zepto = Zepto\nwindow.$ === undefined && (window.$ = Zepto)\n\n;(function($){\n  var _zid = 1, undefined,\n      slice = Array.prototype.slice,\n      isFunction = $.isFunction,\n      isString = function(obj){ return typeof obj == 'string' },\n      handlers = {},\n      specialEvents={},\n      focusinSupported = 'onfocusin' in window,\n      focus = { focus: 'focusin', blur: 'focusout' },\n      hover = { mouseenter: 'mouseover', mouseleave: 'mouseout' }\n\n  specialEvents.click = specialEvents.mousedown = specialEvents.mouseup = specialEvents.mousemove = 'MouseEvents'\n\n  function zid(element) {\n    return element._zid || (element._zid = _zid++)\n  }\n  function findHandlers(element, event, fn, selector) {\n    event = parse(event)\n    if (event.ns) var matcher = matcherFor(event.ns)\n    return (handlers[zid(element)] || []).filter(function(handler) {\n      return handler\n        && (!event.e  || handler.e == event.e)\n        && (!event.ns || matcher.test(handler.ns))\n        && (!fn       || zid(handler.fn) === zid(fn))\n        && (!selector || handler.sel == selector)\n    })\n  }\n  function parse(event) {\n    var parts = ('' + event).split('.')\n    return {e: parts[0], ns: parts.slice(1).sort().join(' ')}\n  }\n  function matcherFor(ns) {\n    return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)')\n  }\n\n  function eventCapture(handler, captureSetting) {\n    return handler.del &&\n      (!focusinSupported && (handler.e in focus)) ||\n      !!captureSetting\n  }\n\n  function realEvent(type) {\n    return hover[type] || (focusinSupported && focus[type]) || type\n  }\n\n  function add(element, events, fn, data, selector, delegator, capture){\n    var id = zid(element), set = (handlers[id] || (handlers[id] = []))\n    events.split(/\\s/).forEach(function(event){\n      if (event == 'ready') return $(document).ready(fn)\n      var handler   = parse(event)\n      handler.fn    = fn\n      handler.sel   = selector\n      // emulate mouseenter, mouseleave\n      if (handler.e in hover) fn = function(e){\n        var related = e.relatedTarget\n        if (!related || (related !== this && !$.contains(this, related)))\n          return handler.fn.apply(this, arguments)\n      }\n      handler.del   = delegator\n      var callback  = delegator || fn\n      handler.proxy = function(e){\n        e = compatible(e)\n        if (e.isImmediatePropagationStopped()) return\n        e.data = data\n        var result = callback.apply(element, e._args == undefined ? [e] : [e].concat(e._args))\n        if (result === false) e.preventDefault(), e.stopPropagation()\n        return result\n      }\n      handler.i = set.length\n      set.push(handler)\n      if ('addEventListener' in element)\n        element.addEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))\n    })\n  }\n  function remove(element, events, fn, selector, capture){\n    var id = zid(element)\n    ;(events || '').split(/\\s/).forEach(function(event){\n      findHandlers(element, event, fn, selector).forEach(function(handler){\n        delete handlers[id][handler.i]\n      if ('removeEventListener' in element)\n        element.removeEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))\n      })\n    })\n  }\n\n  $.event = { add: add, remove: remove }\n\n  $.proxy = function(fn, context) {\n    var args = (2 in arguments) && slice.call(arguments, 2)\n    if (isFunction(fn)) {\n      var proxyFn = function(){ return fn.apply(context, args ? args.concat(slice.call(arguments)) : arguments) }\n      proxyFn._zid = zid(fn)\n      return proxyFn\n    } else if (isString(context)) {\n      if (args) {\n        args.unshift(fn[context], fn)\n        return $.proxy.apply(null, args)\n      } else {\n        return $.proxy(fn[context], fn)\n      }\n    } else {\n      throw new TypeError(\"expected function\")\n    }\n  }\n\n  $.fn.bind = function(event, data, callback){\n    return this.on(event, data, callback)\n  }\n  $.fn.unbind = function(event, callback){\n    return this.off(event, callback)\n  }\n  $.fn.one = function(event, selector, data, callback){\n    return this.on(event, selector, data, callback, 1)\n  }\n\n  var returnTrue = function(){return true},\n      returnFalse = function(){return false},\n      ignoreProperties = /^([A-Z]|returnValue$|layer[XY]$|webkitMovement[XY]$)/,\n      eventMethods = {\n        preventDefault: 'isDefaultPrevented',\n        stopImmediatePropagation: 'isImmediatePropagationStopped',\n        stopPropagation: 'isPropagationStopped'\n      }\n\n  function compatible(event, source) {\n    if (source || !event.isDefaultPrevented) {\n      source || (source = event)\n\n      $.each(eventMethods, function(name, predicate) {\n        var sourceMethod = source[name]\n        event[name] = function(){\n          this[predicate] = returnTrue\n          return sourceMethod && sourceMethod.apply(source, arguments)\n        }\n        event[predicate] = returnFalse\n      })\n\n      event.timeStamp || (event.timeStamp = Date.now())\n\n      if (source.defaultPrevented !== undefined ? source.defaultPrevented :\n          'returnValue' in source ? source.returnValue === false :\n          source.getPreventDefault && source.getPreventDefault())\n        event.isDefaultPrevented = returnTrue\n    }\n    return event\n  }\n\n  function createProxy(event) {\n    var key, proxy = { originalEvent: event }\n    for (key in event)\n      if (!ignoreProperties.test(key) && event[key] !== undefined) proxy[key] = event[key]\n\n    return compatible(proxy, event)\n  }\n\n  $.fn.delegate = function(selector, event, callback){\n    return this.on(event, selector, callback)\n  }\n  $.fn.undelegate = function(selector, event, callback){\n    return this.off(event, selector, callback)\n  }\n\n  $.fn.live = function(event, callback){\n    $(document.body).delegate(this.selector, event, callback)\n    return this\n  }\n  $.fn.die = function(event, callback){\n    $(document.body).undelegate(this.selector, event, callback)\n    return this\n  }\n\n  $.fn.on = function(event, selector, data, callback, one){\n    var autoRemove, delegator, $this = this\n    if (event && !isString(event)) {\n      $.each(event, function(type, fn){\n        $this.on(type, selector, data, fn, one)\n      })\n      return $this\n    }\n\n    if (!isString(selector) && !isFunction(callback) && callback !== false)\n      callback = data, data = selector, selector = undefined\n    if (callback === undefined || data === false)\n      callback = data, data = undefined\n\n    if (callback === false) callback = returnFalse\n\n    return $this.each(function(_, element){\n      if (one) autoRemove = function(e){\n        remove(element, e.type, callback)\n        return callback.apply(this, arguments)\n      }\n\n      if (selector) delegator = function(e){\n        var evt, match = $(e.target).closest(selector, element).get(0)\n        if (match && match !== element) {\n          evt = $.extend(createProxy(e), {currentTarget: match, liveFired: element})\n          return (autoRemove || callback).apply(match, [evt].concat(slice.call(arguments, 1)))\n        }\n      }\n\n      add(element, event, callback, data, selector, delegator || autoRemove)\n    })\n  }\n  $.fn.off = function(event, selector, callback){\n    var $this = this\n    if (event && !isString(event)) {\n      $.each(event, function(type, fn){\n        $this.off(type, selector, fn)\n      })\n      return $this\n    }\n\n    if (!isString(selector) && !isFunction(callback) && callback !== false)\n      callback = selector, selector = undefined\n\n    if (callback === false) callback = returnFalse\n\n    return $this.each(function(){\n      remove(this, event, callback, selector)\n    })\n  }\n\n  $.fn.trigger = function(event, args){\n    event = (isString(event) || $.isPlainObject(event)) ? $.Event(event) : compatible(event)\n    event._args = args\n    return this.each(function(){\n      // handle focus(), blur() by calling them directly\n      if (event.type in focus && typeof this[event.type] == \"function\") this[event.type]()\n      // items in the collection might not be DOM elements\n      else if ('dispatchEvent' in this) this.dispatchEvent(event)\n      else $(this).triggerHandler(event, args)\n    })\n  }\n\n  // triggers event handlers on current element just as if an event occurred,\n  // doesn't trigger an actual event, doesn't bubble\n  $.fn.triggerHandler = function(event, args){\n    var e, result\n    this.each(function(i, element){\n      e = createProxy(isString(event) ? $.Event(event) : event)\n      e._args = args\n      e.target = element\n      $.each(findHandlers(element, event.type || event), function(i, handler){\n        result = handler.proxy(e)\n        if (e.isImmediatePropagationStopped()) return false\n      })\n    })\n    return result\n  }\n\n  // shortcut methods for `.bind(event, fn)` for each event type\n  ;('focusin focusout focus blur load resize scroll unload click dblclick '+\n  'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave '+\n  'change select keydown keypress keyup error').split(' ').forEach(function(event) {\n    $.fn[event] = function(callback) {\n      return (0 in arguments) ?\n        this.bind(event, callback) :\n        this.trigger(event)\n    }\n  })\n\n  $.Event = function(type, props) {\n    if (!isString(type)) props = type, type = props.type\n    var event = document.createEvent(specialEvents[type] || 'Events'), bubbles = true\n    if (props) for (var name in props) (name == 'bubbles') ? (bubbles = !!props[name]) : (event[name] = props[name])\n    event.initEvent(type, bubbles, true)\n    return compatible(event)\n  }\n\n})(Zepto)\n\n;(function($){\n  var jsonpID = +new Date(),\n      document = window.document,\n      key,\n      name,\n      rscript = /<script\\b[^<]*(?:(?!<\\/script>)<[^<]*)*<\\/script>/gi,\n      scriptTypeRE = /^(?:text|application)\\/javascript/i,\n      xmlTypeRE = /^(?:text|application)\\/xml/i,\n      jsonType = 'application/json',\n      htmlType = 'text/html',\n      blankRE = /^\\s*$/,\n      originAnchor = document.createElement('a')\n\n  originAnchor.href = window.location.href\n\n  // trigger a custom event and return false if it was cancelled\n  function triggerAndReturn(context, eventName, data) {\n    var event = $.Event(eventName)\n    $(context).trigger(event, data)\n    return !event.isDefaultPrevented()\n  }\n\n  // trigger an Ajax \"global\" event\n  function triggerGlobal(settings, context, eventName, data) {\n    if (settings.global) return triggerAndReturn(context || document, eventName, data)\n  }\n\n  // Number of active Ajax requests\n  $.active = 0\n\n  function ajaxStart(settings) {\n    if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')\n  }\n  function ajaxStop(settings) {\n    if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop')\n  }\n\n  // triggers an extra global event \"ajaxBeforeSend\" that's like \"ajaxSend\" but cancelable\n  function ajaxBeforeSend(xhr, settings) {\n    var context = settings.context\n    if (settings.beforeSend.call(context, xhr, settings) === false ||\n        triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false)\n      return false\n\n    triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])\n  }\n  function ajaxSuccess(data, xhr, settings, deferred) {\n    var context = settings.context, status = 'success'\n    settings.success.call(context, data, status, xhr)\n    if (deferred) deferred.resolveWith(context, [data, status, xhr])\n    triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])\n    ajaxComplete(status, xhr, settings)\n  }\n  // type: \"timeout\", \"error\", \"abort\", \"parsererror\"\n  function ajaxError(error, type, xhr, settings, deferred) {\n    var context = settings.context\n    settings.error.call(context, xhr, type, error)\n    if (deferred) deferred.rejectWith(context, [xhr, type, error])\n    triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error || type])\n    ajaxComplete(type, xhr, settings)\n  }\n  // status: \"success\", \"notmodified\", \"error\", \"timeout\", \"abort\", \"parsererror\"\n  function ajaxComplete(status, xhr, settings) {\n    var context = settings.context\n    settings.complete.call(context, xhr, status)\n    triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])\n    ajaxStop(settings)\n  }\n\n  function ajaxDataFilter(data, type, settings) {\n    if (settings.dataFilter == empty) return data\n    var context = settings.context\n    return settings.dataFilter.call(context, data, type)\n  }\n\n  // Empty function, used as default callback\n  function empty() {}\n\n  $.ajaxJSONP = function(options, deferred){\n    if (!('type' in options)) return $.ajax(options)\n\n    var _callbackName = options.jsonpCallback,\n      callbackName = ($.isFunction(_callbackName) ?\n        _callbackName() : _callbackName) || ('Zepto' + (jsonpID++)),\n      script = document.createElement('script'),\n      originalCallback = window[callbackName],\n      responseData,\n      abort = function(errorType) {\n        $(script).triggerHandler('error', errorType || 'abort')\n      },\n      xhr = { abort: abort }, abortTimeout\n\n    if (deferred) deferred.promise(xhr)\n\n    $(script).on('load error', function(e, errorType){\n      clearTimeout(abortTimeout)\n      $(script).off().remove()\n\n      if (e.type == 'error' || !responseData) {\n        ajaxError(null, errorType || 'error', xhr, options, deferred)\n      } else {\n        ajaxSuccess(responseData[0], xhr, options, deferred)\n      }\n\n      window[callbackName] = originalCallback\n      if (responseData && $.isFunction(originalCallback))\n        originalCallback(responseData[0])\n\n      originalCallback = responseData = undefined\n    })\n\n    if (ajaxBeforeSend(xhr, options) === false) {\n      abort('abort')\n      return xhr\n    }\n\n    window[callbackName] = function(){\n      responseData = arguments\n    }\n\n    script.src = options.url.replace(/\\?(.+)=\\?/, '?$1=' + callbackName)\n    document.head.appendChild(script)\n\n    if (options.timeout > 0) abortTimeout = setTimeout(function(){\n      abort('timeout')\n    }, options.timeout)\n\n    return xhr\n  }\n\n  $.ajaxSettings = {\n    // Default type of request\n    type: 'GET',\n    // Callback that is executed before request\n    beforeSend: empty,\n    // Callback that is executed if the request succeeds\n    success: empty,\n    // Callback that is executed the the server drops error\n    error: empty,\n    // Callback that is executed on request complete (both: error and success)\n    complete: empty,\n    // The context for the callbacks\n    context: null,\n    // Whether to trigger \"global\" Ajax events\n    global: true,\n    // Transport\n    xhr: function () {\n      return new window.XMLHttpRequest()\n    },\n    // MIME types mapping\n    // IIS returns Javascript as \"application/x-javascript\"\n    accepts: {\n      script: 'text/javascript, application/javascript, application/x-javascript',\n      json:   jsonType,\n      xml:    'application/xml, text/xml',\n      html:   htmlType,\n      text:   'text/plain'\n    },\n    // Whether the request is to another domain\n    crossDomain: false,\n    // Default timeout\n    timeout: 0,\n    // Whether data should be serialized to string\n    processData: true,\n    // Whether the browser should be allowed to cache GET responses\n    cache: true,\n    //Used to handle the raw response data of XMLHttpRequest.\n    //This is a pre-filtering function to sanitize the response.\n    //The sanitized response should be returned\n    dataFilter: empty\n  }\n\n  function mimeToDataType(mime) {\n    if (mime) mime = mime.split(';', 2)[0]\n    return mime && ( mime == htmlType ? 'html' :\n      mime == jsonType ? 'json' :\n      scriptTypeRE.test(mime) ? 'script' :\n      xmlTypeRE.test(mime) && 'xml' ) || 'text'\n  }\n\n  function appendQuery(url, query) {\n    if (query == '') return url\n    return (url + '&' + query).replace(/[&?]{1,2}/, '?')\n  }\n\n  // serialize payload and append it to the URL for GET requests\n  function serializeData(options) {\n    if (options.processData && options.data && $.type(options.data) != \"string\")\n      options.data = $.param(options.data, options.traditional)\n    if (options.data && (!options.type || options.type.toUpperCase() == 'GET' || 'jsonp' == options.dataType))\n      options.url = appendQuery(options.url, options.data), options.data = undefined\n  }\n\n  $.ajax = function(options){\n    var settings = $.extend({}, options || {}),\n        deferred = $.Deferred && $.Deferred(),\n        urlAnchor, hashIndex\n    for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key]\n\n    ajaxStart(settings)\n\n    if (!settings.crossDomain) {\n      urlAnchor = document.createElement('a')\n      urlAnchor.href = settings.url\n      // cleans up URL for .href (IE only), see https://github.com/madrobby/zepto/pull/1049\n      urlAnchor.href = urlAnchor.href\n      settings.crossDomain = (originAnchor.protocol + '//' + originAnchor.host) !== (urlAnchor.protocol + '//' + urlAnchor.host)\n    }\n\n    if (!settings.url) settings.url = window.location.toString()\n    if ((hashIndex = settings.url.indexOf('#')) > -1) settings.url = settings.url.slice(0, hashIndex)\n    serializeData(settings)\n\n    var dataType = settings.dataType, hasPlaceholder = /\\?.+=\\?/.test(settings.url)\n    if (hasPlaceholder) dataType = 'jsonp'\n\n    if (settings.cache === false || (\n         (!options || options.cache !== true) &&\n         ('script' == dataType || 'jsonp' == dataType)\n        ))\n      settings.url = appendQuery(settings.url, '_=' + Date.now())\n\n    if ('jsonp' == dataType) {\n      if (!hasPlaceholder)\n        settings.url = appendQuery(settings.url,\n          settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?')\n      return $.ajaxJSONP(settings, deferred)\n    }\n\n    var mime = settings.accepts[dataType],\n        headers = { },\n        setHeader = function(name, value) { headers[name.toLowerCase()] = [name, value] },\n        protocol = /^([\\w-]+:)\\/\\//.test(settings.url) ? RegExp.$1 : window.location.protocol,\n        xhr = settings.xhr(),\n        nativeSetHeader = xhr.setRequestHeader,\n        abortTimeout\n\n    if (deferred) deferred.promise(xhr)\n\n    if (!settings.crossDomain) setHeader('X-Requested-With', 'XMLHttpRequest')\n    setHeader('Accept', mime || '*/*')\n    if (mime = settings.mimeType || mime) {\n      if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]\n      xhr.overrideMimeType && xhr.overrideMimeType(mime)\n    }\n    if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET'))\n      setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded')\n\n    if (settings.headers) for (name in settings.headers) setHeader(name, settings.headers[name])\n    xhr.setRequestHeader = setHeader\n\n    xhr.onreadystatechange = function(){\n      if (xhr.readyState == 4) {\n        xhr.onreadystatechange = empty\n        clearTimeout(abortTimeout)\n        var result, error = false\n        if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {\n          dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'))\n\n          if (xhr.responseType == 'arraybuffer' || xhr.responseType == 'blob')\n            result = xhr.response\n          else {\n            result = xhr.responseText\n\n            try {\n              // http://perfectionkills.com/global-eval-what-are-the-options/\n              // sanitize response accordingly if data filter callback provided\n              result = ajaxDataFilter(result, dataType, settings)\n              if (dataType == 'script')    (1,eval)(result)\n              else if (dataType == 'xml')  result = xhr.responseXML\n              else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result)\n            } catch (e) { error = e }\n\n            if (error) return ajaxError(error, 'parsererror', xhr, settings, deferred)\n          }\n\n          ajaxSuccess(result, xhr, settings, deferred)\n        } else {\n          ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred)\n        }\n      }\n    }\n\n    if (ajaxBeforeSend(xhr, settings) === false) {\n      xhr.abort()\n      ajaxError(null, 'abort', xhr, settings, deferred)\n      return xhr\n    }\n\n    var async = 'async' in settings ? settings.async : true\n    xhr.open(settings.type, settings.url, async, settings.username, settings.password)\n\n    if (settings.xhrFields) for (name in settings.xhrFields) xhr[name] = settings.xhrFields[name]\n\n    for (name in headers) nativeSetHeader.apply(xhr, headers[name])\n\n    if (settings.timeout > 0) abortTimeout = setTimeout(function(){\n        xhr.onreadystatechange = empty\n        xhr.abort()\n        ajaxError(null, 'timeout', xhr, settings, deferred)\n      }, settings.timeout)\n\n    // avoid sending empty string (#319)\n    xhr.send(settings.data ? settings.data : null)\n    return xhr\n  }\n\n  // handle optional data/success arguments\n  function parseArguments(url, data, success, dataType) {\n    if ($.isFunction(data)) dataType = success, success = data, data = undefined\n    if (!$.isFunction(success)) dataType = success, success = undefined\n    return {\n      url: url\n    , data: data\n    , success: success\n    , dataType: dataType\n    }\n  }\n\n  $.get = function(/* url, data, success, dataType */){\n    return $.ajax(parseArguments.apply(null, arguments))\n  }\n\n  $.post = function(/* url, data, success, dataType */){\n    var options = parseArguments.apply(null, arguments)\n    options.type = 'POST'\n    return $.ajax(options)\n  }\n\n  $.getJSON = function(/* url, data, success */){\n    var options = parseArguments.apply(null, arguments)\n    options.dataType = 'json'\n    return $.ajax(options)\n  }\n\n  $.fn.load = function(url, data, success){\n    if (!this.length) return this\n    var self = this, parts = url.split(/\\s/), selector,\n        options = parseArguments(url, data, success),\n        callback = options.success\n    if (parts.length > 1) options.url = parts[0], selector = parts[1]\n    options.success = function(response){\n      self.html(selector ?\n        $('<div>').html(response.replace(rscript, \"\")).find(selector)\n        : response)\n      callback && callback.apply(self, arguments)\n    }\n    $.ajax(options)\n    return this\n  }\n\n  var escape = encodeURIComponent\n\n  function serialize(params, obj, traditional, scope){\n    var type, array = $.isArray(obj), hash = $.isPlainObject(obj)\n    $.each(obj, function(key, value) {\n      type = $.type(value)\n      if (scope) key = traditional ? scope :\n        scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'\n      // handle data in serializeArray() format\n      if (!scope && array) params.add(value.name, value.value)\n      // recurse into nested objects\n      else if (type == \"array\" || (!traditional && type == \"object\"))\n        serialize(params, value, traditional, key)\n      else params.add(key, value)\n    })\n  }\n\n  $.param = function(obj, traditional){\n    var params = []\n    params.add = function(key, value) {\n      if ($.isFunction(value)) value = value()\n      if (value == null) value = \"\"\n      this.push(escape(key) + '=' + escape(value))\n    }\n    serialize(params, obj, traditional)\n    return params.join('&').replace(/%20/g, '+')\n  }\n})(Zepto)\n\n;(function($){\n  $.fn.serializeArray = function() {\n    var name, type, result = [],\n      add = function(value) {\n        if (value.forEach) return value.forEach(add)\n        result.push({ name: name, value: value })\n      }\n    if (this[0]) $.each(this[0].elements, function(_, field){\n      type = field.type, name = field.name\n      if (name && field.nodeName.toLowerCase() != 'fieldset' &&\n        !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&\n        ((type != 'radio' && type != 'checkbox') || field.checked))\n          add($(field).val())\n    })\n    return result\n  }\n\n  $.fn.serialize = function(){\n    var result = []\n    this.serializeArray().forEach(function(elm){\n      result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))\n    })\n    return result.join('&')\n  }\n\n  $.fn.submit = function(callback) {\n    if (0 in arguments) this.bind('submit', callback)\n    else if (this.length) {\n      var event = $.Event('submit')\n      this.eq(0).trigger(event)\n      if (!event.isDefaultPrevented()) this.get(0).submit()\n    }\n    return this\n  }\n\n})(Zepto)\n\n;(function(){\n  // getComputedStyle shouldn't freak out when called\n  // without a valid element as argument\n  try {\n    getComputedStyle(undefined)\n  } catch(e) {\n    var nativeGetComputedStyle = getComputedStyle\n    window.getComputedStyle = function(element, pseudoElement){\n      try {\n        return nativeGetComputedStyle(element, pseudoElement)\n      } catch(e) {\n        return null\n      }\n    }\n  }\n})()\n  return Zepto\n}))\n\n}.call(window));","module.exports = global[\"moment\"] = require(\"-!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\expose-loader\\\\index.js?dayjs!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\babel-loader\\\\lib\\\\index.js??ref--5!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\source-map-loader\\\\index.js!.\\\\dayjs.min.js\");","module.exports = global[\"dayjs\"] = require(\"-!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\babel-loader\\\\lib\\\\index.js??ref--5!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\source-map-loader\\\\index.js!.\\\\dayjs.min.js\");","!function(t,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=n():\"function\"==typeof define&&define.amd?define(n):t.dayjs=n()}(this,function(){\"use strict\";var t=\"millisecond\",n=\"second\",e=\"minute\",r=\"hour\",i=\"day\",s=\"week\",u=\"month\",o=\"quarter\",a=\"year\",h=/^(\\d{4})-?(\\d{1,2})-?(\\d{0,2})[^0-9]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?.?(\\d{1,3})?$/,f=/\\[([^\\]]+)]|Y{2,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,c=function(t,n,e){var r=String(t);return!r||r.length>=n?t:\"\"+Array(n+1-r.length).join(e)+t},d={s:c,z:function(t){var n=-t.utcOffset(),e=Math.abs(n),r=Math.floor(e/60),i=e%60;return(n<=0?\"+\":\"-\")+c(r,2,\"0\")+\":\"+c(i,2,\"0\")},m:function(t,n){var e=12*(n.year()-t.year())+(n.month()-t.month()),r=t.clone().add(e,u),i=n-r<0,s=t.clone().add(e+(i?-1:1),u);return Number(-(e+(n-r)/(i?r-s:s-r))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(h){return{M:u,y:a,w:s,d:i,D:\"date\",h:r,m:e,s:n,ms:t,Q:o}[h]||String(h||\"\").toLowerCase().replace(/s$/,\"\")},u:function(t){return void 0===t}},$={name:\"en\",weekdays:\"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday\".split(\"_\"),months:\"January_February_March_April_May_June_July_August_September_October_November_December\".split(\"_\")},l=\"en\",m={};m[l]=$;var y=function(t){return t instanceof v},M=function(t,n,e){var r;if(!t)return l;if(\"string\"==typeof t)m[t]&&(r=t),n&&(m[t]=n,r=t);else{var i=t.name;m[i]=t,r=i}return!e&&r&&(l=r),r||!e&&l},g=function(t,n,e){if(y(t))return t.clone();var r=n?\"string\"==typeof n?{format:n,pl:e}:n:{};return r.date=t,new v(r)},D=d;D.l=M,D.i=y,D.w=function(t,n){return g(t,{locale:n.$L,utc:n.$u,$offset:n.$offset})};var v=function(){function c(t){this.$L=this.$L||M(t.locale,null,!0),this.parse(t)}var d=c.prototype;return d.parse=function(t){this.$d=function(t){var n=t.date,e=t.utc;if(null===n)return new Date(NaN);if(D.u(n))return new Date;if(n instanceof Date)return new Date(n);if(\"string\"==typeof n&&!/Z$/i.test(n)){var r=n.match(h);if(r)return e?new Date(Date.UTC(r[1],r[2]-1,r[3]||1,r[4]||0,r[5]||0,r[6]||0,r[7]||0)):new Date(r[1],r[2]-1,r[3]||1,r[4]||0,r[5]||0,r[6]||0,r[7]||0)}return new Date(n)}(t),this.init()},d.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},d.$utils=function(){return D},d.isValid=function(){return!(\"Invalid Date\"===this.$d.toString())},d.isSame=function(t,n){var e=g(t);return this.startOf(n)<=e&&e<=this.endOf(n)},d.isAfter=function(t,n){return g(t)<this.startOf(n)},d.isBefore=function(t,n){return this.endOf(n)<g(t)},d.$g=function(t,n,e){return D.u(t)?this[n]:this.set(e,t)},d.year=function(t){return this.$g(t,\"$y\",a)},d.month=function(t){return this.$g(t,\"$M\",u)},d.day=function(t){return this.$g(t,\"$W\",i)},d.date=function(t){return this.$g(t,\"$D\",\"date\")},d.hour=function(t){return this.$g(t,\"$H\",r)},d.minute=function(t){return this.$g(t,\"$m\",e)},d.second=function(t){return this.$g(t,\"$s\",n)},d.millisecond=function(n){return this.$g(n,\"$ms\",t)},d.unix=function(){return Math.floor(this.valueOf()/1e3)},d.valueOf=function(){return this.$d.getTime()},d.startOf=function(t,o){var h=this,f=!!D.u(o)||o,c=D.p(t),d=function(t,n){var e=D.w(h.$u?Date.UTC(h.$y,n,t):new Date(h.$y,n,t),h);return f?e:e.endOf(i)},$=function(t,n){return D.w(h.toDate()[t].apply(h.toDate(),(f?[0,0,0,0]:[23,59,59,999]).slice(n)),h)},l=this.$W,m=this.$M,y=this.$D,M=\"set\"+(this.$u?\"UTC\":\"\");switch(c){case a:return f?d(1,0):d(31,11);case u:return f?d(1,m):d(0,m+1);case s:var g=this.$locale().weekStart||0,v=(l<g?l+7:l)-g;return d(f?y-v:y+(6-v),m);case i:case\"date\":return $(M+\"Hours\",0);case r:return $(M+\"Minutes\",1);case e:return $(M+\"Seconds\",2);case n:return $(M+\"Milliseconds\",3);default:return this.clone()}},d.endOf=function(t){return this.startOf(t,!1)},d.$set=function(s,o){var h,f=D.p(s),c=\"set\"+(this.$u?\"UTC\":\"\"),d=(h={},h[i]=c+\"Date\",h.date=c+\"Date\",h[u]=c+\"Month\",h[a]=c+\"FullYear\",h[r]=c+\"Hours\",h[e]=c+\"Minutes\",h[n]=c+\"Seconds\",h[t]=c+\"Milliseconds\",h)[f],$=f===i?this.$D+(o-this.$W):o;if(f===u||f===a){var l=this.clone().set(\"date\",1);l.$d[d]($),l.init(),this.$d=l.set(\"date\",Math.min(this.$D,l.daysInMonth())).toDate()}else d&&this.$d[d]($);return this.init(),this},d.set=function(t,n){return this.clone().$set(t,n)},d.get=function(t){return this[D.p(t)]()},d.add=function(t,o){var h,f=this;t=Number(t);var c=D.p(o),d=function(n){var e=g(f);return D.w(e.date(e.date()+Math.round(n*t)),f)};if(c===u)return this.set(u,this.$M+t);if(c===a)return this.set(a,this.$y+t);if(c===i)return d(1);if(c===s)return d(7);var $=(h={},h[e]=6e4,h[r]=36e5,h[n]=1e3,h)[c]||1,l=this.$d.getTime()+t*$;return D.w(l,this)},d.subtract=function(t,n){return this.add(-1*t,n)},d.format=function(t){var n=this;if(!this.isValid())return\"Invalid Date\";var e=t||\"YYYY-MM-DDTHH:mm:ssZ\",r=D.z(this),i=this.$locale(),s=this.$H,u=this.$m,o=this.$M,a=i.weekdays,h=i.months,c=function(t,r,i,s){return t&&(t[r]||t(n,e))||i[r].substr(0,s)},d=function(t){return D.s(s%12||12,t,\"0\")},$=i.meridiem||function(t,n,e){var r=t<12?\"AM\":\"PM\";return e?r.toLowerCase():r},l={YY:String(this.$y).slice(-2),YYYY:this.$y,M:o+1,MM:D.s(o+1,2,\"0\"),MMM:c(i.monthsShort,o,h,3),MMMM:h[o]||h(this,e),D:this.$D,DD:D.s(this.$D,2,\"0\"),d:String(this.$W),dd:c(i.weekdaysMin,this.$W,a,2),ddd:c(i.weekdaysShort,this.$W,a,3),dddd:a[this.$W],H:String(s),HH:D.s(s,2,\"0\"),h:d(1),hh:d(2),a:$(s,u,!0),A:$(s,u,!1),m:String(u),mm:D.s(u,2,\"0\"),s:String(this.$s),ss:D.s(this.$s,2,\"0\"),SSS:D.s(this.$ms,3,\"0\"),Z:r};return e.replace(f,function(t,n){return n||l[t]||r.replace(\":\",\"\")})},d.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},d.diff=function(t,h,f){var c,d=D.p(h),$=g(t),l=6e4*($.utcOffset()-this.utcOffset()),m=this-$,y=D.m(this,$);return y=(c={},c[a]=y/12,c[u]=y,c[o]=y/3,c[s]=(m-l)/6048e5,c[i]=(m-l)/864e5,c[r]=m/36e5,c[e]=m/6e4,c[n]=m/1e3,c)[d]||m,f?y:D.a(y)},d.daysInMonth=function(){return this.endOf(u).$D},d.$locale=function(){return m[this.$L]},d.locale=function(t,n){if(!t)return this.$L;var e=this.clone(),r=M(t,n,!0);return r&&(e.$L=r),e},d.clone=function(){return D.w(this.$d,this)},d.toDate=function(){return new Date(this.valueOf())},d.toJSON=function(){return this.isValid()?this.toISOString():null},d.toISOString=function(){return this.$d.toISOString()},d.toString=function(){return this.$d.toUTCString()},c}();return g.prototype=v.prototype,g.extend=function(t,n){return t(n,v,g),g},g.locale=M,g.isDayjs=y,g.unix=function(t){return g(1e3*t)},g.en=m[l],g.Ls=m,g});\n","module.exports = global[\"m\"] = require(\"-!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\babel-loader\\\\lib\\\\index.js??ref--5!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\source-map-loader\\\\index.js!.\\\\index.js\");","\"use strict\"\n\nvar hyperscript = require(\"./hyperscript\")\nvar request = require(\"./request\")\nvar mountRedraw = require(\"./mount-redraw\")\n\nvar m = function m() { return hyperscript.apply(this, arguments) }\nm.m = hyperscript\nm.trust = hyperscript.trust\nm.fragment = hyperscript.fragment\nm.mount = mountRedraw.mount\nm.route = require(\"./route\")\nm.render = require(\"./render\")\nm.redraw = mountRedraw.redraw\nm.request = request.request\nm.jsonp = request.jsonp\nm.parseQueryString = require(\"./querystring/parse\")\nm.buildQueryString = require(\"./querystring/build\")\nm.parsePathname = require(\"./pathname/parse\")\nm.buildPathname = require(\"./pathname/build\")\nm.vnode = require(\"./render/vnode\")\nm.PromisePolyfill = require(\"./promise/polyfill\")\n\nmodule.exports = m\n","\"use strict\"\n\nvar hyperscript = require(\"./render/hyperscript\")\n\nhyperscript.trust = require(\"./render/trust\")\nhyperscript.fragment = require(\"./render/fragment\")\n\nmodule.exports = hyperscript\n","\"use strict\"\n\nvar Vnode = require(\"../render/vnode\")\n\nmodule.exports = function(html) {\n\tif (html == null) html = \"\"\n\treturn Vnode(\"<\", undefined, undefined, html, undefined, undefined)\n}\n","\"use strict\"\n\nvar Vnode = require(\"../render/vnode\")\nvar hyperscriptVnode = require(\"./hyperscriptVnode\")\n\nmodule.exports = function() {\n\tvar vnode = hyperscriptVnode.apply(0, arguments)\n\n\tvnode.tag = \"[\"\n\tvnode.children = Vnode.normalizeChildren(vnode.children)\n\treturn vnode\n}\n","\"use strict\"\n\nvar PromisePolyfill = require(\"./promise/promise\")\nvar mountRedraw = require(\"./mount-redraw\")\n\nmodule.exports = require(\"./request/request\")(window, PromisePolyfill, mountRedraw.redraw)\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","\"use strict\"\n\nvar Vnode = require(\"../render/vnode\")\n\nmodule.exports = function($window) {\n\tvar $doc = $window && $window.document\n\tvar currentRedraw\n\n\tvar nameSpace = {\n\t\tsvg: \"http://www.w3.org/2000/svg\",\n\t\tmath: \"http://www.w3.org/1998/Math/MathML\"\n\t}\n\n\tfunction getNameSpace(vnode) {\n\t\treturn vnode.attrs && vnode.attrs.xmlns || nameSpace[vnode.tag]\n\t}\n\n\t//sanity check to discourage people from doing `vnode.state = ...`\n\tfunction checkState(vnode, original) {\n\t\tif (vnode.state !== original) throw new Error(\"`vnode.state` must not be modified\")\n\t}\n\n\t//Note: the hook is passed as the `this` argument to allow proxying the\n\t//arguments without requiring a full array allocation to do so. It also\n\t//takes advantage of the fact the current `vnode` is the first argument in\n\t//all lifecycle methods.\n\tfunction callHook(vnode) {\n\t\tvar original = vnode.state\n\t\ttry {\n\t\t\treturn this.apply(original, arguments)\n\t\t} finally {\n\t\t\tcheckState(vnode, original)\n\t\t}\n\t}\n\n\t// IE11 (at least) throws an UnspecifiedError when accessing document.activeElement when\n\t// inside an iframe. Catch and swallow this error, and heavy-handidly return null.\n\tfunction activeElement() {\n\t\ttry {\n\t\t\treturn $doc.activeElement\n\t\t} catch (e) {\n\t\t\treturn null\n\t\t}\n\t}\n\t//create\n\tfunction createNodes(parent, vnodes, start, end, hooks, nextSibling, ns) {\n\t\tfor (var i = start; i < end; i++) {\n\t\t\tvar vnode = vnodes[i]\n\t\t\tif (vnode != null) {\n\t\t\t\tcreateNode(parent, vnode, hooks, ns, nextSibling)\n\t\t\t}\n\t\t}\n\t}\n\tfunction createNode(parent, vnode, hooks, ns, nextSibling) {\n\t\tvar tag = vnode.tag\n\t\tif (typeof tag === \"string\") {\n\t\t\tvnode.state = {}\n\t\t\tif (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks)\n\t\t\tswitch (tag) {\n\t\t\t\tcase \"#\": createText(parent, vnode, nextSibling); break\n\t\t\t\tcase \"<\": createHTML(parent, vnode, ns, nextSibling); break\n\t\t\t\tcase \"[\": createFragment(parent, vnode, hooks, ns, nextSibling); break\n\t\t\t\tdefault: createElement(parent, vnode, hooks, ns, nextSibling)\n\t\t\t}\n\t\t}\n\t\telse createComponent(parent, vnode, hooks, ns, nextSibling)\n\t}\n\tfunction createText(parent, vnode, nextSibling) {\n\t\tvnode.dom = $doc.createTextNode(vnode.children)\n\t\tinsertNode(parent, vnode.dom, nextSibling)\n\t}\n\tvar possibleParents = {caption: \"table\", thead: \"table\", tbody: \"table\", tfoot: \"table\", tr: \"tbody\", th: \"tr\", td: \"tr\", colgroup: \"table\", col: \"colgroup\"}\n\tfunction createHTML(parent, vnode, ns, nextSibling) {\n\t\tvar match = vnode.children.match(/^\\s*?<(\\w+)/im) || []\n\t\t// not using the proper parent makes the child element(s) vanish.\n\t\t//     var div = document.createElement(\"div\")\n\t\t//     div.innerHTML = \"<td>i</td><td>j</td>\"\n\t\t//     console.log(div.innerHTML)\n\t\t// --> \"ij\", no <td> in sight.\n\t\tvar temp = $doc.createElement(possibleParents[match[1]] || \"div\")\n\t\tif (ns === \"http://www.w3.org/2000/svg\") {\n\t\t\ttemp.innerHTML = \"<svg xmlns=\\\"http://www.w3.org/2000/svg\\\">\" + vnode.children + \"</svg>\"\n\t\t\ttemp = temp.firstChild\n\t\t} else {\n\t\t\ttemp.innerHTML = vnode.children\n\t\t}\n\t\tvnode.dom = temp.firstChild\n\t\tvnode.domSize = temp.childNodes.length\n\t\t// Capture nodes to remove, so we don't confuse them.\n\t\tvnode.instance = []\n\t\tvar fragment = $doc.createDocumentFragment()\n\t\tvar child\n\t\twhile (child = temp.firstChild) {\n\t\t\tvnode.instance.push(child)\n\t\t\tfragment.appendChild(child)\n\t\t}\n\t\tinsertNode(parent, fragment, nextSibling)\n\t}\n\tfunction createFragment(parent, vnode, hooks, ns, nextSibling) {\n\t\tvar fragment = $doc.createDocumentFragment()\n\t\tif (vnode.children != null) {\n\t\t\tvar children = vnode.children\n\t\t\tcreateNodes(fragment, children, 0, children.length, hooks, null, ns)\n\t\t}\n\t\tvnode.dom = fragment.firstChild\n\t\tvnode.domSize = fragment.childNodes.length\n\t\tinsertNode(parent, fragment, nextSibling)\n\t}\n\tfunction createElement(parent, vnode, hooks, ns, nextSibling) {\n\t\tvar tag = vnode.tag\n\t\tvar attrs = vnode.attrs\n\t\tvar is = attrs && attrs.is\n\n\t\tns = getNameSpace(vnode) || ns\n\n\t\tvar element = ns ?\n\t\t\tis ? $doc.createElementNS(ns, tag, {is: is}) : $doc.createElementNS(ns, tag) :\n\t\t\tis ? $doc.createElement(tag, {is: is}) : $doc.createElement(tag)\n\t\tvnode.dom = element\n\n\t\tif (attrs != null) {\n\t\t\tsetAttrs(vnode, attrs, ns)\n\t\t}\n\n\t\tinsertNode(parent, element, nextSibling)\n\n\t\tif (!maybeSetContentEditable(vnode)) {\n\t\t\tif (vnode.text != null) {\n\t\t\t\tif (vnode.text !== \"\") element.textContent = vnode.text\n\t\t\t\telse vnode.children = [Vnode(\"#\", undefined, undefined, vnode.text, undefined, undefined)]\n\t\t\t}\n\t\t\tif (vnode.children != null) {\n\t\t\t\tvar children = vnode.children\n\t\t\t\tcreateNodes(element, children, 0, children.length, hooks, null, ns)\n\t\t\t\tif (vnode.tag === \"select\" && attrs != null) setLateSelectAttrs(vnode, attrs)\n\t\t\t}\n\t\t}\n\t}\n\tfunction initComponent(vnode, hooks) {\n\t\tvar sentinel\n\t\tif (typeof vnode.tag.view === \"function\") {\n\t\t\tvnode.state = Object.create(vnode.tag)\n\t\t\tsentinel = vnode.state.view\n\t\t\tif (sentinel.$$reentrantLock$$ != null) return\n\t\t\tsentinel.$$reentrantLock$$ = true\n\t\t} else {\n\t\t\tvnode.state = void 0\n\t\t\tsentinel = vnode.tag\n\t\t\tif (sentinel.$$reentrantLock$$ != null) return\n\t\t\tsentinel.$$reentrantLock$$ = true\n\t\t\tvnode.state = (vnode.tag.prototype != null && typeof vnode.tag.prototype.view === \"function\") ? new vnode.tag(vnode) : vnode.tag(vnode)\n\t\t}\n\t\tinitLifecycle(vnode.state, vnode, hooks)\n\t\tif (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks)\n\t\tvnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))\n\t\tif (vnode.instance === vnode) throw Error(\"A view cannot return the vnode it received as argument\")\n\t\tsentinel.$$reentrantLock$$ = null\n\t}\n\tfunction createComponent(parent, vnode, hooks, ns, nextSibling) {\n\t\tinitComponent(vnode, hooks)\n\t\tif (vnode.instance != null) {\n\t\t\tcreateNode(parent, vnode.instance, hooks, ns, nextSibling)\n\t\t\tvnode.dom = vnode.instance.dom\n\t\t\tvnode.domSize = vnode.dom != null ? vnode.instance.domSize : 0\n\t\t}\n\t\telse {\n\t\t\tvnode.domSize = 0\n\t\t}\n\t}\n\n\t//update\n\t/**\n\t * @param {Element|Fragment} parent - the parent element\n\t * @param {Vnode[] | null} old - the list of vnodes of the last `render()` call for\n\t *                               this part of the tree\n\t * @param {Vnode[] | null} vnodes - as above, but for the current `render()` call.\n\t * @param {Function[]} hooks - an accumulator of post-render hooks (oncreate/onupdate)\n\t * @param {Element | null} nextSibling - the next DOM node if we're dealing with a\n\t *                                       fragment that is not the last item in its\n\t *                                       parent\n\t * @param {'svg' | 'math' | String | null} ns) - the current XML namespace, if any\n\t * @returns void\n\t */\n\t// This function diffs and patches lists of vnodes, both keyed and unkeyed.\n\t//\n\t// We will:\n\t//\n\t// 1. describe its general structure\n\t// 2. focus on the diff algorithm optimizations\n\t// 3. discuss DOM node operations.\n\n\t// ## Overview:\n\t//\n\t// The updateNodes() function:\n\t// - deals with trivial cases\n\t// - determines whether the lists are keyed or unkeyed based on the first non-null node\n\t//   of each list.\n\t// - diffs them and patches the DOM if needed (that's the brunt of the code)\n\t// - manages the leftovers: after diffing, are there:\n\t//   - old nodes left to remove?\n\t// \t - new nodes to insert?\n\t// \t deal with them!\n\t//\n\t// The lists are only iterated over once, with an exception for the nodes in `old` that\n\t// are visited in the fourth part of the diff and in the `removeNodes` loop.\n\n\t// ## Diffing\n\t//\n\t// Reading https://github.com/localvoid/ivi/blob/ddc09d06abaef45248e6133f7040d00d3c6be853/packages/ivi/src/vdom/implementation.ts#L617-L837\n\t// may be good for context on longest increasing subsequence-based logic for moving nodes.\n\t//\n\t// In order to diff keyed lists, one has to\n\t//\n\t// 1) match nodes in both lists, per key, and update them accordingly\n\t// 2) create the nodes present in the new list, but absent in the old one\n\t// 3) remove the nodes present in the old list, but absent in the new one\n\t// 4) figure out what nodes in 1) to move in order to minimize the DOM operations.\n\t//\n\t// To achieve 1) one can create a dictionary of keys => index (for the old list), then iterate\n\t// over the new list and for each new vnode, find the corresponding vnode in the old list using\n\t// the map.\n\t// 2) is achieved in the same step: if a new node has no corresponding entry in the map, it is new\n\t// and must be created.\n\t// For the removals, we actually remove the nodes that have been updated from the old list.\n\t// The nodes that remain in that list after 1) and 2) have been performed can be safely removed.\n\t// The fourth step is a bit more complex and relies on the longest increasing subsequence (LIS)\n\t// algorithm.\n\t//\n\t// the longest increasing subsequence is the list of nodes that can remain in place. Imagine going\n\t// from `1,2,3,4,5` to `4,5,1,2,3` where the numbers are not necessarily the keys, but the indices\n\t// corresponding to the keyed nodes in the old list (keyed nodes `e,d,c,b,a` => `b,a,e,d,c` would\n\t//  match the above lists, for example).\n\t//\n\t// In there are two increasing subsequences: `4,5` and `1,2,3`, the latter being the longest. We\n\t// can update those nodes without moving them, and only call `insertNode` on `4` and `5`.\n\t//\n\t// @localvoid adapted the algo to also support node deletions and insertions (the `lis` is actually\n\t// the longest increasing subsequence *of old nodes still present in the new list*).\n\t//\n\t// It is a general algorithm that is fireproof in all circumstances, but it requires the allocation\n\t// and the construction of a `key => oldIndex` map, and three arrays (one with `newIndex => oldIndex`,\n\t// the `LIS` and a temporary one to create the LIS).\n\t//\n\t// So we cheat where we can: if the tails of the lists are identical, they are guaranteed to be part of\n\t// the LIS and can be updated without moving them.\n\t//\n\t// If two nodes are swapped, they are guaranteed not to be part of the LIS, and must be moved (with\n\t// the exception of the last node if the list is fully reversed).\n\t//\n\t// ## Finding the next sibling.\n\t//\n\t// `updateNode()` and `createNode()` expect a nextSibling parameter to perform DOM operations.\n\t// When the list is being traversed top-down, at any index, the DOM nodes up to the previous\n\t// vnode reflect the content of the new list, whereas the rest of the DOM nodes reflect the old\n\t// list. The next sibling must be looked for in the old list using `getNextSibling(... oldStart + 1 ...)`.\n\t//\n\t// In the other scenarios (swaps, upwards traversal, map-based diff),\n\t// the new vnodes list is traversed upwards. The DOM nodes at the bottom of the list reflect the\n\t// bottom part of the new vnodes list, and we can use the `v.dom`  value of the previous node\n\t// as the next sibling (cached in the `nextSibling` variable).\n\n\n\t// ## DOM node moves\n\t//\n\t// In most scenarios `updateNode()` and `createNode()` perform the DOM operations. However,\n\t// this is not the case if the node moved (second and fourth part of the diff algo). We move\n\t// the old DOM nodes before updateNode runs because it enables us to use the cached `nextSibling`\n\t// variable rather than fetching it using `getNextSibling()`.\n\t//\n\t// The fourth part of the diff currently inserts nodes unconditionally, leading to issues\n\t// like #1791 and #1999. We need to be smarter about those situations where adjascent old\n\t// nodes remain together in the new list in a way that isn't covered by parts one and\n\t// three of the diff algo.\n\n\tfunction updateNodes(parent, old, vnodes, hooks, nextSibling, ns) {\n\t\tif (old === vnodes || old == null && vnodes == null) return\n\t\telse if (old == null || old.length === 0) createNodes(parent, vnodes, 0, vnodes.length, hooks, nextSibling, ns)\n\t\telse if (vnodes == null || vnodes.length === 0) removeNodes(parent, old, 0, old.length)\n\t\telse {\n\t\t\tvar isOldKeyed = old[0] != null && old[0].key != null\n\t\t\tvar isKeyed = vnodes[0] != null && vnodes[0].key != null\n\t\t\tvar start = 0, oldStart = 0\n\t\t\tif (!isOldKeyed) while (oldStart < old.length && old[oldStart] == null) oldStart++\n\t\t\tif (!isKeyed) while (start < vnodes.length && vnodes[start] == null) start++\n\t\t\tif (isKeyed === null && isOldKeyed == null) return // both lists are full of nulls\n\t\t\tif (isOldKeyed !== isKeyed) {\n\t\t\t\tremoveNodes(parent, old, oldStart, old.length)\n\t\t\t\tcreateNodes(parent, vnodes, start, vnodes.length, hooks, nextSibling, ns)\n\t\t\t} else if (!isKeyed) {\n\t\t\t\t// Don't index past the end of either list (causes deopts).\n\t\t\t\tvar commonLength = old.length < vnodes.length ? old.length : vnodes.length\n\t\t\t\t// Rewind if necessary to the first non-null index on either side.\n\t\t\t\t// We could alternatively either explicitly create or remove nodes when `start !== oldStart`\n\t\t\t\t// but that would be optimizing for sparse lists which are more rare than dense ones.\n\t\t\t\tstart = start < oldStart ? start : oldStart\n\t\t\t\tfor (; start < commonLength; start++) {\n\t\t\t\t\to = old[start]\n\t\t\t\t\tv = vnodes[start]\n\t\t\t\t\tif (o === v || o == null && v == null) continue\n\t\t\t\t\telse if (o == null) createNode(parent, v, hooks, ns, getNextSibling(old, start + 1, nextSibling))\n\t\t\t\t\telse if (v == null) removeNode(parent, o)\n\t\t\t\t\telse updateNode(parent, o, v, hooks, getNextSibling(old, start + 1, nextSibling), ns)\n\t\t\t\t}\n\t\t\t\tif (old.length > commonLength) removeNodes(parent, old, start, old.length)\n\t\t\t\tif (vnodes.length > commonLength) createNodes(parent, vnodes, start, vnodes.length, hooks, nextSibling, ns)\n\t\t\t} else {\n\t\t\t\t// keyed diff\n\t\t\t\tvar oldEnd = old.length - 1, end = vnodes.length - 1, map, o, v, oe, ve, topSibling\n\n\t\t\t\t// bottom-up\n\t\t\t\twhile (oldEnd >= oldStart && end >= start) {\n\t\t\t\t\toe = old[oldEnd]\n\t\t\t\t\tve = vnodes[end]\n\t\t\t\t\tif (oe.key !== ve.key) break\n\t\t\t\t\tif (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns)\n\t\t\t\t\tif (ve.dom != null) nextSibling = ve.dom\n\t\t\t\t\toldEnd--, end--\n\t\t\t\t}\n\t\t\t\t// top-down\n\t\t\t\twhile (oldEnd >= oldStart && end >= start) {\n\t\t\t\t\to = old[oldStart]\n\t\t\t\t\tv = vnodes[start]\n\t\t\t\t\tif (o.key !== v.key) break\n\t\t\t\t\toldStart++, start++\n\t\t\t\t\tif (o !== v) updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, nextSibling), ns)\n\t\t\t\t}\n\t\t\t\t// swaps and list reversals\n\t\t\t\twhile (oldEnd >= oldStart && end >= start) {\n\t\t\t\t\tif (start === end) break\n\t\t\t\t\tif (o.key !== ve.key || oe.key !== v.key) break\n\t\t\t\t\ttopSibling = getNextSibling(old, oldStart, nextSibling)\n\t\t\t\t\tmoveNodes(parent, oe, topSibling)\n\t\t\t\t\tif (oe !== v) updateNode(parent, oe, v, hooks, topSibling, ns)\n\t\t\t\t\tif (++start <= --end) moveNodes(parent, o, nextSibling)\n\t\t\t\t\tif (o !== ve) updateNode(parent, o, ve, hooks, nextSibling, ns)\n\t\t\t\t\tif (ve.dom != null) nextSibling = ve.dom\n\t\t\t\t\toldStart++; oldEnd--\n\t\t\t\t\toe = old[oldEnd]\n\t\t\t\t\tve = vnodes[end]\n\t\t\t\t\to = old[oldStart]\n\t\t\t\t\tv = vnodes[start]\n\t\t\t\t}\n\t\t\t\t// bottom up once again\n\t\t\t\twhile (oldEnd >= oldStart && end >= start) {\n\t\t\t\t\tif (oe.key !== ve.key) break\n\t\t\t\t\tif (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns)\n\t\t\t\t\tif (ve.dom != null) nextSibling = ve.dom\n\t\t\t\t\toldEnd--, end--\n\t\t\t\t\toe = old[oldEnd]\n\t\t\t\t\tve = vnodes[end]\n\t\t\t\t}\n\t\t\t\tif (start > end) removeNodes(parent, old, oldStart, oldEnd + 1)\n\t\t\t\telse if (oldStart > oldEnd) createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns)\n\t\t\t\telse {\n\t\t\t\t\t// inspired by ivi https://github.com/ivijs/ivi/ by Boris Kaul\n\t\t\t\t\tvar originalNextSibling = nextSibling, vnodesLength = end - start + 1, oldIndices = new Array(vnodesLength), li=0, i=0, pos = 2147483647, matched = 0, map, lisIndices\n\t\t\t\t\tfor (i = 0; i < vnodesLength; i++) oldIndices[i] = -1\n\t\t\t\t\tfor (i = end; i >= start; i--) {\n\t\t\t\t\t\tif (map == null) map = getKeyMap(old, oldStart, oldEnd + 1)\n\t\t\t\t\t\tve = vnodes[i]\n\t\t\t\t\t\tvar oldIndex = map[ve.key]\n\t\t\t\t\t\tif (oldIndex != null) {\n\t\t\t\t\t\t\tpos = (oldIndex < pos) ? oldIndex : -1 // becomes -1 if nodes were re-ordered\n\t\t\t\t\t\t\toldIndices[i-start] = oldIndex\n\t\t\t\t\t\t\toe = old[oldIndex]\n\t\t\t\t\t\t\told[oldIndex] = null\n\t\t\t\t\t\t\tif (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns)\n\t\t\t\t\t\t\tif (ve.dom != null) nextSibling = ve.dom\n\t\t\t\t\t\t\tmatched++\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tnextSibling = originalNextSibling\n\t\t\t\t\tif (matched !== oldEnd - oldStart + 1) removeNodes(parent, old, oldStart, oldEnd + 1)\n\t\t\t\t\tif (matched === 0) createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns)\n\t\t\t\t\telse {\n\t\t\t\t\t\tif (pos === -1) {\n\t\t\t\t\t\t\t// the indices of the indices of the items that are part of the\n\t\t\t\t\t\t\t// longest increasing subsequence in the oldIndices list\n\t\t\t\t\t\t\tlisIndices = makeLisIndices(oldIndices)\n\t\t\t\t\t\t\tli = lisIndices.length - 1\n\t\t\t\t\t\t\tfor (i = end; i >= start; i--) {\n\t\t\t\t\t\t\t\tv = vnodes[i]\n\t\t\t\t\t\t\t\tif (oldIndices[i-start] === -1) createNode(parent, v, hooks, ns, nextSibling)\n\t\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\t\tif (lisIndices[li] === i - start) li--\n\t\t\t\t\t\t\t\t\telse moveNodes(parent, v, nextSibling)\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif (v.dom != null) nextSibling = vnodes[i].dom\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tfor (i = end; i >= start; i--) {\n\t\t\t\t\t\t\t\tv = vnodes[i]\n\t\t\t\t\t\t\t\tif (oldIndices[i-start] === -1) createNode(parent, v, hooks, ns, nextSibling)\n\t\t\t\t\t\t\t\tif (v.dom != null) nextSibling = vnodes[i].dom\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tfunction updateNode(parent, old, vnode, hooks, nextSibling, ns) {\n\t\tvar oldTag = old.tag, tag = vnode.tag\n\t\tif (oldTag === tag) {\n\t\t\tvnode.state = old.state\n\t\t\tvnode.events = old.events\n\t\t\tif (shouldNotUpdate(vnode, old)) return\n\t\t\tif (typeof oldTag === \"string\") {\n\t\t\t\tif (vnode.attrs != null) {\n\t\t\t\t\tupdateLifecycle(vnode.attrs, vnode, hooks)\n\t\t\t\t}\n\t\t\t\tswitch (oldTag) {\n\t\t\t\t\tcase \"#\": updateText(old, vnode); break\n\t\t\t\t\tcase \"<\": updateHTML(parent, old, vnode, ns, nextSibling); break\n\t\t\t\t\tcase \"[\": updateFragment(parent, old, vnode, hooks, nextSibling, ns); break\n\t\t\t\t\tdefault: updateElement(old, vnode, hooks, ns)\n\t\t\t\t}\n\t\t\t}\n\t\t\telse updateComponent(parent, old, vnode, hooks, nextSibling, ns)\n\t\t}\n\t\telse {\n\t\t\tremoveNode(parent, old)\n\t\t\tcreateNode(parent, vnode, hooks, ns, nextSibling)\n\t\t}\n\t}\n\tfunction updateText(old, vnode) {\n\t\tif (old.children.toString() !== vnode.children.toString()) {\n\t\t\told.dom.nodeValue = vnode.children\n\t\t}\n\t\tvnode.dom = old.dom\n\t}\n\tfunction updateHTML(parent, old, vnode, ns, nextSibling) {\n\t\tif (old.children !== vnode.children) {\n\t\t\tremoveHTML(parent, old)\n\t\t\tcreateHTML(parent, vnode, ns, nextSibling)\n\t\t}\n\t\telse {\n\t\t\tvnode.dom = old.dom\n\t\t\tvnode.domSize = old.domSize\n\t\t\tvnode.instance = old.instance\n\t\t}\n\t}\n\tfunction updateFragment(parent, old, vnode, hooks, nextSibling, ns) {\n\t\tupdateNodes(parent, old.children, vnode.children, hooks, nextSibling, ns)\n\t\tvar domSize = 0, children = vnode.children\n\t\tvnode.dom = null\n\t\tif (children != null) {\n\t\t\tfor (var i = 0; i < children.length; i++) {\n\t\t\t\tvar child = children[i]\n\t\t\t\tif (child != null && child.dom != null) {\n\t\t\t\t\tif (vnode.dom == null) vnode.dom = child.dom\n\t\t\t\t\tdomSize += child.domSize || 1\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (domSize !== 1) vnode.domSize = domSize\n\t\t}\n\t}\n\tfunction updateElement(old, vnode, hooks, ns) {\n\t\tvar element = vnode.dom = old.dom\n\t\tns = getNameSpace(vnode) || ns\n\n\t\tif (vnode.tag === \"textarea\") {\n\t\t\tif (vnode.attrs == null) vnode.attrs = {}\n\t\t\tif (vnode.text != null) {\n\t\t\t\tvnode.attrs.value = vnode.text //FIXME handle multiple children\n\t\t\t\tvnode.text = undefined\n\t\t\t}\n\t\t}\n\t\tupdateAttrs(vnode, old.attrs, vnode.attrs, ns)\n\t\tif (!maybeSetContentEditable(vnode)) {\n\t\t\tif (old.text != null && vnode.text != null && vnode.text !== \"\") {\n\t\t\t\tif (old.text.toString() !== vnode.text.toString()) old.dom.firstChild.nodeValue = vnode.text\n\t\t\t}\n\t\t\telse {\n\t\t\t\tif (old.text != null) old.children = [Vnode(\"#\", undefined, undefined, old.text, undefined, old.dom.firstChild)]\n\t\t\t\tif (vnode.text != null) vnode.children = [Vnode(\"#\", undefined, undefined, vnode.text, undefined, undefined)]\n\t\t\t\tupdateNodes(element, old.children, vnode.children, hooks, null, ns)\n\t\t\t}\n\t\t}\n\t}\n\tfunction updateComponent(parent, old, vnode, hooks, nextSibling, ns) {\n\t\tvnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))\n\t\tif (vnode.instance === vnode) throw Error(\"A view cannot return the vnode it received as argument\")\n\t\tupdateLifecycle(vnode.state, vnode, hooks)\n\t\tif (vnode.attrs != null) updateLifecycle(vnode.attrs, vnode, hooks)\n\t\tif (vnode.instance != null) {\n\t\t\tif (old.instance == null) createNode(parent, vnode.instance, hooks, ns, nextSibling)\n\t\t\telse updateNode(parent, old.instance, vnode.instance, hooks, nextSibling, ns)\n\t\t\tvnode.dom = vnode.instance.dom\n\t\t\tvnode.domSize = vnode.instance.domSize\n\t\t}\n\t\telse if (old.instance != null) {\n\t\t\tremoveNode(parent, old.instance)\n\t\t\tvnode.dom = undefined\n\t\t\tvnode.domSize = 0\n\t\t}\n\t\telse {\n\t\t\tvnode.dom = old.dom\n\t\t\tvnode.domSize = old.domSize\n\t\t}\n\t}\n\tfunction getKeyMap(vnodes, start, end) {\n\t\tvar map = Object.create(null)\n\t\tfor (; start < end; start++) {\n\t\t\tvar vnode = vnodes[start]\n\t\t\tif (vnode != null) {\n\t\t\t\tvar key = vnode.key\n\t\t\t\tif (key != null) map[key] = start\n\t\t\t}\n\t\t}\n\t\treturn map\n\t}\n\t// Lifted from ivi https://github.com/ivijs/ivi/\n\t// takes a list of unique numbers (-1 is special and can\n\t// occur multiple times) and returns an array with the indices\n\t// of the items that are part of the longest increasing\n\t// subsequece\n\tvar lisTemp = []\n\tfunction makeLisIndices(a) {\n\t\tvar result = [0]\n\t\tvar u = 0, v = 0, i = 0\n\t\tvar il = lisTemp.length = a.length\n\t\tfor (var i = 0; i < il; i++) lisTemp[i] = a[i]\n\t\tfor (var i = 0; i < il; ++i) {\n\t\t\tif (a[i] === -1) continue\n\t\t\tvar j = result[result.length - 1]\n\t\t\tif (a[j] < a[i]) {\n\t\t\t\tlisTemp[i] = j\n\t\t\t\tresult.push(i)\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tu = 0\n\t\t\tv = result.length - 1\n\t\t\twhile (u < v) {\n\t\t\t\t// Fast integer average without overflow.\n\t\t\t\t// eslint-disable-next-line no-bitwise\n\t\t\t\tvar c = (u >>> 1) + (v >>> 1) + (u & v & 1)\n\t\t\t\tif (a[result[c]] < a[i]) {\n\t\t\t\t\tu = c + 1\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tv = c\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (a[i] < a[result[u]]) {\n\t\t\t\tif (u > 0) lisTemp[i] = result[u - 1]\n\t\t\t\tresult[u] = i\n\t\t\t}\n\t\t}\n\t\tu = result.length\n\t\tv = result[u - 1]\n\t\twhile (u-- > 0) {\n\t\t\tresult[u] = v\n\t\t\tv = lisTemp[v]\n\t\t}\n\t\tlisTemp.length = 0\n\t\treturn result\n\t}\n\n\tfunction getNextSibling(vnodes, i, nextSibling) {\n\t\tfor (; i < vnodes.length; i++) {\n\t\t\tif (vnodes[i] != null && vnodes[i].dom != null) return vnodes[i].dom\n\t\t}\n\t\treturn nextSibling\n\t}\n\n\t// This covers a really specific edge case:\n\t// - Parent node is keyed and contains child\n\t// - Child is removed, returns unresolved promise in `onbeforeremove`\n\t// - Parent node is moved in keyed diff\n\t// - Remaining children still need moved appropriately\n\t//\n\t// Ideally, I'd track removed nodes as well, but that introduces a lot more\n\t// complexity and I'm not exactly interested in doing that.\n\tfunction moveNodes(parent, vnode, nextSibling) {\n\t\tvar frag = $doc.createDocumentFragment()\n\t\tmoveChildToFrag(parent, frag, vnode)\n\t\tinsertNode(parent, frag, nextSibling)\n\t}\n\tfunction moveChildToFrag(parent, frag, vnode) {\n\t\t// Dodge the recursion overhead in a few of the most common cases.\n\t\twhile (vnode.dom != null && vnode.dom.parentNode === parent) {\n\t\t\tif (typeof vnode.tag !== \"string\") {\n\t\t\t\tvnode = vnode.instance\n\t\t\t\tif (vnode != null) continue\n\t\t\t} else if (vnode.tag === \"<\") {\n\t\t\t\tfor (var i = 0; i < vnode.instance.length; i++) {\n\t\t\t\t\tfrag.appendChild(vnode.instance[i])\n\t\t\t\t}\n\t\t\t} else if (vnode.tag !== \"[\") {\n\t\t\t\t// Don't recurse for text nodes *or* elements, just fragments\n\t\t\t\tfrag.appendChild(vnode.dom)\n\t\t\t} else if (vnode.children.length === 1) {\n\t\t\t\tvnode = vnode.children[0]\n\t\t\t\tif (vnode != null) continue\n\t\t\t} else {\n\t\t\t\tfor (var i = 0; i < vnode.children.length; i++) {\n\t\t\t\t\tvar child = vnode.children[i]\n\t\t\t\t\tif (child != null) moveChildToFrag(parent, frag, child)\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\t}\n\n\tfunction insertNode(parent, dom, nextSibling) {\n\t\tif (nextSibling != null) parent.insertBefore(dom, nextSibling)\n\t\telse parent.appendChild(dom)\n\t}\n\n\tfunction maybeSetContentEditable(vnode) {\n\t\tif (vnode.attrs == null || (\n\t\t\tvnode.attrs.contenteditable == null && // attribute\n\t\t\tvnode.attrs.contentEditable == null // property\n\t\t)) return false\n\t\tvar children = vnode.children\n\t\tif (children != null && children.length === 1 && children[0].tag === \"<\") {\n\t\t\tvar content = children[0].children\n\t\t\tif (vnode.dom.innerHTML !== content) vnode.dom.innerHTML = content\n\t\t}\n\t\telse if (vnode.text != null || children != null && children.length !== 0) throw new Error(\"Child node of a contenteditable must be trusted\")\n\t\treturn true\n\t}\n\n\t//remove\n\tfunction removeNodes(parent, vnodes, start, end) {\n\t\tfor (var i = start; i < end; i++) {\n\t\t\tvar vnode = vnodes[i]\n\t\t\tif (vnode != null) removeNode(parent, vnode)\n\t\t}\n\t}\n\tfunction removeNode(parent, vnode) {\n\t\tvar mask = 0\n\t\tvar original = vnode.state\n\t\tvar stateResult, attrsResult\n\t\tif (typeof vnode.tag !== \"string\" && typeof vnode.state.onbeforeremove === \"function\") {\n\t\t\tvar result = callHook.call(vnode.state.onbeforeremove, vnode)\n\t\t\tif (result != null && typeof result.then === \"function\") {\n\t\t\t\tmask = 1\n\t\t\t\tstateResult = result\n\t\t\t}\n\t\t}\n\t\tif (vnode.attrs && typeof vnode.attrs.onbeforeremove === \"function\") {\n\t\t\tvar result = callHook.call(vnode.attrs.onbeforeremove, vnode)\n\t\t\tif (result != null && typeof result.then === \"function\") {\n\t\t\t\t// eslint-disable-next-line no-bitwise\n\t\t\t\tmask |= 2\n\t\t\t\tattrsResult = result\n\t\t\t}\n\t\t}\n\t\tcheckState(vnode, original)\n\n\t\t// If we can, try to fast-path it and avoid all the overhead of awaiting\n\t\tif (!mask) {\n\t\t\tonremove(vnode)\n\t\t\tremoveChild(parent, vnode)\n\t\t} else {\n\t\t\tif (stateResult != null) {\n\t\t\t\tvar next = function () {\n\t\t\t\t\t// eslint-disable-next-line no-bitwise\n\t\t\t\t\tif (mask & 1) { mask &= 2; if (!mask) reallyRemove() }\n\t\t\t\t}\n\t\t\t\tstateResult.then(next, next)\n\t\t\t}\n\t\t\tif (attrsResult != null) {\n\t\t\t\tvar next = function () {\n\t\t\t\t\t// eslint-disable-next-line no-bitwise\n\t\t\t\t\tif (mask & 2) { mask &= 1; if (!mask) reallyRemove() }\n\t\t\t\t}\n\t\t\t\tattrsResult.then(next, next)\n\t\t\t}\n\t\t}\n\n\t\tfunction reallyRemove() {\n\t\t\tcheckState(vnode, original)\n\t\t\tonremove(vnode)\n\t\t\tremoveChild(parent, vnode)\n\t\t}\n\t}\n\tfunction removeHTML(parent, vnode) {\n\t\tfor (var i = 0; i < vnode.instance.length; i++) {\n\t\t\tparent.removeChild(vnode.instance[i])\n\t\t}\n\t}\n\tfunction removeChild(parent, vnode) {\n\t\t// Dodge the recursion overhead in a few of the most common cases.\n\t\twhile (vnode.dom != null && vnode.dom.parentNode === parent) {\n\t\t\tif (typeof vnode.tag !== \"string\") {\n\t\t\t\tvnode = vnode.instance\n\t\t\t\tif (vnode != null) continue\n\t\t\t} else if (vnode.tag === \"<\") {\n\t\t\t\tremoveHTML(parent, vnode)\n\t\t\t} else {\n\t\t\t\tif (vnode.tag !== \"[\") {\n\t\t\t\t\tparent.removeChild(vnode.dom)\n\t\t\t\t\tif (!Array.isArray(vnode.children)) break\n\t\t\t\t}\n\t\t\t\tif (vnode.children.length === 1) {\n\t\t\t\t\tvnode = vnode.children[0]\n\t\t\t\t\tif (vnode != null) continue\n\t\t\t\t} else {\n\t\t\t\t\tfor (var i = 0; i < vnode.children.length; i++) {\n\t\t\t\t\t\tvar child = vnode.children[i]\n\t\t\t\t\t\tif (child != null) removeChild(parent, child)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\t}\n\tfunction onremove(vnode) {\n\t\tif (typeof vnode.tag !== \"string\" && typeof vnode.state.onremove === \"function\") callHook.call(vnode.state.onremove, vnode)\n\t\tif (vnode.attrs && typeof vnode.attrs.onremove === \"function\") callHook.call(vnode.attrs.onremove, vnode)\n\t\tif (typeof vnode.tag !== \"string\") {\n\t\t\tif (vnode.instance != null) onremove(vnode.instance)\n\t\t} else {\n\t\t\tvar children = vnode.children\n\t\t\tif (Array.isArray(children)) {\n\t\t\t\tfor (var i = 0; i < children.length; i++) {\n\t\t\t\t\tvar child = children[i]\n\t\t\t\t\tif (child != null) onremove(child)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t//attrs\n\tfunction setAttrs(vnode, attrs, ns) {\n\t\tfor (var key in attrs) {\n\t\t\tsetAttr(vnode, key, null, attrs[key], ns)\n\t\t}\n\t}\n\tfunction setAttr(vnode, key, old, value, ns) {\n\t\tif (key === \"key\" || key === \"is\" || value == null || isLifecycleMethod(key) || (old === value && !isFormAttribute(vnode, key)) && typeof value !== \"object\") return\n\t\tif (key[0] === \"o\" && key[1] === \"n\") return updateEvent(vnode, key, value)\n\t\tif (key.slice(0, 6) === \"xlink:\") vnode.dom.setAttributeNS(\"http://www.w3.org/1999/xlink\", key.slice(6), value)\n\t\telse if (key === \"style\") updateStyle(vnode.dom, old, value)\n\t\telse if (hasPropertyKey(vnode, key, ns)) {\n\t\t\tif (key === \"value\") {\n\t\t\t\t// Only do the coercion if we're actually going to check the value.\n\t\t\t\t/* eslint-disable no-implicit-coercion */\n\t\t\t\t//setting input[value] to same value by typing on focused element moves cursor to end in Chrome\n\t\t\t\tif ((vnode.tag === \"input\" || vnode.tag === \"textarea\") && vnode.dom.value === \"\" + value && vnode.dom === activeElement()) return\n\t\t\t\t//setting select[value] to same value while having select open blinks select dropdown in Chrome\n\t\t\t\tif (vnode.tag === \"select\" && old !== null && vnode.dom.value === \"\" + value) return\n\t\t\t\t//setting option[value] to same value while having select open blinks select dropdown in Chrome\n\t\t\t\tif (vnode.tag === \"option\" && old !== null && vnode.dom.value === \"\" + value) return\n\t\t\t\t/* eslint-enable no-implicit-coercion */\n\t\t\t}\n\t\t\t// If you assign an input type that is not supported by IE 11 with an assignment expression, an error will occur.\n\t\t\tif (vnode.tag === \"input\" && key === \"type\") vnode.dom.setAttribute(key, value)\n\t\t\telse vnode.dom[key] = value\n\t\t} else {\n\t\t\tif (typeof value === \"boolean\") {\n\t\t\t\tif (value) vnode.dom.setAttribute(key, \"\")\n\t\t\t\telse vnode.dom.removeAttribute(key)\n\t\t\t}\n\t\t\telse vnode.dom.setAttribute(key === \"className\" ? \"class\" : key, value)\n\t\t}\n\t}\n\tfunction removeAttr(vnode, key, old, ns) {\n\t\tif (key === \"key\" || key === \"is\" || old == null || isLifecycleMethod(key)) return\n\t\tif (key[0] === \"o\" && key[1] === \"n\" && !isLifecycleMethod(key)) updateEvent(vnode, key, undefined)\n\t\telse if (key === \"style\") updateStyle(vnode.dom, old, null)\n\t\telse if (\n\t\t\thasPropertyKey(vnode, key, ns)\n\t\t\t&& key !== \"className\"\n\t\t\t&& !(key === \"value\" && (\n\t\t\t\tvnode.tag === \"option\"\n\t\t\t\t|| vnode.tag === \"select\" && vnode.dom.selectedIndex === -1 && vnode.dom === activeElement()\n\t\t\t))\n\t\t\t&& !(vnode.tag === \"input\" && key === \"type\")\n\t\t) {\n\t\t\tvnode.dom[key] = null\n\t\t} else {\n\t\t\tvar nsLastIndex = key.indexOf(\":\")\n\t\t\tif (nsLastIndex !== -1) key = key.slice(nsLastIndex + 1)\n\t\t\tif (old !== false) vnode.dom.removeAttribute(key === \"className\" ? \"class\" : key)\n\t\t}\n\t}\n\tfunction setLateSelectAttrs(vnode, attrs) {\n\t\tif (\"value\" in attrs) {\n\t\t\tif(attrs.value === null) {\n\t\t\t\tif (vnode.dom.selectedIndex !== -1) vnode.dom.value = null\n\t\t\t} else {\n\t\t\t\tvar normalized = \"\" + attrs.value // eslint-disable-line no-implicit-coercion\n\t\t\t\tif (vnode.dom.value !== normalized || vnode.dom.selectedIndex === -1) {\n\t\t\t\t\tvnode.dom.value = normalized\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (\"selectedIndex\" in attrs) setAttr(vnode, \"selectedIndex\", null, attrs.selectedIndex, undefined)\n\t}\n\tfunction updateAttrs(vnode, old, attrs, ns) {\n\t\tif (attrs != null) {\n\t\t\tfor (var key in attrs) {\n\t\t\t\tsetAttr(vnode, key, old && old[key], attrs[key], ns)\n\t\t\t}\n\t\t}\n\t\tvar val\n\t\tif (old != null) {\n\t\t\tfor (var key in old) {\n\t\t\t\tif (((val = old[key]) != null) && (attrs == null || attrs[key] == null)) {\n\t\t\t\t\tremoveAttr(vnode, key, val, ns)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tfunction isFormAttribute(vnode, attr) {\n\t\treturn attr === \"value\" || attr === \"checked\" || attr === \"selectedIndex\" || attr === \"selected\" && vnode.dom === activeElement() || vnode.tag === \"option\" && vnode.dom.parentNode === $doc.activeElement\n\t}\n\tfunction isLifecycleMethod(attr) {\n\t\treturn attr === \"oninit\" || attr === \"oncreate\" || attr === \"onupdate\" || attr === \"onremove\" || attr === \"onbeforeremove\" || attr === \"onbeforeupdate\"\n\t}\n\tfunction hasPropertyKey(vnode, key, ns) {\n\t\t// Filter out namespaced keys\n\t\treturn ns === undefined && (\n\t\t\t// If it's a custom element, just keep it.\n\t\t\tvnode.tag.indexOf(\"-\") > -1 || vnode.attrs != null && vnode.attrs.is ||\n\t\t\t// If it's a normal element, let's try to avoid a few browser bugs.\n\t\t\tkey !== \"href\" && key !== \"list\" && key !== \"form\" && key !== \"width\" && key !== \"height\"// && key !== \"type\"\n\t\t\t// Defer the property check until *after* we check everything.\n\t\t) && key in vnode.dom\n\t}\n\n\t//style\n\tvar uppercaseRegex = /[A-Z]/g\n\tfunction toLowerCase(capital) { return \"-\" + capital.toLowerCase() }\n\tfunction normalizeKey(key) {\n\t\treturn key[0] === \"-\" && key[1] === \"-\" ? key :\n\t\t\tkey === \"cssFloat\" ? \"float\" :\n\t\t\t\tkey.replace(uppercaseRegex, toLowerCase)\n\t}\n\tfunction updateStyle(element, old, style) {\n\t\tif (old === style) {\n\t\t\t// Styles are equivalent, do nothing.\n\t\t} else if (style == null) {\n\t\t\t// New style is missing, just clear it.\n\t\t\telement.style.cssText = \"\"\n\t\t} else if (typeof style !== \"object\") {\n\t\t\t// New style is a string, let engine deal with patching.\n\t\t\telement.style.cssText = style\n\t\t} else if (old == null || typeof old !== \"object\") {\n\t\t\t// `old` is missing or a string, `style` is an object.\n\t\t\telement.style.cssText = \"\"\n\t\t\t// Add new style properties\n\t\t\tfor (var key in style) {\n\t\t\t\tvar value = style[key]\n\t\t\t\tif (value != null) element.style.setProperty(normalizeKey(key), String(value))\n\t\t\t}\n\t\t} else {\n\t\t\t// Both old & new are (different) objects.\n\t\t\t// Update style properties that have changed\n\t\t\tfor (var key in style) {\n\t\t\t\tvar value = style[key]\n\t\t\t\tif (value != null && (value = String(value)) !== String(old[key])) {\n\t\t\t\t\telement.style.setProperty(normalizeKey(key), value)\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Remove style properties that no longer exist\n\t\t\tfor (var key in old) {\n\t\t\t\tif (old[key] != null && style[key] == null) {\n\t\t\t\t\telement.style.removeProperty(normalizeKey(key))\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Here's an explanation of how this works:\n\t// 1. The event names are always (by design) prefixed by `on`.\n\t// 2. The EventListener interface accepts either a function or an object\n\t//    with a `handleEvent` method.\n\t// 3. The object does not inherit from `Object.prototype`, to avoid\n\t//    any potential interference with that (e.g. setters).\n\t// 4. The event name is remapped to the handler before calling it.\n\t// 5. In function-based event handlers, `ev.target === this`. We replicate\n\t//    that below.\n\t// 6. In function-based event handlers, `return false` prevents the default\n\t//    action and stops event propagation. We replicate that below.\n\tfunction EventDict() {\n\t\t// Save this, so the current redraw is correctly tracked.\n\t\tthis._ = currentRedraw\n\t}\n\tEventDict.prototype = Object.create(null)\n\tEventDict.prototype.handleEvent = function (ev) {\n\t\tvar handler = this[\"on\" + ev.type]\n\t\tvar result\n\t\tif (typeof handler === \"function\") result = handler.call(ev.currentTarget, ev)\n\t\telse if (typeof handler.handleEvent === \"function\") handler.handleEvent(ev)\n\t\tif (this._ && ev.redraw !== false) (0, this._)()\n\t\tif (result === false) {\n\t\t\tev.preventDefault()\n\t\t\tev.stopPropagation()\n\t\t}\n\t}\n\n\t//event\n\tfunction updateEvent(vnode, key, value) {\n\t\tif (vnode.events != null) {\n\t\t\tif (vnode.events[key] === value) return\n\t\t\tif (value != null && (typeof value === \"function\" || typeof value === \"object\")) {\n\t\t\t\tif (vnode.events[key] == null) vnode.dom.addEventListener(key.slice(2), vnode.events, false)\n\t\t\t\tvnode.events[key] = value\n\t\t\t} else {\n\t\t\t\tif (vnode.events[key] != null) vnode.dom.removeEventListener(key.slice(2), vnode.events, false)\n\t\t\t\tvnode.events[key] = undefined\n\t\t\t}\n\t\t} else if (value != null && (typeof value === \"function\" || typeof value === \"object\")) {\n\t\t\tvnode.events = new EventDict()\n\t\t\tvnode.dom.addEventListener(key.slice(2), vnode.events, false)\n\t\t\tvnode.events[key] = value\n\t\t}\n\t}\n\n\t//lifecycle\n\tfunction initLifecycle(source, vnode, hooks) {\n\t\tif (typeof source.oninit === \"function\") callHook.call(source.oninit, vnode)\n\t\tif (typeof source.oncreate === \"function\") hooks.push(callHook.bind(source.oncreate, vnode))\n\t}\n\tfunction updateLifecycle(source, vnode, hooks) {\n\t\tif (typeof source.onupdate === \"function\") hooks.push(callHook.bind(source.onupdate, vnode))\n\t}\n\tfunction shouldNotUpdate(vnode, old) {\n\t\tdo {\n\t\t\tif (vnode.attrs != null && typeof vnode.attrs.onbeforeupdate === \"function\") {\n\t\t\t\tvar force = callHook.call(vnode.attrs.onbeforeupdate, vnode, old)\n\t\t\t\tif (force !== undefined && !force) break\n\t\t\t}\n\t\t\tif (typeof vnode.tag !== \"string\" && typeof vnode.state.onbeforeupdate === \"function\") {\n\t\t\t\tvar force = callHook.call(vnode.state.onbeforeupdate, vnode, old)\n\t\t\t\tif (force !== undefined && !force) break\n\t\t\t}\n\t\t\treturn false\n\t\t} while (false); // eslint-disable-line no-constant-condition\n\t\tvnode.dom = old.dom\n\t\tvnode.domSize = old.domSize\n\t\tvnode.instance = old.instance\n\t\t// One would think having the actual latest attributes would be ideal,\n\t\t// but it doesn't let us properly diff based on our current internal\n\t\t// representation. We have to save not only the old DOM info, but also\n\t\t// the attributes used to create it, as we diff *that*, not against the\n\t\t// DOM directly (with a few exceptions in `setAttr`). And, of course, we\n\t\t// need to save the children and text as they are conceptually not\n\t\t// unlike special \"attributes\" internally.\n\t\tvnode.attrs = old.attrs\n\t\tvnode.children = old.children\n\t\tvnode.text = old.text\n\t\treturn true\n\t}\n\n\treturn function(dom, vnodes, redraw) {\n\t\tif (!dom) throw new TypeError(\"Ensure the DOM element being passed to m.route/m.mount/m.render is not undefined.\")\n\t\tvar hooks = []\n\t\tvar active = activeElement()\n\t\tvar namespace = dom.namespaceURI\n\n\t\t// First time rendering into a node clears it out\n\t\tif (dom.vnodes == null) dom.textContent = \"\"\n\n\t\tvnodes = Vnode.normalizeChildren(Array.isArray(vnodes) ? vnodes : [vnodes])\n\t\tvar prevRedraw = currentRedraw\n\t\ttry {\n\t\t\tcurrentRedraw = typeof redraw === \"function\" ? redraw : undefined\n\t\t\tupdateNodes(dom, dom.vnodes, vnodes, hooks, null, namespace === \"http://www.w3.org/1999/xhtml\" ? undefined : namespace)\n\t\t} finally {\n\t\t\tcurrentRedraw = prevRedraw\n\t\t}\n\t\tdom.vnodes = vnodes\n\t\t// `document.activeElement` can return null: https://html.spec.whatwg.org/multipage/interaction.html#dom-document-activeelement\n\t\tif (active != null && activeElement() !== active && typeof active.focus === \"function\") active.focus()\n\t\tfor (var i = 0; i < hooks.length; i++) hooks[i]()\n\t}\n}\n","\"use strict\"\n\nvar Vnode = require(\"../render/vnode\")\n\nmodule.exports = function(render, schedule, console) {\n\tvar subscriptions = []\n\tvar rendering = false\n\tvar pending = false\n\n\tfunction sync() {\n\t\tif (rendering) throw new Error(\"Nested m.redraw.sync() call\")\n\t\trendering = true\n\t\tfor (var i = 0; i < subscriptions.length; i += 2) {\n\t\t\ttry { render(subscriptions[i], Vnode(subscriptions[i + 1]), redraw) }\n\t\t\tcatch (e) { console.error(e) }\n\t\t}\n\t\trendering = false\n\t}\n\n\tfunction redraw() {\n\t\tif (!pending) {\n\t\t\tpending = true\n\t\t\tschedule(function() {\n\t\t\t\tpending = false\n\t\t\t\tsync()\n\t\t\t})\n\t\t}\n\t}\n\n\tredraw.sync = sync\n\n\tfunction mount(root, component) {\n\t\tif (component != null && component.view == null && typeof component !== \"function\") {\n\t\t\tthrow new TypeError(\"m.mount(element, component) expects a component, not a vnode\")\n\t\t}\n\n\t\tvar index = subscriptions.indexOf(root)\n\t\tif (index >= 0) {\n\t\t\tsubscriptions.splice(index, 2)\n\t\t\trender(root, [], redraw)\n\t\t}\n\n\t\tif (component != null) {\n\t\t\tsubscriptions.push(root, component)\n\t\t\trender(root, Vnode(component), redraw)\n\t\t}\n\t}\n\n\treturn {mount: mount, redraw: redraw}\n}\n","\"use strict\"\n\nvar buildPathname = require(\"../pathname/build\")\n\nmodule.exports = function($window, Promise, oncompletion) {\n\tvar callbackCount = 0\n\n\tfunction PromiseProxy(executor) {\n\t\treturn new Promise(executor)\n\t}\n\n\t// In case the global Promise is some userland library's where they rely on\n\t// `foo instanceof this.constructor`, `this.constructor.resolve(value)`, or\n\t// similar. Let's *not* break them.\n\tPromiseProxy.prototype = Promise.prototype\n\tPromiseProxy.__proto__ = Promise // eslint-disable-line no-proto\n\n\tfunction makeRequest(factory) {\n\t\treturn function(url, args) {\n\t\t\tif (typeof url !== \"string\") { args = url; url = url.url }\n\t\t\telse if (args == null) args = {}\n\t\t\tvar promise = new Promise(function(resolve, reject) {\n\t\t\t\tfactory(buildPathname(url, args.params), args, function (data) {\n\t\t\t\t\tif (typeof args.type === \"function\") {\n\t\t\t\t\t\tif (Array.isArray(data)) {\n\t\t\t\t\t\t\tfor (var i = 0; i < data.length; i++) {\n\t\t\t\t\t\t\t\tdata[i] = new args.type(data[i])\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse data = new args.type(data)\n\t\t\t\t\t}\n\t\t\t\t\tresolve(data)\n\t\t\t\t}, reject)\n\t\t\t})\n\t\t\tif (args.background === true) return promise\n\t\t\tvar count = 0\n\t\t\tfunction complete() {\n\t\t\t\tif (--count === 0 && typeof oncompletion === \"function\") oncompletion()\n\t\t\t}\n\n\t\t\treturn wrap(promise)\n\n\t\t\tfunction wrap(promise) {\n\t\t\t\tvar then = promise.then\n\t\t\t\t// Set the constructor, so engines know to not await or resolve\n\t\t\t\t// this as a native promise. At the time of writing, this is\n\t\t\t\t// only necessary for V8, but their behavior is the correct\n\t\t\t\t// behavior per spec. See this spec issue for more details:\n\t\t\t\t// https://github.com/tc39/ecma262/issues/1577. Also, see the\n\t\t\t\t// corresponding comment in `request/tests/test-request.js` for\n\t\t\t\t// a bit more background on the issue at hand.\n\t\t\t\tpromise.constructor = PromiseProxy\n\t\t\t\tpromise.then = function() {\n\t\t\t\t\tcount++\n\t\t\t\t\tvar next = then.apply(promise, arguments)\n\t\t\t\t\tnext.then(complete, function(e) {\n\t\t\t\t\t\tcomplete()\n\t\t\t\t\t\tif (count === 0) throw e\n\t\t\t\t\t})\n\t\t\t\t\treturn wrap(next)\n\t\t\t\t}\n\t\t\t\treturn promise\n\t\t\t}\n\t\t}\n\t}\n\n\tfunction hasHeader(args, name) {\n\t\tfor (var key in args.headers) {\n\t\t\tif ({}.hasOwnProperty.call(args.headers, key) && name.test(key)) return true\n\t\t}\n\t\treturn false\n\t}\n\n\treturn {\n\t\trequest: makeRequest(function(url, args, resolve, reject) {\n\t\t\tvar method = args.method != null ? args.method.toUpperCase() : \"GET\"\n\t\t\tvar body = args.body\n\t\t\tvar assumeJSON = (args.serialize == null || args.serialize === JSON.serialize) && !(body instanceof $window.FormData)\n\t\t\tvar responseType = args.responseType || (typeof args.extract === \"function\" ? \"\" : \"json\")\n\n\t\t\tvar xhr = new $window.XMLHttpRequest(), aborted = false\n\t\t\tvar original = xhr, replacedAbort\n\t\t\tvar abort = xhr.abort\n\n\t\t\txhr.abort = function() {\n\t\t\t\taborted = true\n\t\t\t\tabort.call(this)\n\t\t\t}\n\n\t\t\txhr.open(method, url, args.async !== false, typeof args.user === \"string\" ? args.user : undefined, typeof args.password === \"string\" ? args.password : undefined)\n\n\t\t\tif (assumeJSON && body != null && !hasHeader(args, /^content-type$/i)) {\n\t\t\t\txhr.setRequestHeader(\"Content-Type\", \"application/json; charset=utf-8\")\n\t\t\t}\n\t\t\tif (typeof args.deserialize !== \"function\" && !hasHeader(args, /^accept$/i)) {\n\t\t\t\txhr.setRequestHeader(\"Accept\", \"application/json, text/*\")\n\t\t\t}\n\t\t\tif (args.withCredentials) xhr.withCredentials = args.withCredentials\n\t\t\tif (args.timeout) xhr.timeout = args.timeout\n\t\t\txhr.responseType = responseType\n\n\t\t\tfor (var key in args.headers) {\n\t\t\t\tif ({}.hasOwnProperty.call(args.headers, key)) {\n\t\t\t\t\txhr.setRequestHeader(key, args.headers[key])\n\t\t\t\t}\n\t\t\t}\n\n\t\t\txhr.onreadystatechange = function(ev) {\n\t\t\t\t// Don't throw errors on xhr.abort().\n\t\t\t\tif (aborted) return\n\n\t\t\t\tif (ev.target.readyState === 4) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tvar success = (ev.target.status >= 200 && ev.target.status < 300) || ev.target.status === 304 || (/^file:\\/\\//i).test(url)\n\t\t\t\t\t\t// When the response type isn't \"\" or \"text\",\n\t\t\t\t\t\t// `xhr.responseText` is the wrong thing to use.\n\t\t\t\t\t\t// Browsers do the right thing and throw here, and we\n\t\t\t\t\t\t// should honor that and do the right thing by\n\t\t\t\t\t\t// preferring `xhr.response` where possible/practical.\n\t\t\t\t\t\tvar response = ev.target.response, message\n\n\t\t\t\t\t\tif (responseType === \"json\") {\n\t\t\t\t\t\t\t// For IE and Edge, which don't implement\n\t\t\t\t\t\t\t// `responseType: \"json\"`.\n\t\t\t\t\t\t\tif (!ev.target.responseType && typeof args.extract !== \"function\") response = JSON.parse(ev.target.responseText)\n\t\t\t\t\t\t} else if (!responseType || responseType === \"text\") {\n\t\t\t\t\t\t\t// Only use this default if it's text. If a parsed\n\t\t\t\t\t\t\t// document is needed on old IE and friends (all\n\t\t\t\t\t\t\t// unsupported), the user should use a custom\n\t\t\t\t\t\t\t// `config` instead. They're already using this at\n\t\t\t\t\t\t\t// their own risk.\n\t\t\t\t\t\t\tif (response == null) response = ev.target.responseText\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (typeof args.extract === \"function\") {\n\t\t\t\t\t\t\tresponse = args.extract(ev.target, args)\n\t\t\t\t\t\t\tsuccess = true\n\t\t\t\t\t\t} else if (typeof args.deserialize === \"function\") {\n\t\t\t\t\t\t\tresponse = args.deserialize(response)\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (success) resolve(response)\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\ttry { message = ev.target.responseText }\n\t\t\t\t\t\t\tcatch (e) { message = response }\n\t\t\t\t\t\t\tvar error = new Error(message)\n\t\t\t\t\t\t\terror.code = ev.target.status\n\t\t\t\t\t\t\terror.response = response\n\t\t\t\t\t\t\treject(error)\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tcatch (e) {\n\t\t\t\t\t\treject(e)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (typeof args.config === \"function\") {\n\t\t\t\txhr = args.config(xhr, args, url) || xhr\n\n\t\t\t\t// Propagate the `abort` to any replacement XHR as well.\n\t\t\t\tif (xhr !== original) {\n\t\t\t\t\treplacedAbort = xhr.abort\n\t\t\t\t\txhr.abort = function() {\n\t\t\t\t\t\taborted = true\n\t\t\t\t\t\treplacedAbort.call(this)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (body == null) xhr.send()\n\t\t\telse if (typeof args.serialize === \"function\") xhr.send(args.serialize(body))\n\t\t\telse if (body instanceof $window.FormData) xhr.send(body)\n\t\t\telse xhr.send(JSON.stringify(body))\n\t\t}),\n\t\tjsonp: makeRequest(function(url, args, resolve, reject) {\n\t\t\tvar callbackName = args.callbackName || \"_mithril_\" + Math.round(Math.random() * 1e16) + \"_\" + callbackCount++\n\t\t\tvar script = $window.document.createElement(\"script\")\n\t\t\t$window[callbackName] = function(data) {\n\t\t\t\tdelete $window[callbackName]\n\t\t\t\tscript.parentNode.removeChild(script)\n\t\t\t\tresolve(data)\n\t\t\t}\n\t\t\tscript.onerror = function() {\n\t\t\t\tdelete $window[callbackName]\n\t\t\t\tscript.parentNode.removeChild(script)\n\t\t\t\treject(new Error(\"JSONP request failed\"))\n\t\t\t}\n\t\t\tscript.src = url + (url.indexOf(\"?\") < 0 ? \"?\" : \"&\") +\n\t\t\t\tencodeURIComponent(args.callbackKey || \"callback\") + \"=\" +\n\t\t\t\tencodeURIComponent(callbackName)\n\t\t\t$window.document.documentElement.appendChild(script)\n\t\t}),\n\t}\n}\n","\"use strict\"\n\nvar mountRedraw = require(\"./mount-redraw\")\n\nmodule.exports = require(\"./api/router\")(window, mountRedraw)\n","\"use strict\"\n\nvar Vnode = require(\"../render/vnode\")\nvar m = require(\"../render/hyperscript\")\nvar Promise = require(\"../promise/promise\")\n\nvar buildPathname = require(\"../pathname/build\")\nvar parsePathname = require(\"../pathname/parse\")\nvar compileTemplate = require(\"../pathname/compileTemplate\")\nvar assign = require(\"../pathname/assign\")\n\nvar sentinel = {}\n\nmodule.exports = function($window, mountRedraw) {\n\tvar fireAsync\n\n\tfunction setPath(path, data, options) {\n\t\tpath = buildPathname(path, data)\n\t\tif (fireAsync != null) {\n\t\t\tfireAsync()\n\t\t\tvar state = options ? options.state : null\n\t\t\tvar title = options ? options.title : null\n\t\t\tif (options && options.replace) $window.history.replaceState(state, title, route.prefix + path)\n\t\t\telse $window.history.pushState(state, title, route.prefix + path)\n\t\t}\n\t\telse {\n\t\t\t$window.location.href = route.prefix + path\n\t\t}\n\t}\n\n\tvar currentResolver = sentinel, component, attrs, currentPath, lastUpdate\n\n\tvar SKIP = route.SKIP = {}\n\n\tfunction route(root, defaultRoute, routes) {\n\t\tif (root == null) throw new Error(\"Ensure the DOM element that was passed to `m.route` is not undefined\")\n\t\t// 0 = start\n\t\t// 1 = init\n\t\t// 2 = ready\n\t\tvar state = 0\n\n\t\tvar compiled = Object.keys(routes).map(function(route) {\n\t\t\tif (route[0] !== \"/\") throw new SyntaxError(\"Routes must start with a `/`\")\n\t\t\tif ((/:([^\\/\\.-]+)(\\.{3})?:/).test(route)) {\n\t\t\t\tthrow new SyntaxError(\"Route parameter names must be separated with either `/`, `.`, or `-`\")\n\t\t\t}\n\t\t\treturn {\n\t\t\t\troute: route,\n\t\t\t\tcomponent: routes[route],\n\t\t\t\tcheck: compileTemplate(route),\n\t\t\t}\n\t\t})\n\t\tvar callAsync = typeof setImmediate === \"function\" ? setImmediate : setTimeout\n\t\tvar p = Promise.resolve()\n\t\tvar scheduled = false\n\t\tvar onremove\n\n\t\tfireAsync = null\n\n\t\tif (defaultRoute != null) {\n\t\t\tvar defaultData = parsePathname(defaultRoute)\n\n\t\t\tif (!compiled.some(function (i) { return i.check(defaultData) })) {\n\t\t\t\tthrow new ReferenceError(\"Default route doesn't match any known routes\")\n\t\t\t}\n\t\t}\n\n\t\tfunction resolveRoute() {\n\t\t\tscheduled = false\n\t\t\t// Consider the pathname holistically. The prefix might even be invalid,\n\t\t\t// but that's not our problem.\n\t\t\tvar prefix = $window.location.hash\n\t\t\tif (route.prefix[0] !== \"#\") {\n\t\t\t\tprefix = $window.location.search + prefix\n\t\t\t\tif (route.prefix[0] !== \"?\") {\n\t\t\t\t\tprefix = $window.location.pathname + prefix\n\t\t\t\t\tif (prefix[0] !== \"/\") prefix = \"/\" + prefix\n\t\t\t\t}\n\t\t\t}\n\t\t\t// This seemingly useless `.concat()` speeds up the tests quite a bit,\n\t\t\t// since the representation is consistently a relatively poorly\n\t\t\t// optimized cons string.\n\t\t\tvar path = prefix.concat()\n\t\t\t\t.replace(/(?:%[a-f89][a-f0-9])+/gim, decodeURIComponent)\n\t\t\t\t.slice(route.prefix.length)\n\t\t\tvar data = parsePathname(path)\n\n\t\t\tassign(data.params, $window.history.state)\n\n\t\t\tfunction fail() {\n\t\t\t\tif (path === defaultRoute) throw new Error(\"Could not resolve default route \" + defaultRoute)\n\t\t\t\tsetPath(defaultRoute, null, {replace: true})\n\t\t\t}\n\n\t\t\tloop(0)\n\t\t\tfunction loop(i) {\n\t\t\t\t// 0 = init\n\t\t\t\t// 1 = scheduled\n\t\t\t\t// 2 = done\n\t\t\t\tfor (; i < compiled.length; i++) {\n\t\t\t\t\tif (compiled[i].check(data)) {\n\t\t\t\t\t\tvar payload = compiled[i].component\n\t\t\t\t\t\tvar matchedRoute = compiled[i].route\n\t\t\t\t\t\tvar localComp = payload\n\t\t\t\t\t\tvar update = lastUpdate = function(comp) {\n\t\t\t\t\t\t\tif (update !== lastUpdate) return\n\t\t\t\t\t\t\tif (comp === SKIP) return loop(i + 1)\n\t\t\t\t\t\t\tcomponent = comp != null && (typeof comp.view === \"function\" || typeof comp === \"function\")? comp : \"div\"\n\t\t\t\t\t\t\tattrs = data.params, currentPath = path, lastUpdate = null\n\t\t\t\t\t\t\tcurrentResolver = payload.render ? payload : null\n\t\t\t\t\t\t\tif (state === 2) mountRedraw.redraw()\n\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\tstate = 2\n\t\t\t\t\t\t\t\tmountRedraw.redraw.sync()\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// There's no understating how much I *wish* I could\n\t\t\t\t\t\t// use `async`/`await` here...\n\t\t\t\t\t\tif (payload.view || typeof payload === \"function\") {\n\t\t\t\t\t\t\tpayload = {}\n\t\t\t\t\t\t\tupdate(localComp)\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if (payload.onmatch) {\n\t\t\t\t\t\t\tp.then(function () {\n\t\t\t\t\t\t\t\treturn payload.onmatch(data.params, path, matchedRoute)\n\t\t\t\t\t\t\t}).then(update, fail)\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse update(\"div\")\n\t\t\t\t\t\treturn\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfail()\n\t\t\t}\n\t\t}\n\n\t\t// Set it unconditionally so `m.route.set` and `m.route.Link` both work,\n\t\t// even if neither `pushState` nor `hashchange` are supported. It's\n\t\t// cleared if `hashchange` is used, since that makes it automatically\n\t\t// async.\n\t\tfireAsync = function() {\n\t\t\tif (!scheduled) {\n\t\t\t\tscheduled = true\n\t\t\t\tcallAsync(resolveRoute)\n\t\t\t}\n\t\t}\n\n\t\tif (typeof $window.history.pushState === \"function\") {\n\t\t\tonremove = function() {\n\t\t\t\t$window.removeEventListener(\"popstate\", fireAsync, false)\n\t\t\t}\n\t\t\t$window.addEventListener(\"popstate\", fireAsync, false)\n\t\t} else if (route.prefix[0] === \"#\") {\n\t\t\tfireAsync = null\n\t\t\tonremove = function() {\n\t\t\t\t$window.removeEventListener(\"hashchange\", resolveRoute, false)\n\t\t\t}\n\t\t\t$window.addEventListener(\"hashchange\", resolveRoute, false)\n\t\t}\n\n\t\treturn mountRedraw.mount(root, {\n\t\t\tonbeforeupdate: function() {\n\t\t\t\tstate = state ? 2 : 1\n\t\t\t\treturn !(!state || sentinel === currentResolver)\n\t\t\t},\n\t\t\toncreate: resolveRoute,\n\t\t\tonremove: onremove,\n\t\t\tview: function() {\n\t\t\t\tif (!state || sentinel === currentResolver) return\n\t\t\t\t// Wrap in a fragment to preserve existing key semantics\n\t\t\t\tvar vnode = [Vnode(component, attrs.key, attrs)]\n\t\t\t\tif (currentResolver) vnode = currentResolver.render(vnode[0])\n\t\t\t\treturn vnode\n\t\t\t},\n\t\t})\n\t}\n\troute.set = function(path, data, options) {\n\t\tif (lastUpdate != null) {\n\t\t\toptions = options || {}\n\t\t\toptions.replace = true\n\t\t}\n\t\tlastUpdate = null\n\t\tsetPath(path, data, options)\n\t}\n\troute.get = function() {return currentPath}\n\troute.prefix = \"#!\"\n\troute.Link = {\n\t\tview: function(vnode) {\n\t\t\tvar options = vnode.attrs.options\n\t\t\t// Remove these so they don't get overwritten\n\t\t\tvar attrs = {}, onclick, href\n\t\t\tassign(attrs, vnode.attrs)\n\t\t\t// The first two are internal, but the rest are magic attributes\n\t\t\t// that need censored to not screw up rendering.\n\t\t\tattrs.selector = attrs.options = attrs.key = attrs.oninit =\n\t\t\tattrs.oncreate = attrs.onbeforeupdate = attrs.onupdate =\n\t\t\tattrs.onbeforeremove = attrs.onremove = null\n\n\t\t\t// Do this now so we can get the most current `href` and `disabled`.\n\t\t\t// Those attributes may also be specified in the selector, and we\n\t\t\t// should honor that.\n\t\t\tvar child = m(vnode.attrs.selector || \"a\", attrs, vnode.children)\n\n\t\t\t// Let's provide a *right* way to disable a route link, rather than\n\t\t\t// letting people screw up accessibility on accident.\n\t\t\t//\n\t\t\t// The attribute is coerced so users don't get surprised over\n\t\t\t// `disabled: 0` resulting in a button that's somehow routable\n\t\t\t// despite being visibly disabled.\n\t\t\tif (child.attrs.disabled = Boolean(child.attrs.disabled)) {\n\t\t\t\tchild.attrs.href = null\n\t\t\t\tchild.attrs[\"aria-disabled\"] = \"true\"\n\t\t\t\t// If you *really* do want to do this on a disabled link, use\n\t\t\t\t// an `oncreate` hook to add it.\n\t\t\t\tchild.attrs.onclick = null\n\t\t\t} else {\n\t\t\t\tonclick = child.attrs.onclick\n\t\t\t\thref = child.attrs.href\n\t\t\t\tchild.attrs.href = route.prefix + href\n\t\t\t\tchild.attrs.onclick = function(e) {\n\t\t\t\t\tvar result\n\t\t\t\t\tif (typeof onclick === \"function\") {\n\t\t\t\t\t\tresult = onclick.call(e.currentTarget, e)\n\t\t\t\t\t} else if (onclick == null || typeof onclick !== \"object\") {\n\t\t\t\t\t\t// do nothing\n\t\t\t\t\t} else if (typeof onclick.handleEvent === \"function\") {\n\t\t\t\t\t\tonclick.handleEvent(e)\n\t\t\t\t\t}\n\n\t\t\t\t\t// Adapted from React Router's implementation:\n\t\t\t\t\t// https://github.com/ReactTraining/react-router/blob/520a0acd48ae1b066eb0b07d6d4d1790a1d02482/packages/react-router-dom/modules/Link.js\n\t\t\t\t\t//\n\t\t\t\t\t// Try to be flexible and intuitive in how we handle links.\n\t\t\t\t\t// Fun fact: links aren't as obvious to get right as you\n\t\t\t\t\t// would expect. There's a lot more valid ways to click a\n\t\t\t\t\t// link than this, and one might want to not simply click a\n\t\t\t\t\t// link, but right click or command-click it to copy the\n\t\t\t\t\t// link target, etc. Nope, this isn't just for blind people.\n\t\t\t\t\tif (\n\t\t\t\t\t\t// Skip if `onclick` prevented default\n\t\t\t\t\t\tresult !== false && !e.defaultPrevented &&\n\t\t\t\t\t\t// Ignore everything but left clicks\n\t\t\t\t\t\t(e.button === 0 || e.which === 0 || e.which === 1) &&\n\t\t\t\t\t\t// Let the browser handle `target=_blank`, etc.\n\t\t\t\t\t\t(!e.currentTarget.target || e.currentTarget.target === \"_self\") &&\n\t\t\t\t\t\t// No modifier keys\n\t\t\t\t\t\t!e.ctrlKey && !e.metaKey && !e.shiftKey && !e.altKey\n\t\t\t\t\t) {\n\t\t\t\t\t\te.preventDefault()\n\t\t\t\t\t\te.redraw = false\n\t\t\t\t\t\troute.set(href, null, options)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn child\n\t\t},\n\t}\n\troute.param = function(key) {\n\t\treturn attrs && key != null ? attrs[key] : attrs\n\t}\n\n\treturn route\n}\n","\"use strict\"\n\nvar parsePathname = require(\"./parse\")\n\n// Compiles a template into a function that takes a resolved path (without query\n// strings) and returns an object containing the template parameters with their\n// parsed values. This expects the input of the compiled template to be the\n// output of `parsePathname`. Note that it does *not* remove query parameters\n// specified in the template.\nmodule.exports = function(template) {\n\tvar templateData = parsePathname(template)\n\tvar templateKeys = Object.keys(templateData.params)\n\tvar keys = []\n\tvar regexp = new RegExp(\"^\" + templateData.path.replace(\n\t\t// I escape literal text so people can use things like `:file.:ext` or\n\t\t// `:lang-:locale` in routes. This is all merged into one pass so I\n\t\t// don't also accidentally escape `-` and make it harder to detect it to\n\t\t// ban it from template parameters.\n\t\t/:([^\\/.-]+)(\\.{3}|\\.(?!\\.)|-)?|[\\\\^$*+.()|\\[\\]{}]/g,\n\t\tfunction(m, key, extra) {\n\t\t\tif (key == null) return \"\\\\\" + m\n\t\t\tkeys.push({k: key, r: extra === \"...\"})\n\t\t\tif (extra === \"...\") return \"(.*)\"\n\t\t\tif (extra === \".\") return \"([^/]+)\\\\.\"\n\t\t\treturn \"([^/]+)\" + (extra || \"\")\n\t\t}\n\t) + \"$\")\n\treturn function(data) {\n\t\t// First, check the params. Usually, there isn't any, and it's just\n\t\t// checking a static set.\n\t\tfor (var i = 0; i < templateKeys.length; i++) {\n\t\t\tif (templateData.params[templateKeys[i]] !== data.params[templateKeys[i]]) return false\n\t\t}\n\t\t// If no interpolations exist, let's skip all the ceremony\n\t\tif (!keys.length) return regexp.test(data.path)\n\t\tvar values = regexp.exec(data.path)\n\t\tif (values == null) return false\n\t\tfor (var i = 0; i < keys.length; i++) {\n\t\t\tdata.params[keys[i].k] = keys[i].r ? values[i + 1] : decodeURIComponent(values[i + 1])\n\t\t}\n\t\treturn true\n\t}\n}\n","if(!global[\"m\"]) global[\"m\"] = {};\nmodule.exports = global[\"m\"][\"bidi\"] = require(\"-!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\babel-loader\\\\lib\\\\index.js??ref--5!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\source-map-loader\\\\index.js!.\\\\bidi.js\");","( function _package( factory ){\r\n\tif( typeof define === 'function' && define.amd ){\r\n\t\tdefine( [ 'mithril' ], factory )\r\n\t}\r\n\telse if( typeof exports === 'object' ){\r\n\t\tmodule.exports = factory( require( 'mithril' ) )\r\n\t}\r\n\telse{\r\n\t\tfactory( m )\r\n\t}\r\n}( function define( m ){\r\n\tfunction bidi( node, prop ){\r\n\t\tvar type = node.tag === 'select'\r\n\t\t\t? node.attrs.multi\r\n\t\t\t\t? 'multi'\r\n\t\t\t\t: 'select'\r\n\t\t\t: node.attrs.type\r\n\r\n\t\t// Setup: bind listeners\r\n\t\tif( type === 'multi' ){\r\n\t\t\tnode.attrs.onchange = function(){\r\n\t\t\t\tprop( [].slice.call( this.selectedOptions, function( x ){\r\n\t\t\t\t\treturn x.value\r\n\t\t\t\t} ) )\r\n\t\t\t}\r\n\t\t}\r\n\t\telse if( type === 'select' ){\r\n\t\t\tnode.attrs.onchange = function( e ){\r\n\t\t\t\tprop( this.selectedOptions[ 0 ].value )\r\n\t\t\t}\r\n\t\t}\r\n\t\telse if( type === 'checkbox' ){\r\n\t\t\tnode.attrs.onchange = function( e ){\r\n\t\t\t\tprop( this.checked )\r\n\t\t\t}\r\n\t\t}\r\n\t\telse {\r\n\t\t\tnode.attrs.onchange = node.attrs.oninput = function( e ){\r\n\t\t\t\tprop( this.value )\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif( node.tag === 'select' ){\r\n\t\t\tnode.children.forEach( function( option ){\r\n\t\t\t\tif( option.attrs.value === prop() || option.children[ 0 ] === prop() ){\r\n\t\t\t\t\toption.attrs.selected = true\r\n\t\t\t\t}\r\n\t\t\t} )\r\n\t\t}\r\n\t\telse if( type === 'checkbox' ){\r\n\t\t\tnode.attrs.checked = prop()\r\n\t\t}\r\n\t\telse if( type === 'radio' ){\r\n\t\t\tnode.attrs.checked = prop() === node.attrs.value\r\n\t\t}\r\n\t\telse {\r\n\t\t\tnode.attrs.value   = prop()\r\n\t\t}\r\n\r\n\t\treturn node\r\n\t}\r\n\r\n\tbidi.view = function( ctrl, node, prop ){\r\n\t  return bidi( node, node.attrs.bidi )\r\n\t}\r\n\r\n\tif( m.attrs ) m.attrs.bidi = bidi\r\n\t\r\n\tm.bidi = bidi\r\n\r\n\treturn bidi\r\n} ) )\r\n","module.exports = global[\"Mousetrap\"] = require(\"-!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\babel-loader\\\\lib\\\\index.js??ref--5!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\source-map-loader\\\\index.js!.\\\\mousetrap.js\");","/*global define:false */\n/**\n * Copyright 2012-2017 Craig Campbell\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * Mousetrap is a simple keyboard shortcut library for Javascript with\n * no external dependencies\n *\n * @version 1.6.5\n * @url craig.is/killing/mice\n */\n(function(window, document, undefined) {\n\n    // Check if mousetrap is used inside browser, if not, return\n    if (!window) {\n        return;\n    }\n\n    /**\n     * mapping of special keycodes to their corresponding keys\n     *\n     * everything in this dictionary cannot use keypress events\n     * so it has to be here to map to the correct keycodes for\n     * keyup/keydown events\n     *\n     * @type {Object}\n     */\n    var _MAP = {\n        8: 'backspace',\n        9: 'tab',\n        13: 'enter',\n        16: 'shift',\n        17: 'ctrl',\n        18: 'alt',\n        20: 'capslock',\n        27: 'esc',\n        32: 'space',\n        33: 'pageup',\n        34: 'pagedown',\n        35: 'end',\n        36: 'home',\n        37: 'left',\n        38: 'up',\n        39: 'right',\n        40: 'down',\n        45: 'ins',\n        46: 'del',\n        91: 'meta',\n        93: 'meta',\n        224: 'meta'\n    };\n\n    /**\n     * mapping for special characters so they can support\n     *\n     * this dictionary is only used incase you want to bind a\n     * keyup or keydown event to one of these keys\n     *\n     * @type {Object}\n     */\n    var _KEYCODE_MAP = {\n        106: '*',\n        107: '+',\n        109: '-',\n        110: '.',\n        111 : '/',\n        186: ';',\n        187: '=',\n        188: ',',\n        189: '-',\n        190: '.',\n        191: '/',\n        192: '`',\n        219: '[',\n        220: '\\\\',\n        221: ']',\n        222: '\\''\n    };\n\n    /**\n     * this is a mapping of keys that require shift on a US keypad\n     * back to the non shift equivelents\n     *\n     * this is so you can use keyup events with these keys\n     *\n     * note that this will only work reliably on US keyboards\n     *\n     * @type {Object}\n     */\n    var _SHIFT_MAP = {\n        '~': '`',\n        '!': '1',\n        '@': '2',\n        '#': '3',\n        '$': '4',\n        '%': '5',\n        '^': '6',\n        '&': '7',\n        '*': '8',\n        '(': '9',\n        ')': '0',\n        '_': '-',\n        '+': '=',\n        ':': ';',\n        '\\\"': '\\'',\n        '<': ',',\n        '>': '.',\n        '?': '/',\n        '|': '\\\\'\n    };\n\n    /**\n     * this is a list of special strings you can use to map\n     * to modifier keys when you specify your keyboard shortcuts\n     *\n     * @type {Object}\n     */\n    var _SPECIAL_ALIASES = {\n        'option': 'alt',\n        'command': 'meta',\n        'return': 'enter',\n        'escape': 'esc',\n        'plus': '+',\n        'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'\n    };\n\n    /**\n     * variable to store the flipped version of _MAP from above\n     * needed to check if we should use keypress or not when no action\n     * is specified\n     *\n     * @type {Object|undefined}\n     */\n    var _REVERSE_MAP;\n\n    /**\n     * loop through the f keys, f1 to f19 and add them to the map\n     * programatically\n     */\n    for (var i = 1; i < 20; ++i) {\n        _MAP[111 + i] = 'f' + i;\n    }\n\n    /**\n     * loop through to map numbers on the numeric keypad\n     */\n    for (i = 0; i <= 9; ++i) {\n\n        // This needs to use a string cause otherwise since 0 is falsey\n        // mousetrap will never fire for numpad 0 pressed as part of a keydown\n        // event.\n        //\n        // @see https://github.com/ccampbell/mousetrap/pull/258\n        _MAP[i + 96] = i.toString();\n    }\n\n    /**\n     * cross browser add event method\n     *\n     * @param {Element|HTMLDocument} object\n     * @param {string} type\n     * @param {Function} callback\n     * @returns void\n     */\n    function _addEvent(object, type, callback) {\n        if (object.addEventListener) {\n            object.addEventListener(type, callback, false);\n            return;\n        }\n\n        object.attachEvent('on' + type, callback);\n    }\n\n    /**\n     * takes the event and returns the key character\n     *\n     * @param {Event} e\n     * @return {string}\n     */\n    function _characterFromEvent(e) {\n\n        // for keypress events we should return the character as is\n        if (e.type == 'keypress') {\n            var character = String.fromCharCode(e.which);\n\n            // if the shift key is not pressed then it is safe to assume\n            // that we want the character to be lowercase.  this means if\n            // you accidentally have caps lock on then your key bindings\n            // will continue to work\n            //\n            // the only side effect that might not be desired is if you\n            // bind something like 'A' cause you want to trigger an\n            // event when capital A is pressed caps lock will no longer\n            // trigger the event.  shift+a will though.\n            if (!e.shiftKey) {\n                character = character.toLowerCase();\n            }\n\n            return character;\n        }\n\n        // for non keypress events the special maps are needed\n        if (_MAP[e.which]) {\n            return _MAP[e.which];\n        }\n\n        if (_KEYCODE_MAP[e.which]) {\n            return _KEYCODE_MAP[e.which];\n        }\n\n        // if it is not in the special map\n\n        // with keydown and keyup events the character seems to always\n        // come in as an uppercase character whether you are pressing shift\n        // or not.  we should make sure it is always lowercase for comparisons\n        return String.fromCharCode(e.which).toLowerCase();\n    }\n\n    /**\n     * checks if two arrays are equal\n     *\n     * @param {Array} modifiers1\n     * @param {Array} modifiers2\n     * @returns {boolean}\n     */\n    function _modifiersMatch(modifiers1, modifiers2) {\n        return modifiers1.sort().join(',') === modifiers2.sort().join(',');\n    }\n\n    /**\n     * takes a key event and figures out what the modifiers are\n     *\n     * @param {Event} e\n     * @returns {Array}\n     */\n    function _eventModifiers(e) {\n        var modifiers = [];\n\n        if (e.shiftKey) {\n            modifiers.push('shift');\n        }\n\n        if (e.altKey) {\n            modifiers.push('alt');\n        }\n\n        if (e.ctrlKey) {\n            modifiers.push('ctrl');\n        }\n\n        if (e.metaKey) {\n            modifiers.push('meta');\n        }\n\n        return modifiers;\n    }\n\n    /**\n     * prevents default for this event\n     *\n     * @param {Event} e\n     * @returns void\n     */\n    function _preventDefault(e) {\n        if (e.preventDefault) {\n            e.preventDefault();\n            return;\n        }\n\n        e.returnValue = false;\n    }\n\n    /**\n     * stops propogation for this event\n     *\n     * @param {Event} e\n     * @returns void\n     */\n    function _stopPropagation(e) {\n        if (e.stopPropagation) {\n            e.stopPropagation();\n            return;\n        }\n\n        e.cancelBubble = true;\n    }\n\n    /**\n     * determines if the keycode specified is a modifier key or not\n     *\n     * @param {string} key\n     * @returns {boolean}\n     */\n    function _isModifier(key) {\n        return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';\n    }\n\n    /**\n     * reverses the map lookup so that we can look for specific keys\n     * to see what can and can't use keypress\n     *\n     * @return {Object}\n     */\n    function _getReverseMap() {\n        if (!_REVERSE_MAP) {\n            _REVERSE_MAP = {};\n            for (var key in _MAP) {\n\n                // pull out the numeric keypad from here cause keypress should\n                // be able to detect the keys from the character\n                if (key > 95 && key < 112) {\n                    continue;\n                }\n\n                if (_MAP.hasOwnProperty(key)) {\n                    _REVERSE_MAP[_MAP[key]] = key;\n                }\n            }\n        }\n        return _REVERSE_MAP;\n    }\n\n    /**\n     * picks the best action based on the key combination\n     *\n     * @param {string} key - character for key\n     * @param {Array} modifiers\n     * @param {string=} action passed in\n     */\n    function _pickBestAction(key, modifiers, action) {\n\n        // if no action was picked in we should try to pick the one\n        // that we think would work best for this key\n        if (!action) {\n            action = _getReverseMap()[key] ? 'keydown' : 'keypress';\n        }\n\n        // modifier keys don't work as expected with keypress,\n        // switch to keydown\n        if (action == 'keypress' && modifiers.length) {\n            action = 'keydown';\n        }\n\n        return action;\n    }\n\n    /**\n     * Converts from a string key combination to an array\n     *\n     * @param  {string} combination like \"command+shift+l\"\n     * @return {Array}\n     */\n    function _keysFromString(combination) {\n        if (combination === '+') {\n            return ['+'];\n        }\n\n        combination = combination.replace(/\\+{2}/g, '+plus');\n        return combination.split('+');\n    }\n\n    /**\n     * Gets info for a specific key combination\n     *\n     * @param  {string} combination key combination (\"command+s\" or \"a\" or \"*\")\n     * @param  {string=} action\n     * @returns {Object}\n     */\n    function _getKeyInfo(combination, action) {\n        var keys;\n        var key;\n        var i;\n        var modifiers = [];\n\n        // take the keys from this pattern and figure out what the actual\n        // pattern is all about\n        keys = _keysFromString(combination);\n\n        for (i = 0; i < keys.length; ++i) {\n            key = keys[i];\n\n            // normalize key names\n            if (_SPECIAL_ALIASES[key]) {\n                key = _SPECIAL_ALIASES[key];\n            }\n\n            // if this is not a keypress event then we should\n            // be smart about using shift keys\n            // this will only work for US keyboards however\n            if (action && action != 'keypress' && _SHIFT_MAP[key]) {\n                key = _SHIFT_MAP[key];\n                modifiers.push('shift');\n            }\n\n            // if this key is a modifier then add it to the list of modifiers\n            if (_isModifier(key)) {\n                modifiers.push(key);\n            }\n        }\n\n        // depending on what the key combination is\n        // we will try to pick the best event for it\n        action = _pickBestAction(key, modifiers, action);\n\n        return {\n            key: key,\n            modifiers: modifiers,\n            action: action\n        };\n    }\n\n    function _belongsTo(element, ancestor) {\n        if (element === null || element === document) {\n            return false;\n        }\n\n        if (element === ancestor) {\n            return true;\n        }\n\n        return _belongsTo(element.parentNode, ancestor);\n    }\n\n    function Mousetrap(targetElement) {\n        var self = this;\n\n        targetElement = targetElement || document;\n\n        if (!(self instanceof Mousetrap)) {\n            return new Mousetrap(targetElement);\n        }\n\n        /**\n         * element to attach key events to\n         *\n         * @type {Element}\n         */\n        self.target = targetElement;\n\n        /**\n         * a list of all the callbacks setup via Mousetrap.bind()\n         *\n         * @type {Object}\n         */\n        self._callbacks = {};\n\n        /**\n         * direct map of string combinations to callbacks used for trigger()\n         *\n         * @type {Object}\n         */\n        self._directMap = {};\n\n        /**\n         * keeps track of what level each sequence is at since multiple\n         * sequences can start out with the same sequence\n         *\n         * @type {Object}\n         */\n        var _sequenceLevels = {};\n\n        /**\n         * variable to store the setTimeout call\n         *\n         * @type {null|number}\n         */\n        var _resetTimer;\n\n        /**\n         * temporary state where we will ignore the next keyup\n         *\n         * @type {boolean|string}\n         */\n        var _ignoreNextKeyup = false;\n\n        /**\n         * temporary state where we will ignore the next keypress\n         *\n         * @type {boolean}\n         */\n        var _ignoreNextKeypress = false;\n\n        /**\n         * are we currently inside of a sequence?\n         * type of action (\"keyup\" or \"keydown\" or \"keypress\") or false\n         *\n         * @type {boolean|string}\n         */\n        var _nextExpectedAction = false;\n\n        /**\n         * resets all sequence counters except for the ones passed in\n         *\n         * @param {Object} doNotReset\n         * @returns void\n         */\n        function _resetSequences(doNotReset) {\n            doNotReset = doNotReset || {};\n\n            var activeSequences = false,\n                key;\n\n            for (key in _sequenceLevels) {\n                if (doNotReset[key]) {\n                    activeSequences = true;\n                    continue;\n                }\n                _sequenceLevels[key] = 0;\n            }\n\n            if (!activeSequences) {\n                _nextExpectedAction = false;\n            }\n        }\n\n        /**\n         * finds all callbacks that match based on the keycode, modifiers,\n         * and action\n         *\n         * @param {string} character\n         * @param {Array} modifiers\n         * @param {Event|Object} e\n         * @param {string=} sequenceName - name of the sequence we are looking for\n         * @param {string=} combination\n         * @param {number=} level\n         * @returns {Array}\n         */\n        function _getMatches(character, modifiers, e, sequenceName, combination, level) {\n            var i;\n            var callback;\n            var matches = [];\n            var action = e.type;\n\n            // if there are no events related to this keycode\n            if (!self._callbacks[character]) {\n                return [];\n            }\n\n            // if a modifier key is coming up on its own we should allow it\n            if (action == 'keyup' && _isModifier(character)) {\n                modifiers = [character];\n            }\n\n            // loop through all callbacks for the key that was pressed\n            // and see if any of them match\n            for (i = 0; i < self._callbacks[character].length; ++i) {\n                callback = self._callbacks[character][i];\n\n                // if a sequence name is not specified, but this is a sequence at\n                // the wrong level then move onto the next match\n                if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {\n                    continue;\n                }\n\n                // if the action we are looking for doesn't match the action we got\n                // then we should keep going\n                if (action != callback.action) {\n                    continue;\n                }\n\n                // if this is a keypress event and the meta key and control key\n                // are not pressed that means that we need to only look at the\n                // character, otherwise check the modifiers as well\n                //\n                // chrome will not fire a keypress if meta or control is down\n                // safari will fire a keypress if meta or meta+shift is down\n                // firefox will fire a keypress if meta or control is down\n                if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {\n\n                    // when you bind a combination or sequence a second time it\n                    // should overwrite the first one.  if a sequenceName or\n                    // combination is specified in this call it does just that\n                    //\n                    // @todo make deleting its own method?\n                    var deleteCombo = !sequenceName && callback.combo == combination;\n                    var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;\n                    if (deleteCombo || deleteSequence) {\n                        self._callbacks[character].splice(i, 1);\n                    }\n\n                    matches.push(callback);\n                }\n            }\n\n            return matches;\n        }\n\n        /**\n         * actually calls the callback function\n         *\n         * if your callback function returns false this will use the jquery\n         * convention - prevent default and stop propogation on the event\n         *\n         * @param {Function} callback\n         * @param {Event} e\n         * @returns void\n         */\n        function _fireCallback(callback, e, combo, sequence) {\n\n            // if this event should not happen stop here\n            if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {\n                return;\n            }\n\n            if (callback(e, combo) === false) {\n                _preventDefault(e);\n                _stopPropagation(e);\n            }\n        }\n\n        /**\n         * handles a character key event\n         *\n         * @param {string} character\n         * @param {Array} modifiers\n         * @param {Event} e\n         * @returns void\n         */\n        self._handleKey = function(character, modifiers, e) {\n            var callbacks = _getMatches(character, modifiers, e);\n            var i;\n            var doNotReset = {};\n            var maxLevel = 0;\n            var processedSequenceCallback = false;\n\n            // Calculate the maxLevel for sequences so we can only execute the longest callback sequence\n            for (i = 0; i < callbacks.length; ++i) {\n                if (callbacks[i].seq) {\n                    maxLevel = Math.max(maxLevel, callbacks[i].level);\n                }\n            }\n\n            // loop through matching callbacks for this key event\n            for (i = 0; i < callbacks.length; ++i) {\n\n                // fire for all sequence callbacks\n                // this is because if for example you have multiple sequences\n                // bound such as \"g i\" and \"g t\" they both need to fire the\n                // callback for matching g cause otherwise you can only ever\n                // match the first one\n                if (callbacks[i].seq) {\n\n                    // only fire callbacks for the maxLevel to prevent\n                    // subsequences from also firing\n                    //\n                    // for example 'a option b' should not cause 'option b' to fire\n                    // even though 'option b' is part of the other sequence\n                    //\n                    // any sequences that do not match here will be discarded\n                    // below by the _resetSequences call\n                    if (callbacks[i].level != maxLevel) {\n                        continue;\n                    }\n\n                    processedSequenceCallback = true;\n\n                    // keep a list of which sequences were matches for later\n                    doNotReset[callbacks[i].seq] = 1;\n                    _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);\n                    continue;\n                }\n\n                // if there were no sequence matches but we are still here\n                // that means this is a regular match so we should fire that\n                if (!processedSequenceCallback) {\n                    _fireCallback(callbacks[i].callback, e, callbacks[i].combo);\n                }\n            }\n\n            // if the key you pressed matches the type of sequence without\n            // being a modifier (ie \"keyup\" or \"keypress\") then we should\n            // reset all sequences that were not matched by this event\n            //\n            // this is so, for example, if you have the sequence \"h a t\" and you\n            // type \"h e a r t\" it does not match.  in this case the \"e\" will\n            // cause the sequence to reset\n            //\n            // modifier keys are ignored because you can have a sequence\n            // that contains modifiers such as \"enter ctrl+space\" and in most\n            // cases the modifier key will be pressed before the next key\n            //\n            // also if you have a sequence such as \"ctrl+b a\" then pressing the\n            // \"b\" key will trigger a \"keypress\" and a \"keydown\"\n            //\n            // the \"keydown\" is expected when there is a modifier, but the\n            // \"keypress\" ends up matching the _nextExpectedAction since it occurs\n            // after and that causes the sequence to reset\n            //\n            // we ignore keypresses in a sequence that directly follow a keydown\n            // for the same character\n            var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;\n            if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {\n                _resetSequences(doNotReset);\n            }\n\n            _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';\n        };\n\n        /**\n         * handles a keydown event\n         *\n         * @param {Event} e\n         * @returns void\n         */\n        function _handleKeyEvent(e) {\n\n            // normalize e.which for key events\n            // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion\n            if (typeof e.which !== 'number') {\n                e.which = e.keyCode;\n            }\n\n            var character = _characterFromEvent(e);\n\n            // no character found then stop\n            if (!character) {\n                return;\n            }\n\n            // need to use === for the character check because the character can be 0\n            if (e.type == 'keyup' && _ignoreNextKeyup === character) {\n                _ignoreNextKeyup = false;\n                return;\n            }\n\n            self.handleKey(character, _eventModifiers(e), e);\n        }\n\n        /**\n         * called to set a 1 second timeout on the specified sequence\n         *\n         * this is so after each key press in the sequence you have 1 second\n         * to press the next key before you have to start over\n         *\n         * @returns void\n         */\n        function _resetSequenceTimer() {\n            clearTimeout(_resetTimer);\n            _resetTimer = setTimeout(_resetSequences, 1000);\n        }\n\n        /**\n         * binds a key sequence to an event\n         *\n         * @param {string} combo - combo specified in bind call\n         * @param {Array} keys\n         * @param {Function} callback\n         * @param {string=} action\n         * @returns void\n         */\n        function _bindSequence(combo, keys, callback, action) {\n\n            // start off by adding a sequence level record for this combination\n            // and setting the level to 0\n            _sequenceLevels[combo] = 0;\n\n            /**\n             * callback to increase the sequence level for this sequence and reset\n             * all other sequences that were active\n             *\n             * @param {string} nextAction\n             * @returns {Function}\n             */\n            function _increaseSequence(nextAction) {\n                return function() {\n                    _nextExpectedAction = nextAction;\n                    ++_sequenceLevels[combo];\n                    _resetSequenceTimer();\n                };\n            }\n\n            /**\n             * wraps the specified callback inside of another function in order\n             * to reset all sequence counters as soon as this sequence is done\n             *\n             * @param {Event} e\n             * @returns void\n             */\n            function _callbackAndReset(e) {\n                _fireCallback(callback, e, combo);\n\n                // we should ignore the next key up if the action is key down\n                // or keypress.  this is so if you finish a sequence and\n                // release the key the final key will not trigger a keyup\n                if (action !== 'keyup') {\n                    _ignoreNextKeyup = _characterFromEvent(e);\n                }\n\n                // weird race condition if a sequence ends with the key\n                // another sequence begins with\n                setTimeout(_resetSequences, 10);\n            }\n\n            // loop through keys one at a time and bind the appropriate callback\n            // function.  for any key leading up to the final one it should\n            // increase the sequence. after the final, it should reset all sequences\n            //\n            // if an action is specified in the original bind call then that will\n            // be used throughout.  otherwise we will pass the action that the\n            // next key in the sequence should match.  this allows a sequence\n            // to mix and match keypress and keydown events depending on which\n            // ones are better suited to the key provided\n            for (var i = 0; i < keys.length; ++i) {\n                var isFinal = i + 1 === keys.length;\n                var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);\n                _bindSingle(keys[i], wrappedCallback, action, combo, i);\n            }\n        }\n\n        /**\n         * binds a single keyboard combination\n         *\n         * @param {string} combination\n         * @param {Function} callback\n         * @param {string=} action\n         * @param {string=} sequenceName - name of sequence if part of sequence\n         * @param {number=} level - what part of the sequence the command is\n         * @returns void\n         */\n        function _bindSingle(combination, callback, action, sequenceName, level) {\n\n            // store a direct mapped reference for use with Mousetrap.trigger\n            self._directMap[combination + ':' + action] = callback;\n\n            // make sure multiple spaces in a row become a single space\n            combination = combination.replace(/\\s+/g, ' ');\n\n            var sequence = combination.split(' ');\n            var info;\n\n            // if this pattern is a sequence of keys then run through this method\n            // to reprocess each pattern one key at a time\n            if (sequence.length > 1) {\n                _bindSequence(combination, sequence, callback, action);\n                return;\n            }\n\n            info = _getKeyInfo(combination, action);\n\n            // make sure to initialize array if this is the first time\n            // a callback is added for this key\n            self._callbacks[info.key] = self._callbacks[info.key] || [];\n\n            // remove an existing match if there is one\n            _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);\n\n            // add this call back to the array\n            // if it is a sequence put it at the beginning\n            // if not put it at the end\n            //\n            // this is important because the way these are processed expects\n            // the sequence ones to come first\n            self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({\n                callback: callback,\n                modifiers: info.modifiers,\n                action: info.action,\n                seq: sequenceName,\n                level: level,\n                combo: combination\n            });\n        }\n\n        /**\n         * binds multiple combinations to the same callback\n         *\n         * @param {Array} combinations\n         * @param {Function} callback\n         * @param {string|undefined} action\n         * @returns void\n         */\n        self._bindMultiple = function(combinations, callback, action) {\n            for (var i = 0; i < combinations.length; ++i) {\n                _bindSingle(combinations[i], callback, action);\n            }\n        };\n\n        // start!\n        _addEvent(targetElement, 'keypress', _handleKeyEvent);\n        _addEvent(targetElement, 'keydown', _handleKeyEvent);\n        _addEvent(targetElement, 'keyup', _handleKeyEvent);\n    }\n\n    /**\n     * binds an event to mousetrap\n     *\n     * can be a single key, a combination of keys separated with +,\n     * an array of keys, or a sequence of keys separated by spaces\n     *\n     * be sure to list the modifier keys first to make sure that the\n     * correct key ends up getting bound (the last key in the pattern)\n     *\n     * @param {string|Array} keys\n     * @param {Function} callback\n     * @param {string=} action - 'keypress', 'keydown', or 'keyup'\n     * @returns void\n     */\n    Mousetrap.prototype.bind = function(keys, callback, action) {\n        var self = this;\n        keys = keys instanceof Array ? keys : [keys];\n        self._bindMultiple.call(self, keys, callback, action);\n        return self;\n    };\n\n    /**\n     * unbinds an event to mousetrap\n     *\n     * the unbinding sets the callback function of the specified key combo\n     * to an empty function and deletes the corresponding key in the\n     * _directMap dict.\n     *\n     * TODO: actually remove this from the _callbacks dictionary instead\n     * of binding an empty function\n     *\n     * the keycombo+action has to be exactly the same as\n     * it was defined in the bind method\n     *\n     * @param {string|Array} keys\n     * @param {string} action\n     * @returns void\n     */\n    Mousetrap.prototype.unbind = function(keys, action) {\n        var self = this;\n        return self.bind.call(self, keys, function() {}, action);\n    };\n\n    /**\n     * triggers an event that has already been bound\n     *\n     * @param {string} keys\n     * @param {string=} action\n     * @returns void\n     */\n    Mousetrap.prototype.trigger = function(keys, action) {\n        var self = this;\n        if (self._directMap[keys + ':' + action]) {\n            self._directMap[keys + ':' + action]({}, keys);\n        }\n        return self;\n    };\n\n    /**\n     * resets the library back to its initial state.  this is useful\n     * if you want to clear out the current keyboard shortcuts and bind\n     * new ones - for example if you switch to another page\n     *\n     * @returns void\n     */\n    Mousetrap.prototype.reset = function() {\n        var self = this;\n        self._callbacks = {};\n        self._directMap = {};\n        return self;\n    };\n\n    /**\n     * should we stop this event before firing off callbacks\n     *\n     * @param {Event} e\n     * @param {Element} element\n     * @return {boolean}\n     */\n    Mousetrap.prototype.stopCallback = function(e, element) {\n        var self = this;\n\n        // if the element has the class \"mousetrap\" then no need to stop\n        if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {\n            return false;\n        }\n\n        if (_belongsTo(element, self.target)) {\n            return false;\n        }\n\n        // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,\n        // not the initial event target in the shadow tree. Note that not all events cross the\n        // shadow boundary.\n        // For shadow trees with `mode: 'open'`, the initial event target is the first element in\n        // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event\n        // target cannot be obtained.\n        if ('composedPath' in e && typeof e.composedPath === 'function') {\n            // For open shadow trees, update `element` so that the following check works.\n            var initialEventTarget = e.composedPath()[0];\n            if (initialEventTarget !== e.target) {\n                element = initialEventTarget;\n            }\n        }\n\n        // stop for input, select, and textarea\n        return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;\n    };\n\n    /**\n     * exposes _handleKey publicly so it can be overwritten by extensions\n     */\n    Mousetrap.prototype.handleKey = function() {\n        var self = this;\n        return self._handleKey.apply(self, arguments);\n    };\n\n    /**\n     * allow custom key mappings\n     */\n    Mousetrap.addKeycodes = function(object) {\n        for (var key in object) {\n            if (object.hasOwnProperty(key)) {\n                _MAP[key] = object[key];\n            }\n        }\n        _REVERSE_MAP = null;\n    };\n\n    /**\n     * Init the global mousetrap functions\n     *\n     * This method is needed to allow the global mousetrap functions to work\n     * now that mousetrap is a constructor function.\n     */\n    Mousetrap.init = function() {\n        var documentMousetrap = Mousetrap(document);\n        for (var method in documentMousetrap) {\n            if (method.charAt(0) !== '_') {\n                Mousetrap[method] = (function(method) {\n                    return function() {\n                        return documentMousetrap[method].apply(documentMousetrap, arguments);\n                    };\n                } (method));\n            }\n        }\n    };\n\n    Mousetrap.init();\n\n    // expose mousetrap to the global object\n    window.Mousetrap = Mousetrap;\n\n    // expose as a common js module\n    if (typeof module !== 'undefined' && module.exports) {\n        module.exports = Mousetrap;\n    }\n\n    // expose mousetrap as an AMD module\n    if (typeof define === 'function' && define.amd) {\n        define(function() {\n            return Mousetrap;\n        });\n    }\n}) (typeof window !== 'undefined' ? window : null, typeof  window !== 'undefined' ? document : null);\n","module.exports = global[\"classNames\"] = require(\"-!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\babel-loader\\\\lib\\\\index.js??ref--5!E:\\\\sites\\\\flarum-new\\\\packages\\\\flarum-core\\\\js\\\\node_modules\\\\source-map-loader\\\\index.js!.\\\\index.js\");","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg) && arg.length) {\n\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\tif (inner) {\n\t\t\t\t\tclasses.push(inner);\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","//     Zepto.js\n//     (c) 2010-2016 Thomas Fuchs\n//     Zepto.js may be freely distributed under the MIT license.\n\n;(function($){\n  var zepto = $.zepto, oldQsa = zepto.qsa, oldMatches = zepto.matches\n\n  function visible(elem){\n    elem = $(elem)\n    return !!(elem.width() || elem.height()) && elem.css(\"display\") !== \"none\"\n  }\n\n  // Implements a subset from:\n  // http://api.jquery.com/category/selectors/jquery-selector-extensions/\n  //\n  // Each filter function receives the current index, all nodes in the\n  // considered set, and a value if there were parentheses. The value\n  // of `this` is the node currently being considered. The function returns the\n  // resulting node(s), null, or undefined.\n  //\n  // Complex selectors are not supported:\n  //   li:has(label:contains(\"foo\")) + li:has(label:contains(\"bar\"))\n  //   ul.inner:first > li\n  var filters = $.expr[':'] = {\n    visible:  function(){ if (visible(this)) return this },\n    hidden:   function(){ if (!visible(this)) return this },\n    selected: function(){ if (this.selected) return this },\n    checked:  function(){ if (this.checked) return this },\n    parent:   function(){ return this.parentNode },\n    first:    function(idx){ if (idx === 0) return this },\n    last:     function(idx, nodes){ if (idx === nodes.length - 1) return this },\n    eq:       function(idx, _, value){ if (idx === value) return this },\n    contains: function(idx, _, text){ if ($(this).text().indexOf(text) > -1) return this },\n    has:      function(idx, _, sel){ if (zepto.qsa(this, sel).length) return this }\n  }\n\n  var filterRe = new RegExp('(.*):(\\\\w+)(?:\\\\(([^)]+)\\\\))?$\\\\s*'),\n      childRe  = /^\\s*>/,\n      classTag = 'Zepto' + (+new Date())\n\n  function process(sel, fn) {\n    // quote the hash in `a[href^=#]` expression\n    sel = sel.replace(/=#\\]/g, '=\"#\"]')\n    var filter, arg, match = filterRe.exec(sel)\n    if (match && match[2] in filters) {\n      filter = filters[match[2]], arg = match[3]\n      sel = match[1]\n      if (arg) {\n        var num = Number(arg)\n        if (isNaN(num)) arg = arg.replace(/^[\"']|[\"']$/g, '')\n        else arg = num\n      }\n    }\n    return fn(sel, filter, arg)\n  }\n\n  zepto.qsa = function(node, selector) {\n    return process(selector, function(sel, filter, arg){\n      try {\n        var taggedParent\n        if (!sel && filter) sel = '*'\n        else if (childRe.test(sel))\n          // support \"> *\" child queries by tagging the parent node with a\n          // unique class and prepending that classname onto the selector\n          taggedParent = $(node).addClass(classTag), sel = '.'+classTag+' '+sel\n\n        var nodes = oldQsa(node, sel)\n      } catch(e) {\n        console.error('error performing selector: %o', selector)\n        throw e\n      } finally {\n        if (taggedParent) taggedParent.removeClass(classTag)\n      }\n      return !filter ? nodes :\n        zepto.uniq($.map(nodes, function(n, i){ return filter.call(n, i, nodes, arg) }))\n    })\n  }\n\n  zepto.matches = function(node, selector){\n    return process(selector, function(sel, filter, arg){\n      return (!sel || oldMatches(node, sel)) &&\n        (!filter || filter.call(node, null, arg) === node)\n    })\n  }\n})(Zepto)\n","//     Zepto.js\n//     (c) 2010-2016 Thomas Fuchs\n//     Zepto.js may be freely distributed under the MIT license.\n\n// The following code is heavily inspired by jQuery's $.fn.data()\n\n;(function($){\n  var data = {}, dataAttr = $.fn.data, camelize = $.camelCase,\n    exp = $.expando = 'Zepto' + (+new Date()), emptyArray = []\n\n  // Get value from node:\n  // 1. first try key as given,\n  // 2. then try camelized key,\n  // 3. fall back to reading \"data-*\" attribute.\n  function getData(node, name) {\n    var id = node[exp], store = id && data[id]\n    if (name === undefined) return store || setData(node)\n    else {\n      if (store) {\n        if (name in store) return store[name]\n        var camelName = camelize(name)\n        if (camelName in store) return store[camelName]\n      }\n      return dataAttr.call($(node), name)\n    }\n  }\n\n  // Store value under camelized key on node\n  function setData(node, name, value) {\n    var id = node[exp] || (node[exp] = ++$.uuid),\n      store = data[id] || (data[id] = attributeData(node))\n    if (name !== undefined) store[camelize(name)] = value\n    return store\n  }\n\n  // Read all \"data-*\" attributes from a node\n  function attributeData(node) {\n    var store = {}\n    $.each(node.attributes || emptyArray, function(i, attr){\n      if (attr.name.indexOf('data-') == 0)\n        store[camelize(attr.name.replace('data-', ''))] =\n          $.zepto.deserializeValue(attr.value)\n    })\n    return store\n  }\n\n  $.fn.data = function(name, value) {\n    return value === undefined ?\n      // set multiple values via object\n      $.isPlainObject(name) ?\n        this.each(function(i, node){\n          $.each(name, function(key, value){ setData(node, key, value) })\n        }) :\n        // get value from first element\n        (0 in this ? getData(this[0], name) : undefined) :\n      // set value on all elements\n      this.each(function(){ setData(this, name, value) })\n  }\n\n  $.data = function(elem, name, value) {\n    return $(elem).data(name, value)\n  }\n\n  $.hasData = function(elem) {\n    var id = elem[exp], store = id && data[id]\n    return store ? !$.isEmptyObject(store) : false\n  }\n\n  $.fn.removeData = function(names) {\n    if (typeof names == 'string') names = names.split(/\\s+/)\n    return this.each(function(){\n      var id = this[exp], store = id && data[id]\n      if (store) $.each(names || store, function(key){\n        delete store[names ? camelize(this) : key]\n      })\n    })\n  }\n\n  // Generate extended `remove` and `empty` functions\n  ;['remove', 'empty'].forEach(function(methodName){\n    var origFn = $.fn[methodName]\n    $.fn[methodName] = function() {\n      var elements = this.find('*')\n      if (methodName === 'remove') elements = elements.add(this)\n      elements.removeData()\n      return origFn.call(this)\n    }\n  })\n})(Zepto)\n","//     Zepto.js\n//     (c) 2010-2016 Thomas Fuchs\n//     Zepto.js may be freely distributed under the MIT license.\n\n;(function($, undefined){\n  var prefix = '', eventPrefix,\n    vendors = { Webkit: 'webkit', Moz: '', O: 'o' },\n    testEl = document.createElement('div'),\n    supportedTransforms = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i,\n    transform,\n    transitionProperty, transitionDuration, transitionTiming, transitionDelay,\n    animationName, animationDuration, animationTiming, animationDelay,\n    cssReset = {}\n\n  function dasherize(str) { return str.replace(/([A-Z])/g, '-$1').toLowerCase() }\n  function normalizeEvent(name) { return eventPrefix ? eventPrefix + name : name.toLowerCase() }\n\n  if (testEl.style.transform === undefined) $.each(vendors, function(vendor, event){\n    if (testEl.style[vendor + 'TransitionProperty'] !== undefined) {\n      prefix = '-' + vendor.toLowerCase() + '-'\n      eventPrefix = event\n      return false\n    }\n  })\n\n  transform = prefix + 'transform'\n  cssReset[transitionProperty = prefix + 'transition-property'] =\n  cssReset[transitionDuration = prefix + 'transition-duration'] =\n  cssReset[transitionDelay    = prefix + 'transition-delay'] =\n  cssReset[transitionTiming   = prefix + 'transition-timing-function'] =\n  cssReset[animationName      = prefix + 'animation-name'] =\n  cssReset[animationDuration  = prefix + 'animation-duration'] =\n  cssReset[animationDelay     = prefix + 'animation-delay'] =\n  cssReset[animationTiming    = prefix + 'animation-timing-function'] = ''\n\n  $.fx = {\n    off: (eventPrefix === undefined && testEl.style.transitionProperty === undefined),\n    speeds: { _default: 400, fast: 200, slow: 600 },\n    cssPrefix: prefix,\n    transitionEnd: normalizeEvent('TransitionEnd'),\n    animationEnd: normalizeEvent('AnimationEnd')\n  }\n\n  $.fn.animate = function(properties, duration, ease, callback, delay){\n    if ($.isFunction(duration))\n      callback = duration, ease = undefined, duration = undefined\n    if ($.isFunction(ease))\n      callback = ease, ease = undefined\n    if ($.isPlainObject(duration))\n      ease = duration.easing, callback = duration.complete, delay = duration.delay, duration = duration.duration\n    if (duration) duration = (typeof duration == 'number' ? duration :\n                    ($.fx.speeds[duration] || $.fx.speeds._default)) / 1000\n    if (delay) delay = parseFloat(delay) / 1000\n    return this.anim(properties, duration, ease, callback, delay)\n  }\n\n  $.fn.anim = function(properties, duration, ease, callback, delay){\n    var key, cssValues = {}, cssProperties, transforms = '',\n        that = this, wrappedCallback, endEvent = $.fx.transitionEnd,\n        fired = false\n\n    if (duration === undefined) duration = $.fx.speeds._default / 1000\n    if (delay === undefined) delay = 0\n    if ($.fx.off) duration = 0\n\n    if (typeof properties == 'string') {\n      // keyframe animation\n      cssValues[animationName] = properties\n      cssValues[animationDuration] = duration + 's'\n      cssValues[animationDelay] = delay + 's'\n      cssValues[animationTiming] = (ease || 'linear')\n      endEvent = $.fx.animationEnd\n    } else {\n      cssProperties = []\n      // CSS transitions\n      for (key in properties)\n        if (supportedTransforms.test(key)) transforms += key + '(' + properties[key] + ') '\n        else cssValues[key] = properties[key], cssProperties.push(dasherize(key))\n\n      if (transforms) cssValues[transform] = transforms, cssProperties.push(transform)\n      if (duration > 0 && typeof properties === 'object') {\n        cssValues[transitionProperty] = cssProperties.join(', ')\n        cssValues[transitionDuration] = duration + 's'\n        cssValues[transitionDelay] = delay + 's'\n        cssValues[transitionTiming] = (ease || 'linear')\n      }\n    }\n\n    wrappedCallback = function(event){\n      if (typeof event !== 'undefined') {\n        if (event.target !== event.currentTarget) return // makes sure the event didn't bubble from \"below\"\n        $(event.target).unbind(endEvent, wrappedCallback)\n      } else\n        $(this).unbind(endEvent, wrappedCallback) // triggered by setTimeout\n\n      fired = true\n      $(this).css(cssReset)\n      callback && callback.call(this)\n    }\n    if (duration > 0){\n      this.bind(endEvent, wrappedCallback)\n      // transitionEnd is not always firing on older Android phones\n      // so make sure it gets fired\n      setTimeout(function(){\n        if (fired) return\n        wrappedCallback.call(that)\n      }, ((duration + delay) * 1000) + 25)\n    }\n\n    // trigger page reflow so new elements can animate\n    this.size() && this.get(0).clientLeft\n\n    this.css(cssValues)\n\n    if (duration <= 0) setTimeout(function() {\n      that.each(function(){ wrappedCallback.call(this) })\n    }, 0)\n\n    return this\n  }\n\n  testEl = null\n})(Zepto)\n","//     Zepto.js\n//     (c) 2010-2016 Thomas Fuchs\n//     Zepto.js may be freely distributed under the MIT license.\n\n;(function($, undefined){\n  var document = window.document, docElem = document.documentElement,\n    origShow = $.fn.show, origHide = $.fn.hide, origToggle = $.fn.toggle\n\n  function anim(el, speed, opacity, scale, callback) {\n    if (typeof speed == 'function' && !callback) callback = speed, speed = undefined\n    var props = { opacity: opacity }\n    if (scale) {\n      props.scale = scale\n      el.css($.fx.cssPrefix + 'transform-origin', '0 0')\n    }\n    return el.animate(props, speed, null, callback)\n  }\n\n  function hide(el, speed, scale, callback) {\n    return anim(el, speed, 0, scale, function(){\n      origHide.call($(this))\n      callback && callback.call(this)\n    })\n  }\n\n  $.fn.show = function(speed, callback) {\n    origShow.call(this)\n    if (speed === undefined) speed = 0\n    else this.css('opacity', 0)\n    return anim(this, speed, 1, '1,1', callback)\n  }\n\n  $.fn.hide = function(speed, callback) {\n    if (speed === undefined) return origHide.call(this)\n    else return hide(this, speed, '0,0', callback)\n  }\n\n  $.fn.toggle = function(speed, callback) {\n    if (speed === undefined || typeof speed == 'boolean')\n      return origToggle.call(this, speed)\n    else return this.each(function(){\n      var el = $(this)\n      el[el.css('display') == 'none' ? 'show' : 'hide'](speed, callback)\n    })\n  }\n\n  $.fn.fadeTo = function(speed, opacity, callback) {\n    return anim(this, speed, opacity, null, callback)\n  }\n\n  $.fn.fadeIn = function(speed, callback) {\n    var target = this.css('opacity')\n    if (target > 0) this.css('opacity', 0)\n    else target = 1\n    return origShow.call(this).fadeTo(speed, target, callback)\n  }\n\n  $.fn.fadeOut = function(speed, callback) {\n    return hide(this, speed, null, callback)\n  }\n\n  $.fn.fadeToggle = function(speed, callback) {\n    return this.each(function(){\n      var el = $(this)\n      el[\n        (el.css('opacity') == 0 || el.css('display') == 'none') ? 'fadeIn' : 'fadeOut'\n      ](speed, callback)\n    })\n  }\n\n})(Zepto)\n","/*!\n * HC-Sticky\n * =========\n * Version: 2.2.3\n * Author: Some Web Media\n * Author URL: http://somewebmedia.com\n * Plugin URL: https://github.com/somewebmedia/hc-sticky\n * Description: Cross-browser plugin that makes any element on your page visible while you scroll\n * License: MIT\n */\n!function(t,e){\"use strict\";if(\"object\"==typeof module&&\"object\"==typeof module.exports){if(!t.document)throw new Error(\"HC-Sticky requires a browser to run.\");module.exports=e(t)}else\"function\"==typeof define&&define.amd?define(\"hcSticky\",[],e(t)):e(t)}(\"undefined\"!=typeof window?window:this,function(U){\"use strict\";var Y={top:0,bottom:0,bottomEnd:0,innerTop:0,innerSticker:null,stickyClass:\"sticky\",stickTo:null,followScroll:!0,responsive:null,mobileFirst:!1,onStart:null,onStop:null,onBeforeResize:null,onResize:null,resizeDebounce:100,disable:!1,queries:null,queryFlow:\"down\"},$=function(t,e,o){console.log(\"%c! HC Sticky:%c \"+t+\"%c \"+o+\" is now deprecated and will be removed. Use%c \"+e+\"%c instead.\",\"color: red\",\"color: darkviolet\",\"color: black\",\"color: darkviolet\",\"color: black\")},Q=U.document,X=function(n,f){var o=this;if(\"string\"==typeof n&&(n=Q.querySelector(n)),!n)return!1;f.queries&&$(\"queries\",\"responsive\",\"option\"),f.queryFlow&&$(\"queryFlow\",\"mobileFirst\",\"option\");var p={},d=X.Helpers,s=n.parentNode;\"static\"===d.getStyle(s,\"position\")&&(s.style.position=\"relative\");var u=function(){var t=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{};d.isEmptyObject(t)&&!d.isEmptyObject(p)||(p=Object.assign({},Y,p,t))},t=function(){return p.disable},e=function(){var t,e=p.responsive||p.queries;if(e){var o=U.innerWidth;if(t=f,(p=Object.assign({},Y,t||{})).mobileFirst)for(var i in e)i<=o&&!d.isEmptyObject(e[i])&&u(e[i]);else{var n=[];for(var s in e){var r={};r[s]=e[s],n.push(r)}for(var l=n.length-1;0<=l;l--){var a=n[l],c=Object.keys(a)[0];o<=c&&!d.isEmptyObject(a[c])&&u(a[c])}}}},r={css:{},position:null,stick:function(){var t=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{};d.hasClass(n,p.stickyClass)||(!1===l.isAttached&&l.attach(),r.position=\"fixed\",n.style.position=\"fixed\",n.style.left=l.offsetLeft+\"px\",n.style.width=l.width,void 0===t.bottom?n.style.bottom=\"auto\":n.style.bottom=t.bottom+\"px\",void 0===t.top?n.style.top=\"auto\":n.style.top=t.top+\"px\",n.classList?n.classList.add(p.stickyClass):n.className+=\" \"+p.stickyClass,p.onStart&&p.onStart.call(n,Object.assign({},p)))},release:function(){var t=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{};if(t.stop=t.stop||!1,!0===t.stop||\"fixed\"===r.position||null===r.position||!(void 0===t.top&&void 0===t.bottom||void 0!==t.top&&(parseInt(d.getStyle(n,\"top\"))||0)===t.top||void 0!==t.bottom&&(parseInt(d.getStyle(n,\"bottom\"))||0)===t.bottom)){!0===t.stop?!0===l.isAttached&&l.detach():!1===l.isAttached&&l.attach();var e=t.position||r.css.position;r.position=e,n.style.position=e,n.style.left=!0===t.stop?r.css.left:l.positionLeft+\"px\",n.style.width=\"absolute\"!==e?r.css.width:l.width,void 0===t.bottom?n.style.bottom=!0===t.stop?\"\":\"auto\":n.style.bottom=t.bottom+\"px\",void 0===t.top?n.style.top=!0===t.stop?\"\":\"auto\":n.style.top=t.top+\"px\",n.classList?n.classList.remove(p.stickyClass):n.className=n.className.replace(new RegExp(\"(^|\\\\b)\"+p.stickyClass.split(\" \").join(\"|\")+\"(\\\\b|$)\",\"gi\"),\" \"),p.onStop&&p.onStop.call(n,Object.assign({},p))}}},l={el:Q.createElement(\"div\"),offsetLeft:null,positionLeft:null,width:null,isAttached:!1,init:function(){for(var t in l.el.className=\"sticky-spacer\",r.css)l.el.style[t]=r.css[t];l.el.style[\"z-index\"]=\"-1\";var e=d.getStyle(n);l.offsetLeft=d.offset(n).left-(parseInt(e.marginLeft)||0),l.positionLeft=d.position(n).left,l.width=d.getStyle(n,\"width\")},attach:function(){s.insertBefore(l.el,n),l.isAttached=!0},detach:function(){l.el=s.removeChild(l.el),l.isAttached=!1}},a=void 0,c=void 0,g=void 0,m=void 0,h=void 0,v=void 0,y=void 0,b=void 0,S=void 0,w=void 0,k=void 0,E=void 0,x=void 0,L=void 0,T=void 0,j=void 0,O=void 0,C=void 0,i=function(){var t,e,o,i;r.css=(t=n,e=d.getCascadedStyle(t),o=d.getStyle(t),i={height:t.offsetHeight+\"px\",left:e.left,right:e.right,top:e.top,bottom:e.bottom,position:o.position,display:o.display,verticalAlign:o.verticalAlign,boxSizing:o.boxSizing,marginLeft:e.marginLeft,marginRight:e.marginRight,marginTop:e.marginTop,marginBottom:e.marginBottom,paddingLeft:e.paddingLeft,paddingRight:e.paddingRight},e.float&&(i.float=e.float||\"none\"),e.cssFloat&&(i.cssFloat=e.cssFloat||\"none\"),o.MozBoxSizing&&(i.MozBoxSizing=o.MozBoxSizing),i.width=\"auto\"!==e.width?e.width:\"border-box\"===i.boxSizing||\"border-box\"===i.MozBoxSizing?t.offsetWidth+\"px\":o.width,i),l.init(),a=!(!p.stickTo||!(\"document\"===p.stickTo||p.stickTo.nodeType&&9===p.stickTo.nodeType||\"object\"==typeof p.stickTo&&p.stickTo instanceof(\"undefined\"!=typeof HTMLDocument?HTMLDocument:Document))),c=p.stickTo?a?Q:\"string\"==typeof p.stickTo?Q.querySelector(p.stickTo):p.stickTo:s,T=(C=function(){var t=n.offsetHeight+(parseInt(r.css.marginTop)||0)+(parseInt(r.css.marginBottom)||0),e=(T||0)-t;return-1<=e&&e<=1?T:t})(),m=(O=function(){return a?Math.max(Q.documentElement.clientHeight,Q.body.scrollHeight,Q.documentElement.scrollHeight,Q.body.offsetHeight,Q.documentElement.offsetHeight):c.offsetHeight})(),h=a?0:d.offset(c).top,v=p.stickTo?a?0:d.offset(s).top:h,y=U.innerHeight,j=n.offsetTop-(parseInt(r.css.marginTop)||0),g=p.innerSticker?\"string\"==typeof p.innerSticker?Q.querySelector(p.innerSticker):p.innerSticker:null,b=isNaN(p.top)&&-1<p.top.indexOf(\"%\")?parseFloat(p.top)/100*y:p.top,S=isNaN(p.bottom)&&-1<p.bottom.indexOf(\"%\")?parseFloat(p.bottom)/100*y:p.bottom,w=g?g.offsetTop:p.innerTop?p.innerTop:0,k=isNaN(p.bottomEnd)&&-1<p.bottomEnd.indexOf(\"%\")?parseFloat(p.bottomEnd)/100*y:p.bottomEnd,E=h-b+w+j},z=U.pageYOffset||Q.documentElement.scrollTop,N=0,H=void 0,R=function(){T=C(),m=O(),x=h+m-b-k,L=y<T;var t=U.pageYOffset||Q.documentElement.scrollTop,e=d.offset(n).top,o=e-t,i=void 0;H=t<z?\"up\":\"down\",N=t-z,E<(z=t)?x+b+(L?S:0)-(p.followScroll&&L?0:b)<=t+T-w-(y-(E-w)<T-w&&p.followScroll&&0<(i=T-y-w)?i:0)?r.release({position:\"absolute\",bottom:v+s.offsetHeight-x-b}):L&&p.followScroll?\"down\"===H?o+T+S<=y+.9?r.stick({bottom:S}):\"fixed\"===r.position&&r.release({position:\"absolute\",top:e-b-E-N+w}):Math.ceil(o+w)<0&&\"fixed\"===r.position?r.release({position:\"absolute\",top:e-b-E+w-N}):t+b-w<=e&&r.stick({top:b-w}):r.stick({top:b-w}):r.release({stop:!0})},A=!1,B=!1,I=function(){A&&(d.event.unbind(U,\"scroll\",R),A=!1)},q=function(){null!==n.offsetParent&&\"none\"!==d.getStyle(n,\"display\")?(i(),m<=T?I():(R(),A||(d.event.bind(U,\"scroll\",R),A=!0))):I()},F=function(){n.style.position=\"\",n.style.left=\"\",n.style.top=\"\",n.style.bottom=\"\",n.style.width=\"\",n.classList?n.classList.remove(p.stickyClass):n.className=n.className.replace(new RegExp(\"(^|\\\\b)\"+p.stickyClass.split(\" \").join(\"|\")+\"(\\\\b|$)\",\"gi\"),\" \"),r.css={},!(r.position=null)===l.isAttached&&l.detach()},M=function(){F(),e(),t()?I():q()},D=function(){p.onBeforeResize&&p.onBeforeResize.call(n,Object.assign({},p)),M(),p.onResize&&p.onResize.call(n,Object.assign({},p))},P=p.resizeDebounce?d.debounce(D,p.resizeDebounce):D,W=function(){B&&(d.event.unbind(U,\"resize\",P),B=!1),I()},V=function(){B||(d.event.bind(U,\"resize\",P),B=!0),e(),t()?I():q()};this.options=function(t){return t?p[t]:Object.assign({},p)},this.refresh=M,this.update=function(t){u(t),f=Object.assign({},f,t||{}),M()},this.attach=V,this.detach=W,this.destroy=function(){W(),F()},this.triggerMethod=function(t,e){\"function\"==typeof o[t]&&o[t](e)},this.reinit=function(){$(\"reinit\",\"refresh\",\"method\"),M()},u(f),V(),d.event.bind(U,\"load\",M)};if(void 0!==U.jQuery){var i=U.jQuery,n=\"hcSticky\";i.fn.extend({hcSticky:function(e,o){return this.length?\"options\"===e?i.data(this.get(0),n).options():this.each(function(){var t=i.data(this,n);t?t.triggerMethod(e,o):(t=new X(this,e),i.data(this,n,t))}):this}})}return U.hcSticky=U.hcSticky||X,X}),function(c){\"use strict\";var t=c.hcSticky,f=c.document;\"function\"!=typeof Object.assign&&Object.defineProperty(Object,\"assign\",{value:function(t,e){if(null==t)throw new TypeError(\"Cannot convert undefined or null to object\");for(var o=Object(t),i=1;i<arguments.length;i++){var n=arguments[i];if(null!=n)for(var s in n)Object.prototype.hasOwnProperty.call(n,s)&&(o[s]=n[s])}return o},writable:!0,configurable:!0}),Array.prototype.forEach||(Array.prototype.forEach=function(t){var e,o;if(null==this)throw new TypeError(\"this is null or not defined\");var i=Object(this),n=i.length>>>0;if(\"function\"!=typeof t)throw new TypeError(t+\" is not a function\");for(1<arguments.length&&(e=arguments[1]),o=0;o<n;){var s;o in i&&(s=i[o],t.call(e,s,o,i)),o++}});var e=function(){var t=f.documentElement,e=function(){};function i(t){var e=c.event;return e.target=e.target||e.srcElement||t,e}t.addEventListener?e=function(t,e,o){t.addEventListener(e,o,!1)}:t.attachEvent&&(e=function(e,t,o){e[t+o]=o.handleEvent?function(){var t=i(e);o.handleEvent.call(o,t)}:function(){var t=i(e);o.call(e,t)},e.attachEvent(\"on\"+t,e[t+o])});var o=function(){};return t.removeEventListener?o=function(t,e,o){t.removeEventListener(e,o,!1)}:t.detachEvent&&(o=function(e,o,i){e.detachEvent(\"on\"+o,e[o+i]);try{delete e[o+i]}catch(t){e[o+i]=void 0}}),{bind:e,unbind:o}}(),r=function(t,e){return c.getComputedStyle?e?f.defaultView.getComputedStyle(t,null).getPropertyValue(e):f.defaultView.getComputedStyle(t,null):t.currentStyle?e?t.currentStyle[e.replace(/-\\w/g,function(t){return t.toUpperCase().replace(\"-\",\"\")})]:t.currentStyle:void 0},l=function(t){var e=t.getBoundingClientRect(),o=c.pageYOffset||f.documentElement.scrollTop,i=c.pageXOffset||f.documentElement.scrollLeft;return{top:e.top+o,left:e.left+i}};t.Helpers={isEmptyObject:function(t){for(var e in t)return!1;return!0},debounce:function(i,n,s){var r=void 0;return function(){var t=this,e=arguments,o=s&&!r;clearTimeout(r),r=setTimeout(function(){r=null,s||i.apply(t,e)},n),o&&i.apply(t,e)}},hasClass:function(t,e){return t.classList?t.classList.contains(e):new RegExp(\"(^| )\"+e+\"( |$)\",\"gi\").test(t.className)},offset:l,position:function(t){var e=t.offsetParent,o=l(e),i=l(t),n=r(e),s=r(t);return o.top+=parseInt(n.borderTopWidth)||0,o.left+=parseInt(n.borderLeftWidth)||0,{top:i.top-o.top-(parseInt(s.marginTop)||0),left:i.left-o.left-(parseInt(s.marginLeft)||0)}},getStyle:r,getCascadedStyle:function(t){var e=t.cloneNode(!0);e.style.display=\"none\",Array.prototype.slice.call(e.querySelectorAll('input[type=\"radio\"]')).forEach(function(t){t.removeAttribute(\"name\")}),t.parentNode.insertBefore(e,t.nextSibling);var o=void 0;e.currentStyle?o=e.currentStyle:c.getComputedStyle&&(o=f.defaultView.getComputedStyle(e,null));var i={};for(var n in o)!isNaN(n)||\"string\"!=typeof o[n]&&\"number\"!=typeof o[n]||(i[n]=o[n]);if(Object.keys(i).length<3)for(var s in i={},o)isNaN(s)||(i[o[s].replace(/-\\w/g,function(t){return t.toUpperCase().replace(\"-\",\"\")})]=o.getPropertyValue(o[s]));if(i.margin||\"auto\"!==i.marginLeft?i.margin||i.marginLeft!==i.marginRight||i.marginLeft!==i.marginTop||i.marginLeft!==i.marginBottom||(i.margin=i.marginLeft):i.margin=\"auto\",!i.margin&&\"0px\"===i.marginLeft&&\"0px\"===i.marginRight){var r=t.offsetLeft-t.parentNode.offsetLeft,l=r-(parseInt(i.left)||0)-(parseInt(i.right)||0),a=t.parentNode.offsetWidth-t.offsetWidth-r-(parseInt(i.right)||0)+(parseInt(i.left)||0)-l;0!==a&&1!==a||(i.margin=\"auto\")}return e.parentNode.removeChild(e),e=null,i},event:e}}(window);","module.exports = function(originalModule) {\n\tif (!originalModule.webpackPolyfill) {\n\t\tvar module = Object.create(originalModule);\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"exports\", {\n\t\t\tenumerable: true\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","/* ========================================================================\n * Bootstrap: dropdown.js v3.4.1\n * https://getbootstrap.com/docs/3.4/javascript/#dropdowns\n * ========================================================================\n * Copyright 2011-2019 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // DROPDOWN CLASS DEFINITION\n  // =========================\n\n  var backdrop = '.dropdown-backdrop'\n  var toggle   = '[data-toggle=\"dropdown\"]'\n  var Dropdown = function (element) {\n    $(element).on('click.bs.dropdown', this.toggle)\n  }\n\n  Dropdown.VERSION = '3.4.1'\n\n  function getParent($this) {\n    var selector = $this.attr('data-target')\n\n    if (!selector) {\n      selector = $this.attr('href')\n      selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\\s]*$)/, '') // strip for ie7\n    }\n\n    var $parent = selector !== '#' ? $(document).find(selector) : null\n\n    return $parent && $parent.length ? $parent : $this.parent()\n  }\n\n  function clearMenus(e) {\n    if (e && e.which === 3) return\n    $(backdrop).remove()\n    $(toggle).each(function () {\n      var $this         = $(this)\n      var $parent       = getParent($this)\n      var relatedTarget = { relatedTarget: this }\n\n      if (!$parent.hasClass('open')) return\n\n      if (e && e.type == 'click' && /input|textarea/i.test(e.target.tagName) && $.contains($parent[0], e.target)) return\n\n      $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))\n\n      if (e.isDefaultPrevented()) return\n\n      $this.attr('aria-expanded', 'false')\n      $parent.removeClass('open').trigger($.Event('hidden.bs.dropdown', relatedTarget))\n    })\n  }\n\n  Dropdown.prototype.toggle = function (e) {\n    var $this = $(this)\n\n    if ($this.is('.disabled, :disabled')) return\n\n    var $parent  = getParent($this)\n    var isActive = $parent.hasClass('open')\n\n    clearMenus()\n\n    if (!isActive) {\n      if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {\n        // if mobile we use a backdrop because click events don't delegate\n        $(document.createElement('div'))\n          .addClass('dropdown-backdrop')\n          .insertAfter($(this))\n          .on('click', clearMenus)\n      }\n\n      var relatedTarget = { relatedTarget: this }\n      $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))\n\n      if (e.isDefaultPrevented()) return\n\n      $this\n        .trigger('focus')\n        .attr('aria-expanded', 'true')\n\n      $parent\n        .toggleClass('open')\n        .trigger($.Event('shown.bs.dropdown', relatedTarget))\n    }\n\n    return false\n  }\n\n  Dropdown.prototype.keydown = function (e) {\n    if (!/(38|40|27|32)/.test(e.which) || /input|textarea/i.test(e.target.tagName)) return\n\n    var $this = $(this)\n\n    e.preventDefault()\n    e.stopPropagation()\n\n    if ($this.is('.disabled, :disabled')) return\n\n    var $parent  = getParent($this)\n    var isActive = $parent.hasClass('open')\n\n    if (!isActive && e.which != 27 || isActive && e.which == 27) {\n      if (e.which == 27) $parent.find(toggle).trigger('focus')\n      return $this.trigger('click')\n    }\n\n    var desc = ' li:not(.disabled):visible a'\n    var $items = $parent.find('.dropdown-menu' + desc)\n\n    if (!$items.length) return\n\n    var index = $items.index(e.target)\n\n    if (e.which == 38 && index > 0)                 index--         // up\n    if (e.which == 40 && index < $items.length - 1) index++         // down\n    if (!~index)                                    index = 0\n\n    $items.eq(index).trigger('focus')\n  }\n\n\n  // DROPDOWN PLUGIN DEFINITION\n  // ==========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this = $(this)\n      var data  = $this.data('bs.dropdown')\n\n      if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))\n      if (typeof option == 'string') data[option].call($this)\n    })\n  }\n\n  var old = $.fn.dropdown\n\n  $.fn.dropdown             = Plugin\n  $.fn.dropdown.Constructor = Dropdown\n\n\n  // DROPDOWN NO CONFLICT\n  // ====================\n\n  $.fn.dropdown.noConflict = function () {\n    $.fn.dropdown = old\n    return this\n  }\n\n\n  // APPLY TO STANDARD DROPDOWN ELEMENTS\n  // ===================================\n\n  $(document)\n    .on('click.bs.dropdown.data-api', clearMenus)\n    .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })\n    .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)\n    .on('keydown.bs.dropdown.data-api', toggle, Dropdown.prototype.keydown)\n    .on('keydown.bs.dropdown.data-api', '.dropdown-menu', Dropdown.prototype.keydown)\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: transition.js v3.4.1\n * https://getbootstrap.com/docs/3.4/javascript/#transitions\n * ========================================================================\n * Copyright 2011-2019 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // CSS TRANSITION SUPPORT (Shoutout: https://modernizr.com/)\n  // ============================================================\n\n  function transitionEnd() {\n    var el = document.createElement('bootstrap')\n\n    var transEndEventNames = {\n      WebkitTransition : 'webkitTransitionEnd',\n      MozTransition    : 'transitionend',\n      OTransition      : 'oTransitionEnd otransitionend',\n      transition       : 'transitionend'\n    }\n\n    for (var name in transEndEventNames) {\n      if (el.style[name] !== undefined) {\n        return { end: transEndEventNames[name] }\n      }\n    }\n\n    return false // explicit for ie8 (  ._.)\n  }\n\n  // https://blog.alexmaccaw.com/css-transitions\n  $.fn.emulateTransitionEnd = function (duration) {\n    var called = false\n    var $el = this\n    $(this).one('bsTransitionEnd', function () { called = true })\n    var callback = function () { if (!called) $($el).trigger($.support.transition.end) }\n    setTimeout(callback, duration)\n    return this\n  }\n\n  $(function () {\n    $.support.transition = transitionEnd()\n\n    if (!$.support.transition) return\n\n    $.event.special.bsTransitionEnd = {\n      bindType: $.support.transition.end,\n      delegateType: $.support.transition.end,\n      handle: function (e) {\n        if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)\n      }\n    }\n  })\n\n}(jQuery);\n","/* eslint-disable */\n;(function() {\n\"use strict\"\n/* eslint-enable */\nStream.SKIP = {}\nStream.lift = lift\nStream.scan = scan\nStream.merge = merge\nStream.combine = combine\nStream.scanMerge = scanMerge\nStream[\"fantasy-land/of\"] = Stream\n\nvar warnedHalt = false\nObject.defineProperty(Stream, \"HALT\", {\n\tget: function() {\n\t\twarnedHalt || console.log(\"HALT is deprecated and has been renamed to SKIP\");\n\t\twarnedHalt = true\n\t\treturn Stream.SKIP\n\t}\n})\n\nfunction Stream(value) {\n\tvar dependentStreams = []\n\tvar dependentFns = []\n\n\tfunction stream(v) {\n\t\tif (arguments.length && v !== Stream.SKIP) {\n\t\t\tvalue = v\n\t\t\tif (open(stream)) {\n\t\t\t\tstream._changing()\n\t\t\t\tstream._state = \"active\"\n\t\t\t\tdependentStreams.forEach(function(s, i) { s(dependentFns[i](value)) })\n\t\t\t}\n\t\t}\n\n\t\treturn value\n\t}\n\n\tstream.constructor = Stream\n\tstream._state = arguments.length && value !== Stream.SKIP ? \"active\" : \"pending\"\n\tstream._parents = []\n\n\tstream._changing = function() {\n\t\tif (open(stream)) stream._state = \"changing\"\n\t\tdependentStreams.forEach(function(s) {\n\t\t\ts._changing()\n\t\t})\n\t}\n\n\tstream._map = function(fn, ignoreInitial) {\n\t\tvar target = ignoreInitial ? Stream() : Stream(fn(value))\n\t\ttarget._parents.push(stream)\n\t\tdependentStreams.push(target)\n\t\tdependentFns.push(fn)\n\t\treturn target\n\t}\n\n\tstream.map = function(fn) {\n\t\treturn stream._map(fn, stream._state !== \"active\")\n\t}\n\n\tvar end\n\tfunction createEnd() {\n\t\tend = Stream()\n\t\tend.map(function(value) {\n\t\t\tif (value === true) {\n\t\t\t\tstream._parents.forEach(function (p) {p._unregisterChild(stream)})\n\t\t\t\tstream._state = \"ended\"\n\t\t\t\tstream._parents.length = dependentStreams.length = dependentFns.length = 0\n\t\t\t}\n\t\t\treturn value\n\t\t})\n\t\treturn end\n\t}\n\n\tstream.toJSON = function() { return value != null && typeof value.toJSON === \"function\" ? value.toJSON() : value }\n\n\tstream[\"fantasy-land/map\"] = stream.map\n\tstream[\"fantasy-land/ap\"] = function(x) { return combine(function(s1, s2) { return s1()(s2()) }, [x, stream]) }\n\n\tstream._unregisterChild = function(child) {\n\t\tvar childIndex = dependentStreams.indexOf(child)\n\t\tif (childIndex !== -1) {\n\t\t\tdependentStreams.splice(childIndex, 1)\n\t\t\tdependentFns.splice(childIndex, 1)\n\t\t}\n\t}\n\n\tObject.defineProperty(stream, \"end\", {\n\t\tget: function() { return end || createEnd() }\n\t})\n\n\treturn stream\n}\n\nfunction combine(fn, streams) {\n\tvar ready = streams.every(function(s) {\n\t\tif (s.constructor !== Stream)\n\t\t\tthrow new Error(\"Ensure that each item passed to stream.combine/stream.merge/lift is a stream\")\n\t\treturn s._state === \"active\"\n\t})\n\tvar stream = ready\n\t\t? Stream(fn.apply(null, streams.concat([streams])))\n\t\t: Stream()\n\n\tvar changed = []\n\n\tvar mappers = streams.map(function(s) {\n\t\treturn s._map(function(value) {\n\t\t\tchanged.push(s)\n\t\t\tif (ready || streams.every(function(s) { return s._state !== \"pending\" })) {\n\t\t\t\tready = true\n\t\t\t\tstream(fn.apply(null, streams.concat([changed])))\n\t\t\t\tchanged = []\n\t\t\t}\n\t\t\treturn value\n\t\t}, true)\n\t})\n\n\tvar endStream = stream.end.map(function(value) {\n\t\tif (value === true) {\n\t\t\tmappers.forEach(function(mapper) { mapper.end(true) })\n\t\t\tendStream.end(true)\n\t\t}\n\t\treturn undefined\n\t})\n\n\treturn stream\n}\n\nfunction merge(streams) {\n\treturn combine(function() { return streams.map(function(s) { return s() }) }, streams)\n}\n\nfunction scan(fn, acc, origin) {\n\tvar stream = origin.map(function(v) {\n\t\tvar next = fn(acc, v)\n\t\tif (next !== Stream.SKIP) acc = next\n\t\treturn next\n\t})\n\tstream(acc)\n\treturn stream\n}\n\nfunction scanMerge(tuples, seed) {\n\tvar streams = tuples.map(function(tuple) { return tuple[0] })\n\n\tvar stream = combine(function() {\n\t\tvar changed = arguments[arguments.length - 1]\n\t\tstreams.forEach(function(stream, i) {\n\t\t\tif (changed.indexOf(stream) > -1)\n\t\t\t\tseed = tuples[i][1](seed, stream())\n\t\t})\n\n\t\treturn seed\n\t}, streams)\n\n\tstream(seed)\n\n\treturn stream\n}\n\nfunction lift() {\n\tvar fn = arguments[0]\n\tvar streams = Array.prototype.slice.call(arguments, 1)\n\treturn merge(streams).map(function(streams) {\n\t\treturn fn.apply(undefined, streams)\n\t})\n}\n\nfunction open(s) {\n\treturn s._state === \"pending\" || s._state === \"active\" || s._state === \"changing\"\n}\n\nif (typeof module !== \"undefined\") module[\"exports\"] = Stream\nelse if (typeof window.m === \"function\" && !(\"stream\" in window.m)) window.m.stream = Stream\nelse window.m = {stream : Stream}\n\n}());\n","/*\r\n * This file is part of Flarum.\r\n *\r\n * (c) Toby Zerner <toby.zerner@gmail.com>\r\n *\r\n * For the full copyright and license information, please view the LICENSE\r\n * file that was distributed with this source code.\r\n */\r\n\r\nexport * from './src/common';\r\nexport * from './src/admin';\r\n"],"sourceRoot":""}