From 31cfe0f9df26ef5f4aae888a973ac09ee0adff3c Mon Sep 17 00:00:00 2001 From: David Sevilla Martin Date: Sat, 7 Mar 2020 17:40:23 -0500 Subject: [PATCH] forum: resolve some typings issues & move Notifications to not use Component#render --- js/dist/admin.js.map | 2 +- js/dist/forum.js | 2 +- js/dist/forum.js.map | 2 +- js/src/common/Session.ts | 2 +- js/src/common/components/Dropdown.tsx | 2 +- js/src/forum/Forum.ts | 2 +- js/src/forum/components/HeaderSecondary.tsx | 10 +++++++--- js/src/forum/components/NotificationList.tsx | 6 ++++-- js/src/forum/components/NotificationsDropdown.tsx | 10 ++++------ js/webpack-flarum-shims.d.ts | 4 ++-- 10 files changed, 23 insertions(+), 19 deletions(-) diff --git a/js/dist/admin.js.map b/js/dist/admin.js.map index c41413de5..b1605f828 100644 --- a/js/dist/admin.js.map +++ b/js/dist/admin.js.map @@ -1 +1 @@ -{"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/./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/utils/patchMithril.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","attrs","oncreate","dom","onbeforeupdate","onupdate","onbeforeremove","onremove","$","selector","$element","find","render","fragment","component","children","componentProps","initProps","constructor","_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","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","args","destructure","keys","forEach","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","animatedScrollTop","to","fx","speeds","_default","jump","extend","special","bindBeforeSpecialEvents","eventName","el","specialEvent","_init","originalHandler","$target","trigger","setup","mo","_m","dayjs","relativeTime","localizedFormat","comp","writable","concat","bidi","route","href","Link","withAttr","cb","getAttribute","prop","navigator","timeoutDuration","longerTimeoutBrowsers","isBrowser","called","scheduled","isFunction","getStyleComputedProperty","getParentNode","getScrollParent","overflow","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","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","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","ms","Q","weekdays","months","pl","date","D","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","animate","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 = 143);\n","import Mithril from 'mithril';\n\nexport type ComponentProps = {\n children?: Mithril.Children;\n\n className?: string;\n\n [key: string]: any;\n};\n\nexport default class Component {\n element: HTMLElement;\n\n props: T;\n\n constructor(props: T = {}) {\n this.props = props.tag ? {} : props;\n }\n\n view(vnode) {\n throw new Error('Component#view must be implemented by subclass');\n }\n\n oninit(vnode) {\n this.setProps(vnode.attrs);\n }\n\n oncreate(vnode) {\n this.setProps(vnode.attrs);\n this.element = vnode.dom;\n }\n\n onbeforeupdate(vnode) {\n this.setProps(vnode.attrs);\n }\n\n onupdate(vnode) {\n this.setProps(vnode.attrs);\n }\n\n onbeforeremove(vnode) {\n this.setProps(vnode.attrs);\n }\n\n onremove(vnode) {\n this.setProps(vnode.attrs);\n }\n\n /**\n * Returns a jQuery object for this component's element. If you pass in a\n * selector string, this method will return a jQuery object, using the current\n * element as its buffer.\n *\n * For example, calling `component.$('li')` will return a jQuery object\n * containing all of the `li` elements inside the DOM element of this\n * component.\n *\n * @param selector a jQuery-compatible selector string\n * @final\n */\n $(selector?: string): ZeptoCollection {\n const $element = $(this.element);\n\n return selector ? $element.find(selector) : $element;\n }\n\n render() {\n return m.fragment(\n {\n ...this.props,\n oninit: (...args) => this.oninit(...args),\n oncreate: (...args) => this.oncreate(...args),\n onbeforeupdate: (...args) => this.onbeforeupdate(...args),\n onupdate: (...args) => this.onupdate.bind(...args),\n onbeforeremove: (...args) => this.onbeforeremove.bind(...args),\n onremove: (...args) => this.onremove.bind(...args),\n },\n this.view()\n );\n }\n\n static component(props: ComponentProps | any = {}, children?: Mithril.Children) {\n const componentProps: ComponentProps = Object.assign({}, props);\n\n if (children) componentProps.children = children;\n\n return m(this, componentProps);\n }\n\n static initProps(props: ComponentProps = {}) {}\n\n private setProps(props: T) {\n (this.constructor as typeof Component).initProps(props);\n\n this.props = props;\n }\n}\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","\"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.
\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';\nimport Tooltip from 'tooltip.js';\n\n// add $.fn.tooltip\n$.fn.tooltip = function(option) {\n return this.each(function() {\n const $this = $(this);\n let data = $this.data('bs.tooltip');\n const options = (typeof option === 'object' && option) || {};\n\n if ($this.attr('title')) {\n options.title = $this.attr('title');\n $this.removeAttr('title');\n $this.attr('data-original-title', options.title);\n }\n\n if (option === 'destroy') option = 'dispose';\n\n if (!data && ['dispose', 'hide'].includes(option)) return;\n\n if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)));\n if (typeof option === 'string' && data[option]) data[option]();\n });\n};\n\n// add $.fn.outerWidth and $.fn.outerHeight\n['width', 'height'].forEach(function(dimension) {\n const Dimension = dimension.replace(/./, function(m) {\n return m[0].toUpperCase();\n });\n\n $.fn[`outer${Dimension}`] = function(margin) {\n const elem = this;\n\n if (elem) {\n const sides = { width: ['left', 'right'], height: ['top', 'bottom'] };\n let size = elem[dimension]();\n\n sides[dimension].forEach(function(side) {\n if (margin) size += parseInt(elem.css('margin-' + side), 10);\n });\n\n return size;\n } else {\n return null;\n }\n };\n});\n\n// allow use of $(':input')\n// @ts-ignore\n$.expr[':']['input'] = function() {\n if ('disabled' in this || ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON'].includes(this.tagName)) return this;\n};\n\n// add $().hover() method\n$.fn.hover = function(hover, leave) {\n return this.on('mouseenter', hover).on('mouseleave', leave || hover);\n};\n\n// add animated scroll\n$.fn.animatedScrollTop = function(to, duration = $.fx.speeds._default, callback) {\n if (typeof to === 'number') to -= window.scrollY || window.pageYOffset;\n\n jump(to, {\n duration: $.fx.speeds[duration] || duration,\n callback,\n });\n\n return this;\n};\n\n// required for compatibility with jquery plugins\n// ex: bootstrap plugins\n$.fn.extend = $.extend.bind($);\n\n/**\n * Enable special events on Zepto\n * @license Original Copyright 2013 Enideo. Released under dual MIT and GPL licenses.\n */\n// @ts-ignore\n$.event.special = $.event.special || {};\n\nconst bindBeforeSpecialEvents = $.fn.bind;\n\n$.fn.bind = function(eventName, data, callback) {\n const el = this;\n\n if (!callback) {\n callback = data;\n data = null;\n }\n\n $.each(eventName.split(/\\s/), (key: string, value: any): boolean => {\n value = value.split(/\\./)[0];\n\n if (value in $.event.special) {\n let specialEvent = $.event.special[value];\n\n /// init enable special events on Zepto\n if (!specialEvent._init) {\n specialEvent._init = true;\n\n /// intercept and replace the special event handler to add functionality\n specialEvent.originalHandler = specialEvent.handler;\n specialEvent.handler = function() {\n /// make event argument writable, like on jQuery\n const args = Array.prototype.slice.call(arguments);\n\n args[0] = $.extend({}, args[0]);\n\n /// define the event handle, $.event.dispatch is only for newer versions of jQuery\n $.event.handle = function() {\n /// make context of trigger the event element\n const args = Array.prototype.slice.call(arguments);\n const event = args[0];\n const $target = $(event.target);\n\n $target.trigger.apply($target, arguments);\n };\n\n specialEvent.originalHandler.apply(this, args);\n };\n }\n\n /// setup special events on Zepto\n specialEvent.setup.apply(el, [data]);\n }\n\n return true;\n });\n\n return bindBeforeSpecialEvents.apply(this, [eventName, callback]);\n};\n","import m from 'mithril';\nimport prop from 'mithril/stream';\n\nimport Component from '../Component';\n\nexport default () => {\n const mo = window['m'];\n\n const _m = function(comp, ...args) {\n if (!arguments[1]) arguments[1] = {};\n\n if (comp.prototype && comp.prototype instanceof Component) {\n let children = args.slice(1);\n if (children.length === 1 && Array.isArray(children[0])) {\n children = children[0];\n }\n\n if (children) {\n Object.defineProperty(arguments[1], 'children', {\n writable: true,\n });\n\n arguments[1].children = (arguments[1].children || []).concat(children);\n }\n }\n\n const node = mo.apply(this, arguments);\n\n if (!node.attrs) node.attrs = {};\n\n if (node.attrs.bidi) {\n m.bidi(node, node.attrs.bidi);\n }\n\n if (node.attrs.route) {\n node.attrs.href = node.attrs.route;\n node.attrs.tag = m.route.Link;\n\n delete node.attrs.route;\n }\n\n return node;\n };\n\n Object.keys(mo).forEach(key => (_m[key] = mo[key]));\n\n _m.withAttr = (key: string, cb: Function) =>\n function() {\n cb(this.getAttribute(key) || this[key]);\n };\n\n _m.prop = prop;\n\n window['m'] = _m;\n};\n","import 'expose-loader?jQuery!zepto';\nimport 'expose-loader?moment!expose-loader?dayjs!dayjs';\nimport 'expose-loader?m!mithril';\nimport 'expose-loader?m.bidi!m.attrs.bidi';\nimport 'expose-loader?Mousetrap!mousetrap';\nimport 'expose-loader?classNames!classNames';\n\nimport 'zepto/src/selector';\nimport 'zepto/src/data';\nimport 'zepto/src/fx';\nimport 'zepto/src/fx_methods';\n\nimport './utils/patchZepto';\n\nimport 'hc-sticky';\nimport 'bootstrap/js/dropdown';\nimport 'bootstrap/js/transition';\n\nimport relativeTime from 'dayjs/plugin/relativeTime';\nimport localizedFormat from 'dayjs/plugin/localizedFormat';\n\ndayjs.extend(relativeTime);\ndayjs.extend(localizedFormat);\n\nimport patchMithril from './utils/patchMithril';\n\npatchMithril();\n\n// import * as Extend from './extend/index';\n\n// export { Extend };\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.
\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 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.
\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.
\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.
\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.
\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.
\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.
\n * It will read the variation of the `placement` property.
\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.
\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.
\n * The latter is a deprecated method because it leads to confusion and will be\n * removed in v2.
\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.
\n * We can say it has \"escaped the boundaries\" — or just \"escaped\".
\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.
\n * These can be overridden using the `options` argument of Popper.js.
\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.
\n * By default, it is set to no-op.
\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.
\n * By default, it is set to no-op.
\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;l0,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>\")\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>/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 $('
').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,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||(l=r),r},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) 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 = \"ij\"\n\t\t// console.log(div.innerHTML)\n\t\t// --> \"ij\", no 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 = \"\" + vnode.children + \"\"\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>>0;if(\"function\"!=typeof t)throw new TypeError(t+\" is not a function\");for(1 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","/*\n * This file is part of Flarum.\n *\n * (c) Toby Zerner \n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nexport * from './src/common';\nexport * from './src/admin';\n"],"sourceRoot":""} \ No newline at end of file +{"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/./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/utils/patchMithril.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","attrs","oncreate","dom","onbeforeupdate","onupdate","onbeforeremove","onremove","$","selector","$element","find","render","fragment","component","children","componentProps","initProps","constructor","_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","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","args","destructure","keys","forEach","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","animatedScrollTop","to","fx","speeds","_default","jump","extend","special","bindBeforeSpecialEvents","eventName","el","specialEvent","_init","originalHandler","$target","trigger","setup","mo","_m","dayjs","relativeTime","localizedFormat","comp","writable","concat","bidi","route","href","Link","withAttr","cb","getAttribute","prop","navigator","timeoutDuration","longerTimeoutBrowsers","isBrowser","called","scheduled","isFunction","getStyleComputedProperty","getParentNode","getScrollParent","overflow","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","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","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","ms","Q","weekdays","months","pl","date","D","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","animate","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 = 143);\n","import Mithril 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 {\r\n element: HTMLElement;\r\n\r\n props: T;\r\n\r\n constructor(props: T = {}) {\r\n this.props = props.tag ? {} : 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.attrs);\r\n }\r\n\r\n oncreate(vnode) {\r\n this.setProps(vnode.attrs);\r\n this.element = vnode.dom;\r\n }\r\n\r\n onbeforeupdate(vnode) {\r\n this.setProps(vnode.attrs);\r\n }\r\n\r\n onupdate(vnode) {\r\n this.setProps(vnode.attrs);\r\n }\r\n\r\n onbeforeremove(vnode) {\r\n this.setProps(vnode.attrs);\r\n }\r\n\r\n onremove(vnode) {\r\n this.setProps(vnode.attrs);\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.fragment(\r\n {\r\n ...this.props,\r\n oninit: (...args) => this.oninit(...args),\r\n oncreate: (...args) => this.oncreate(...args),\r\n onbeforeupdate: (...args) => this.onbeforeupdate(...args),\r\n onupdate: (...args) => this.onupdate.bind(...args),\r\n onbeforeremove: (...args) => this.onbeforeremove.bind(...args),\r\n onremove: (...args) => this.onremove.bind(...args),\r\n },\r\n this.view()\r\n );\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(props: T) {\r\n (this.constructor as typeof Component).initProps(props);\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","\"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.
\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';\nimport Tooltip from 'tooltip.js';\n\n// add $.fn.tooltip\n$.fn.tooltip = function(option) {\n return this.each(function() {\n const $this = $(this);\n let data = $this.data('bs.tooltip');\n const options = (typeof option === 'object' && option) || {};\n\n if ($this.attr('title')) {\n options.title = $this.attr('title');\n $this.removeAttr('title');\n $this.attr('data-original-title', options.title);\n }\n\n if (option === 'destroy') option = 'dispose';\n\n if (!data && ['dispose', 'hide'].includes(option)) return;\n\n if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)));\n if (typeof option === 'string' && data[option]) data[option]();\n });\n};\n\n// add $.fn.outerWidth and $.fn.outerHeight\n['width', 'height'].forEach(function(dimension) {\n const Dimension = dimension.replace(/./, function(m) {\n return m[0].toUpperCase();\n });\n\n $.fn[`outer${Dimension}`] = function(margin) {\n const elem = this;\n\n if (elem) {\n const sides = { width: ['left', 'right'], height: ['top', 'bottom'] };\n let size = elem[dimension]();\n\n sides[dimension].forEach(function(side) {\n if (margin) size += parseInt(elem.css('margin-' + side), 10);\n });\n\n return size;\n } else {\n return null;\n }\n };\n});\n\n// allow use of $(':input')\n// @ts-ignore\n$.expr[':']['input'] = function() {\n if ('disabled' in this || ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON'].includes(this.tagName)) return this;\n};\n\n// add $().hover() method\n$.fn.hover = function(hover, leave) {\n return this.on('mouseenter', hover).on('mouseleave', leave || hover);\n};\n\n// add animated scroll\n$.fn.animatedScrollTop = function(to, duration = $.fx.speeds._default, callback) {\n if (typeof to === 'number') to -= window.scrollY || window.pageYOffset;\n\n jump(to, {\n duration: $.fx.speeds[duration] || duration,\n callback,\n });\n\n return this;\n};\n\n// required for compatibility with jquery plugins\n// ex: bootstrap plugins\n$.fn.extend = $.extend.bind($);\n\n/**\n * Enable special events on Zepto\n * @license Original Copyright 2013 Enideo. Released under dual MIT and GPL licenses.\n */\n// @ts-ignore\n$.event.special = $.event.special || {};\n\nconst bindBeforeSpecialEvents = $.fn.bind;\n\n$.fn.bind = function(eventName, data, callback) {\n const el = this;\n\n if (!callback) {\n callback = data;\n data = null;\n }\n\n $.each(eventName.split(/\\s/), (key: string, value: any): boolean => {\n value = value.split(/\\./)[0];\n\n if (value in $.event.special) {\n let specialEvent = $.event.special[value];\n\n /// init enable special events on Zepto\n if (!specialEvent._init) {\n specialEvent._init = true;\n\n /// intercept and replace the special event handler to add functionality\n specialEvent.originalHandler = specialEvent.handler;\n specialEvent.handler = function() {\n /// make event argument writable, like on jQuery\n const args = Array.prototype.slice.call(arguments);\n\n args[0] = $.extend({}, args[0]);\n\n /// define the event handle, $.event.dispatch is only for newer versions of jQuery\n $.event.handle = function() {\n /// make context of trigger the event element\n const args = Array.prototype.slice.call(arguments);\n const event = args[0];\n const $target = $(event.target);\n\n $target.trigger.apply($target, arguments);\n };\n\n specialEvent.originalHandler.apply(this, args);\n };\n }\n\n /// setup special events on Zepto\n specialEvent.setup.apply(el, [data]);\n }\n\n return true;\n });\n\n return bindBeforeSpecialEvents.apply(this, [eventName, callback]);\n};\n","import m from 'mithril';\nimport prop from 'mithril/stream';\n\nimport Component from '../Component';\n\nexport default () => {\n const mo = window['m'];\n\n const _m = function(comp, ...args) {\n if (!arguments[1]) arguments[1] = {};\n\n if (comp.prototype && comp.prototype instanceof Component) {\n let children = args.slice(1);\n if (children.length === 1 && Array.isArray(children[0])) {\n children = children[0];\n }\n\n if (children) {\n Object.defineProperty(arguments[1], 'children', {\n writable: true,\n });\n\n arguments[1].children = (arguments[1].children || []).concat(children);\n }\n }\n\n const node = mo.apply(this, arguments);\n\n if (!node.attrs) node.attrs = {};\n\n if (node.attrs.bidi) {\n m.bidi(node, node.attrs.bidi);\n }\n\n if (node.attrs.route) {\n node.attrs.href = node.attrs.route;\n node.attrs.tag = m.route.Link;\n\n delete node.attrs.route;\n }\n\n return node;\n };\n\n Object.keys(mo).forEach(key => (_m[key] = mo[key]));\n\n _m.withAttr = (key: string, cb: Function) =>\n function() {\n cb(this.getAttribute(key) || this[key]);\n };\n\n _m.prop = prop;\n\n window['m'] = _m;\n};\n","import 'expose-loader?jQuery!zepto';\nimport 'expose-loader?moment!expose-loader?dayjs!dayjs';\nimport 'expose-loader?m!mithril';\nimport 'expose-loader?m.bidi!m.attrs.bidi';\nimport 'expose-loader?Mousetrap!mousetrap';\nimport 'expose-loader?classNames!classNames';\n\nimport 'zepto/src/selector';\nimport 'zepto/src/data';\nimport 'zepto/src/fx';\nimport 'zepto/src/fx_methods';\n\nimport './utils/patchZepto';\n\nimport 'hc-sticky';\nimport 'bootstrap/js/dropdown';\nimport 'bootstrap/js/transition';\n\nimport relativeTime from 'dayjs/plugin/relativeTime';\nimport localizedFormat from 'dayjs/plugin/localizedFormat';\n\ndayjs.extend(relativeTime);\ndayjs.extend(localizedFormat);\n\nimport patchMithril from './utils/patchMithril';\n\npatchMithril();\n\n// import * as Extend from './extend/index';\n\n// export { Extend };\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.
\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 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.
\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.
\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.
\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.
\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.
\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.
\n * It will read the variation of the `placement` property.
\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.
\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.
\n * The latter is a deprecated method because it leads to confusion and will be\n * removed in v2.
\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.
\n * We can say it has \"escaped the boundaries\" — or just \"escaped\".
\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.
\n * These can be overridden using the `options` argument of Popper.js.
\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.
\n * By default, it is set to no-op.
\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.
\n * By default, it is set to no-op.
\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;l0,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>\")\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>/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 $('
').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,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||(l=r),r},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) 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 = \"ij\"\n\t\t// console.log(div.innerHTML)\n\t\t// --> \"ij\", no 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 = \"\" + vnode.children + \"\"\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>>0;if(\"function\"!=typeof t)throw new TypeError(t+\" is not a function\");for(1 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","/*\n * This file is part of Flarum.\n *\n * (c) Toby Zerner \n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nexport * from './src/common';\nexport * from './src/admin';\n"],"sourceRoot":""} \ No newline at end of file diff --git a/js/dist/forum.js b/js/dist/forum.js index 654bd3a3c..883252341 100644 --- a/js/dist/forum.js +++ b/js/dist/forum.js @@ -68,5 +68,5 @@ var n="undefined"!=typeof window&&"undefined"!=typeof document&&"undefined"!=typ * Plugin URL: https://github.com/somewebmedia/hc-sticky * Description: Cross-browser plugin that makes any element on your page visible while you scroll * License: MIT - */!function(e,r){if("object"==typeof t.exports){if(!e.document)throw new Error("HC-Sticky requires a browser to run.");t.exports=r(e)}else"function"==typeof define&&n(60)?define("hcSticky",[],r(e)):r(e)}("undefined"!=typeof window?window:void 0,(function(t){var n={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"},r=function(t,e,n){console.log("%c! HC Sticky:%c "+t+"%c "+n+" is now deprecated and will be removed. Use%c "+e+"%c instead.","color: red","color: darkviolet","color: black","color: darkviolet","color: black")},i=t.document,o=function o(s,a){var c=this;if("string"==typeof s&&(s=i.querySelector(s)),!s)return!1;a.queries&&r("queries","responsive","option"),a.queryFlow&&r("queryFlow","mobileFirst","option");var u={},l=o.Helpers,f=s.parentNode;"static"===l.getStyle(f,"position")&&(f.style.position="relative");var d=function(){var t=0>>0;if("function"!=typeof t)throw new TypeError(t+" is not a function");for(10&&c--,40==n.which&&c-1&&(e=t[i][1](e,n()))})),e}),n);return i(e),i},n["fantasy-land/of"]=n;var e=!1;function n(t){var e,i=[],s=[];function a(e){return arguments.length&&e!==n.SKIP&&(t=e,o(a)&&(a._changing(),a._state="active",i.forEach((function(e,n){e(s[n](t))})))),t}function c(){return(e=n()).map((function(t){return!0===t&&(a._parents.forEach((function(t){t._unregisterChild(a)})),a._state="ended",a._parents.length=i.length=s.length=0),t})),e}return a.constructor=n,a._state=arguments.length&&t!==n.SKIP?"active":"pending",a._parents=[],a._changing=function(){o(a)&&(a._state="changing"),i.forEach((function(t){t._changing()}))},a._map=function(e,r){var o=r?n():n(e(t));return o._parents.push(a),i.push(o),s.push(e),o},a.map=function(t){return a._map(t,"active"!==a._state)},a.toJSON=function(){return null!=t&&"function"==typeof t.toJSON?t.toJSON():t},a["fantasy-land/map"]=a.map,a["fantasy-land/ap"]=function(t){return r((function(t,e){return t()(e())}),[t,a])},a._unregisterChild=function(t){var e=i.indexOf(t);-1!==e&&(i.splice(e,1),s.splice(e,1))},Object.defineProperty(a,"end",{get:function(){return e||c()}}),a}function r(t,e){var r=e.every((function(t){if(t.constructor!==n)throw new Error("Ensure that each item passed to stream.combine/stream.merge/lift is a stream");return"active"===t._state})),i=r?n(t.apply(null,e.concat([e]))):n(),o=[],s=e.map((function(n){return n._map((function(s){return o.push(n),(r||e.every((function(t){return"pending"!==t._state})))&&(r=!0,i(t.apply(null,e.concat([o]))),o=[]),s}),!0)})),a=i.end.map((function(t){!0===t&&(s.forEach((function(t){t.end(!0)})),a.end(!0))}));return i}function i(t){return r((function(){return t.map((function(t){return t()}))}),t)}function o(t){return"pending"===t._state||"active"===t._state||"changing"===t._state}Object.defineProperty(n,"HALT",{get:function(){return e||console.log("HALT is deprecated and has been renamed to SKIP"),e=!0,n.SKIP}}),t.exports=n}()},function(t,e,n){var r=n(24).Symbol;t.exports=r},function(t,e){t.exports=function(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}},function(t,e,n){var r=n(23),i=n(25);t.exports=function(t){return"symbol"==typeof t||i(t)&&"[object Symbol]"==r(t)}},function(t,e,n){var r=n(115),i=n(119);t.exports=function(t,e){var n=i(t,e);return r(n)?n:void 0}},function(t,e,n){(function(e){var n="object"==typeof e&&e&&e.Object===Object&&e;t.exports=n}).call(this,n(2))},function(t,e){t.exports=function(t){return t.webpackPolyfill||(t.deprecate=function(){},t.paths=[],t.children||(t.children=[]),Object.defineProperty(t,"loaded",{enumerable:!0,get:function(){return t.l}}),Object.defineProperty(t,"id",{enumerable:!0,get:function(){return t.i}}),t.webpackPolyfill=1),t}},function(t,e){var n=/^(?:0|[1-9]\d*)$/;t.exports=function(t,e){var r=typeof t;return!!(e=null==e?9007199254740991:e)&&("number"==r||"symbol"!=r&&n.test(t))&&t>-1&&t%1==0&&t-1&&t%1==0&&t<=9007199254740991}},function(t,e,n){var r=n(73),i=n(71);t.exports=function(t){return null!=t&&i(t.length)&&!r(t)}},function(t,e,n){var r=n(23),i=n(65);t.exports=function(t){if(!i(t))return!1;var e=r(t);return"[object Function]"==e||"[object GeneratorFunction]"==e||"[object AsyncFunction]"==e||"[object Proxy]"==e}},function(t,e,n){var r=n(17),i=n(107),o=n(108),s=n(136);t.exports=function(t,e){return r(t)?t:i(t,e)?[t]:o(s(t))}},function(t,e){t.exports=function(t,e){return t===e||t!=t&&e!=e}},function(t,e,n){var r=n(66);t.exports=function(t){if("string"==typeof t||r(t))return t;var e=t+"";return"0"==e&&1/t==-1/0?"-0":e}},,function(t,e,n){var r=n(81),i=n(82),o=n(104),s=n(17);t.exports=function(t,e){return(s(t)?r:i)(t,o(e))}},function(t,e,n){var r=n(106);t.exports=function(t,e,n){var i=null==t?void 0:r(t,e);return void 0===i?n:i}},function(t,e,n){var r=n(139);t.exports=function(t,e,n){return null==t?t:r(t,e,n)}},function(t,e){t.exports=function(t,e){for(var n=-1,r=null==t?0:t.length;++n-1}},function(t,e,n){var r=n(27);t.exports=function(t,e){var n=this.__data__,i=r(n,t);return i<0?(++this.size,n.push([t,e])):n[i][1]=e,this}},function(t,e,n){var r=n(67)(n(24),"Map");t.exports=r},function(t,e,n){var r=n(28);t.exports=function(t){var e=r(this,t).delete(t);return this.size-=e?1:0,e}},function(t,e){t.exports=function(t){var e=typeof t;return"string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t}},function(t,e,n){var r=n(28);t.exports=function(t){return r(this,t).get(t)}},function(t,e,n){var r=n(28);t.exports=function(t){return r(this,t).has(t)}},function(t,e,n){var r=n(28);t.exports=function(t,e){var n=r(this,t),i=n.size;return n.set(t,e),this.size+=n.size==i?0:1,this}},function(t,e,n){var r=n(137);t.exports=function(t){return null==t?"":r(t)}},function(t,e,n){var r=n(64),i=n(138),o=n(17),s=n(66),a=r?r.prototype:void 0,c=a?a.toString:void 0;t.exports=function t(e){if("string"==typeof e)return e;if(o(e))return i(e,t)+"";if(s(e))return c?c.call(e):"";var n=e+"";return"0"==n&&1/e==-1/0?"-0":n}},function(t,e){t.exports=function(t,e){for(var n=-1,r=null==t?0:t.length,i=Array(r);++n)","gi")),i=[],o=[i];return r.forEach((function(t){var n=t.match(new RegExp("{([a-z0-9_]+)}|<(/?)([a-z0-9_]+)>","i"));if(n){if(n[1])o[0].push(e[n[1]]);else if(n[3])if(n[2])o.shift();else{var r=e[n[3]]||{tag:n[3],children:[]};o[0].push(r),o.unshift(r.children||r)}}else o[0].push({tag:"span",text:t})})),i.filter((function(t){return t}))},e.pluralize=function(t,e){var n=this,r=new RegExp(/^\w+\: +(.+)$/),i=new RegExp(/^\s*((\{\s*(\-?\d+[\s*,\s*\-?\d+]*)\s*\})|([\[\]])\s*(-Inf|\-?\d+)\s*,\s*(\+?Inf|\-?\d+)\s*([\[\]]))\s?(.+?)$/),o=new RegExp(/^\s*(\{\s*(\-?\d+[\s*,\s*\-?\d+]*)\s*\})|([\[\]])\s*(-Inf|\-?\d+)\s*,\s*(\+?Inf|\-?\d+)\s*([\[\]])/),s=[],a=[];return t.split("|").forEach((function(t){if(i.test(t)){var e=t.match(i);a[e[0]]=e[e.length-1]}else if(r.test(t)){var n=t.match(r);s.push(n[1])}else s.push(t)})),a.forEach((function(t,r){if(o.test(r)){var i=r.match(o);if(i[1]){var s=i[2].split(",");for(var c in s)if(e==s[c])return a[r]}else{var u=n.convertNumber(i[4]),l=n.convertNumber(i[5]);if(("["===i[3]?e>=u:e>u)&&("]"===i[6]?e<=l:e3&&(e=e.split("_")[0]),e){case"bo":case"dz":case"id":case"ja":case"jv":case"ka":case"km":case"kn":case"ko":case"ms":case"th":case"vi":case"zh":return 0;case"af":case"az":case"bn":case"bg":case"ca":case"da":case"de":case"el":case"en":case"eo":case"es":case"et":case"eu":case"fa":case"fi":case"fo":case"fur":case"fy":case"gl":case"gu":case"ha":case"he":case"hu":case"is":case"it":case"ku":case"lb":case"ml":case"mn":case"mr":case"nah":case"nb":case"ne":case"nl":case"nn":case"no":case"om":case"or":case"pa":case"pap":case"ps":case"pt":case"so":case"sq":case"sv":case"sw":case"ta":case"te":case"tk":case"tr":case"ur":case"zu":return 1==t?0:1;case"am":case"bh":case"fil":case"fr":case"gun":case"hi":case"ln":case"mg":case"nso":case"xbr":case"ti":case"wa":return 0===t||1==t?0:1;case"be":case"bs":case"hr":case"ru":case"sr":case"uk":return t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2;case"cs":case"sk":return 1==t?0:t>=2&&t<=4?1:2;case"ga":return 1==t?0:2==t?1:2;case"lt":return t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2;case"sl":return t%100==1?0:t%100==2?1:t%100==3||t%100==4?2:3;case"mk":return t%10==1?0:1;case"mt":return 1==t?0:0===t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3;case"lv":return 0===t?0:t%10==1&&t%100!=11?1:2;case"pl":return 1==t?0:t%10>=2&&t%10<=4&&(t%100<12||t%100>14)?1:2;case"cy":return 1==t?0:2==t?1:8==t||11==t?2:3;case"ro":return 1==t?0:0===t||t%100>0&&t%100<20?1:2;case"ar":return 0===t?0:1==t?1:2==t?2:t>=3&&t<=10?3:t>=11&&t<=99?4:5;default:return 0}},t}(),y=function(){function t(t,e){this.user=void 0,this.csrfToken=void 0,this.user=t,this.csrfToken=e}var e=t.prototype;return e.login=function(t,e){return void 0===e&&(e={}),app.request(Object(o.a)({method:"POST",url:app.forum.attribute("baseUrl")+"/login",body:t},e))},e.logout=function(){window.location.href=app.forum.attribute("baseUrl")+"/logout?token="+this.csrfToken},t}(),b=function(){function t(t){this.data={},this.models=void 0,this.models=t}var e=t.prototype;return e.pushPayload=function(t){t.included&&t.included.map(this.pushObject.bind(this));var e=t.data instanceof Array?t.data.map(this.pushObject.bind(this)):this.pushObject(t.data);return e.payload=t,e},e.pushObject=function(t){if(!this.models[t.type])return null;var e=this.data[t.type]=this.data[t.type]||{};return e[t.id]?e[t.id].pushData(t):e[t.id]=this.createRecord(t.type,t),e[t.id].exists=!0,e[t.id]},e.find=function(t,e,n,r){void 0===n&&(n={}),void 0===r&&(r={});var i=n,s=app.forum.attribute("apiUrl")+"/"+t;return e instanceof Array?s+="?filter[id]="+e.join(","):"object"==typeof e?i=e:e&&(s+="/"+e),app.request(Object(o.a)({method:"GET",url:s,params:i},r)).then(this.pushPayload.bind(this))},e.getById=function(t,e){return this.data[t]&&this.data[t][e]},e.getBy=function(t,e,n){return this.all(t).filter((function(t){return t[e]()===n}))[0]},e.all=function(t){var e=this.data[t];return e?Object.keys(e).map((function(t){return e[t]})):[]},e.remove=function(t){delete this.data[t.data.type][t.id()]},e.createRecord=function(t,e){return void 0===e&&(e={}),e.type=e.type||t,new this.models[t](e,this)},t}();function w(t,e,n){var r=t[e];t[e]=function(){for(var e=arguments.length,i=new Array(e),o=0;o").addClass("drawer-backdrop fade").appendTo("body").click((function(){return t.hide()})),setTimeout((function(){return t.$backdrop.addClass("in")}))},t}(),k=function(t,e,n,r){this.status=void 0,this.responseText=void 0,this.options=void 0,this.xhr=void 0,this.response=void 0,this.alert=void 0,this.status=t,this.responseText=e,this.options=n,this.xhr=r;try{this.response=JSON.parse(e)}catch(t){this.response=null}this.alert=null},T=function(){function t(t,e){void 0===t&&(t={}),void 0===e&&(e=null),this.data=void 0,this.payload=void 0,this.freshness=void 0,this.exists=void 0,this.store=void 0,this.data=t,this.store=e,this.freshness=new Date,this.exists=!1}var e=t.prototype;return e.id=function(){return this.data.id},e.attribute=function(t){return this.data.attributes[t]},e.pushData=function(e){for(var n in e)if("object"==typeof e[n])for(var r in this.data[n]=this.data[n]||{},e[n])e[n][r]instanceof t&&(e[n][r]={data:t.getIdentifier(e[n][r])}),this.data[n][r]=e[n][r];else this.data[n]=e[n];this.freshness=new Date},e.pushAttributes=function(t){this.pushData({attributes:t})},e.save=function(e,n){var r=this;void 0===n&&(n={});var i={type:this.data.type,id:this.data.id,attributes:e,relationships:void 0};if(e.relationships){for(var s in i.relationships={},e.relationships){var a=e.relationships[s];i.relationships[s]={data:a instanceof Array?a.map(t.getIdentifier):t.getIdentifier(a)}}delete e.relationships}var c=this.copyData();this.pushData(i);var u={data:i};return n.meta&&(u.meta=n.meta),app.request(Object(o.a)({method:this.exists?"PATCH":"POST",url:app.forum.attribute("apiUrl")+this.apiEndpoint(),body:u},n)).then((function(t){return r.store.data[t.data.type]=r.store.data[t.data.type]||{},r.store.data[t.data.type][t.data.id]=r,r.store.pushPayload(t)}),(function(t){throw r.pushData(c),m.redraw(),t}))},e.delete=function(t,e){var n=this;return void 0===t&&(t={}),void 0===e&&(e={}),this.exists?app.request(Object(o.a)({method:"DELETE",url:app.forum.attribute("apiUrl")+this.apiEndpoint(),body:t},e)).then((function(){n.exists=!1,n.store.remove(n)})):Promise.resolve()},e.apiEndpoint=function(){return"/"+this.data.type+(this.exists?"/"+this.data.id:"")},e.copyData=function(){return JSON.parse(JSON.stringify(this.data))},t.attribute=function(t,e){return function(){var n=this.data.attributes&&this.data.attributes[t];return e?e(n):n}},t.hasOne=function(t){return function(){if(this.data.relationships){var e=this.data.relationships[t];if(e)return app.store.getById(e.data.type,e.data.id)}return!1}},t.hasMany=function(t){return function(){if(this.data.relationships){var e=this.data.relationships[t];if(e)return e.data.map((function(t){return app.store.getById(t.type,t.id)}))}return!1}},t.transformDate=function(t){return t?new Date(t):null},t.getIdentifier=function(t){return{type:t.data.type,id:t.data.id}},t}(),E=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.apiEndpoint=function(){return"/"},e}(T);function _(t,e){var n,r=[].concat(t),i={};return function(){var t=this,o=!1;return r.forEach((function(e){var n="function"==typeof t[e]?t[e]():t[e];i[e]!==n&&(o=!0,i[e]=n)})),o&&(n=e.apply(this,r.map((function(t){return i[t]})))),n}}var C=function(t,e){this.content=void 0,this.priority=void 0,this.key=0,this.content=t,this.priority=e},S=function(){function t(){this.items={}}var e=t.prototype;return e.isEmpty=function(){for(var t in this.items)if(this.items.hasOwnProperty(t))return!1;return!0},e.has=function(t){return!!this.items[t]},e.get=function(t){var e;return null===(e=this.items[t])||void 0===e?void 0:e.content},e.add=function(t,e,n){return void 0===n&&(n=0),this.items[t]=new C(e,n),this},e.toArray=function(){var t=[];for(var e in this.items)this.items.hasOwnProperty(e)&&null!==this.items[e]&&this.items[e]instanceof C&&(this.items[e].content=Object(this.items[e].content),this.items[e].content.itemName=e,t.push(this.items[e]),this.items[e].key=t.length);return t.sort((function(t,e){return t.priority===e.priority?t.key-e.key:t.priority>e.priority?-1:1})).map((function(t){return t.content}))},t}(),O=n(0);function A(t,e){return void 0===e&&(e={}),e.className="icon "+t+" "+(e.className||""),m("i",e)}var P=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(t){var e=t.attrs,n=p(e,"type"),r=p(e,"icon");return e.className="Badge "+(n?"Badge--"+n:"")+" "+(e.className||""),e.title=p(e,"label")||"",m("span",e,r?A(r,{className:"Badge-icon"}):m.trust(" "))},n.oncreate=function(e){t.prototype.oncreate.call(this,e),this.props.label&&this.$().tooltip({container:"body"})},e}(O.a),j=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;idayjs().subtract(5,"minutes").toDate()},n.badges=function(){var t=new S,e=this.groups();return e&&e.forEach((function(e){t.add("group"+e.id(),D.component({group:e}))})),t},n.calculateAvatarColor=function(){var t=new Image,e=this;t.onload=function(){var t=new ColorThief;e.avatarColor=t.getColor(this),e.freshness=new Date,m.redraw()},t.crossOrigin="anonymous",t.src=this.avatarUrl()},n.savePreferences=function(t){var e=this.preferences();return Object(o.a)(e,t),this.save({preferences:e})},e}(T);function L(t){var e=t.replace(/(<\/p>|
)/g,"$1  ").replace(/]*>/gi," "),n=$("
").html(e);return n.find(L.removeSelectors.join(",")).remove(),n.text().replace(/\s+/g," ").trim()}L.removeSelectors=["blockquote","script"];var R=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=0||(i[n]=t[n]);return i}(t,["children"]);n.className=n.className||"",n.type=n.type||"button",n.title&&!this.props.children&&(n["aria-label"]=n.title),!n.title&&this.props.children&&(n.title=h(this.props.children));var r=p(n,"icon");r&&(n.className+=" hasIcon");var i=p(n,"loading");return(n.disabled||i)&&(n.className=classNames(n.className,"disabled",i&&"loading"),delete n.onclick),m("button",n,this.getButtonContent(r,n.loading,e))},n.getButtonContent=function(t,e,n){return[t&&!0!==t?A(t,{className:"Button-icon"}):"",n?m("span",{className:"Button-label"},n):"",e?K.component({size:"tiny",className:"LoadingIndicator--inline"}):""]},e}(O.a),G=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.view=function(){return m("li",{className:"Dropdown-separator"})},e}(O.a);function J(t){return(null==t?void 0:t.tag)===G}function X(t){return t instanceof Array||(t=[t]),function(t){var e,n=[];return t.forEach((function(r,i){(!J(r)||e&&!J(e)&&i!==t.length-1)&&(e=r,n.push(r))})),n}(t).map((function(t){var e,n,r,i,o=null===(e=t.tag)||void 0===e?void 0:e.isListItem,s=(null===(n=t.tag)||void 0===n?void 0:n.isActive)&&t.tag.isActive(t.attrs),a=(null===(r=t.attrs)||void 0===r?void 0:r.itemClassName)||t.itemClassName;o&&(t.attrs=t.attrs||{},t.attrs.key=t.attrs.key||t.itemName,t.key=t.attrs.key);var c=o?t:m("li",{className:classNames(a,t.itemName&&"item-"+t.itemName,s&&"active"),key:(null===(i=t.attrs)||void 0===i?void 0:i.key)||t.itemName},t);return c.state=c.state||{},c}))}G.isListItem=!0;var Q,tt,et,nt,rt,it=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.view=function(){var t=Object(o.a)({},this.props),e=p(t,"type");t.className="Alert Alert--"+e+" "+(t.className||"");var n=p(t,"children"),r=p(t,"controls")||[],i=p(t,"dismissible"),s=p(t,"ondismiss"),a=[];return(i||void 0===i)&&a.push(m(Z,{icon:"fas fa-times",className:"Button Button--link Button--icon Alert-dismiss",onclick:s})),m("div",t,m("span",{className:"Alert-body"},n),m("ul",{className:"Alert-controls"},X(r.concat(a))))},e}(O.a),ot=(Q=["a[href]","area[href]",'input:not([disabled]):not([type="hidden"]):not([aria-hidden])',"select:not([disabled]):not([aria-hidden])","textarea:not([disabled]):not([aria-hidden])","button:not([disabled]):not([aria-hidden])","iframe","object","embed","[contenteditable]",'[tabindex]:not([tabindex^="-"])'],tt=function(){function t(t){var e=t.targetModal,n=t.triggers,r=void 0===n?[]:n,i=t.onShow,o=void 0===i?function(){}:i,s=t.onClose,a=void 0===s?function(){}:s,c=t.openTrigger,u=void 0===c?"data-micromodal-trigger":c,l=t.closeTrigger,f=void 0===l?"data-micromodal-close":l,d=t.disableScroll,p=void 0!==d&&d,h=t.disableFocus,m=void 0!==h&&h,v=t.awaitCloseAnimation,g=void 0!==v&&v,y=t.awaitOpenAnimation,b=void 0!==y&&y,w=t.debugMode,x=void 0!==w&&w;this.modal=document.getElementById(e),this.config={debugMode:x,disableScroll:p,openTrigger:u,closeTrigger:f,onShow:o,onClose:a,awaitCloseAnimation:g,awaitOpenAnimation:b,disableFocus:m},r.length>0&&this.registerTriggers.apply(this,r),this.onClick=this.onClick.bind(this),this.onKeydown=this.onKeydown.bind(this)}var e=t.prototype;return e.registerTriggers=function(){for(var t=this,e=arguments.length,n=new Array(e),r=0;r
'),!1},rt=function(t,e){if(function(t){t.length<=0&&(console.warn("MicroModal: ❗Please specify at least one %c'micromodal-trigger'","background-color: #f8f9fa;color: #50596c;font-weight: bold;","data attribute."),console.warn("%cExample:","background-color: #f8f9fa;color: #50596c;font-weight: bold;",''))}(t),!e)return!0;for(var n in e)nt(n);return!0},{init:function(t){var e=Object(o.a)({},{openTrigger:"data-micromodal-trigger"},t),n=[].concat(document.querySelectorAll("["+e.openTrigger+"]")),r=function(t,e){var n=[];return t.forEach((function(t){var r=t.attributes[e].value;void 0===n[r]&&(n[r]=[]),n[r].push(t)})),n}(n,e.openTrigger);if(!0!==e.debugMode||!1!==rt(n,r))for(var i in r){var s=r[i];e.targetModal=i,e.triggers=[].concat(s),et=new tt(e)}},show:function(t,e){var n=e||{};n.targetModal=t,!0===n.debugMode&&!1===nt(t)||(et=new tt(n)).showModal()},close:function(t){t?et.closeModalById(t):et.closeModal()}}),st=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i").addClass("modal-backdrop").appendTo("body"),ot.show("Modal",{awaitCloseAnimation:!0,onClose:function(){$(".modal-backdrop").fadeOut(200,(function(){this.remove()})),n.showing=!1}}),this.onready()},n.onclick=function(t){t.target===this.element&&this.close()},n.close=function(){this.showing&&(this.hideTimeout=setTimeout((function(){return ot.close("Modal")})))},n.clear=function(){this.component&&this.component.onhide(),this.component=null,m.redraw()},n.onready=function(){this.component&&this.component.onready()},e}(O.a),ct=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.className=function(){return"RequestErrorModal Modal--large"},n.title=function(){return this.props.error.xhr?this.props.error.xhr.status+" "+this.props.error.xhr.statusText:""},n.content=function(){var t;try{t=JSON.stringify(JSON.parse(this.props.error.responseText),null,2)}catch(e){t=this.props.error.responseText}return m("div",{className:"Modal-body"},m("pre",null,this.props.error.options.method," ",this.props.error.options.url,m("br",null),m("br",null),t))},e}(st),ut=function(){function t(){this.forum=void 0,this.data=void 0,this.translator=new g,this.bus=new d,this.session=void 0,this.store=new b({forums:E,users:I,discussions:j,posts:R,groups:B,notifications:H}),this.drawer=new N,this.modal=void 0,this.cache={},this.routes={},this.title="",this.titleCount=0,this.requestError=null}var e=t.prototype;return e.mount=function(t){void 0===t&&(t=""),m.mount(document.getElementById("modal"),new at),m.route(document.getElementById("content"),t+"/",function(t,e){void 0===e&&(e="");var n={};for(var r in t){var i=t[r];i.component&&(i.component.attrs||(i.component.attrs={}),i.component.attrs.routeName=r),n[e+i.path]=i.component}return n}(this.routes,t))},e.boot=function(t){this.data=t,this.store.pushPayload({data:this.data.resources}),this.forum=this.store.getById("forums",1),this.session=new y(this.store.getById("users",this.data.session.userId),this.data.session.csrfToken),this.locale(),this.plugins(),this.setupRoutes(),this.mount(),this.bus.dispatch("app.booting")},e.locale=function(){this.translator.locale=this.data.locale,this.bus.dispatch("app.locale")},e.plugins=function(){this.bus.dispatch("app.plugins")},e.setupRoutes=function(){this.bus.dispatch("app.routes")},e.preloadedApiDocument=function(){if(this.data.apiDocument){var t=this.store.pushPayload(this.data.apiDocument);return this.data.apiDocument=null,t}return null},e.setTitle=function(t){this.title=t,this.updateTitle()},e.setTitleCount=function(t){this.titleCount=t,this.updateTitle()},e.updateTitle=function(){document.title=(this.titleCount?"("+this.titleCount+") ":"")+(this.title?this.title+" - ":"")+this.forum.attribute("title")},e.route=function(t,e){void 0===e&&(e={});var n=this.routes[t];if(!n)throw new Error("Route '"+t+"' does not exist");var r=n.path.replace(/:([^\/]+)/g,(function(t,n){return p(e,n)})),i=m.buildQueryString(e);return(""===m.route.prefix?this.forum.attribute("basePath"):"")+r+(i?"?"+i:"")},e.request=function(t){var e=this,n=Object(o.a)({},t);if(n.background=n.background||!0,w(n,"config",(function(t,n){return n.setRequestHeader("X-CSRF-Token",e.session.csrfToken)})),"GET"!==n.method&&"POST"!==n.method){var r=n.method;w(n,"config",(function(t,e){return e.setRequestHeader("X-HTTP-Method-Override",r)})),n.method="POST"}n.deserialize=n.deserialize||function(t){return t},n.errorHandler=n.errorHandler||function(t){throw t};var i=n.extract;return n.extract=function(t){var e;e=i?i(t.responseText):t.responseText||null;var r=t.status;if(r<200||r>299)throw new k(r,e,n,t);if(t.getResponseHeader){var o=t.getResponseHeader("X-CSRF-Token");o&&(app.session.csrfToken=o)}try{return JSON.parse(e)}catch(r){throw new k(500,e,n,t)}},m.request(n).then((function(t){return t}),(function(t){var r;switch(e.requestError=t,t.status){case 422:r=t.response.errors.map((function(t){return[t.detail,m("br")]})).reduce((function(t,e){return t.concat(e)}),[]).slice(0,-1);break;case 401:case 403:r=e.translator.trans("core.lib.error.permission_denied_message");break;case 404:case 410:r=e.translator.trans("core.lib.error.not_found_message");break;case 429:r=e.translator.trans("core.lib.error.rate_limit_exceeded_message");break;default:r=e.translator.trans("core.lib.error.generic_message")}var i=app.forum.attribute("debug");t.alert=it.component({type:"error",children:r,controls:i&&[Z.component({className:"Button Button--link",onclick:e.showDebug.bind(e,t),children:"DEBUG"})]});try{n.errorHandler(t)}catch(t){console.error(t)}return Promise.reject(t)}))},e.showDebug=function(t){this.modal.show(ct.component({error:t}))},t}(),lt=function(){function t(){this.stack=[]}var e=t.prototype;return e.getCurrent=function(){return this.stack[this.stack.length-1]},e.getPrevious=function(){return this.stack[this.stack.length-2]},e.push=function(t,e,n){void 0===n&&(n=m.route.get());var r=this.stack[this.stack.length-2];r&&r.name===t&&this.stack.pop();var i=this.getCurrent();i&&i.name===t?Object(o.a)(i,{url:n,title:e}):this.stack.push({name:t,url:n,title:e})},e.canGoBack=function(){return this.stack.length>1},e.back=function(){if(!this.canGoBack())return this.home();this.stack.pop(),m.route.set(this.getCurrent().url)},e.backUrl=function(){return this.stack[this.stack.length-2].url},e.home=function(){this.stack.splice(0),m.route.set("/")},t}(),ft=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){return m("ul",{className:"Header-controls"},X(this.items().toArray()))},n.items=function(){return new S},e}(O.a),dt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){return m("div",{className:"LogInButtons"},this.items().toArray())},n.items=function(){return new S},e}(O.a),pt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i .Dropdown-toggle").dropdown(),this.element.addEventListener("shown.bs.dropdown",(function(){n.showing=!0,n.props.onshow&&n.props.onshow(),m.redraw();var t=n.$(".Dropdown-menu"),e=t.hasClass("Dropdown-menu--right");t.removeClass("Dropdown-menu--top Dropdown-menu--right"),t.toggleClass("Dropdown-menu--top",t.offset().top+t.height()>$(window).scrollTop()+$(window).height()),t.offset().top<0&&t.removeClass("Dropdown-menu--top"),t.toggleClass("Dropdown-menu--right",e||t.offset().left+t.width()>$(window).scrollLeft()+$(window).width())})),this.element.addEventListener("hidden.bs.dropdown",(function(){n.showing=!1,n.props.onhide&&n.props.onhide(),m.redraw()}))},n.getButton=function(){return m("button",{className:"Dropdown-toggle "+this.props.buttonClassName,"data-toggle":"dropdown",onclick:this.props.onclick},this.getButtonContent())},n.getButtonContent=function(){var t=this.props;return[t.icon?A(t.icon,{className:"Button-icon"}):"",m("span",{className:"Button-label"},t.label),t.caretIcon?A(t.caretIcon,{className:"Button-caret"}):""]},n.getMenu=function(t){return m("ul",{className:"Dropdown-menu dropdown-menu "+this.props.menuClassName},t)},e}(O.a),vt=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.initProps=function(t){t.active=this.isActive(t)},e.prototype.view=function(){var e=t.prototype.view.call(this);return e.tag=m.route.Link,e.attrs.active=String(e.attrs.active),e},e.isActive=function(t){return void 0!==t.active?t.active:m.route.get()===t.href},e}(Z),gt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t),e.initProps=function(e){t.initProps.call(this,e),e.className="SessionDropdown",e.buttonClassName="Button Button--user Button--flat",e.menuClassName="Dropdown-menu--right"};var n=e.prototype;return n.view=function(){return this.props.children=this.items().toArray(),t.prototype.view.call(this)},n.getButtonContent=function(){var t=app.session.user;return[ht(t)," ",m("span",{className:"Button-label"},v(t))]},n.items=function(){var t=new S,e=app.session.user;return t.add("profile",vt.component({icon:"fas fa-user",children:app.translator.trans("core.forum.header.profile_button"),href:app.route.user(e)}),100),t.add("settings",vt.component({icon:"fas fa-cog",children:app.translator.trans("core.forum.header.settings_button"),href:app.route("settings")}),50),app.forum.attribute("adminUrl")&&t.add("administration",vt.component({icon:"fas fa-wrench",children:app.translator.trans("core.forum.header.admin_button"),href:app.forum.attribute("adminUrl"),target:"_blank"}),0),t.add("separator",G.component(),-90),t.add("logOut",Z.component({icon:"fas fa-sign-out-alt",children:app.translator.trans("core.forum.header.log_out_button"),onclick:app.session.logout.bind(app.session)}),-100),t},e}(mt),yt=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.initProps=function(e){e.caretIcon=void 0!==e.caretIcon?e.caretIcon:"fas fa-sort",t.initProps.call(this,e),e.className+=" Dropdown--select"},e.prototype.getButtonContent=function(){var t=this.props.children.filter((function(t){return t.attrs.active}))[0],e=t&&t.attrs.children||this.props.defaultLabel;return e instanceof Array&&(e=e[0]),[m("span",{className:"Button-label"},e),A(this.props.caretIcon,{className:"Button-caret"})]},e}(mt),bt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=o+s&&n.loadMore()},i.on("scroll",this.scrollHandler)},n.onremove=function(e){t.prototype.onremove.call(this,e),this.$scrollParent.off("scroll",this.scrollHandler)},n.load=function(){app.session.user.newNotificationCount()&&delete app.cache.notifications,app.cache.notifications||(app.session.user.pushAttributes({newNotificationCount:0}),this.loadMore())},n.loadMore=function(){var t=this;this.loading=!0,m.redraw();var e=app.cache.notifications?{page:{offset:10*app.cache.notifications.length}}:null;return app.store.find("notifications",e).then(this.parseResults.bind(this)).catch((function(){})).then((function(){t.loading=!1,m.redraw()}))},n.parseResults=function(t){return app.cache.notifications=app.cache.notifications||[],t.length&&app.cache.notifications.push(t),this.moreResults=!!t.payload.links.next,t},n.markAllAsRead=function(){app.cache.notifications&&(app.session.user.pushAttributes({unreadNotificationCount:0}),app.cache.notifications.forEach((function(t){t.forEach((function(t){return t.pushAttributes({isRead:!0})}))})),app.request({url:app.forum.attribute("apiUrl")+"/notifications/read",method:"POST"}))},e}(O.a),wt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i0?"...":"")+t.substring(n,n+e)+(t.length>n+e?"...":"")}(i,n,o)),i=$("
").text(i).html(),e&&(i=i.replace(r,"$&")),m.trust(i)}var kt=function(){},Tt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i li:not(.Dropdown-header)",(function(){r.setIndex(r.selectableItems().index(this))}));var i=this.$("input");this.navigator=new xt,this.navigator.onUp((function(){return n.setIndex(n.getCurrentNumericIndex()-1,!0)})).onDown((function(){return n.setIndex(n.getCurrentNumericIndex()+1,!0)})).onSelect(this.selectResult.bind(this)).onCancel(this.clear.bind(this)).bindTo(i),i.on("input focus",(function(){var t=this.value.toLowerCase();t&&(clearTimeout(r.searchTimeout),r.searchTimeout=setTimeout((function(){-1===r.searched.indexOf(t)&&(t.length>=3&&r.sources.map((function(e){e.search&&(r.loadingSources++,e.search(t).then((function(){r.loadingSources=Math.max(0,r.loadingSources-1),m.redraw()})))})),r.searched.push(t),m.redraw())}),250))})).on("focus",(function(){$(this).one("mouseup",(function(t){return t.preventDefault()})).select()}))},n.getCurrentSearch=function(){return app.current&&"function"==typeof app.current.searching&&app.current.searching()},n.selectResult=function(){clearTimeout(this.searchTimeout),this.loadingSources=0,this.value()?m.route.set(this.getItem(this.index).find("a").attr("href")):this.clear(),this.$("input").blur()},n.clear=function(){this.value(""),this.getCurrentSearch()?app.current.clearSearch():m.redraw()},n.sourceItems=function(){var t=new S;return app.forum.attribute("canViewDiscussions")&&t.add("discussions",new Tt),app.forum.attribute("canViewUserList")&&t.add("users",new Et),t},n.selectableItems=function(){return this.$(".Search-results > li:not(.Dropdown-header)")},n.getCurrentNumericIndex=function(){return this.selectableItems().index(this.getItem(this.index))},n.getItem=function(t){var e=this.selectableItems(),n=e.filter('[data-index="'+t+'"]');return n.length||(n=e.eq(t)),n},n.setIndex=function(t,e){var n=this.selectableItems(),r=n.parent(),i=t;t<0?i=n.length-1:t>=n.length&&(i=0);var o=n.removeClass("active").eq(i).addClass("active");if(this.index=o.attr("data-index")||i,e){var s,a=r.scrollTop(),c=r.offset().top,u=c+r.outerHeight(),l=o.offset().top,f=l+o.outerHeight();lu&&(s=a-u+f+parseInt(r.css("padding-bottom"),10)),void 0!==s&&r.animate({scrollTop:s},100)}},e}(O.a),Ct=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){return m("ul",{className:"Header-controls"},X(this.items().toArray()))},n.items=function(){var t=new S;if(t.add("search",_t.component(),30),app.forum.attribute("showLanguageSelector")&&Object.keys(app.data.locales).length>1){var e=[],n=function(t){e.push(Z.component({active:app.data.locale===t,children:app.data.locales[t],icon:app.data.locale!==t||"fas fa-check",onclick:function(){app.session.user?app.session.user.savePreferences({locale:t}).then((function(){return window.location.reload()})):(document.cookie="locale="+t+"; path=/; expires=Tue, 19 Jan 2038 03:14:07 GMT",window.location.reload())}}))};for(var r in app.data.locales)n(r);t.add("locale",yt.component({children:e,buttonClassName:"Button Button--link"}),20)}return app.session.user?(t.add("notifications",wt.component(),10),t.add("session",gt.component(),0)):(app.forum.attribute("allowSignUp")&&t.add("signUp",Z.component({children:app.translator.trans("core.forum.header.sign_up_link"),className:"Button Button--link",onclick:function(){return app.modal.show(new SignUpModal)}}),10),t.add("logIn",Z.component({children:app.translator.trans("core.forum.header.log_in_link"),className:"Button Button--link",onclick:function(){return app.modal.show(new pt)}}),0)),t},e}(O.a),St=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.oninit=function(){console.log("IndexPage#oninit")},n.view=function(){return m("div",{class:"container"},m("h1",null,"hi"))},e}(O.a),Ot=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=$(document).height();s9e.TextFormatter.preview(e||"",t.dom),r&&$(window).scrollTop($(document).height())}}}),50);t.attrs.onunload=function(){return clearInterval(n)}},e}(O.a),Rt=function(){function t(){this.handlers={}}var e=t.prototype;return e.getHandlers=function(t){return this.handlers=this.handlers||{},this.handlers[t]=this.handlers[t]||[],this.handlers[t]},e.trigger=function(t){for(var e=this,n=arguments.length,r=new Array(n>1?n-1:0),i=1;i3456e5&&(a=[m("div",{className:"PostStream-timeGap"},m("span",null,app.translator.trans("core.forum.post_stream.time_lapsed_text",{period:dayjs(u).from(dayjs(t,!0))}))),a]),t=u}else c.key="post"+i[e.visibleStart+s],a=m(Dt,null);return m("div",Object(o.a)({className:"PostStream-item"},c),a)}));return!this.viewingEnd&&r[this.visibleEnd-this.visibleStart-1]&&s.push(m("div",{className:"PostStream-loadMore",key:"loadMore"},m(Z,{className:"Button",onclick:this.loadNext.bind(this)},app.translator.trans("core.forum.post_stream.load_more_button")))),!this.viewingEnd||app.session.user&&!this.discussion.canReply()||s.push(m("div",{className:"PostStream-item",key:"reply"},Lt.component({discussion:this.discussion}))),m("div",{className:"PostStream"},s)},n.oncreate=function(e){t.prototype.oncreate.call(this,e),this.scrollListener.start()},n.onremove=function(e){t.prototype.onremove.call(this,e),this.scrollListener.stop(),clearTimeout(this.calculatePositionTimeout)},n.onscroll=function(t){if(!this.paused){var e=this.getMarginTop(),n=$(window).height()-e,r=t+e;if(this.visibleStart>0){var i=this.$('.PostStream-item[data-index="'+this.visibleStart+'"]');i.length&&i.offset().top>r-300&&this.loadPrevious()}if(this.visibleEndthis.visibleStart&&n>=0&&(this.visibleStart=n+this.constructor.loadCount+1,this.loadPageTimeouts[n]&&(clearTimeout(this.loadPageTimeouts[n]),this.loadPageTimeouts[n]=null,this.pagesLoading--)),this.loadPage(t,e)},n.loadPrevious=function(){var t=this.visibleStart,e=this.visibleStart=this.sanitizeIndex(this.visibleStart-this.constructor.loadCount),n=e+2*this.constructor.loadCount;nr.visibleEnd||($t('.PostStream-item[data-index="'+(n?r.visibleEnd-1:r.visibleStart)+'"]',(function(){return m.redraw(!0)})),r.unpause())};i(),this.loadPageTimeouts[t]=setTimeout((function(){r.loadRange(t,e).then((function(){i(),r.pagesLoading--})),r.loadPageTimeouts[t]=null}),this.pagesLoading?1e3:0),this.pagesLoading++},n.loadRange=function(t,e){var n=[],r=[];return this.discussion.postIds().slice(t,e).forEach((function(t){var e=app.store.getById("posts",t);e&&e.discussion()&&void 0!==e.canEdit()?r.push(e):n.push(t)})),n.length?app.store.find("posts",n):Promise.resolve(r)},n.loadNearNumber=function(t){return this.posts().some((function(e){return e&&Number(e.number())===Number(t)}))?Promise.resolve():(this.reset(),app.store.find("posts",{filter:{discussion:this.discussion.id()},page:{near:t}}).then(this.show.bind(this)))},n.loadNearIndex=function(t){if(t>=this.visibleStart&&t<=this.visibleEnd)return Promise.resolve();var e=this.sanitizeIndex(t-this.constructor.loadCount/2),n=e+this.constructor.loadCount;return this.reset(e,n),this.loadRange(e,n).then(this.show.bind(this))},n.calculatePosition=function(){var t,e,n=this.getMarginTop(),r=$(window),i=r.height()-n,o=r.scrollTop()+n;this.$(".PostStream-item").each((function(n,r){var s=$(r),a=s.offset().top,c=s.outerHeight(!0);if(a+c>o){if(t||(t=e=s.data("number")),!(a+cc){var u=r?s-$(window).height():t.is(":first-child")?0:o;return new Promise((function(t){e?(i.scrollTop(u),t()):u!==a?i.animatedScrollTop(u,"fast",t):t()}))}}return Promise.resolve()},n.flashItem=function(t){t.addClass("flash").one("animationend webkitAnimationEnd",(function(){return t.removeClass("flash")}))},n.unpause=function(){this.paused=!1,this.scrollListener.update(),this.trigger("unpaused")},e}(O.a);Bt.loadCount=20,Object(o.a)(Bt.prototype,Rt.prototype);var Ht=Bt,Ut=function(){function t(){this.callbacks=void 0,this.data={};for(var t=arguments.length,e=new Array(t),n=0;n=this.count()},n.onscroll=function(t){var e=this.props.stream.state;e&&!e.paused&&e.$()&&(this.update(t),this.renderScrollbar())},n.update=function(t){var e=this.props.stream.state,n=e.getMarginTop(),r=t+n,i=$(window).height()-n,o=e.$(".PostStream-item[data-index]"),s=o.first().data("index")||0,a=0,c="";o.each((function(){var t=$(this),e=t.offset().top,n=t.outerHeight(!0);if(e+nr+i)return!1;var o=Math.max(0,r-e),u=Math.min(n,r+i-e)-o;e<=r&&(s=parseFloat(t.data("index"))+o/n),u>0&&(a+=u/n);var l=t.data("time");l&&(c=l)})),this.index=s,this.visible=a,this.description=c?dayjs(c).format("MMMM YYYY"):""},n.onremove=function(e){t.prototype.onremove.call(this,e),this.ondestroy()},n.oncreate=function(e){var n=this;t.prototype.oncreate.call(this,e),this.props.stream.state.on("unpaused",this.handlers.streamWasUnpaused=this.streamWasUnpaused.bind(this)),this.props.stream.state.on("update",(function(){return n.update()})),this.scrollListener.start(),$(window).on("resize",this.handlers.onresize=this.onresize.bind(this)).resize(),this.$(".Scrubber-scrollbar").on("click",this.onclick.bind(this)).css({cursor:"pointer","user-select":"none"}).on("dragstart mousedown touchstart",(function(t){return t.preventDefault()})),this.$(".Scrubber-handle").css("cursor","move").on("mousedown touchstart",this.onmousedown.bind(this)).click((function(t){return t.stopPropagation()})),$(document).on("mousemove touchmove",this.handlers.onmousemove=this.onmousemove.bind(this)).on("mouseup touchend",this.handlers.onmouseup=this.onmouseup.bind(this))},n.ondestroy=function(){this.scrollListener.stop(),this.props.stream.state.off("unpaused",this.handlers.streamWasUnpaused),$(window).off("resize",this.handlers.onresize),$(document).off("mousemove touchmove",this.handlers.onmousemove).off("mouseup touchend",this.handlers.onmouseup)},n.renderScrollbar=function(t){var e=this.percentPerPost(),n=this.index,r=this.count(),i=this.visible||1,o=this.$();o.find(".Scrubber-index").text(Ft(Math.min(Math.ceil(n+i),r))),o.find(".Scrubber-description").text(this.description),o.toggleClass("disabled",this.disabled());var s={};s.before=Math.max(0,e.index*Math.min(n,r-i)),s.handle=Math.min(100-s.before,e.visible*i),s.after=100-s.before-s.handle;var a=t?"animate":"css";for(var c in s){var u=o.find(".Scrubber-"+c);u[a]({height:s[c]+"%"},"fast"),"animate"===a&&u.css("overflow","visible")}},n.percentPerPost=function(){var t=this.count()||1,e=this.visible||1,n=50/this.$(".Scrubber-scrollbar").outerHeight()*100,r=Math.max(100/t,n/e),i=t===e?0:(100-r*e)/(t-e);return{index:i,visible:r}},n.onresize=function(){this.scrollListener.update();var t=this.$(),e=this.$(".Scrubber-scrollbar");e.css("max-height",$(window).height()-t.offset().top+$(window).scrollTop()-parseInt($("#app").css("padding-bottom"),10)-(t.outerHeight()-e.outerHeight()))},n.onmousedown=function(t){this.mouseStart=t.clientY||t.originalEvent.touches[0].clientY,this.indexStart=this.index,this.dragging=!0,this.props.stream.state.paused=!0,$("body").css("cursor","move")},n.onmousemove=function(t){if(this.dragging){var e=((t.clientY||t.originalEvent.touches[0].clientY)-this.mouseStart)/this.$(".Scrubber-scrollbar").outerHeight()*100/this.percentPerPost().index||0,n=Math.min(this.indexStart+e,this.count()-1);this.index=Math.max(0,n),this.renderScrollbar()}},n.onmouseup=function(){var t;if(this.dragging){this.mouseStart=0,this.indexStart=0,this.dragging=!1,$("body").css("cursor",""),this.$().removeClass("open");var e=Math.floor(this.index);null===(t=this.props.stream.state)||void 0===t||t.goToIndex(e),this.renderScrollbar(!0)}},n.onclick=function(t){var e,n=this.$(".Scrubber-scrollbar"),r=((t.clientY||t.originalEvent.touches[0].clientY)-n.offset().top+$("body").scrollTop())/n.outerHeight()*100,i=(r-=parseFloat(n.find(".Scrubber-handle")[0].style.height)/2)/this.percentPerPost().index;i=Math.max(0,Math.min(this.count()-1,i)),null===(e=this.props.stream.state)||void 0===e||e.goToIndex(Math.floor(i)),this.index=i,this.renderScrollbar(!0),this.$().removeClass("open")},e}(O.a),qt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t),e.initProps=function(e){t.initProps.call(this,e),e.className+=" Dropdown--split",e.menuClassName+=" Dropdown-menu--right"};var n=e.prototype;return n.getButton=function(){var t=this.getFirstChild(),e=Object(o.a)({},t.attrs);return e.className=classNames(e.className,"SplitDropdown-button","Button",this.props.buttonClassName),[Z.component(e),m("button",{className:"Dropdown-toggle Button Button--icon "+this.props.buttonClassName,"data-toggle":"dropdown"},A(this.props.icon,{className:"Button-icon"}),A("fas fa-caret-down",{className:"Button-caret"}))]},n.getFirstChild=function(){for(var t=this.props.children;t instanceof Array;)t=t[0];return t},e}(mt),Yt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;is)&&e.scrollTop(e.scrollTop()-o+a)}},n.sidebarItems=function(){var t=new S;return t.add("controls",qt.component({children:It.controls(this.discussion,this).toArray(),icon:"fas fa-ellipsis-v",className:"App-primaryControl",buttonClassName:"Button--primary"})),t.add("scrubber",m(zt,{stream:this.stream,className:"App-titleControl"}),-100),t},n.positionChanged=function(t,e){var n=this.discussion,r=app.route.discussion(n,this.near=t);m.route.set(r,!0),window.history.replaceState(null,document.title,r),app.history.push("discussion",n.title()),app.session.user&&e>(n.lastReadPostNumber()||0)&&(n.save({lastReadPostNumber:e}),m.redraw())},e}(Ot);function Wt(t){var e=t.dom,n=$(e),r=$("#header"),i=n.find("> ul")[0];$(window).off(".affix"),new hcSticky(i,{stickTo:e,top:r.outerHeight(!0)+parseInt(n.css("margin-top"),10)})}function Vt(t){var e=dayjs(t),n=dayjs();e.isAfter(n)&&(e=n);return e.diff(dayjs())<-2592e6?e.year()===dayjs().year()?e.format("D MMM"):e.format("MMM 'YY"):e.fromNow()}var Kt={controls:function(t,e){var n=this,r=new S;return["user","moderation","destructive"].forEach((function(i){var o=n[i+"Controls"](t,e).toArray();o.length&&(o.forEach((function(t){return r.add(t.itemName,t)})),r.add(i+"Separator",G.component()))})),r},userControls:function(){return new S},moderationControls:function(t){var e=new S;return t.canEdit()&&e.add("edit",Z.component({icon:"fas fa-pencil-alt",children:app.translator.trans("core.forum.user_controls.edit_button"),onclick:this.editAction.bind(this,t)})),e},destructiveControls:function(t){var e=new S;return"1"!==t.id()&&t.canDelete()&&e.add("delete",Z.component({icon:"fas fa-times",children:app.translator.trans("core.forum.user_controls.delete_button"),onclick:this.deleteAction.bind(this,t)})),e},deleteAction:function(t){var e=this;confirm(app.translator.transText("core.forum.user_controls.delete_confirmation"))&&t.delete().then((function(){e.showDeletionAlert(t,"success"),app.current instanceof Jt&&app.current.user===t?app.history.back():window.location.reload()})).catch((function(){return e.showDeletionAlert(t,"error")}))},showDeletionAlert:function(t,e){var n=t.data.attributes,r=n.username,i=n.email,o="core.forum.user_controls.delete_"+e+"_message";app.alerts.show(it.component({type:e,children:app.translator.trans(o,{username:r,email:i})}))},editAction:function(t){app.modal.show(new EditUserModal({user:t}))}},Zt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i').appendTo("body").hide().click().on("change",(function(e){t.upload($(e.target)[0].files[0])}))}},n.upload=function(t){if(!this.loading){var e=this.props.user,n=new FormData;data.append("avatar",t),this.loading=!0,m.redraw(),app.request({method:"POST",url:app.forum.attribute("apiUrl")+"/users/"+e.id()+"/avatar",serialize:function(t){return t},body:n}).then(this.success.bind(this),this.failure.bind(this))}},n.remove=function(){var t=this.props.user;this.loading=!0,m.redraw(),app.request({method:"DELETE",url:app.forum.attribute("apiUrl")+"/users/"+t.id()+"/avatar"}).then(this.success.bind(this),this.failure.bind(this))},n.success=function(t){app.store.pushPayload(t),delete this.props.user.avatarColor,this.loading=!1,m.redraw()},n.failure=function(t){this.loading=!1,m.redraw()},e}(O.a),Gt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){var t=this.props.user,e=Kt.controls(t,this).toArray(),n=t.color(),r=t.badges().toArray();return m("div",{className:"UserCard "+(this.props.className||""),style:n?{backgroundColor:n}:""},m("div",{className:"darkenBackground"},m("div",{className:"container"},e.length?mt.component({children:e,className:"UserCard-controls App-primaryControl",menuClassName:"Dropdown-menu--right",buttonClassName:this.props.controlsButtonClassName,label:app.translator.trans("core.forum.user_controls.button"),icon:"fas fa-ellipsis-v"}):"",m("div",{className:"UserCard-profile"},m("h2",{className:"UserCard-identity"},this.props.editable?[Zt.component({user:t,className:"UserCard-avatar"}),v(t)]:m(m.route.Link,{href:app.route.user(t)},m("div",{className:"UserCard-avatar"},ht(t)),v(t))),r.length?m("ul",{className:"UserCard-badges badges"},X(r)):"",m("ul",{className:"UserCard-info"},X(this.infoItems().toArray()))))))},n.infoItems=function(){var t=new S,e=this.props.user,n=e.lastSeenAt();if(n){var r=e.isOnline();t.add("lastSeen",m("span",{className:"UserCard-lastSeen"+(r?" online":"")},r?[A("fas fa-circle")," ",app.translator.trans("core.forum.user.online_text")]:[A("far fa-clock")," ",Vt(n)]))}return t.add("joined",app.translator.trans("core.forum.user.joined_date_text",{ago:Vt(e.joinTime())})),t},e}(O.a),Jt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=this.loadLimit,m.redraw(),t},e}(Jt);function ie(t){var e=dayjs(t),n=e.format(),r=e.format("LLLL"),i=Vt(t);return m("time",{pubdate:!0,datetime:n,title:r,"data-humantime":!0},i)}var oe=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.view=function(){var t=this.props.discussion,e=this.props.lastPost&&t.replyCount(),n=t[e?"lastPostedUser":"user"](),r=t[e?"lastPostedAt":"createdAt"]();return m("span",null,e?A("fas fa-reply"):""," ",app.translator.trans("core.forum.discussion_list."+(e?"replied":"started")+"_text",{user:n,ago:ie(r)}))},e}(O.a),se=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=1e6?Math.floor(t/1e6)+app.translator.transText("core.lib.number_suffix.mega_text"):t>=1e3?Math.floor(t/1e3)+app.translator.transText("core.lib.number_suffix.kilo_text"):t.toString())))},n.oncreate=function(e){if(t.prototype.oncreate.call(this,e),"ontouchstart"in window){var n=slidable(this.$().addClass("Slidable"));this.$(".DiscussionListItem-controls").on("hidden.bs.dropdown",(function(){return n.reset()}))}},n.onbeforeupdate=function(e){return t.prototype.onbeforeupdate.call(this,e),this.subtree.update()},n.active=function(){var t=m.route.param("id");return t&&t.split("-")[0]===this.props.discussion.id()},n.showFirstPost=function(){return-1!==["newest","oldest"].indexOf(this.props.params.sort)},n.showRepliesCount=function(){return"replies"===this.props.params.sort},n.markAsRead=function(){var t=this.props.discussion;t.isUnread()&&(t.save({lastReadPostNumber:t.lastPostNumber()}),m.redraw())},n.infoItems=function(){var t=new S;if(this.props.params.q){var e=this.props.discussion.mostRelevantPost()||this.props.discussion.firstPost();if(e&&"comment"===e.contentType()){var n=Nt(e.contentPlain(),this.highlightRegExp,175);t.add("excerpt",n,-100)}}else t.add("terminalPost",oe.component({discussion:this.props.discussion,lastPost:!this.showFirstPost()}));return t},e}(O.a),ae=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i>>0;if("function"!=typeof t)throw new TypeError(t+" is not a function");for(10&&c--,40==n.which&&c-1&&(e=t[i][1](e,n()))})),e}),n);return i(e),i},n["fantasy-land/of"]=n;var e=!1;function n(t){var e,i=[],s=[];function a(e){return arguments.length&&e!==n.SKIP&&(t=e,o(a)&&(a._changing(),a._state="active",i.forEach((function(e,n){e(s[n](t))})))),t}function c(){return(e=n()).map((function(t){return!0===t&&(a._parents.forEach((function(t){t._unregisterChild(a)})),a._state="ended",a._parents.length=i.length=s.length=0),t})),e}return a.constructor=n,a._state=arguments.length&&t!==n.SKIP?"active":"pending",a._parents=[],a._changing=function(){o(a)&&(a._state="changing"),i.forEach((function(t){t._changing()}))},a._map=function(e,r){var o=r?n():n(e(t));return o._parents.push(a),i.push(o),s.push(e),o},a.map=function(t){return a._map(t,"active"!==a._state)},a.toJSON=function(){return null!=t&&"function"==typeof t.toJSON?t.toJSON():t},a["fantasy-land/map"]=a.map,a["fantasy-land/ap"]=function(t){return r((function(t,e){return t()(e())}),[t,a])},a._unregisterChild=function(t){var e=i.indexOf(t);-1!==e&&(i.splice(e,1),s.splice(e,1))},Object.defineProperty(a,"end",{get:function(){return e||c()}}),a}function r(t,e){var r=e.every((function(t){if(t.constructor!==n)throw new Error("Ensure that each item passed to stream.combine/stream.merge/lift is a stream");return"active"===t._state})),i=r?n(t.apply(null,e.concat([e]))):n(),o=[],s=e.map((function(n){return n._map((function(s){return o.push(n),(r||e.every((function(t){return"pending"!==t._state})))&&(r=!0,i(t.apply(null,e.concat([o]))),o=[]),s}),!0)})),a=i.end.map((function(t){!0===t&&(s.forEach((function(t){t.end(!0)})),a.end(!0))}));return i}function i(t){return r((function(){return t.map((function(t){return t()}))}),t)}function o(t){return"pending"===t._state||"active"===t._state||"changing"===t._state}Object.defineProperty(n,"HALT",{get:function(){return e||console.log("HALT is deprecated and has been renamed to SKIP"),e=!0,n.SKIP}}),t.exports=n}()},function(t,e,n){var r=n(24).Symbol;t.exports=r},function(t,e){t.exports=function(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}},function(t,e,n){var r=n(23),i=n(25);t.exports=function(t){return"symbol"==typeof t||i(t)&&"[object Symbol]"==r(t)}},function(t,e,n){var r=n(115),i=n(119);t.exports=function(t,e){var n=i(t,e);return r(n)?n:void 0}},function(t,e,n){(function(e){var n="object"==typeof e&&e&&e.Object===Object&&e;t.exports=n}).call(this,n(2))},function(t,e){t.exports=function(t){return t.webpackPolyfill||(t.deprecate=function(){},t.paths=[],t.children||(t.children=[]),Object.defineProperty(t,"loaded",{enumerable:!0,get:function(){return t.l}}),Object.defineProperty(t,"id",{enumerable:!0,get:function(){return t.i}}),t.webpackPolyfill=1),t}},function(t,e){var n=/^(?:0|[1-9]\d*)$/;t.exports=function(t,e){var r=typeof t;return!!(e=null==e?9007199254740991:e)&&("number"==r||"symbol"!=r&&n.test(t))&&t>-1&&t%1==0&&t-1&&t%1==0&&t<=9007199254740991}},function(t,e,n){var r=n(73),i=n(71);t.exports=function(t){return null!=t&&i(t.length)&&!r(t)}},function(t,e,n){var r=n(23),i=n(65);t.exports=function(t){if(!i(t))return!1;var e=r(t);return"[object Function]"==e||"[object GeneratorFunction]"==e||"[object AsyncFunction]"==e||"[object Proxy]"==e}},function(t,e,n){var r=n(17),i=n(107),o=n(108),s=n(136);t.exports=function(t,e){return r(t)?t:i(t,e)?[t]:o(s(t))}},function(t,e){t.exports=function(t,e){return t===e||t!=t&&e!=e}},function(t,e,n){var r=n(66);t.exports=function(t){if("string"==typeof t||r(t))return t;var e=t+"";return"0"==e&&1/t==-1/0?"-0":e}},,function(t,e,n){var r=n(81),i=n(82),o=n(104),s=n(17);t.exports=function(t,e){return(s(t)?r:i)(t,o(e))}},function(t,e,n){var r=n(106);t.exports=function(t,e,n){var i=null==t?void 0:r(t,e);return void 0===i?n:i}},function(t,e,n){var r=n(139);t.exports=function(t,e,n){return null==t?t:r(t,e,n)}},function(t,e){t.exports=function(t,e){for(var n=-1,r=null==t?0:t.length;++n-1}},function(t,e,n){var r=n(27);t.exports=function(t,e){var n=this.__data__,i=r(n,t);return i<0?(++this.size,n.push([t,e])):n[i][1]=e,this}},function(t,e,n){var r=n(67)(n(24),"Map");t.exports=r},function(t,e,n){var r=n(28);t.exports=function(t){var e=r(this,t).delete(t);return this.size-=e?1:0,e}},function(t,e){t.exports=function(t){var e=typeof t;return"string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t}},function(t,e,n){var r=n(28);t.exports=function(t){return r(this,t).get(t)}},function(t,e,n){var r=n(28);t.exports=function(t){return r(this,t).has(t)}},function(t,e,n){var r=n(28);t.exports=function(t,e){var n=r(this,t),i=n.size;return n.set(t,e),this.size+=n.size==i?0:1,this}},function(t,e,n){var r=n(137);t.exports=function(t){return null==t?"":r(t)}},function(t,e,n){var r=n(64),i=n(138),o=n(17),s=n(66),a=r?r.prototype:void 0,c=a?a.toString:void 0;t.exports=function t(e){if("string"==typeof e)return e;if(o(e))return i(e,t)+"";if(s(e))return c?c.call(e):"";var n=e+"";return"0"==n&&1/e==-1/0?"-0":n}},function(t,e){t.exports=function(t,e){for(var n=-1,r=null==t?0:t.length,i=Array(r);++n)","gi")),i=[],o=[i];return r.forEach((function(t){var n=t.match(new RegExp("{([a-z0-9_]+)}|<(/?)([a-z0-9_]+)>","i"));if(n){if(n[1])o[0].push(e[n[1]]);else if(n[3])if(n[2])o.shift();else{var r=e[n[3]]||{tag:n[3],children:[]};o[0].push(r),o.unshift(r.children||r)}}else o[0].push({tag:"span",text:t})})),i.filter((function(t){return t}))},e.pluralize=function(t,e){var n=this,r=new RegExp(/^\w+\: +(.+)$/),i=new RegExp(/^\s*((\{\s*(\-?\d+[\s*,\s*\-?\d+]*)\s*\})|([\[\]])\s*(-Inf|\-?\d+)\s*,\s*(\+?Inf|\-?\d+)\s*([\[\]]))\s?(.+?)$/),o=new RegExp(/^\s*(\{\s*(\-?\d+[\s*,\s*\-?\d+]*)\s*\})|([\[\]])\s*(-Inf|\-?\d+)\s*,\s*(\+?Inf|\-?\d+)\s*([\[\]])/),s=[],a=[];return t.split("|").forEach((function(t){if(i.test(t)){var e=t.match(i);a[e[0]]=e[e.length-1]}else if(r.test(t)){var n=t.match(r);s.push(n[1])}else s.push(t)})),a.forEach((function(t,r){if(o.test(r)){var i=r.match(o);if(i[1]){var s=i[2].split(",");for(var c in s)if(e==s[c])return a[r]}else{var u=n.convertNumber(i[4]),l=n.convertNumber(i[5]);if(("["===i[3]?e>=u:e>u)&&("]"===i[6]?e<=l:e3&&(e=e.split("_")[0]),e){case"bo":case"dz":case"id":case"ja":case"jv":case"ka":case"km":case"kn":case"ko":case"ms":case"th":case"vi":case"zh":return 0;case"af":case"az":case"bn":case"bg":case"ca":case"da":case"de":case"el":case"en":case"eo":case"es":case"et":case"eu":case"fa":case"fi":case"fo":case"fur":case"fy":case"gl":case"gu":case"ha":case"he":case"hu":case"is":case"it":case"ku":case"lb":case"ml":case"mn":case"mr":case"nah":case"nb":case"ne":case"nl":case"nn":case"no":case"om":case"or":case"pa":case"pap":case"ps":case"pt":case"so":case"sq":case"sv":case"sw":case"ta":case"te":case"tk":case"tr":case"ur":case"zu":return 1==t?0:1;case"am":case"bh":case"fil":case"fr":case"gun":case"hi":case"ln":case"mg":case"nso":case"xbr":case"ti":case"wa":return 0===t||1==t?0:1;case"be":case"bs":case"hr":case"ru":case"sr":case"uk":return t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2;case"cs":case"sk":return 1==t?0:t>=2&&t<=4?1:2;case"ga":return 1==t?0:2==t?1:2;case"lt":return t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2;case"sl":return t%100==1?0:t%100==2?1:t%100==3||t%100==4?2:3;case"mk":return t%10==1?0:1;case"mt":return 1==t?0:0===t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3;case"lv":return 0===t?0:t%10==1&&t%100!=11?1:2;case"pl":return 1==t?0:t%10>=2&&t%10<=4&&(t%100<12||t%100>14)?1:2;case"cy":return 1==t?0:2==t?1:8==t||11==t?2:3;case"ro":return 1==t?0:0===t||t%100>0&&t%100<20?1:2;case"ar":return 0===t?0:1==t?1:2==t?2:t>=3&&t<=10?3:t>=11&&t<=99?4:5;default:return 0}},t}(),y=function(){function t(t,e){this.user=void 0,this.csrfToken=void 0,this.user=t,this.csrfToken=e}var e=t.prototype;return e.login=function(t,e){return void 0===e&&(e={}),app.request(Object(o.a)({method:"POST",url:app.forum.attribute("baseUrl")+"/login",body:t},e))},e.logout=function(){window.location.href=app.forum.attribute("baseUrl")+"/logout?token="+this.csrfToken},t}(),b=function(){function t(t){this.data={},this.models=void 0,this.models=t}var e=t.prototype;return e.pushPayload=function(t){t.included&&t.included.map(this.pushObject.bind(this));var e=t.data instanceof Array?t.data.map(this.pushObject.bind(this)):this.pushObject(t.data);return e.payload=t,e},e.pushObject=function(t){if(!this.models[t.type])return null;var e=this.data[t.type]=this.data[t.type]||{};return e[t.id]?e[t.id].pushData(t):e[t.id]=this.createRecord(t.type,t),e[t.id].exists=!0,e[t.id]},e.find=function(t,e,n,r){void 0===n&&(n={}),void 0===r&&(r={});var i=n,s=app.forum.attribute("apiUrl")+"/"+t;return e instanceof Array?s+="?filter[id]="+e.join(","):"object"==typeof e?i=e:e&&(s+="/"+e),app.request(Object(o.a)({method:"GET",url:s,params:i},r)).then(this.pushPayload.bind(this))},e.getById=function(t,e){return this.data[t]&&this.data[t][e]},e.getBy=function(t,e,n){return this.all(t).filter((function(t){return t[e]()===n}))[0]},e.all=function(t){var e=this.data[t];return e?Object.keys(e).map((function(t){return e[t]})):[]},e.remove=function(t){delete this.data[t.data.type][t.id()]},e.createRecord=function(t,e){return void 0===e&&(e={}),e.type=e.type||t,new this.models[t](e,this)},t}();function w(t,e,n){var r=t[e];t[e]=function(){for(var e=arguments.length,i=new Array(e),o=0;o").addClass("drawer-backdrop fade").appendTo("body").click((function(){return t.hide()})),setTimeout((function(){return t.$backdrop.addClass("in")}))},t}(),k=function(t,e,n,r){this.status=void 0,this.responseText=void 0,this.options=void 0,this.xhr=void 0,this.response=void 0,this.alert=void 0,this.status=t,this.responseText=e,this.options=n,this.xhr=r;try{this.response=JSON.parse(e)}catch(t){this.response=null}this.alert=null},T=function(){function t(t,e){void 0===t&&(t={}),void 0===e&&(e=null),this.data=void 0,this.payload=void 0,this.freshness=void 0,this.exists=void 0,this.store=void 0,this.data=t,this.store=e,this.freshness=new Date,this.exists=!1}var e=t.prototype;return e.id=function(){return this.data.id},e.attribute=function(t){return this.data.attributes[t]},e.pushData=function(e){for(var n in e)if("object"==typeof e[n])for(var r in this.data[n]=this.data[n]||{},e[n])e[n][r]instanceof t&&(e[n][r]={data:t.getIdentifier(e[n][r])}),this.data[n][r]=e[n][r];else this.data[n]=e[n];this.freshness=new Date},e.pushAttributes=function(t){this.pushData({attributes:t})},e.save=function(e,n){var r=this;void 0===n&&(n={});var i={type:this.data.type,id:this.data.id,attributes:e,relationships:void 0};if(e.relationships){for(var s in i.relationships={},e.relationships){var a=e.relationships[s];i.relationships[s]={data:a instanceof Array?a.map(t.getIdentifier):t.getIdentifier(a)}}delete e.relationships}var c=this.copyData();this.pushData(i);var u={data:i};return n.meta&&(u.meta=n.meta),app.request(Object(o.a)({method:this.exists?"PATCH":"POST",url:app.forum.attribute("apiUrl")+this.apiEndpoint(),body:u},n)).then((function(t){return r.store.data[t.data.type]=r.store.data[t.data.type]||{},r.store.data[t.data.type][t.data.id]=r,r.store.pushPayload(t)}),(function(t){throw r.pushData(c),m.redraw(),t}))},e.delete=function(t,e){var n=this;return void 0===t&&(t={}),void 0===e&&(e={}),this.exists?app.request(Object(o.a)({method:"DELETE",url:app.forum.attribute("apiUrl")+this.apiEndpoint(),body:t},e)).then((function(){n.exists=!1,n.store.remove(n)})):Promise.resolve()},e.apiEndpoint=function(){return"/"+this.data.type+(this.exists?"/"+this.data.id:"")},e.copyData=function(){return JSON.parse(JSON.stringify(this.data))},t.attribute=function(t,e){return function(){var n=this.data.attributes&&this.data.attributes[t];return e?e(n):n}},t.hasOne=function(t){return function(){if(this.data.relationships){var e=this.data.relationships[t];if(e)return app.store.getById(e.data.type,e.data.id)}return!1}},t.hasMany=function(t){return function(){if(this.data.relationships){var e=this.data.relationships[t];if(e)return e.data.map((function(t){return app.store.getById(t.type,t.id)}))}return!1}},t.transformDate=function(t){return t?new Date(t):null},t.getIdentifier=function(t){return{type:t.data.type,id:t.data.id}},t}(),E=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.apiEndpoint=function(){return"/"},e}(T);function _(t,e){var n,r=[].concat(t),i={};return function(){var t=this,o=!1;return r.forEach((function(e){var n="function"==typeof t[e]?t[e]():t[e];i[e]!==n&&(o=!0,i[e]=n)})),o&&(n=e.apply(this,r.map((function(t){return i[t]})))),n}}var C=function(t,e){this.content=void 0,this.priority=void 0,this.key=0,this.content=t,this.priority=e},S=function(){function t(){this.items={}}var e=t.prototype;return e.isEmpty=function(){for(var t in this.items)if(this.items.hasOwnProperty(t))return!1;return!0},e.has=function(t){return!!this.items[t]},e.get=function(t){var e;return null===(e=this.items[t])||void 0===e?void 0:e.content},e.add=function(t,e,n){return void 0===n&&(n=0),this.items[t]=new C(e,n),this},e.toArray=function(){var t=[];for(var e in this.items)this.items.hasOwnProperty(e)&&null!==this.items[e]&&this.items[e]instanceof C&&(this.items[e].content=Object(this.items[e].content),this.items[e].content.itemName=e,t.push(this.items[e]),this.items[e].key=t.length);return t.sort((function(t,e){return t.priority===e.priority?t.key-e.key:t.priority>e.priority?-1:1})).map((function(t){return t.content}))},t}(),O=n(0);function A(t,e){return void 0===e&&(e={}),e.className="icon "+t+" "+(e.className||""),m("i",e)}var P=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(t){var e=t.attrs,n=p(e,"type"),r=p(e,"icon");return e.className="Badge "+(n?"Badge--"+n:"")+" "+(e.className||""),e.title=p(e,"label")||"",m("span",e,r?A(r,{className:"Badge-icon"}):m.trust(" "))},n.oncreate=function(e){t.prototype.oncreate.call(this,e),this.props.label&&this.$().tooltip({container:"body"})},e}(O.a),j=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;idayjs().subtract(5,"minutes").toDate()},n.badges=function(){var t=new S,e=this.groups();return e&&e.forEach((function(e){t.add("group"+e.id(),D.component({group:e}))})),t},n.calculateAvatarColor=function(){var t=new Image,e=this;t.onload=function(){var t=new ColorThief;e.avatarColor=t.getColor(this),e.freshness=new Date,m.redraw()},t.crossOrigin="anonymous",t.src=this.avatarUrl()},n.savePreferences=function(t){var e=this.preferences();return Object(o.a)(e,t),this.save({preferences:e})},e}(T);function L(t){var e=t.replace(/(<\/p>|
)/g,"$1  ").replace(/]*>/gi," "),n=$("
").html(e);return n.find(L.removeSelectors.join(",")).remove(),n.text().replace(/\s+/g," ").trim()}L.removeSelectors=["blockquote","script"];var R=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=0||(i[n]=t[n]);return i}(t,["children"]);n.className=n.className||"",n.type=n.type||"button",n.title&&!this.props.children&&(n["aria-label"]=n.title),!n.title&&this.props.children&&(n.title=h(this.props.children));var r=p(n,"icon");r&&(n.className+=" hasIcon");var i=p(n,"loading");return(n.disabled||i)&&(n.className=classNames(n.className,"disabled",i&&"loading"),delete n.onclick),m("button",n,this.getButtonContent(r,n.loading,e))},n.getButtonContent=function(t,e,n){return[t&&!0!==t?A(t,{className:"Button-icon"}):"",n?m("span",{className:"Button-label"},n):"",e?K.component({size:"tiny",className:"LoadingIndicator--inline"}):""]},e}(O.a),G=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.view=function(){return m("li",{className:"Dropdown-separator"})},e}(O.a);function J(t){return(null==t?void 0:t.tag)===G}function X(t){return t instanceof Array||(t=[t]),function(t){var e,n=[];return t.forEach((function(r,i){(!J(r)||e&&!J(e)&&i!==t.length-1)&&(e=r,n.push(r))})),n}(t).map((function(t){var e,n,r,i,o=null===(e=t.tag)||void 0===e?void 0:e.isListItem,s=(null===(n=t.tag)||void 0===n?void 0:n.isActive)&&t.tag.isActive(t.attrs),a=(null===(r=t.attrs)||void 0===r?void 0:r.itemClassName)||t.itemClassName;o&&(t.attrs=t.attrs||{},t.attrs.key=t.attrs.key||t.itemName,t.key=t.attrs.key);var c=o?t:m("li",{className:classNames(a,t.itemName&&"item-"+t.itemName,s&&"active"),key:(null===(i=t.attrs)||void 0===i?void 0:i.key)||t.itemName},t);return c.state=c.state||{},c}))}G.isListItem=!0;var Q,tt,et,nt,rt,it=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.view=function(){var t=Object(o.a)({},this.props),e=p(t,"type");t.className="Alert Alert--"+e+" "+(t.className||"");var n=p(t,"children"),r=p(t,"controls")||[],i=p(t,"dismissible"),s=p(t,"ondismiss"),a=[];return(i||void 0===i)&&a.push(m(Z,{icon:"fas fa-times",className:"Button Button--link Button--icon Alert-dismiss",onclick:s})),m("div",t,m("span",{className:"Alert-body"},n),m("ul",{className:"Alert-controls"},X(r.concat(a))))},e}(O.a),ot=(Q=["a[href]","area[href]",'input:not([disabled]):not([type="hidden"]):not([aria-hidden])',"select:not([disabled]):not([aria-hidden])","textarea:not([disabled]):not([aria-hidden])","button:not([disabled]):not([aria-hidden])","iframe","object","embed","[contenteditable]",'[tabindex]:not([tabindex^="-"])'],tt=function(){function t(t){var e=t.targetModal,n=t.triggers,r=void 0===n?[]:n,i=t.onShow,o=void 0===i?function(){}:i,s=t.onClose,a=void 0===s?function(){}:s,c=t.openTrigger,u=void 0===c?"data-micromodal-trigger":c,l=t.closeTrigger,f=void 0===l?"data-micromodal-close":l,d=t.disableScroll,p=void 0!==d&&d,h=t.disableFocus,m=void 0!==h&&h,v=t.awaitCloseAnimation,g=void 0!==v&&v,y=t.awaitOpenAnimation,b=void 0!==y&&y,w=t.debugMode,x=void 0!==w&&w;this.modal=document.getElementById(e),this.config={debugMode:x,disableScroll:p,openTrigger:u,closeTrigger:f,onShow:o,onClose:a,awaitCloseAnimation:g,awaitOpenAnimation:b,disableFocus:m},r.length>0&&this.registerTriggers.apply(this,r),this.onClick=this.onClick.bind(this),this.onKeydown=this.onKeydown.bind(this)}var e=t.prototype;return e.registerTriggers=function(){for(var t=this,e=arguments.length,n=new Array(e),r=0;r
'),!1},rt=function(t,e){if(function(t){t.length<=0&&(console.warn("MicroModal: ❗Please specify at least one %c'micromodal-trigger'","background-color: #f8f9fa;color: #50596c;font-weight: bold;","data attribute."),console.warn("%cExample:","background-color: #f8f9fa;color: #50596c;font-weight: bold;",''))}(t),!e)return!0;for(var n in e)nt(n);return!0},{init:function(t){var e=Object(o.a)({},{openTrigger:"data-micromodal-trigger"},t),n=[].concat(document.querySelectorAll("["+e.openTrigger+"]")),r=function(t,e){var n=[];return t.forEach((function(t){var r=t.attributes[e].value;void 0===n[r]&&(n[r]=[]),n[r].push(t)})),n}(n,e.openTrigger);if(!0!==e.debugMode||!1!==rt(n,r))for(var i in r){var s=r[i];e.targetModal=i,e.triggers=[].concat(s),et=new tt(e)}},show:function(t,e){var n=e||{};n.targetModal=t,!0===n.debugMode&&!1===nt(t)||(et=new tt(n)).showModal()},close:function(t){t?et.closeModalById(t):et.closeModal()}}),st=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i").addClass("modal-backdrop").appendTo("body"),ot.show("Modal",{awaitCloseAnimation:!0,onClose:function(){$(".modal-backdrop").fadeOut(200,(function(){this.remove()})),n.showing=!1}}),this.onready()},n.onclick=function(t){t.target===this.element&&this.close()},n.close=function(){this.showing&&(this.hideTimeout=setTimeout((function(){return ot.close("Modal")})))},n.clear=function(){this.component&&this.component.onhide(),this.component=null,m.redraw()},n.onready=function(){this.component&&this.component.onready()},e}(O.a),ct=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.className=function(){return"RequestErrorModal Modal--large"},n.title=function(){return this.props.error.xhr?this.props.error.xhr.status+" "+this.props.error.xhr.statusText:""},n.content=function(){var t;try{t=JSON.stringify(JSON.parse(this.props.error.responseText),null,2)}catch(e){t=this.props.error.responseText}return m("div",{className:"Modal-body"},m("pre",null,this.props.error.options.method," ",this.props.error.options.url,m("br",null),m("br",null),t))},e}(st),ut=function(){function t(){this.forum=void 0,this.data=void 0,this.translator=new g,this.bus=new d,this.session=void 0,this.store=new b({forums:E,users:I,discussions:j,posts:R,groups:B,notifications:H}),this.drawer=new N,this.modal=void 0,this.cache={},this.routes={},this.title="",this.titleCount=0,this.requestError=null}var e=t.prototype;return e.mount=function(t){void 0===t&&(t=""),m.mount(document.getElementById("modal"),new at),m.route(document.getElementById("content"),t+"/",function(t,e){void 0===e&&(e="");var n={};for(var r in t){var i=t[r];i.component&&(i.component.attrs||(i.component.attrs={}),i.component.attrs.routeName=r),n[e+i.path]=i.component}return n}(this.routes,t))},e.boot=function(t){this.data=t,this.store.pushPayload({data:this.data.resources}),this.forum=this.store.getById("forums",1),this.session=new y(this.store.getById("users",this.data.session.userId),this.data.session.csrfToken),this.locale(),this.plugins(),this.setupRoutes(),this.mount(),this.bus.dispatch("app.booting")},e.locale=function(){this.translator.locale=this.data.locale,this.bus.dispatch("app.locale")},e.plugins=function(){this.bus.dispatch("app.plugins")},e.setupRoutes=function(){this.bus.dispatch("app.routes")},e.preloadedApiDocument=function(){if(this.data.apiDocument){var t=this.store.pushPayload(this.data.apiDocument);return this.data.apiDocument=null,t}return null},e.setTitle=function(t){this.title=t,this.updateTitle()},e.setTitleCount=function(t){this.titleCount=t,this.updateTitle()},e.updateTitle=function(){document.title=(this.titleCount?"("+this.titleCount+") ":"")+(this.title?this.title+" - ":"")+this.forum.attribute("title")},e.route=function(t,e){void 0===e&&(e={});var n=this.routes[t];if(!n)throw new Error("Route '"+t+"' does not exist");var r=n.path.replace(/:([^\/]+)/g,(function(t,n){return p(e,n)})),i=m.buildQueryString(e);return(""===m.route.prefix?this.forum.attribute("basePath"):"")+r+(i?"?"+i:"")},e.request=function(t){var e=this,n=Object(o.a)({},t);if(n.background=n.background||!0,w(n,"config",(function(t,n){return n.setRequestHeader("X-CSRF-Token",e.session.csrfToken)})),"GET"!==n.method&&"POST"!==n.method){var r=n.method;w(n,"config",(function(t,e){return e.setRequestHeader("X-HTTP-Method-Override",r)})),n.method="POST"}n.deserialize=n.deserialize||function(t){return t},n.errorHandler=n.errorHandler||function(t){throw t};var i=n.extract;return n.extract=function(t){var e;e=i?i(t.responseText):t.responseText||null;var r=t.status;if(r<200||r>299)throw new k(r,e,n,t);if(t.getResponseHeader){var o=t.getResponseHeader("X-CSRF-Token");o&&(app.session.csrfToken=o)}try{return JSON.parse(e)}catch(r){throw new k(500,e,n,t)}},m.request(n).then((function(t){return t}),(function(t){var r;switch(e.requestError=t,t.status){case 422:r=t.response.errors.map((function(t){return[t.detail,m("br")]})).reduce((function(t,e){return t.concat(e)}),[]).slice(0,-1);break;case 401:case 403:r=e.translator.trans("core.lib.error.permission_denied_message");break;case 404:case 410:r=e.translator.trans("core.lib.error.not_found_message");break;case 429:r=e.translator.trans("core.lib.error.rate_limit_exceeded_message");break;default:r=e.translator.trans("core.lib.error.generic_message")}var i=app.forum.attribute("debug");t.alert=it.component({type:"error",children:r,controls:i&&[Z.component({className:"Button Button--link",onclick:e.showDebug.bind(e,t),children:"DEBUG"})]});try{n.errorHandler(t)}catch(t){console.error(t)}return Promise.reject(t)}))},e.showDebug=function(t){this.modal.show(ct.component({error:t}))},t}(),lt=function(){function t(){this.stack=[]}var e=t.prototype;return e.getCurrent=function(){return this.stack[this.stack.length-1]},e.getPrevious=function(){return this.stack[this.stack.length-2]},e.push=function(t,e,n){void 0===n&&(n=m.route.get());var r=this.stack[this.stack.length-2];r&&r.name===t&&this.stack.pop();var i=this.getCurrent();i&&i.name===t?Object(o.a)(i,{url:n,title:e}):this.stack.push({name:t,url:n,title:e})},e.canGoBack=function(){return this.stack.length>1},e.back=function(){if(!this.canGoBack())return this.home();this.stack.pop(),m.route.set(this.getCurrent().url)},e.backUrl=function(){return this.stack[this.stack.length-2].url},e.home=function(){this.stack.splice(0),m.route.set("/")},t}(),ft=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){return m("ul",{className:"Header-controls"},X(this.items().toArray()))},n.items=function(){return new S},e}(O.a),dt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){return m("div",{className:"LogInButtons"},this.items().toArray())},n.items=function(){return new S},e}(O.a),pt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i .Dropdown-toggle").dropdown(),this.element.addEventListener("shown.bs.dropdown",(function(){n.showing=!0,n.props.onshow&&n.props.onshow(),m.redraw();var t=n.$(".Dropdown-menu"),e=t.hasClass("Dropdown-menu--right");t.removeClass("Dropdown-menu--top Dropdown-menu--right"),t.toggleClass("Dropdown-menu--top",t.offset().top+t.height()>$(window).scrollTop()+$(window).height()),t.offset().top<0&&t.removeClass("Dropdown-menu--top"),t.toggleClass("Dropdown-menu--right",e||t.offset().left+t.width()>$(window).scrollLeft()+$(window).width())})),this.element.addEventListener("hidden.bs.dropdown",(function(){n.showing=!1,n.props.onhide&&n.props.onhide(),m.redraw()}))},n.getButton=function(){return m("button",{className:"Dropdown-toggle "+this.props.buttonClassName,"data-toggle":"dropdown",onclick:this.props.onclick},this.getButtonContent())},n.getButtonContent=function(){var t=this.props;return[t.icon?A(t.icon,{className:"Button-icon"}):"",m("span",{className:"Button-label"},t.label),t.caretIcon?A(t.caretIcon,{className:"Button-caret"}):""]},n.getMenu=function(t){return m("ul",{className:"Dropdown-menu dropdown-menu "+this.props.menuClassName},t)},e}(O.a),vt=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.initProps=function(t){t.active=this.isActive(t)},e.prototype.view=function(){var e=t.prototype.view.call(this);return e.tag=m.route.Link,e.attrs.active=String(e.attrs.active),e},e.isActive=function(t){return void 0!==t.active?t.active:m.route.get()===t.href},e}(Z),gt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t),e.initProps=function(e){t.initProps.call(this,e),e.className="SessionDropdown",e.buttonClassName="Button Button--user Button--flat",e.menuClassName="Dropdown-menu--right"};var n=e.prototype;return n.view=function(){return this.props.children=this.items().toArray(),t.prototype.view.call(this)},n.getButtonContent=function(){var t=app.session.user;return[ht(t)," ",m("span",{className:"Button-label"},v(t))]},n.items=function(){var t=new S,e=app.session.user;return t.add("profile",vt.component({icon:"fas fa-user",children:app.translator.trans("core.forum.header.profile_button"),href:app.route.user(e)}),100),t.add("settings",vt.component({icon:"fas fa-cog",children:app.translator.trans("core.forum.header.settings_button"),href:app.route("settings")}),50),app.forum.attribute("adminUrl")&&t.add("administration",vt.component({icon:"fas fa-wrench",children:app.translator.trans("core.forum.header.admin_button"),href:app.forum.attribute("adminUrl"),target:"_blank"}),0),t.add("separator",G.component(),-90),t.add("logOut",Z.component({icon:"fas fa-sign-out-alt",children:app.translator.trans("core.forum.header.log_out_button"),onclick:app.session.logout.bind(app.session)}),-100),t},e}(mt),yt=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.initProps=function(e){e.caretIcon=void 0!==e.caretIcon?e.caretIcon:"fas fa-sort",t.initProps.call(this,e),e.className+=" Dropdown--select"},e.prototype.getButtonContent=function(){var t=this.props.children.filter((function(t){return t.attrs.active}))[0],e=t&&t.attrs.children||this.props.defaultLabel;return e instanceof Array&&(e=e[0]),[m("span",{className:"Button-label"},e),A(this.props.caretIcon,{className:"Button-caret"})]},e}(mt),bt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=o+s&&n.loadMore()},i.on("scroll",this.scrollHandler),this.load()},n.onremove=function(e){t.prototype.onremove.call(this,e),this.$scrollParent.off("scroll",this.scrollHandler)},n.load=function(){app.session.user.newNotificationCount()&&delete app.cache.notifications,app.cache.notifications||(app.session.user.pushAttributes({newNotificationCount:0}),this.loadMore())},n.loadMore=function(){var t=this;this.loading=!0,m.redraw();var e=app.cache.notifications?{page:{offset:10*app.cache.notifications.length}}:null;return app.store.find("notifications",e).then(this.parseResults.bind(this)).catch((function(){})).then((function(){t.loading=!1,m.redraw()}))},n.parseResults=function(t){return app.cache.notifications=app.cache.notifications||[],t.length&&app.cache.notifications.push(t),this.moreResults=!!t.payload.links.next,t},n.markAllAsRead=function(){app.cache.notifications&&(app.session.user.pushAttributes({unreadNotificationCount:0}),app.cache.notifications.forEach((function(t){t.forEach((function(t){return t.pushAttributes({isRead:!0})}))})),app.request({url:app.forum.attribute("apiUrl")+"/notifications/read",method:"POST"}))},e}(O.a),wt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i0?"...":"")+t.substring(n,n+e)+(t.length>n+e?"...":"")}(i,n,o)),i=$("
").text(i).html(),e&&(i=i.replace(r,"$&")),m.trust(i)}var kt=function(){},Tt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i li:not(.Dropdown-header)",(function(){r.setIndex(r.selectableItems().index(this))}));var i=this.$("input");this.navigator=new xt,this.navigator.onUp((function(){return n.setIndex(n.getCurrentNumericIndex()-1,!0)})).onDown((function(){return n.setIndex(n.getCurrentNumericIndex()+1,!0)})).onSelect(this.selectResult.bind(this)).onCancel(this.clear.bind(this)).bindTo(i),i.on("input focus",(function(){var t=this.value.toLowerCase();t&&(clearTimeout(r.searchTimeout),r.searchTimeout=setTimeout((function(){-1===r.searched.indexOf(t)&&(t.length>=3&&r.sources.map((function(e){e.search&&(r.loadingSources++,e.search(t).then((function(){r.loadingSources=Math.max(0,r.loadingSources-1),m.redraw()})))})),r.searched.push(t),m.redraw())}),250))})).on("focus",(function(){$(this).one("mouseup",(function(t){return t.preventDefault()})).select()}))},n.getCurrentSearch=function(){return app.current&&"function"==typeof app.current.searching&&app.current.searching()},n.selectResult=function(){clearTimeout(this.searchTimeout),this.loadingSources=0,this.value()?m.route.set(this.getItem(this.index).find("a").attr("href")):this.clear(),this.$("input").blur()},n.clear=function(){this.value(""),this.getCurrentSearch()?app.current.clearSearch():m.redraw()},n.sourceItems=function(){var t=new S;return app.forum.attribute("canViewDiscussions")&&t.add("discussions",new Tt),app.forum.attribute("canViewUserList")&&t.add("users",new Et),t},n.selectableItems=function(){return this.$(".Search-results > li:not(.Dropdown-header)")},n.getCurrentNumericIndex=function(){return this.selectableItems().index(this.getItem(this.index))},n.getItem=function(t){var e=this.selectableItems(),n=e.filter('[data-index="'+t+'"]');return n.length||(n=e.eq(t)),n},n.setIndex=function(t,e){var n=this.selectableItems(),r=n.parent(),i=t;t<0?i=n.length-1:t>=n.length&&(i=0);var o=n.removeClass("active").eq(i).addClass("active");if(this.index=o.attr("data-index")||i,e){var s,a=r.scrollTop(),c=r.offset().top,u=c+r.outerHeight(),l=o.offset().top,f=l+o.outerHeight();lu&&(s=a-u+f+parseInt(r.css("padding-bottom"),10)),void 0!==s&&r.animate({scrollTop:s},100)}},e}(O.a),Ct=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){return m("ul",{className:"Header-controls"},X(this.items().toArray()))},n.items=function(){var t=new S;if(t.add("search",_t.component(),30),app.forum.attribute("showLanguageSelector")&&Object.keys(app.data.locales).length>1){var e=[],n=function(t){if(!app.data.locales.hasOwnProperty(t))return"continue";e.push(Z.component({active:app.data.locale===t,children:app.data.locales[t],icon:app.data.locale!==t||"fas fa-check",onclick:function(){app.session.user?app.session.user.savePreferences({locale:t}).then((function(){return window.location.reload()})):(document.cookie="locale="+t+"; path=/; expires=Tue, 19 Jan 2038 03:14:07 GMT",window.location.reload())}}))};for(var r in app.data.locales)n(r);t.add("locale",yt.component({children:e,buttonClassName:"Button Button--link"}),20)}return app.session.user?(t.add("notifications",m(wt,null),10),t.add("session",m(gt,null),0)):(app.forum.attribute("allowSignUp")&&t.add("signUp",Z.component({children:app.translator.trans("core.forum.header.sign_up_link"),className:"Button Button--link",onclick:function(){return app.modal.show(new SignUpModal)}}),10),t.add("logIn",Z.component({children:app.translator.trans("core.forum.header.log_in_link"),className:"Button Button--link",onclick:function(){return app.modal.show(new pt)}}),0)),t},e}(O.a),St=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.oninit=function(){console.log("IndexPage#oninit")},n.view=function(){return m("div",{class:"container"},m("h1",null,"hi"))},e}(O.a),Ot=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=$(document).height();s9e.TextFormatter.preview(e||"",t.dom),r&&$(window).scrollTop($(document).height())}}}),50);t.attrs.onunload=function(){return clearInterval(n)}},e}(O.a),Rt=function(){function t(){this.handlers={}}var e=t.prototype;return e.getHandlers=function(t){return this.handlers=this.handlers||{},this.handlers[t]=this.handlers[t]||[],this.handlers[t]},e.trigger=function(t){for(var e=this,n=arguments.length,r=new Array(n>1?n-1:0),i=1;i3456e5&&(a=[m("div",{className:"PostStream-timeGap"},m("span",null,app.translator.trans("core.forum.post_stream.time_lapsed_text",{period:dayjs(u).from(dayjs(t,!0))}))),a]),t=u}else c.key="post"+i[e.visibleStart+s],a=m(Dt,null);return m("div",Object(o.a)({className:"PostStream-item"},c),a)}));return!this.viewingEnd&&r[this.visibleEnd-this.visibleStart-1]&&s.push(m("div",{className:"PostStream-loadMore",key:"loadMore"},m(Z,{className:"Button",onclick:this.loadNext.bind(this)},app.translator.trans("core.forum.post_stream.load_more_button")))),!this.viewingEnd||app.session.user&&!this.discussion.canReply()||s.push(m("div",{className:"PostStream-item",key:"reply"},Lt.component({discussion:this.discussion}))),m("div",{className:"PostStream"},s)},n.oncreate=function(e){t.prototype.oncreate.call(this,e),this.scrollListener.start()},n.onremove=function(e){t.prototype.onremove.call(this,e),this.scrollListener.stop(),clearTimeout(this.calculatePositionTimeout)},n.onscroll=function(t){if(!this.paused){var e=this.getMarginTop(),n=$(window).height()-e,r=t+e;if(this.visibleStart>0){var i=this.$('.PostStream-item[data-index="'+this.visibleStart+'"]');i.length&&i.offset().top>r-300&&this.loadPrevious()}if(this.visibleEndthis.visibleStart&&n>=0&&(this.visibleStart=n+this.constructor.loadCount+1,this.loadPageTimeouts[n]&&(clearTimeout(this.loadPageTimeouts[n]),this.loadPageTimeouts[n]=null,this.pagesLoading--)),this.loadPage(t,e)},n.loadPrevious=function(){var t=this.visibleStart,e=this.visibleStart=this.sanitizeIndex(this.visibleStart-this.constructor.loadCount),n=e+2*this.constructor.loadCount;nr.visibleEnd||($t('.PostStream-item[data-index="'+(n?r.visibleEnd-1:r.visibleStart)+'"]',(function(){return m.redraw(!0)})),r.unpause())};i(),this.loadPageTimeouts[t]=setTimeout((function(){r.loadRange(t,e).then((function(){i(),r.pagesLoading--})),r.loadPageTimeouts[t]=null}),this.pagesLoading?1e3:0),this.pagesLoading++},n.loadRange=function(t,e){var n=[],r=[];return this.discussion.postIds().slice(t,e).forEach((function(t){var e=app.store.getById("posts",t);e&&e.discussion()&&void 0!==e.canEdit()?r.push(e):n.push(t)})),n.length?app.store.find("posts",n):Promise.resolve(r)},n.loadNearNumber=function(t){return this.posts().some((function(e){return e&&Number(e.number())===Number(t)}))?Promise.resolve():(this.reset(),app.store.find("posts",{filter:{discussion:this.discussion.id()},page:{near:t}}).then(this.show.bind(this)))},n.loadNearIndex=function(t){if(t>=this.visibleStart&&t<=this.visibleEnd)return Promise.resolve();var e=this.sanitizeIndex(t-this.constructor.loadCount/2),n=e+this.constructor.loadCount;return this.reset(e,n),this.loadRange(e,n).then(this.show.bind(this))},n.calculatePosition=function(){var t,e,n=this.getMarginTop(),r=$(window),i=r.height()-n,o=r.scrollTop()+n;this.$(".PostStream-item").each((function(n,r){var s=$(r),a=s.offset().top,c=s.outerHeight(!0);if(a+c>o){if(t||(t=e=s.data("number")),!(a+cc){var u=r?s-$(window).height():t.is(":first-child")?0:o;return new Promise((function(t){e?(i.scrollTop(u),t()):u!==a?i.animatedScrollTop(u,"fast",t):t()}))}}return Promise.resolve()},n.flashItem=function(t){t.addClass("flash").one("animationend webkitAnimationEnd",(function(){return t.removeClass("flash")}))},n.unpause=function(){this.paused=!1,this.scrollListener.update(),this.trigger("unpaused")},e}(O.a);Bt.loadCount=20,Object(o.a)(Bt.prototype,Rt.prototype);var Ht=Bt,Ut=function(){function t(){this.callbacks=void 0,this.data={};for(var t=arguments.length,e=new Array(t),n=0;n=this.count()},n.onscroll=function(t){var e=this.props.stream.state;e&&!e.paused&&e.$()&&(this.update(t),this.renderScrollbar())},n.update=function(t){var e=this.props.stream.state,n=e.getMarginTop(),r=t+n,i=$(window).height()-n,o=e.$(".PostStream-item[data-index]"),s=o.first().data("index")||0,a=0,c="";o.each((function(){var t=$(this),e=t.offset().top,n=t.outerHeight(!0);if(e+nr+i)return!1;var o=Math.max(0,r-e),u=Math.min(n,r+i-e)-o;e<=r&&(s=parseFloat(t.data("index"))+o/n),u>0&&(a+=u/n);var l=t.data("time");l&&(c=l)})),this.index=s,this.visible=a,this.description=c?dayjs(c).format("MMMM YYYY"):""},n.onremove=function(e){t.prototype.onremove.call(this,e),this.ondestroy()},n.oncreate=function(e){var n=this;t.prototype.oncreate.call(this,e),this.props.stream.state.on("unpaused",this.handlers.streamWasUnpaused=this.streamWasUnpaused.bind(this)),this.props.stream.state.on("update",(function(){return n.update()})),this.scrollListener.start(),$(window).on("resize",this.handlers.onresize=this.onresize.bind(this)).resize(),this.$(".Scrubber-scrollbar").on("click",this.onclick.bind(this)).css({cursor:"pointer","user-select":"none"}).on("dragstart mousedown touchstart",(function(t){return t.preventDefault()})),this.$(".Scrubber-handle").css("cursor","move").on("mousedown touchstart",this.onmousedown.bind(this)).click((function(t){return t.stopPropagation()})),$(document).on("mousemove touchmove",this.handlers.onmousemove=this.onmousemove.bind(this)).on("mouseup touchend",this.handlers.onmouseup=this.onmouseup.bind(this))},n.ondestroy=function(){this.scrollListener.stop(),this.props.stream.state.off("unpaused",this.handlers.streamWasUnpaused),$(window).off("resize",this.handlers.onresize),$(document).off("mousemove touchmove",this.handlers.onmousemove).off("mouseup touchend",this.handlers.onmouseup)},n.renderScrollbar=function(t){var e=this.percentPerPost(),n=this.index,r=this.count(),i=this.visible||1,o=this.$();o.find(".Scrubber-index").text(Ft(Math.min(Math.ceil(n+i),r))),o.find(".Scrubber-description").text(this.description),o.toggleClass("disabled",this.disabled());var s={};s.before=Math.max(0,e.index*Math.min(n,r-i)),s.handle=Math.min(100-s.before,e.visible*i),s.after=100-s.before-s.handle;var a=t?"animate":"css";for(var c in s){var u=o.find(".Scrubber-"+c);u[a]({height:s[c]+"%"},"fast"),"animate"===a&&u.css("overflow","visible")}},n.percentPerPost=function(){var t=this.count()||1,e=this.visible||1,n=50/this.$(".Scrubber-scrollbar").outerHeight()*100,r=Math.max(100/t,n/e),i=t===e?0:(100-r*e)/(t-e);return{index:i,visible:r}},n.onresize=function(){this.scrollListener.update();var t=this.$(),e=this.$(".Scrubber-scrollbar");e.css("max-height",$(window).height()-t.offset().top+$(window).scrollTop()-parseInt($("#app").css("padding-bottom"),10)-(t.outerHeight()-e.outerHeight()))},n.onmousedown=function(t){this.mouseStart=t.clientY||t.originalEvent.touches[0].clientY,this.indexStart=this.index,this.dragging=!0,this.props.stream.state.paused=!0,$("body").css("cursor","move")},n.onmousemove=function(t){if(this.dragging){var e=((t.clientY||t.originalEvent.touches[0].clientY)-this.mouseStart)/this.$(".Scrubber-scrollbar").outerHeight()*100/this.percentPerPost().index||0,n=Math.min(this.indexStart+e,this.count()-1);this.index=Math.max(0,n),this.renderScrollbar()}},n.onmouseup=function(){var t;if(this.dragging){this.mouseStart=0,this.indexStart=0,this.dragging=!1,$("body").css("cursor",""),this.$().removeClass("open");var e=Math.floor(this.index);null===(t=this.props.stream.state)||void 0===t||t.goToIndex(e),this.renderScrollbar(!0)}},n.onclick=function(t){var e,n=this.$(".Scrubber-scrollbar"),r=((t.clientY||t.originalEvent.touches[0].clientY)-n.offset().top+$("body").scrollTop())/n.outerHeight()*100,i=(r-=parseFloat(n.find(".Scrubber-handle")[0].style.height)/2)/this.percentPerPost().index;i=Math.max(0,Math.min(this.count()-1,i)),null===(e=this.props.stream.state)||void 0===e||e.goToIndex(Math.floor(i)),this.index=i,this.renderScrollbar(!0),this.$().removeClass("open")},e}(O.a),qt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t),e.initProps=function(e){t.initProps.call(this,e),e.className+=" Dropdown--split",e.menuClassName+=" Dropdown-menu--right"};var n=e.prototype;return n.getButton=function(){var t=this.getFirstChild(),e=Object(o.a)({},t.attrs);return e.className=classNames(e.className,"SplitDropdown-button","Button",this.props.buttonClassName),[Z.component(e),m("button",{className:"Dropdown-toggle Button Button--icon "+this.props.buttonClassName,"data-toggle":"dropdown"},A(this.props.icon,{className:"Button-icon"}),A("fas fa-caret-down",{className:"Button-caret"}))]},n.getFirstChild=function(){for(var t=this.props.children;t instanceof Array;)t=t[0];return t},e}(mt),Yt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;is)&&e.scrollTop(e.scrollTop()-o+a)}},n.sidebarItems=function(){var t=new S;return t.add("controls",qt.component({children:It.controls(this.discussion,this).toArray(),icon:"fas fa-ellipsis-v",className:"App-primaryControl",buttonClassName:"Button--primary"})),t.add("scrubber",m(zt,{stream:this.stream,className:"App-titleControl"}),-100),t},n.positionChanged=function(t,e){var n=this.discussion,r=app.route.discussion(n,this.near=t);m.route.set(r,!0),window.history.replaceState(null,document.title,r),app.history.push("discussion",n.title()),app.session.user&&e>(n.lastReadPostNumber()||0)&&(n.save({lastReadPostNumber:e}),m.redraw())},e}(Ot);function Wt(t){var e=t.dom,n=$(e),r=$("#header"),i=n.find("> ul")[0];$(window).off(".affix"),new hcSticky(i,{stickTo:e,top:r.outerHeight(!0)+parseInt(n.css("margin-top"),10)})}function Vt(t){var e=dayjs(t),n=dayjs();e.isAfter(n)&&(e=n);return e.diff(dayjs())<-2592e6?e.year()===dayjs().year()?e.format("D MMM"):e.format("MMM 'YY"):e.fromNow()}var Kt={controls:function(t,e){var n=this,r=new S;return["user","moderation","destructive"].forEach((function(i){var o=n[i+"Controls"](t,e).toArray();o.length&&(o.forEach((function(t){return r.add(t.itemName,t)})),r.add(i+"Separator",G.component()))})),r},userControls:function(){return new S},moderationControls:function(t){var e=new S;return t.canEdit()&&e.add("edit",Z.component({icon:"fas fa-pencil-alt",children:app.translator.trans("core.forum.user_controls.edit_button"),onclick:this.editAction.bind(this,t)})),e},destructiveControls:function(t){var e=new S;return"1"!==t.id()&&t.canDelete()&&e.add("delete",Z.component({icon:"fas fa-times",children:app.translator.trans("core.forum.user_controls.delete_button"),onclick:this.deleteAction.bind(this,t)})),e},deleteAction:function(t){var e=this;confirm(app.translator.transText("core.forum.user_controls.delete_confirmation"))&&t.delete().then((function(){e.showDeletionAlert(t,"success"),app.current instanceof Jt&&app.current.user===t?app.history.back():window.location.reload()})).catch((function(){return e.showDeletionAlert(t,"error")}))},showDeletionAlert:function(t,e){var n=t.data.attributes,r=n.username,i=n.email,o="core.forum.user_controls.delete_"+e+"_message";app.alerts.show(it.component({type:e,children:app.translator.trans(o,{username:r,email:i})}))},editAction:function(t){app.modal.show(new EditUserModal({user:t}))}},Zt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i').appendTo("body").hide().click().on("change",(function(e){t.upload($(e.target)[0].files[0])}))}},n.upload=function(t){if(!this.loading){var e=this.props.user,n=new FormData;data.append("avatar",t),this.loading=!0,m.redraw(),app.request({method:"POST",url:app.forum.attribute("apiUrl")+"/users/"+e.id()+"/avatar",serialize:function(t){return t},body:n}).then(this.success.bind(this),this.failure.bind(this))}},n.remove=function(){var t=this.props.user;this.loading=!0,m.redraw(),app.request({method:"DELETE",url:app.forum.attribute("apiUrl")+"/users/"+t.id()+"/avatar"}).then(this.success.bind(this),this.failure.bind(this))},n.success=function(t){app.store.pushPayload(t),delete this.props.user.avatarColor,this.loading=!1,m.redraw()},n.failure=function(t){this.loading=!1,m.redraw()},e}(O.a),Gt=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);var n=e.prototype;return n.view=function(){var t=this.props.user,e=Kt.controls(t,this).toArray(),n=t.color(),r=t.badges().toArray();return m("div",{className:"UserCard "+(this.props.className||""),style:n?{backgroundColor:n}:""},m("div",{className:"darkenBackground"},m("div",{className:"container"},e.length?mt.component({children:e,className:"UserCard-controls App-primaryControl",menuClassName:"Dropdown-menu--right",buttonClassName:this.props.controlsButtonClassName,label:app.translator.trans("core.forum.user_controls.button"),icon:"fas fa-ellipsis-v"}):"",m("div",{className:"UserCard-profile"},m("h2",{className:"UserCard-identity"},this.props.editable?[Zt.component({user:t,className:"UserCard-avatar"}),v(t)]:m(m.route.Link,{href:app.route.user(t)},m("div",{className:"UserCard-avatar"},ht(t)),v(t))),r.length?m("ul",{className:"UserCard-badges badges"},X(r)):"",m("ul",{className:"UserCard-info"},X(this.infoItems().toArray()))))))},n.infoItems=function(){var t=new S,e=this.props.user,n=e.lastSeenAt();if(n){var r=e.isOnline();t.add("lastSeen",m("span",{className:"UserCard-lastSeen"+(r?" online":"")},r?[A("fas fa-circle")," ",app.translator.trans("core.forum.user.online_text")]:[A("far fa-clock")," ",Vt(n)]))}return t.add("joined",app.translator.trans("core.forum.user.joined_date_text",{ago:Vt(e.joinTime())})),t},e}(O.a),Jt=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=this.loadLimit,m.redraw(),t},e}(Jt);function ie(t){var e=dayjs(t),n=e.format(),r=e.format("LLLL"),i=Vt(t);return m("time",{pubdate:!0,datetime:n,title:r,"data-humantime":!0},i)}var oe=function(t){function e(){return t.apply(this,arguments)||this}return i(e,t),e.prototype.view=function(){var t=this.props.discussion,e=this.props.lastPost&&t.replyCount(),n=t[e?"lastPostedUser":"user"](),r=t[e?"lastPostedAt":"createdAt"]();return m("span",null,e?A("fas fa-reply"):""," ",app.translator.trans("core.forum.discussion_list."+(e?"replied":"started")+"_text",{user:n,ago:ie(r)}))},e}(O.a),se=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i=1e6?Math.floor(t/1e6)+app.translator.transText("core.lib.number_suffix.mega_text"):t>=1e3?Math.floor(t/1e3)+app.translator.transText("core.lib.number_suffix.kilo_text"):t.toString())))},n.oncreate=function(e){if(t.prototype.oncreate.call(this,e),"ontouchstart"in window){var n=slidable(this.$().addClass("Slidable"));this.$(".DiscussionListItem-controls").on("hidden.bs.dropdown",(function(){return n.reset()}))}},n.onbeforeupdate=function(e){return t.prototype.onbeforeupdate.call(this,e),this.subtree.update()},n.active=function(){var t=m.route.param("id");return t&&t.split("-")[0]===this.props.discussion.id()},n.showFirstPost=function(){return-1!==["newest","oldest"].indexOf(this.props.params.sort)},n.showRepliesCount=function(){return"replies"===this.props.params.sort},n.markAsRead=function(){var t=this.props.discussion;t.isUnread()&&(t.save({lastReadPostNumber:t.lastPostNumber()}),m.redraw())},n.infoItems=function(){var t=new S;if(this.props.params.q){var e=this.props.discussion.mostRelevantPost()||this.props.discussion.firstPost();if(e&&"comment"===e.contentType()){var n=Nt(e.contentPlain(),this.highlightRegExp,175);t.add("excerpt",n,-100)}}else t.add("terminalPost",oe.component({discussion:this.props.discussion,lastPost:!this.showFirstPost()}));return t},e}(O.a),ae=function(t){function e(){for(var e,n=arguments.length,r=new Array(n),i=0;i {\n element: HTMLElement;\n\n props: T;\n\n constructor(props: T = {}) {\n this.props = props.tag ? {} : props;\n }\n\n view(vnode) {\n throw new Error('Component#view must be implemented by subclass');\n }\n\n oninit(vnode) {\n this.setProps(vnode.attrs);\n }\n\n oncreate(vnode) {\n this.setProps(vnode.attrs);\n this.element = vnode.dom;\n }\n\n onbeforeupdate(vnode) {\n this.setProps(vnode.attrs);\n }\n\n onupdate(vnode) {\n this.setProps(vnode.attrs);\n }\n\n onbeforeremove(vnode) {\n this.setProps(vnode.attrs);\n }\n\n onremove(vnode) {\n this.setProps(vnode.attrs);\n }\n\n /**\n * Returns a jQuery object for this component's element. If you pass in a\n * selector string, this method will return a jQuery object, using the current\n * element as its buffer.\n *\n * For example, calling `component.$('li')` will return a jQuery object\n * containing all of the `li` elements inside the DOM element of this\n * component.\n *\n * @param selector a jQuery-compatible selector string\n * @final\n */\n $(selector?: string): ZeptoCollection {\n const $element = $(this.element);\n\n return selector ? $element.find(selector) : $element;\n }\n\n render() {\n return m.fragment(\n {\n ...this.props,\n oninit: (...args) => this.oninit(...args),\n oncreate: (...args) => this.oncreate(...args),\n onbeforeupdate: (...args) => this.onbeforeupdate(...args),\n onupdate: (...args) => this.onupdate.bind(...args),\n onbeforeremove: (...args) => this.onbeforeremove.bind(...args),\n onremove: (...args) => this.onremove.bind(...args),\n },\n this.view()\n );\n }\n\n static component(props: ComponentProps | any = {}, children?: Mithril.Children) {\n const componentProps: ComponentProps = Object.assign({}, props);\n\n if (children) componentProps.children = children;\n\n return m(this, componentProps);\n }\n\n static initProps(props: ComponentProps = {}) {}\n\n private setProps(props: T) {\n (this.constructor as typeof Component).initProps(props);\n\n this.props = props;\n }\n}\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","\"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","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\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.
\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';\nimport Tooltip from 'tooltip.js';\n\n// add $.fn.tooltip\n$.fn.tooltip = function(option) {\n return this.each(function() {\n const $this = $(this);\n let data = $this.data('bs.tooltip');\n const options = (typeof option === 'object' && option) || {};\n\n if ($this.attr('title')) {\n options.title = $this.attr('title');\n $this.removeAttr('title');\n $this.attr('data-original-title', options.title);\n }\n\n if (option === 'destroy') option = 'dispose';\n\n if (!data && ['dispose', 'hide'].includes(option)) return;\n\n if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)));\n if (typeof option === 'string' && data[option]) data[option]();\n });\n};\n\n// add $.fn.outerWidth and $.fn.outerHeight\n['width', 'height'].forEach(function(dimension) {\n const Dimension = dimension.replace(/./, function(m) {\n return m[0].toUpperCase();\n });\n\n $.fn[`outer${Dimension}`] = function(margin) {\n const elem = this;\n\n if (elem) {\n const sides = { width: ['left', 'right'], height: ['top', 'bottom'] };\n let size = elem[dimension]();\n\n sides[dimension].forEach(function(side) {\n if (margin) size += parseInt(elem.css('margin-' + side), 10);\n });\n\n return size;\n } else {\n return null;\n }\n };\n});\n\n// allow use of $(':input')\n// @ts-ignore\n$.expr[':']['input'] = function() {\n if ('disabled' in this || ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON'].includes(this.tagName)) return this;\n};\n\n// add $().hover() method\n$.fn.hover = function(hover, leave) {\n return this.on('mouseenter', hover).on('mouseleave', leave || hover);\n};\n\n// add animated scroll\n$.fn.animatedScrollTop = function(to, duration = $.fx.speeds._default, callback) {\n if (typeof to === 'number') to -= window.scrollY || window.pageYOffset;\n\n jump(to, {\n duration: $.fx.speeds[duration] || duration,\n callback,\n });\n\n return this;\n};\n\n// required for compatibility with jquery plugins\n// ex: bootstrap plugins\n$.fn.extend = $.extend.bind($);\n\n/**\n * Enable special events on Zepto\n * @license Original Copyright 2013 Enideo. Released under dual MIT and GPL licenses.\n */\n// @ts-ignore\n$.event.special = $.event.special || {};\n\nconst bindBeforeSpecialEvents = $.fn.bind;\n\n$.fn.bind = function(eventName, data, callback) {\n const el = this;\n\n if (!callback) {\n callback = data;\n data = null;\n }\n\n $.each(eventName.split(/\\s/), (key: string, value: any): boolean => {\n value = value.split(/\\./)[0];\n\n if (value in $.event.special) {\n let specialEvent = $.event.special[value];\n\n /// init enable special events on Zepto\n if (!specialEvent._init) {\n specialEvent._init = true;\n\n /// intercept and replace the special event handler to add functionality\n specialEvent.originalHandler = specialEvent.handler;\n specialEvent.handler = function() {\n /// make event argument writable, like on jQuery\n const args = Array.prototype.slice.call(arguments);\n\n args[0] = $.extend({}, args[0]);\n\n /// define the event handle, $.event.dispatch is only for newer versions of jQuery\n $.event.handle = function() {\n /// make context of trigger the event element\n const args = Array.prototype.slice.call(arguments);\n const event = args[0];\n const $target = $(event.target);\n\n $target.trigger.apply($target, arguments);\n };\n\n specialEvent.originalHandler.apply(this, args);\n };\n }\n\n /// setup special events on Zepto\n specialEvent.setup.apply(el, [data]);\n }\n\n return true;\n });\n\n return bindBeforeSpecialEvents.apply(this, [eventName, callback]);\n};\n","import m from 'mithril';\nimport prop from 'mithril/stream';\n\nimport Component from '../Component';\n\nexport default () => {\n const mo = window['m'];\n\n const _m = function(comp, ...args) {\n if (!arguments[1]) arguments[1] = {};\n\n if (comp.prototype && comp.prototype instanceof Component) {\n let children = args.slice(1);\n if (children.length === 1 && Array.isArray(children[0])) {\n children = children[0];\n }\n\n if (children) {\n Object.defineProperty(arguments[1], 'children', {\n writable: true,\n });\n\n arguments[1].children = (arguments[1].children || []).concat(children);\n }\n }\n\n const node = mo.apply(this, arguments);\n\n if (!node.attrs) node.attrs = {};\n\n if (node.attrs.bidi) {\n m.bidi(node, node.attrs.bidi);\n }\n\n if (node.attrs.route) {\n node.attrs.href = node.attrs.route;\n node.attrs.tag = m.route.Link;\n\n delete node.attrs.route;\n }\n\n return node;\n };\n\n Object.keys(mo).forEach(key => (_m[key] = mo[key]));\n\n _m.withAttr = (key: string, cb: Function) =>\n function() {\n cb(this.getAttribute(key) || this[key]);\n };\n\n _m.prop = prop;\n\n window['m'] = _m;\n};\n","import 'expose-loader?jQuery!zepto';\nimport 'expose-loader?moment!expose-loader?dayjs!dayjs';\nimport 'expose-loader?m!mithril';\nimport 'expose-loader?m.bidi!m.attrs.bidi';\nimport 'expose-loader?Mousetrap!mousetrap';\nimport 'expose-loader?classNames!classNames';\n\nimport 'zepto/src/selector';\nimport 'zepto/src/data';\nimport 'zepto/src/fx';\nimport 'zepto/src/fx_methods';\n\nimport './utils/patchZepto';\n\nimport 'hc-sticky';\nimport 'bootstrap/js/dropdown';\nimport 'bootstrap/js/transition';\n\nimport relativeTime from 'dayjs/plugin/relativeTime';\nimport localizedFormat from 'dayjs/plugin/localizedFormat';\n\ndayjs.extend(relativeTime);\ndayjs.extend(localizedFormat);\n\nimport patchMithril from './utils/patchMithril';\n\npatchMithril();\n\n// import * as Extend from './extend/index';\n\n// export { Extend };\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.
\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 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.
\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.
\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.
\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.
\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.
\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.
\n * It will read the variation of the `placement` property.
\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.
\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.
\n * The latter is a deprecated method because it leads to confusion and will be\n * removed in v2.
\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.
\n * We can say it has \"escaped the boundaries\" — or just \"escaped\".
\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.
\n * These can be overridden using the `options` argument of Popper.js.
\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.
\n * By default, it is set to no-op.
\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.
\n * By default, it is set to no-op.
\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;l0,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","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\nmodule.exports = assocIndexOf;\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\nmodule.exports = getMapData;\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>\")\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>/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 $('
').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,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||(l=r),r},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) 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 = \"ij\"\n\t\t// console.log(div.innerHTML)\n\t\t// --> \"ij\", no 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 = \"\" + vnode.children + \"\"\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>>0;if(\"function\"!=typeof t)throw new TypeError(t+\" is not a function\");for(1 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","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var baseIsNative = require('./_baseIsNative'),\n getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\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\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","var isFunction = require('./isFunction'),\n isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","var baseGetTag = require('./_baseGetTag'),\n isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","var isArray = require('./isArray'),\n isKey = require('./_isKey'),\n stringToPath = require('./_stringToPath'),\n toString = require('./toString');\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nmodule.exports = castPath;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","var isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = toKey;\n","var arrayEach = require('./_arrayEach'),\n baseEach = require('./_baseEach'),\n castFunction = require('./_castFunction'),\n isArray = require('./isArray');\n\n/**\n * Iterates over elements of `collection` and invokes `iteratee` for each element.\n * The iteratee is invoked with three arguments: (value, index|key, collection).\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n * property are iterated like arrays. To avoid this behavior use `_.forIn`\n * or `_.forOwn` for object iteration.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @alias each\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n * @see _.forEachRight\n * @example\n *\n * _.forEach([1, 2], function(value) {\n * console.log(value);\n * });\n * // => Logs `1` then `2`.\n *\n * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n */\nfunction forEach(collection, iteratee) {\n var func = isArray(collection) ? arrayEach : baseEach;\n return func(collection, castFunction(iteratee));\n}\n\nmodule.exports = forEach;\n","var baseGet = require('./_baseGet');\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n}\n\nmodule.exports = get;\n","var baseSet = require('./_baseSet');\n\n/**\n * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n * it's created. Arrays are created for missing index properties while objects\n * are created for all other missing properties. Use `_.setWith` to customize\n * `path` creation.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.set(object, 'a[0].b.c', 4);\n * console.log(object.a[0].b.c);\n * // => 4\n *\n * _.set(object, ['x', '0', 'y', 'z'], 5);\n * console.log(object.x[0].y.z);\n * // => 5\n */\nfunction set(object, path, value) {\n return object == null ? object : baseSet(object, path, value);\n}\n\nmodule.exports = set;\n","/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n}\n\nmodule.exports = arrayEach;\n","var baseForOwn = require('./_baseForOwn'),\n createBaseEach = require('./_createBaseEach');\n\n/**\n * The base implementation of `_.forEach` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n */\nvar baseEach = createBaseEach(baseForOwn);\n\nmodule.exports = baseEach;\n","var baseFor = require('./_baseFor'),\n keys = require('./keys');\n\n/**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n return object && baseFor(object, iteratee, keys);\n}\n\nmodule.exports = baseForOwn;\n","var createBaseFor = require('./_createBaseFor');\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n}\n\nmodule.exports = createBaseFor;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n baseKeys = require('./_baseKeys'),\n isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n","var baseTimes = require('./_baseTimes'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isBuffer = require('./isBuffer'),\n isIndex = require('./_isIndex'),\n isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\nmodule.exports = baseTimes;\n","var baseIsArguments = require('./_baseIsArguments'),\n isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var root = require('./_root'),\n stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = stubFalse;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n baseUnary = require('./_baseUnary'),\n nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var baseGetTag = require('./_baseGetTag'),\n isLength = require('./isLength'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\nmodule.exports = baseUnary;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","var isPrototype = require('./_isPrototype'),\n nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = baseKeys;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\nmodule.exports = isPrototype;\n","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\nmodule.exports = overArg;\n","var isArrayLike = require('./isArrayLike');\n\n/**\n * Creates a `baseEach` or `baseEachRight` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseEach(eachFunc, fromRight) {\n return function(collection, iteratee) {\n if (collection == null) {\n return collection;\n }\n if (!isArrayLike(collection)) {\n return eachFunc(collection, iteratee);\n }\n var length = collection.length,\n index = fromRight ? length : -1,\n iterable = Object(collection);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (iteratee(iterable[index], index, iterable) === false) {\n break;\n }\n }\n return collection;\n };\n}\n\nmodule.exports = createBaseEach;\n","var identity = require('./identity');\n\n/**\n * Casts `value` to `identity` if it's not a function.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {Function} Returns cast function.\n */\nfunction castFunction(value) {\n return typeof value == 'function' ? value : identity;\n}\n\nmodule.exports = castFunction;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nmodule.exports = identity;\n","var castPath = require('./_castPath'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n","var isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n}\n\nmodule.exports = isKey;\n","var memoizeCapped = require('./_memoizeCapped');\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n});\n\nmodule.exports = stringToPath;\n","var memoize = require('./memoize');\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n}\n\nmodule.exports = memoizeCapped;\n","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n","var mapCacheClear = require('./_mapCacheClear'),\n mapCacheDelete = require('./_mapCacheDelete'),\n mapCacheGet = require('./_mapCacheGet'),\n mapCacheHas = require('./_mapCacheHas'),\n mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var Hash = require('./_Hash'),\n ListCache = require('./_ListCache'),\n Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\nmodule.exports = mapCacheClear;\n","var hashClear = require('./_hashClear'),\n hashDelete = require('./_hashDelete'),\n hashGet = require('./_hashGet'),\n hashHas = require('./_hashHas'),\n hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\nmodule.exports = hashClear;\n","var isFunction = require('./isFunction'),\n isMasked = require('./_isMasked'),\n isObject = require('./isObject'),\n toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\nmodule.exports = toSource;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = hashDelete;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\nmodule.exports = hashSet;\n","var listCacheClear = require('./_listCacheClear'),\n listCacheDelete = require('./_listCacheDelete'),\n listCacheGet = require('./_listCacheGet'),\n listCacheHas = require('./_listCacheHas'),\n listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\nmodule.exports = listCacheDelete;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\nmodule.exports = listCacheSet;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = mapCacheDelete;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\nmodule.exports = mapCacheSet;\n","var baseToString = require('./_baseToString');\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\nmodule.exports = toString;\n","var Symbol = require('./_Symbol'),\n arrayMap = require('./_arrayMap'),\n isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = baseToString;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n}\n\nmodule.exports = arrayMap;\n","var assignValue = require('./_assignValue'),\n castPath = require('./_castPath'),\n isIndex = require('./_isIndex'),\n isObject = require('./isObject'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n}\n\nmodule.exports = baseSet;\n","var baseAssignValue = require('./_baseAssignValue'),\n eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nmodule.exports = assignValue;\n","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n}\n\nmodule.exports = baseAssignValue;\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","export default function _inheritsLoose(subClass, superClass) {\n subClass.prototype = Object.create(superClass.prototype);\n subClass.prototype.constructor = subClass;\n subClass.__proto__ = superClass;\n}","import forEach from 'lodash/forEach';\nimport get from 'lodash/get';\nimport set from 'lodash/set';\n\nexport default class Bus {\n subscribers = {};\n\n subscribe(event, callable) {\n set(this.subscribers, event + '[]', callable);\n }\n\n dispatch(event, args: any = null) {\n forEach(get(this.subscribers, event), function(listener) {\n listener(event, args);\n });\n }\n}\n","/**\n * The `extract` utility deletes a property from an object and returns its\n * value.\n */\nexport default function extract(object: object, property: string): any {\n const value = object[property];\n\n delete object[property];\n\n return value;\n}\n","/**\n * Extract the text nodes from a virtual element.\n *\n * @param {VirtualElement} vdom\n * @return {String}\n */\nexport default function extractText(vdom: any): string {\n if (vdom instanceof Array) {\n return vdom.map(element => extractText(element)).join('');\n } else if (typeof vdom === 'object' && vdom !== null) {\n return vdom.text || extractText(vdom.children);\n } else {\n return vdom;\n }\n}\n","/**\n * The `username` helper displays a user's username in a \n * tag. If the user doesn't exist, the username will be displayed as [deleted].\n *\n * @param {User} user\n */\nexport default function username(user): any {\n const name = (user && user.displayName()) || app.translator.trans('core.lib.username.deleted_text');\n\n return {name};\n}\n","import extract from './utils/extract';\nimport extractText from './utils/extractText';\nimport username from './helpers/username';\n\ntype Translations = { [key: string]: string };\n\nexport default class Translator {\n /**\n * A map of translation keys to their translated values.\n */\n translations: Translations = {};\n locale?: string;\n\n addTranslations(translations) {\n Object.assign(this.translations, translations);\n }\n\n trans(id: string, parameters = null) {\n const translation = this.translations[id];\n\n if (translation) {\n return this.apply(translation, parameters || {});\n }\n\n return id;\n }\n\n transText(id: string, parameters = null) {\n return extractText(this.trans(id, parameters));\n }\n\n transChoice(id: string, number: string | number, parameters: any) {\n let translation = this.translations[id];\n\n if (translation) {\n number = parseInt(number, 10);\n\n translation = this.pluralize(translation, number);\n\n return this.apply(translation, parameters || {});\n }\n\n return id;\n }\n\n apply(translation: string, input: any) {\n if ('user' in input) {\n const user = extract(input, 'user');\n if (!input.username) input.username = username(user);\n }\n\n const parts = translation.split(new RegExp('({[a-z0-9_]+}|)', 'gi'));\n\n const hydrated: any[] = [];\n const open: any[][] = [hydrated];\n\n parts.forEach(part => {\n const match = part.match(new RegExp('{([a-z0-9_]+)}|<(/?)([a-z0-9_]+)>', 'i'));\n\n if (match) {\n if (match[1]) {\n open[0].push(input[match[1]]);\n } else if (match[3]) {\n if (match[2]) {\n open.shift();\n } else {\n let tag = input[match[3]] || { tag: match[3], children: [] };\n open[0].push(tag);\n open.unshift(tag.children || tag);\n }\n }\n } else {\n open[0].push({ tag: 'span', text: part });\n }\n });\n\n return hydrated.filter(part => part);\n }\n\n pluralize(translation: string, number: number) {\n const sPluralRegex = new RegExp(/^\\w+\\: +(.+)$/),\n cPluralRegex = new RegExp(\n /^\\s*((\\{\\s*(\\-?\\d+[\\s*,\\s*\\-?\\d+]*)\\s*\\})|([\\[\\]])\\s*(-Inf|\\-?\\d+)\\s*,\\s*(\\+?Inf|\\-?\\d+)\\s*([\\[\\]]))\\s?(.+?)$/\n ),\n iPluralRegex = new RegExp(/^\\s*(\\{\\s*(\\-?\\d+[\\s*,\\s*\\-?\\d+]*)\\s*\\})|([\\[\\]])\\s*(-Inf|\\-?\\d+)\\s*,\\s*(\\+?Inf|\\-?\\d+)\\s*([\\[\\]])/),\n standardRules = [],\n explicitRules = [];\n\n translation.split('|').forEach(part => {\n if (cPluralRegex.test(part)) {\n const matches = part.match(cPluralRegex);\n explicitRules[matches[0]] = matches[matches.length - 1];\n } else if (sPluralRegex.test(part)) {\n const matches = part.match(sPluralRegex);\n standardRules.push(matches[1]);\n } else {\n standardRules.push(part);\n }\n });\n\n explicitRules.forEach((rule, e) => {\n if (iPluralRegex.test(e)) {\n const matches = e.match(iPluralRegex);\n\n if (matches[1]) {\n const ns = matches[2].split(',');\n\n for (let n in ns) {\n if (number == ns[n]) {\n return explicitRules[e];\n }\n }\n } else {\n const leftNumber = this.convertNumber(matches[4]);\n const rightNumber = this.convertNumber(matches[5]);\n\n if (\n ('[' === matches[3] ? number >= leftNumber : number > leftNumber) &&\n (']' === matches[6] ? number <= rightNumber : number < rightNumber)\n ) {\n return explicitRules[e];\n }\n }\n }\n });\n\n return standardRules[this.pluralPosition(number, this.locale)] || standardRules[0] || undefined;\n }\n\n convertNumber(number: string): number {\n if ('-Inf' === number) {\n return Number.NEGATIVE_INFINITY;\n } else if ('+Inf' === number || 'Inf' === number) {\n return Number.POSITIVE_INFINITY;\n }\n\n return parseInt(number, 10);\n }\n\n pluralPosition(number: number, locale: string) {\n if ('pt_BR' === locale) {\n locale = 'xbr';\n }\n\n if (locale.length > 3) {\n locale = locale.split('_')[0];\n }\n\n switch (locale) {\n case 'bo':\n case 'dz':\n case 'id':\n case 'ja':\n case 'jv':\n case 'ka':\n case 'km':\n case 'kn':\n case 'ko':\n case 'ms':\n case 'th':\n case 'vi':\n case 'zh':\n return 0;\n\n case 'af':\n case 'az':\n case 'bn':\n case 'bg':\n case 'ca':\n case 'da':\n case 'de':\n case 'el':\n case 'en':\n case 'eo':\n case 'es':\n case 'et':\n case 'eu':\n case 'fa':\n case 'fi':\n case 'fo':\n case 'fur':\n case 'fy':\n case 'gl':\n case 'gu':\n case 'ha':\n case 'he':\n case 'hu':\n case 'is':\n case 'it':\n case 'ku':\n case 'lb':\n case 'ml':\n case 'mn':\n case 'mr':\n case 'nah':\n case 'nb':\n case 'ne':\n case 'nl':\n case 'nn':\n case 'no':\n case 'om':\n case 'or':\n case 'pa':\n case 'pap':\n case 'ps':\n case 'pt':\n case 'so':\n case 'sq':\n case 'sv':\n case 'sw':\n case 'ta':\n case 'te':\n case 'tk':\n case 'tr':\n case 'ur':\n case 'zu':\n return number == 1 ? 0 : 1;\n\n case 'am':\n case 'bh':\n case 'fil':\n case 'fr':\n case 'gun':\n case 'hi':\n case 'ln':\n case 'mg':\n case 'nso':\n case 'xbr':\n case 'ti':\n case 'wa':\n return number === 0 || number == 1 ? 0 : 1;\n\n case 'be':\n case 'bs':\n case 'hr':\n case 'ru':\n case 'sr':\n case 'uk':\n return number % 10 == 1 && number % 100 != 11\n ? 0\n : number % 10 >= 2 && number % 10 <= 4 && (number % 100 < 10 || number % 100 >= 20)\n ? 1\n : 2;\n\n case 'cs':\n case 'sk':\n return number == 1 ? 0 : number >= 2 && number <= 4 ? 1 : 2;\n\n case 'ga':\n return number == 1 ? 0 : number == 2 ? 1 : 2;\n\n case 'lt':\n return number % 10 == 1 && number % 100 != 11 ? 0 : number % 10 >= 2 && (number % 100 < 10 || number % 100 >= 20) ? 1 : 2;\n\n case 'sl':\n return number % 100 == 1 ? 0 : number % 100 == 2 ? 1 : number % 100 == 3 || number % 100 == 4 ? 2 : 3;\n\n case 'mk':\n return number % 10 == 1 ? 0 : 1;\n\n case 'mt':\n return number == 1 ? 0 : number === 0 || (number % 100 > 1 && number % 100 < 11) ? 1 : number % 100 > 10 && number % 100 < 20 ? 2 : 3;\n\n case 'lv':\n return number === 0 ? 0 : number % 10 == 1 && number % 100 != 11 ? 1 : 2;\n\n case 'pl':\n return number == 1 ? 0 : number % 10 >= 2 && number % 10 <= 4 && (number % 100 < 12 || number % 100 > 14) ? 1 : 2;\n\n case 'cy':\n return number == 1 ? 0 : number == 2 ? 1 : number == 8 || number == 11 ? 2 : 3;\n\n case 'ro':\n return number == 1 ? 0 : number === 0 || (number % 100 > 0 && number % 100 < 20) ? 1 : 2;\n\n case 'ar':\n return number === 0 ? 0 : number == 1 ? 1 : number == 2 ? 2 : number >= 3 && number <= 10 ? 3 : number >= 11 && number <= 99 ? 4 : 5;\n\n default:\n return 0;\n }\n }\n}\n","import User from './models/User';\n\n/**\n * The `Session` class defines the current user session. It stores a reference\n * to the current authenticated user, and provides methods to log in/out.\n */\nexport default class Session {\n /**\n * The current authenticated user.\n */\n user?: User;\n\n /**\n * The CSRF token.\n */\n csrfToken?: string;\n\n constructor(user, csrfToken) {\n this.user = user;\n\n this.csrfToken = csrfToken;\n }\n\n /**\n * Attempt to log in a user.\n */\n login(body: { identification: string; password: string; remember?: string }, options = {}) {\n return app.request(\n Object.assign(\n {\n method: 'POST',\n url: `${app.forum.attribute('baseUrl')}/login`,\n body,\n },\n options\n )\n );\n }\n\n /**\n * Log the user out.\n *\n * @public\n */\n logout() {\n window.location.href = `${app.forum.attribute('baseUrl')}/logout?token=${this.csrfToken}`;\n }\n}\n","import Model from './Model';\n\n/**\n * The `Store` class defines a local data store, and provides methods to\n * retrieve data from the API.\n */\nexport default class Store {\n /**\n * The local data store. A tree of resource types to IDs, such that\n * accessing data[type][id] will return the model for that type/ID.\n */\n data: { [key: string]: { [key: number]: Model } } = {};\n\n /**\n * The model registry. A map of resource types to the model class that\n * should be used to represent resources of that type.\n */\n models: {};\n\n constructor(models) {\n this.models = models;\n }\n\n /**\n * Push resources contained within an API payload into the store.\n *\n * @param payload\n * @return The model(s) representing the resource(s) contained\n * within the 'data' key of the payload.\n */\n pushPayload(payload: { included?: {}[]; data?: {} | {}[] }): Model | Model[] {\n if (payload.included) payload.included.map(this.pushObject.bind(this));\n\n const result: any = payload.data instanceof Array ? payload.data.map(this.pushObject.bind(this)) : this.pushObject(payload.data);\n\n // Attach the original payload to the model that we give back. This is\n // useful to consumers as it allows them to access meta information\n // associated with their request.\n result.payload = payload;\n\n return result;\n }\n\n /**\n * Create a model to represent a resource object (or update an existing one),\n * and push it into the store.\n *\n * @param {Object} data The resource object\n * @return The model, or null if no model class has been\n * registered for this resource type.\n */\n pushObject(data): Model {\n if (!this.models[data.type]) return null;\n\n const type = (this.data[data.type] = this.data[data.type] || {});\n\n if (type[data.id]) {\n type[data.id].pushData(data);\n } else {\n type[data.id] = this.createRecord(data.type, data);\n }\n\n type[data.id].exists = true;\n\n return type[data.id];\n }\n\n /**\n * Make a request to the API to find record(s) of a specific type.\n *\n * @param type The resource type.\n * @param [id] The ID(s) of the model(s) to retrieve.\n * Alternatively, if an object is passed, it will be handled as the\n * `query` parameter.\n * @param query\n * @param options\n */\n find(type: string, id?: number | number[] | any, query = {}, options = {}): Promise {\n let params = query;\n let url = `${app.forum.attribute('apiUrl')}/${type}`;\n\n if (id instanceof Array) {\n url += `?filter[id]=${id.join(',')}`;\n } else if (typeof id === 'object') {\n params = id;\n } else if (id) {\n url += `/${id}`;\n }\n\n return app\n .request(\n Object.assign(\n {\n method: 'GET',\n url,\n params,\n },\n options\n )\n )\n .then(this.pushPayload.bind(this));\n }\n\n /**\n * Get a record from the store by ID.\n *\n * @param type The resource type.\n * @param id The resource ID.\n */\n getById(type: string, id: number | string): T {\n return this.data[type] && (this.data[type][id] as T);\n }\n\n /**\n * Get a record from the store by the value of a model attribute.\n *\n * @param type The resource type.\n * @param key The name of the method on the model.\n * @param value The value of the model attribute.\n */\n getBy(type: string, key: string, value: any): T {\n return this.all(type).filter(model => model[key]() === value)[0];\n }\n\n /**\n * Get all loaded records of a specific type.\n */\n all(type: string): T[] {\n const records = this.data[type];\n\n return records ? Object.keys(records).map(id => records[id]) : [];\n }\n\n /**\n * Remove the given model from the store.\n */\n remove(model: Model) {\n delete this.data[model.data.type][model.id()];\n }\n\n /**\n * Create a new record of the given type.\n *\n * @param {String} type The resource type\n * @param {Object} [data] Any data to initialize the model with\n */\n createRecord(type: string, data: any = {}): T {\n data.type = data.type || type;\n\n return new this.models[type](data, this);\n }\n}\n","/**\n * Extend an object's method by running its output through a mutating callback\n * every time it is called.\n *\n * The callback accepts the method's return value and should perform any\n * mutations directly on this value. For this reason, this function will not be\n * effective on methods which return scalar values (numbers, strings, booleans).\n *\n * Care should be taken to extend the correct object – in most cases, a class'\n * prototype will be the desired target of extension, not the class itself.\n *\n * @example\n * extend(Discussion.prototype, 'badges', function(badges) {\n * // do something with `badges`\n * });\n *\n * @param {Object} object The object that owns the method\n * @param {String} method The name of the method to extend\n * @param {function} callback A callback which mutates the method's output\n */\nexport function extend(object, method, callback) {\n const original = object[method];\n\n object[method] = (...args) => {\n // @ts-ignore\n const value = original ? original.apply(object, args) : undefined;\n\n // @ts-ignore\n callback.apply(object, [value].concat(args));\n\n return value;\n };\n\n Object.assign(object[method], original);\n}\n\n/**\n * Override an object's method by replacing it with a new function, so that the\n * new function will be run every time the object's method is called.\n *\n * The replacement function accepts the original method as its first argument,\n * which is like a call to 'super'. Any arguments passed to the original method\n * are also passed to the replacement.\n *\n * Care should be taken to extend the correct object – in most cases, a class'\n * prototype will be the desired target of extension, not the class itself.\n *\n * @example\n * override(Discussion.prototype, 'badges', function(original) {\n * const badges = original();\n * // do something with badges\n * return badges;\n * });\n *\n * @param {Object} object The object that owns the method\n * @param {String} method The name of the method to override\n * @param {function} newMethod The method to replace it with\n */\nexport function override(object, method, newMethod) {\n const original = object[method];\n\n object[method] = function(...args) {\n // @ts-ignore\n return newMethod.apply(this, [original.bind(this)].concat(args));\n };\n\n Object.assign(object[method], original);\n}\n","/**\n * The `Drawer` class controls the page's drawer. The drawer is the area the\n * slides out from the left on mobile devices; it contains the header and the\n * footer.\n */\nexport default class Drawer {\n private $backdrop?: ZeptoCollection;\n\n constructor() {\n // Set up an event handler so that whenever the content area is tapped,\n // the drawer will close.\n $('#content').click(e => {\n if (this.isOpen()) {\n e.preventDefault();\n this.hide();\n }\n });\n }\n\n /**\n * Check whether or not the drawer is currently open.\n */\n isOpen(): boolean {\n return $('#app').hasClass('drawerOpen');\n }\n\n /**\n * Hide the drawer.\n */\n hide() {\n $('#app').removeClass('drawerOpen');\n\n if (this.$backdrop) this.$backdrop.remove();\n }\n\n /**\n * Show the drawer.\n *\n * @public\n */\n show() {\n $('#app').addClass('drawerOpen');\n\n this.$backdrop = $('
')\n .addClass('drawer-backdrop fade')\n .appendTo('body')\n .click(() => this.hide());\n\n setTimeout(() => this.$backdrop.addClass('in'));\n }\n}\n","import Mithril from 'mithril';\n\nexport interface RequestErrorResponse extends JSON {\n errors?: {\n code: string;\n source?: {\n pointer: string;\n };\n }[];\n}\n\nexport default class RequestError {\n status: number;\n responseText: string;\n options: Mithril.RequestOptions;\n xhr: XMLHttpRequest;\n response?: RequestErrorResponse;\n alert?: Mithril.Vnode;\n\n constructor(status, responseText, options, xhr) {\n this.status = status;\n this.responseText = responseText;\n this.options = options;\n this.xhr = xhr;\n\n try {\n this.response = JSON.parse(responseText);\n } catch (e) {\n this.response = null;\n }\n\n this.alert = null;\n }\n}\n","/**\n * The `Model` class represents a local data resource. It provides methods to\n * persist changes via the API.\n *\n * @abstract\n */\nimport Store from './Store';\n\nexport default class Model {\n /**\n * The resource object from the API.\n */\n data: any;\n\n payload: any;\n\n /**\n * The time at which the model's data was last updated. Watching the value\n * of this property is a fast way to retain/cache a subtree if data hasn't\n * changed.\n */\n freshness: Date;\n\n /**\n * Whether or not the resource exists on the server.\n */\n exists: boolean;\n\n /**\n * The data store that this resource should be persisted to.\n */\n protected store: Store;\n\n /**\n * @param {Object} data A resource object from the API.\n * @param {Store} store The data store that this model should be persisted to.\n */\n constructor(data = {}, store = null) {\n this.data = data;\n this.store = store;\n\n this.freshness = new Date();\n this.exists = false;\n }\n\n /**\n * Get the model's ID.\n * @final\n */\n id(): string {\n return this.data.id;\n }\n\n /**\n * Get one of the model's attributes.\n * @final\n */\n attribute(attribute: string): any {\n return this.data.attributes[attribute];\n }\n\n /**\n * Merge new data into this model locally.\n *\n * @param data A resource object to merge into this model\n * @public\n */\n pushData(data: {}) {\n // Since most of the top-level items in a resource object are objects\n // (e.g. relationships, attributes), we'll need to check and perform the\n // merge at the second level if that's the case.\n for (const key in data) {\n if (typeof data[key] === 'object') {\n this.data[key] = this.data[key] || {};\n\n // For every item in a second-level object, we want to check if we've\n // been handed a Model instance. If so, we will convert it to a\n // relationship data object.\n for (const innerKey in data[key]) {\n if (data[key][innerKey] instanceof Model) {\n data[key][innerKey] = { data: Model.getIdentifier(data[key][innerKey]) };\n }\n this.data[key][innerKey] = data[key][innerKey];\n }\n } else {\n this.data[key] = data[key];\n }\n }\n\n // Now that we've updated the data, we can say that the model is fresh.\n // This is an easy way to invalidate retained subtrees etc.\n this.freshness = new Date();\n }\n\n /**\n * Merge new attributes into this model locally.\n *\n * @param {Object} attributes The attributes to merge.\n */\n pushAttributes(attributes: any) {\n this.pushData({ attributes });\n }\n\n /**\n * Merge new attributes into this model, both locally and with persistence.\n *\n * @param attributes The attributes to save. If a 'relationships' key\n * exists, it will be extracted and relationships will also be saved.\n * @param [options]\n * @return {Promise}\n */\n save(attributes: any, options: any = {}): Promise {\n const data = {\n type: this.data.type,\n id: this.data.id,\n attributes,\n relationships: undefined,\n };\n\n // If a 'relationships' key exists, extract it from the attributes hash and\n // set it on the top-level data object instead. We will be sending this data\n // object to the API for persistence.\n if (attributes.relationships) {\n data.relationships = {};\n\n for (const key in attributes.relationships) {\n const model = attributes.relationships[key];\n\n data.relationships[key] = {\n data: model instanceof Array ? model.map(Model.getIdentifier) : Model.getIdentifier(model),\n };\n }\n\n delete attributes.relationships;\n }\n\n // Before we update the model's data, we should make a copy of the model's\n // old data so that we can revert back to it if something goes awry during\n // persistence.\n const oldData = this.copyData();\n\n this.pushData(data);\n\n const request = { data };\n if (options.meta) request.meta = options.meta;\n\n return app\n .request(\n Object.assign(\n {\n method: this.exists ? 'PATCH' : 'POST',\n url: app.forum.attribute('apiUrl') + this.apiEndpoint(),\n body: request,\n },\n options\n )\n )\n .then(\n // If everything went well, we'll make sure the store knows that this\n // model exists now (if it didn't already), and we'll push the data that\n // the API returned into the store.\n payload => {\n this.store.data[payload.data.type] = this.store.data[payload.data.type] || {};\n this.store.data[payload.data.type][payload.data.id] = this;\n return this.store.pushPayload(payload);\n },\n\n // If something went wrong, though... good thing we backed up our model's\n // old data! We'll revert to that and let others handle the error.\n response => {\n this.pushData(oldData);\n m.redraw();\n throw response;\n }\n );\n }\n\n /**\n * Send a request to delete the resource.\n *\n * @param {Object} body Data to send along with the DELETE request.\n * @param {Object} [options]\n * @return {Promise}\n * @public\n */\n delete(body = {}, options = {}) {\n if (!this.exists) return Promise.resolve();\n\n return app\n .request(\n Object.assign(\n {\n method: 'DELETE',\n url: app.forum.attribute('apiUrl') + this.apiEndpoint(),\n body,\n },\n options\n )\n )\n .then(() => {\n this.exists = false;\n this.store.remove(this);\n });\n }\n\n /**\n * Construct a path to the API endpoint for this resource.\n *\n * @return {String}\n * @protected\n */\n apiEndpoint() {\n return '/' + this.data.type + (this.exists ? '/' + this.data.id : '');\n }\n\n copyData() {\n return JSON.parse(JSON.stringify(this.data));\n }\n\n /**\n * Generate a function which returns the value of the given attribute.\n *\n * @param {String} name\n * @param [transform] A function to transform the attribute value\n */\n static attribute(name: string, transform?: Function): () => any {\n return function() {\n const value = this.data.attributes && this.data.attributes[name];\n\n return transform ? transform(value) : value;\n };\n }\n\n /**\n * Generate a function which returns the value of the given has-one\n * relationship.\n *\n * @return false if no information about the\n * relationship exists; undefined if the relationship exists but the model\n * has not been loaded; or the model if it has been loaded.\n */\n static hasOne(name: string): () => Model | boolean {\n return function() {\n if (this.data.relationships) {\n const relationship = this.data.relationships[name];\n\n if (relationship) {\n return app.store.getById(relationship.data.type, relationship.data.id);\n }\n }\n\n return false;\n };\n }\n\n /**\n * Generate a function which returns the value of the given has-many\n * relationship.\n *\n * @return false if no information about the relationship\n * exists; an array if it does, containing models if they have been\n * loaded, and undefined for those that have not.\n */\n static hasMany(name: string): () => [] | boolean {\n return function() {\n if (this.data.relationships) {\n const relationship = this.data.relationships[name];\n\n if (relationship) {\n return relationship.data.map(data => app.store.getById(data.type, data.id));\n }\n }\n\n return false;\n };\n }\n\n /**\n * Transform the given value into a Date object.\n */\n static transformDate(value: string): Date {\n return value ? new Date(value) : null;\n }\n\n /**\n * Get a resource identifier object for the given model.\n */\n protected static getIdentifier(model: Model): { type: string; id: string } {\n return {\n type: model.data.type,\n id: model.data.id,\n };\n }\n}\n","import Model from '../Model';\n\nexport default class Forum extends Model {\n apiEndpoint() {\n return '/';\n }\n}\n","/**\n * The `computed` utility creates a function that will cache its output until\n * any of the dependent values are dirty.\n *\n * @param dependentKeys The keys of the dependent values.\n * @param compute The function which computes the value using the\n * dependent values.\n */\nexport default function computed(dependentKeys: string | string[], compute: Function): () => any {\n const keys = [].concat(dependentKeys);\n\n const dependentValues = {};\n let computedValue;\n\n return function() {\n let recompute = false;\n\n // Read all of the dependent values. If any of them have changed since last\n // time, then we'll want to recompute our output.\n keys.forEach(key => {\n const value = typeof this[key] === 'function' ? this[key]() : this[key];\n\n if (dependentValues[key] !== value) {\n recompute = true;\n dependentValues[key] = value;\n }\n });\n\n if (recompute) {\n computedValue = compute.apply(\n this,\n keys.map(key => dependentValues[key])\n );\n }\n\n return computedValue;\n };\n}\n","class Item {\n content: T;\n priority: number;\n key: number = 0;\n\n constructor(content: any, priority: number) {\n this.content = content;\n this.priority = priority;\n }\n}\n\nexport default class ItemList {\n private items: { [key: string]: Item } = {};\n\n /**\n * Check whether the list is empty.\n *\n * @returns {boolean}\n * @public\n */\n isEmpty(): boolean {\n for (const i in this.items) {\n if (this.items.hasOwnProperty(i)) {\n return false;\n }\n }\n\n return true;\n }\n\n /**\n * Check whether an item is present in the list.\n */\n has(key: any): boolean {\n return !!this.items[key];\n }\n\n /**\n * Get the content of an item.\n */\n get(key: any): T {\n return this.items[key]?.content;\n }\n\n /**\n * Add an item to the list.\n *\n * @param {String} key A unique key for the item.\n * @param {*} content The item's content.\n * @param {Integer} [priority] The priority of the item. Items with a higher\n * priority will be positioned before items with a lower priority.\n * @return {ItemList}\n * @public\n */\n add(key: any, content: T, priority = 0) {\n this.items[key] = new Item(content, priority);\n\n return this;\n }\n\n toArray(): T[] {\n const items: Item[] = [];\n\n for (const i in this.items) {\n if (this.items.hasOwnProperty(i)) {\n if (this.items[i] !== null && this.items[i] instanceof Item) {\n this.items[i].content = Object(this.items[i].content);\n\n // @ts-ignore\n this.items[i].content.itemName = i;\n items.push(this.items[i]);\n this.items[i].key = items.length;\n }\n }\n }\n\n return items\n .sort((a, b) => {\n if (a.priority === b.priority) {\n return a.key - b.key;\n } else if (a.priority > b.priority) {\n return -1;\n }\n return 1;\n })\n .map(item => item.content);\n }\n}\n","/**\n * The `icon` helper displays an icon.\n *\n * @param {String} fontClass The full icon class, prefix and the icon’s name.\n * @param {Object} attrs Any other attributes to apply.\n */\nexport default function icon(fontClass: string, attrs: any = {}) {\n attrs.className = 'icon ' + fontClass + ' ' + (attrs.className || '');\n\n return ;\n}\n","import Component from '../Component';\nimport icon from '../helpers/icon';\nimport extract from '../utils/extract';\n\n/**\n * The `Badge` component represents a user/discussion badge, indicating some\n * status (e.g. a discussion is stickied, a user is an admin).\n *\n * A badge may have the following special props:\n *\n * - `type` The type of badge this is. This will be used to give the badge a\n * class name of `Badge--{type}`.\n * - `icon` The name of an icon to show inside the badge.\n * - `label`\n *\n * All other props will be assigned as attributes on the badge element.\n */\nexport default class Badge extends Component {\n view(vnode) {\n const attrs = vnode.attrs;\n const type = extract(attrs, 'type');\n const iconName = extract(attrs, 'icon');\n\n attrs.className = `Badge ${type ? `Badge--${type}` : ''} ${attrs.className || ''}`;\n attrs.title = extract(attrs, 'label') || '';\n\n return {iconName ? icon(iconName, { className: 'Badge-icon' }) : m.trust(' ')};\n }\n\n oncreate(vnode) {\n super.oncreate(vnode);\n\n if (this.props.label) this.$().tooltip({ container: 'body' });\n }\n}\n","import Model from '../Model';\nimport computed from '../utils/computed';\nimport ItemList from '../utils/ItemList';\nimport Badge from '../components/Badge';\n\nimport User from './User';\nimport Post from './Post';\n\nexport default class Discussion extends Model {\n title = Model.attribute('title') as () => string;\n slug = Model.attribute('slug') as () => string;\n\n createdAt = Model.attribute('createdAt', Model.transformDate) as () => Date;\n user = Model.hasOne('user') as () => User;\n firstPost = Model.hasOne('firstPost') as () => Post;\n\n lastPostedAt = Model.attribute('lastPostedAt', Model.transformDate) as () => Date;\n lastPostedUser = Model.hasOne('lastPostedUser') as () => User;\n lastPost = Model.hasOne('lastPost') as () => Post;\n lastPostNumber = Model.attribute('lastPostNumber') as () => number;\n\n commentCount = Model.attribute('commentCount') as () => number;\n replyCount = computed('commentCount', commentCount => Math.max(0, commentCount - 1)) as () => number;\n posts = Model.hasMany('posts') as () => Post[];\n mostRelevantPost = Model.hasOne('mostRelevantPost') as () => Post;\n\n lastReadAt = Model.attribute('lastReadAt', Model.transformDate) as () => Date;\n lastReadPostNumber = Model.attribute('lastReadPostNumber') as () => number;\n isUnread = computed('unreadCount', unreadCount => !!unreadCount) as () => boolean;\n isRead = computed('unreadCount', unreadCount => app.session.user && !unreadCount) as () => boolean;\n\n hiddenAt = Model.attribute('hiddenAt', Model.transformDate) as () => Date;\n hiddenUser = Model.hasOne('hiddenUser') as () => User;\n isHidden = computed('hiddenAt', hiddenAt => !!hiddenAt) as () => boolean;\n\n canReply = Model.attribute('canReply') as () => boolean;\n canRename = Model.attribute('canRename') as () => boolean;\n canHide = Model.attribute('canHide') as () => boolean;\n canDelete = Model.attribute('canDelete') as () => boolean;\n\n /**\n * Remove a post from the discussion's posts relationship.\n *\n * @param id The ID of the post to remove.\n */\n removePost(id: number) {\n const relationships = this.data.relationships;\n const posts = relationships && relationships.posts;\n\n if (posts) {\n posts.data.some((data, i) => {\n if (id === data.id) {\n posts.data.splice(i, 1);\n return true;\n }\n });\n }\n }\n\n /**\n * Get the estimated number of unread posts in this discussion for the current\n * user.\n */\n unreadCount(): number {\n const user = app.session.user;\n\n if (user && user.markedAllAsReadAt() < this.lastPostedAt()) {\n return Math.max(0, this.lastPostNumber() - (this.lastReadPostNumber() || 0));\n }\n\n return 0;\n }\n\n /**\n * Get the Badge components that apply to this discussion.\n */\n badges(): ItemList {\n const items = new ItemList();\n\n if (this.isHidden()) {\n items.add('hidden', );\n }\n\n return items;\n }\n\n /**\n * Get a list of all of the post IDs in this discussion.\n */\n postIds(): string[] {\n const posts = this.data.relationships.posts;\n\n return posts ? posts.data.map(link => link.id) : [];\n }\n}\n","export function hsvToRgb(h: number, s: number, v: number) {\n let r;\n let g;\n let b;\n\n const i = Math.floor(h * 6);\n const f = h * 6 - i;\n const p = v * (1 - s);\n const q = v * (1 - f * s);\n const t = v * (1 - (1 - f) * s);\n\n switch (i % 6) {\n case 0:\n r = v;\n g = t;\n b = p;\n break;\n case 1:\n r = q;\n g = v;\n b = p;\n break;\n case 2:\n r = p;\n g = v;\n b = t;\n break;\n case 3:\n r = p;\n g = q;\n b = v;\n break;\n case 4:\n r = t;\n g = p;\n b = v;\n break;\n case 5:\n r = v;\n g = p;\n b = q;\n break;\n }\n\n return {\n r: Math.floor(r * 255),\n g: Math.floor(g * 255),\n b: Math.floor(b * 255),\n };\n}\n\n/**\n * Convert the given string to a unique color.\n */\nexport default function stringToColor(string: string): string {\n let num = 0;\n\n // Convert the username into a number based on the ASCII value of each\n // character.\n for (let i = 0; i < string.length; i++) {\n num += string.charCodeAt(i);\n }\n\n // Construct a color using the remainder of that number divided by 360, and\n // some predefined saturation and value values.\n const hue = num % 360;\n const rgb = hsvToRgb(hue / 360, 0.3, 0.9);\n\n return '' + rgb.r.toString(16) + rgb.g.toString(16) + rgb.b.toString(16);\n}\n","import Badge from './Badge';\n\nexport default class GroupBadge extends Badge {\n static initProps(props) {\n super.initProps(props);\n\n if (props.group) {\n props.icon = props.group.icon();\n props.style = { backgroundColor: props.group.color() };\n props.label = typeof props.label === 'undefined' ? props.group.nameSingular() : props.label;\n props.type = `group--${props.group.id()}`;\n\n delete props.group;\n }\n }\n}\n","import Model from '../Model';\nimport stringToColor from '../utils/stringToColor';\nimport ItemList from '../utils/ItemList';\nimport computed from '../utils/computed';\nimport GroupBadge from '../components/GroupBadge';\nimport Group from './Group';\n\nexport interface UserPreferences {\n discloseOnline?: boolean;\n indexProfile?: boolean;\n locale?: string;\n\n [key: string]: any;\n}\n\nexport default class User extends Model {\n username = Model.attribute('username') as () => string;\n\n displayName = Model.attribute('displayName') as () => string;\n email = Model.attribute('email') as () => string;\n isEmailConfirmed = Model.attribute('isEmailConfirmed') as () => boolean;\n password = Model.attribute('password') as () => string;\n\n avatarUrl = Model.attribute('avatarUrl') as () => string;\n preferences = Model.attribute('preferences') as () => UserPreferences;\n groups = Model.hasMany('groups') as () => Group[];\n\n joinTime = Model.attribute('joinTime', Model.transformDate) as () => Date;\n lastSeenAt = Model.attribute('lastSeenAt', Model.transformDate) as () => Date;\n markedAllAsReadAt = Model.attribute('markedAllAsReadAt', Model.transformDate) as () => Date;\n unreadNotificationCount = Model.attribute('unreadNotificationCount') as () => number;\n newNotificationCount = Model.attribute('newNotificationCount') as () => number;\n\n discussionCount = Model.attribute('discussionCount') as () => number;\n commentCount = Model.attribute('commentCount') as () => number;\n\n canEdit = Model.attribute('canEdit') as () => boolean;\n canDelete = Model.attribute('canDelete') as () => boolean;\n\n avatarColor = null;\n color = computed(['username', 'avatarUrl', 'avatarColor'], function(username, avatarUrl, avatarColor) {\n // If we've already calculated and cached the dominant color of the user's\n // avatar, then we can return that in RGB format. If we haven't, we'll want\n // to calculate it. Unless the user doesn't have an avatar, in which case\n // we generate a color from their username.\n if (avatarColor) {\n return 'rgb(' + avatarColor.join(', ') + ')';\n } else if (avatarUrl) {\n this.calculateAvatarColor();\n return '';\n }\n\n return '#' + stringToColor(username);\n }) as () => string;\n\n isOnline(): boolean {\n return (\n this.lastSeenAt() >\n dayjs()\n .subtract(5, 'minutes')\n .toDate()\n );\n }\n\n /**\n * Get the Badge components that apply to this user.\n */\n badges(): ItemList {\n const items = new ItemList();\n const groups = this.groups();\n\n if (groups) {\n groups.forEach(group => {\n items.add('group' + group.id(), GroupBadge.component({ group }));\n });\n }\n\n return items;\n }\n\n /**\n * Calculate the dominant color of the user's avatar. The dominant color will\n * be set to the `avatarColor` property once it has been calculated.\n *\n * @protected\n */\n calculateAvatarColor() {\n const image = new Image();\n const user = this;\n\n image.onload = function() {\n const colorThief = new ColorThief();\n user.avatarColor = colorThief.getColor(this);\n user.freshness = new Date();\n m.redraw();\n };\n image.crossOrigin = 'anonymous';\n image.src = this.avatarUrl();\n }\n\n /**\n * Update the user's preferences.\n */\n savePreferences(newPreferences: UserPreferences): Promise {\n const preferences = this.preferences();\n\n Object.assign(preferences, newPreferences);\n\n return >this.save({ preferences });\n }\n}\n","/**\n * Truncate a string to the given length, appending ellipses if necessary.\n */\nexport function truncate(string: string, length: number, start = 0): string {\n return (start > 0 ? '...' : '') + string.substring(start, start + length) + (string.length > start + length ? '...' : '');\n}\n\n/**\n * Create a slug out of the given string. Non-alphanumeric characters are\n * converted to hyphens.\n */\nexport function slug(string: string): string {\n return string\n .toLowerCase()\n .replace(/[^a-z0-9]/gi, '-')\n .replace(/-+/g, '-')\n .replace(/-$|^-/g, '');\n}\n\n/**\n * Strip HTML tags and quotes out of the given string, replacing them with\n * meaningful punctuation.\n */\nexport function getPlainContent(string: string): string {\n const html = string.replace(/(<\\/p>|
)/g, '$1  ').replace(/]*>/gi, ' ');\n\n const dom = $('
').html(html);\n\n dom.find(getPlainContent.removeSelectors.join(',')).remove();\n\n return dom\n .text()\n .replace(/\\s+/g, ' ')\n .trim();\n}\n\n/**\n * An array of DOM selectors to remove when getting plain content.\n *\n * @type {String[]}\n */\ngetPlainContent.removeSelectors = ['blockquote', 'script'];\n\n/**\n * Make a string's first character uppercase.\n */\nexport function ucfirst(string: string): string {\n return string.substr(0, 1).toUpperCase() + string.substr(1);\n}\n","import Model from '../Model';\nimport computed from '../utils/computed';\nimport { getPlainContent } from '../utils/string';\n\nimport Discussion from './Discussion';\nimport User from './User';\n\nexport default class Post extends Model {\n number = Model.attribute('number') as () => number;\n discussion = Model.hasOne('discussion') as () => Discussion;\n\n createdAt = Model.attribute('createdAt', Model.transformDate) as () => Date;\n user = Model.hasOne('user') as () => User;\n contentType = Model.attribute('contentType') as () => string;\n content = Model.attribute('content') as () => string;\n contentHtml = Model.attribute('contentHtml') as () => string;\n contentPlain = computed('contentHtml', getPlainContent) as () => string;\n\n editedAt = Model.attribute('editedAt', Model.transformDate) as () => Date;\n editedUser = Model.hasOne('editedUser') as () => User;\n isEdited = computed('editedAt', editedAt => !!editedAt) as () => boolean;\n\n hiddenAt = Model.attribute('hiddenAt', Model.transformDate) as () => Date;\n hiddenUser = Model.hasOne('hiddenUser') as () => User;\n isHidden = computed('hiddenAt', hiddenAt => !!hiddenAt) as () => boolean;\n\n canEdit = Model.attribute('canEdit') as () => boolean;\n canHide = Model.attribute('canHide') as () => boolean;\n canDelete = Model.attribute('canDelete') as () => boolean;\n}\n","import Model from '../Model';\n\nexport default class Group extends Model {\n static ADMINISTRATOR_ID = '1';\n static GUEST_ID = '2';\n static MEMBER_ID = '3';\n\n nameSingular = Model.attribute('nameSingular') as () => string;\n namePlural = Model.attribute('namePlural') as () => string;\n color = Model.attribute('color') as () => string;\n icon = Model.attribute('icon') as () => string;\n}\n","import Model from '../Model';\nimport User from './User';\n\nexport default class Notification extends Model {\n static ADMINISTRATOR_ID = '1';\n static GUEST_ID = '2';\n static MEMBER_ID = '3';\n\n contentType = Model.attribute('contentType') as () => string;\n content = Model.attribute('content') as () => string;\n createdAt = Model.attribute('createdAt', Model.transformDate) as () => Date;\n\n isRead = Model.attribute('isRead') as () => boolean;\n\n user = Model.hasOne('user') as () => User;\n fromUser = Model.hasOne('fromUser') as () => User;\n subject = Model.hasOne('subhect') as () => any;\n}\n","var __assign = (this && this.__assign) || function () {\r\n __assign = Object.assign || function(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n t[p] = s[p];\r\n }\r\n return t;\r\n };\r\n return __assign.apply(this, arguments);\r\n};\r\nvar defaults = {\r\n lines: 12,\r\n length: 7,\r\n width: 5,\r\n radius: 10,\r\n scale: 1.0,\r\n corners: 1,\r\n color: '#000',\r\n fadeColor: 'transparent',\r\n animation: 'spinner-line-fade-default',\r\n rotate: 0,\r\n direction: 1,\r\n speed: 1,\r\n zIndex: 2e9,\r\n className: 'spinner',\r\n top: '50%',\r\n left: '50%',\r\n shadow: '0 0 1px transparent',\r\n position: 'absolute',\r\n};\r\nvar Spinner = /** @class */ (function () {\r\n function Spinner(opts) {\r\n if (opts === void 0) { opts = {}; }\r\n this.opts = __assign(__assign({}, defaults), opts);\r\n }\r\n /**\r\n * Adds the spinner to the given target element. If this instance is already\r\n * spinning, it is automatically removed from its previous target by calling\r\n * stop() internally.\r\n */\r\n Spinner.prototype.spin = function (target) {\r\n this.stop();\r\n this.el = document.createElement('div');\r\n this.el.className = this.opts.className;\r\n this.el.setAttribute('role', 'progressbar');\r\n css(this.el, {\r\n position: this.opts.position,\r\n width: 0,\r\n zIndex: this.opts.zIndex,\r\n left: this.opts.left,\r\n top: this.opts.top,\r\n transform: \"scale(\" + this.opts.scale + \")\",\r\n });\r\n if (target) {\r\n target.insertBefore(this.el, target.firstChild || null);\r\n }\r\n drawLines(this.el, this.opts);\r\n return this;\r\n };\r\n /**\r\n * Stops and removes the Spinner.\r\n * Stopped spinners may be reused by calling spin() again.\r\n */\r\n Spinner.prototype.stop = function () {\r\n if (this.el) {\r\n if (typeof requestAnimationFrame !== 'undefined') {\r\n cancelAnimationFrame(this.animateId);\r\n }\r\n else {\r\n clearTimeout(this.animateId);\r\n }\r\n if (this.el.parentNode) {\r\n this.el.parentNode.removeChild(this.el);\r\n }\r\n this.el = undefined;\r\n }\r\n return this;\r\n };\r\n return Spinner;\r\n}());\r\nexport { Spinner };\r\n/**\r\n * Sets multiple style properties at once.\r\n */\r\nfunction css(el, props) {\r\n for (var prop in props) {\r\n el.style[prop] = props[prop];\r\n }\r\n return el;\r\n}\r\n/**\r\n * Returns the line color from the given string or array.\r\n */\r\nfunction getColor(color, idx) {\r\n return typeof color == 'string' ? color : color[idx % color.length];\r\n}\r\n/**\r\n * Internal method that draws the individual lines.\r\n */\r\nfunction drawLines(el, opts) {\r\n var borderRadius = (Math.round(opts.corners * opts.width * 500) / 1000) + 'px';\r\n var shadow = 'none';\r\n if (opts.shadow === true) {\r\n shadow = '0 2px 4px #000'; // default shadow\r\n }\r\n else if (typeof opts.shadow === 'string') {\r\n shadow = opts.shadow;\r\n }\r\n var shadows = parseBoxShadow(shadow);\r\n for (var i = 0; i < opts.lines; i++) {\r\n var degrees = ~~(360 / opts.lines * i + opts.rotate);\r\n var backgroundLine = css(document.createElement('div'), {\r\n position: 'absolute',\r\n top: -opts.width / 2 + \"px\",\r\n width: (opts.length + opts.width) + 'px',\r\n height: opts.width + 'px',\r\n background: getColor(opts.fadeColor, i),\r\n borderRadius: borderRadius,\r\n transformOrigin: 'left',\r\n transform: \"rotate(\" + degrees + \"deg) translateX(\" + opts.radius + \"px)\",\r\n });\r\n var delay = i * opts.direction / opts.lines / opts.speed;\r\n delay -= 1 / opts.speed; // so initial animation state will include trail\r\n var line = css(document.createElement('div'), {\r\n width: '100%',\r\n height: '100%',\r\n background: getColor(opts.color, i),\r\n borderRadius: borderRadius,\r\n boxShadow: normalizeShadow(shadows, degrees),\r\n animation: 1 / opts.speed + \"s linear \" + delay + \"s infinite \" + opts.animation,\r\n });\r\n backgroundLine.appendChild(line);\r\n el.appendChild(backgroundLine);\r\n }\r\n}\r\nfunction parseBoxShadow(boxShadow) {\r\n var regex = /^\\s*([a-zA-Z]+\\s+)?(-?\\d+(\\.\\d+)?)([a-zA-Z]*)\\s+(-?\\d+(\\.\\d+)?)([a-zA-Z]*)(.*)$/;\r\n var shadows = [];\r\n for (var _i = 0, _a = boxShadow.split(','); _i < _a.length; _i++) {\r\n var shadow = _a[_i];\r\n var matches = shadow.match(regex);\r\n if (matches === null) {\r\n continue; // invalid syntax\r\n }\r\n var x = +matches[2];\r\n var y = +matches[5];\r\n var xUnits = matches[4];\r\n var yUnits = matches[7];\r\n if (x === 0 && !xUnits) {\r\n xUnits = yUnits;\r\n }\r\n if (y === 0 && !yUnits) {\r\n yUnits = xUnits;\r\n }\r\n if (xUnits !== yUnits) {\r\n continue; // units must match to use as coordinates\r\n }\r\n shadows.push({\r\n prefix: matches[1] || '',\r\n x: x,\r\n y: y,\r\n xUnits: xUnits,\r\n yUnits: yUnits,\r\n end: matches[8],\r\n });\r\n }\r\n return shadows;\r\n}\r\n/**\r\n * Modify box-shadow x/y offsets to counteract rotation\r\n */\r\nfunction normalizeShadow(shadows, degrees) {\r\n var normalized = [];\r\n for (var _i = 0, shadows_1 = shadows; _i < shadows_1.length; _i++) {\r\n var shadow = shadows_1[_i];\r\n var xy = convertOffset(shadow.x, shadow.y, degrees);\r\n normalized.push(shadow.prefix + xy[0] + shadow.xUnits + ' ' + xy[1] + shadow.yUnits + shadow.end);\r\n }\r\n return normalized.join(', ');\r\n}\r\nfunction convertOffset(x, y, degrees) {\r\n var radians = degrees * Math.PI / 180;\r\n var sin = Math.sin(radians);\r\n var cos = Math.cos(radians);\r\n return [\r\n Math.round((x * cos + y * sin) * 1000) / 1000,\r\n Math.round((-x * sin + y * cos) * 1000) / 1000,\r\n ];\r\n}\r\n","import Component from '../Component';\nimport { Spinner, SpinnerOptions } from 'spin.js';\n\n/**\n * The `LoadingIndicator` component displays a loading spinner with spin.js. It\n * may have the following special props:\n *\n * - `size` The spin.js size preset to use. Defaults to 'small'.\n *\n * All other props will be assigned as attributes on the element.\n */\nexport default class LoadingIndicator extends Component {\n view(vnode) {\n const attrs = vnode.attrs;\n\n attrs.className = 'LoadingIndicator ' + (attrs.className || '');\n delete attrs.size;\n\n return
{m.trust(' ')}
;\n }\n\n oncreate(vnode) {\n super.oncreate(vnode);\n\n const options: SpinnerOptions = { zIndex: 'auto', color: this.$().css('color') };\n let sizeOptions: SpinnerOptions = {};\n\n switch (vnode.attrs.size) {\n case 'large':\n sizeOptions = { lines: 10, length: 8, width: 4, radius: 8 };\n break;\n\n case 'tiny':\n sizeOptions = { lines: 8, length: 2, width: 2, radius: 3 };\n break;\n\n default:\n sizeOptions = { lines: 8, length: 4, width: 3, radius: 5 };\n }\n\n new Spinner({ ...options, ...sizeOptions }).spin(this.element);\n }\n}\n","import Component, { ComponentProps } from '../Component';\nimport icon from '../helpers/icon';\nimport extract from '../utils/extract';\nimport extractText from '../utils/extractText';\nimport LoadingIndicator from './LoadingIndicator';\n\nexport interface ButtonProps extends ComponentProps {\n title?: string;\n type?: string;\n icon?: string;\n\n loading?: boolean;\n disabled?: boolean;\n onclick?: Function;\n}\n\n/**\n * The `Button` component defines an element which, when clicked, performs an\n * action. The button may have the following special props:\n *\n * - `icon` The name of the icon class. If specified, the button will be given a\n * 'has-icon' class name.\n * - `disabled` Whether or not the button is disabled. If truthy, the button\n * will be given a 'disabled' class name, and any `onclick` handler will be\n * removed.\n * - `loading` Whether or not the button should be in a disabled loading state.\n *\n * All other props will be assigned as attributes on the button element.\n *\n * Note that a Button has no default class names. This is because a Button can\n * be used to represent any generic clickable control, like a menu item.\n */\nexport default class Button extends Component {\n view() {\n const { children, ...attrs } = this.props;\n\n attrs.className = attrs.className || '';\n attrs.type = attrs.type || 'button';\n\n // If a tooltip was provided for buttons without additional content, we also\n // use this tooltip as text for screen readers\n if (attrs.title && !this.props.children) {\n attrs['aria-label'] = attrs.title;\n }\n\n // If nothing else is provided, we use the textual button content as tooltip\n if (!attrs.title && this.props.children) {\n attrs.title = extractText(this.props.children);\n }\n\n const iconName = extract(attrs, 'icon');\n if (iconName) attrs.className += ' hasIcon';\n\n const loading = extract(attrs, 'loading');\n if (attrs.disabled || loading) {\n attrs.className = classNames(attrs.className, 'disabled', loading && 'loading');\n delete attrs.onclick;\n }\n\n return ;\n }\n\n /**\n * Get the template for the button's content.\n */\n protected getButtonContent(iconName?: string | boolean, loading?: boolean, children?: any): any[] {\n return [\n iconName && iconName !== true ? icon(iconName, { className: 'Button-icon' }) : '',\n children ? {children} : '',\n loading ? LoadingIndicator.component({ size: 'tiny', className: 'LoadingIndicator--inline' }) : '',\n ];\n }\n}\n","export default function _objectWithoutPropertiesLoose(source, excluded) {\n if (source == null) return {};\n var target = {};\n var sourceKeys = Object.keys(source);\n var key, i;\n\n for (i = 0; i < sourceKeys.length; i++) {\n key = sourceKeys[i];\n if (excluded.indexOf(key) >= 0) continue;\n target[key] = source[key];\n }\n\n return target;\n}","import Component from '../Component';\n\n/**\n * The `Separator` component defines a menu separator item.\n */\nexport default class Separator extends Component {\n static isListItem = true;\n\n view() {\n return
  • ;\n }\n}\n","import Separator from '../components/Separator';\n\nexport function isSeparator(item) {\n return item?.tag === Separator;\n}\n\nexport function withoutUnnecessarySeparators(items) {\n const newItems = [];\n let prevItem;\n\n items.forEach((item, i) => {\n if (!isSeparator(item) || (prevItem && !isSeparator(prevItem) && i !== items.length - 1)) {\n prevItem = item;\n newItems.push(item);\n }\n });\n\n return newItems;\n}\n\n/**\n * The `listItems` helper wraps a collection of components in
  • tags,\n * stripping out any unnecessary `Separator` components.\n *\n * @param {*} items\n * @return {Array}\n */\nexport default function listItems(items) {\n if (!(items instanceof Array)) items = [items];\n\n return withoutUnnecessarySeparators(items).map(item => {\n const isListItem = item.tag?.isListItem;\n const active = item.tag?.isActive && item.tag.isActive(item.attrs);\n const className = item.attrs?.itemClassName || item.itemClassName;\n\n if (isListItem) {\n item.attrs = item.attrs || {};\n item.attrs.key = item.attrs.key || item.itemName;\n item.key = item.attrs.key;\n }\n\n const node = isListItem ? (\n item\n ) : (\n \n {item}\n
    • \n );\n\n node.state = node.state || {};\n\n return node;\n });\n}\n","const MicroModal = (() => {\n\n const FOCUSABLE_ELEMENTS = ['a[href]', 'area[href]', 'input:not([disabled]):not([type=\"hidden\"]):not([aria-hidden])', 'select:not([disabled]):not([aria-hidden])', 'textarea:not([disabled]):not([aria-hidden])', 'button:not([disabled]):not([aria-hidden])', 'iframe', 'object', 'embed', '[contenteditable]', '[tabindex]:not([tabindex^=\"-\"])'];\n\n class Modal {\n constructor({\n targetModal,\n triggers = [],\n onShow = () => {},\n onClose = () => {},\n openTrigger = 'data-micromodal-trigger',\n closeTrigger = 'data-micromodal-close',\n disableScroll = false,\n disableFocus = false,\n awaitCloseAnimation = false,\n awaitOpenAnimation = false,\n debugMode = false\n }) {\n // Save a reference of the modal\n this.modal = document.getElementById(targetModal); // Save a reference to the passed config\n\n this.config = {\n debugMode,\n disableScroll,\n openTrigger,\n closeTrigger,\n onShow,\n onClose,\n awaitCloseAnimation,\n awaitOpenAnimation,\n disableFocus // Register click events only if pre binding eventListeners\n\n };\n if (triggers.length > 0) this.registerTriggers(...triggers); // pre bind functions for event listeners\n\n this.onClick = this.onClick.bind(this);\n this.onKeydown = this.onKeydown.bind(this);\n }\n /**\n * Loops through all openTriggers and binds click event\n * @param {array} triggers [Array of node elements]\n * @return {void}\n */\n\n\n registerTriggers(...triggers) {\n triggers.filter(Boolean).forEach(trigger => {\n trigger.addEventListener('click', event => this.showModal(event));\n });\n }\n\n showModal() {\n this.activeElement = document.activeElement;\n this.modal.setAttribute('aria-hidden', 'false');\n this.modal.classList.add('is-open');\n this.scrollBehaviour('disable');\n this.addEventListeners();\n\n if (this.config.awaitOpenAnimation) {\n const handler = () => {\n this.modal.removeEventListener('animationend', handler, false);\n this.setFocusToFirstNode();\n };\n\n this.modal.addEventListener('animationend', handler, false);\n } else {\n this.setFocusToFirstNode();\n }\n\n this.config.onShow(this.modal, this.activeElement);\n }\n\n closeModal() {\n const modal = this.modal;\n this.modal.setAttribute('aria-hidden', 'true');\n this.removeEventListeners();\n this.scrollBehaviour('enable');\n\n if (this.activeElement) {\n this.activeElement.focus();\n }\n\n this.config.onClose(this.modal);\n\n if (this.config.awaitCloseAnimation) {\n this.modal.addEventListener('animationend', function handler() {\n modal.classList.remove('is-open');\n modal.removeEventListener('animationend', handler, false);\n }, false);\n } else {\n modal.classList.remove('is-open');\n }\n }\n\n closeModalById(targetModal) {\n this.modal = document.getElementById(targetModal);\n if (this.modal) this.closeModal();\n }\n\n scrollBehaviour(toggle) {\n if (!this.config.disableScroll) return;\n const body = document.querySelector('body');\n\n switch (toggle) {\n case 'enable':\n Object.assign(body.style, {\n overflow: '',\n height: ''\n });\n break;\n\n case 'disable':\n Object.assign(body.style, {\n overflow: 'hidden',\n height: '100vh'\n });\n break;\n\n default:\n }\n }\n\n addEventListeners() {\n this.modal.addEventListener('touchstart', this.onClick);\n this.modal.addEventListener('click', this.onClick);\n document.addEventListener('keydown', this.onKeydown);\n }\n\n removeEventListeners() {\n this.modal.removeEventListener('touchstart', this.onClick);\n this.modal.removeEventListener('click', this.onClick);\n document.removeEventListener('keydown', this.onKeydown);\n }\n\n onClick(event) {\n if (event.target.hasAttribute(this.config.closeTrigger)) {\n this.closeModal();\n event.preventDefault();\n }\n }\n\n onKeydown(event) {\n if (event.keyCode === 27) this.closeModal(event);\n if (event.keyCode === 9) this.maintainFocus(event);\n }\n\n getFocusableNodes() {\n const nodes = this.modal.querySelectorAll(FOCUSABLE_ELEMENTS);\n return Array(...nodes);\n }\n\n setFocusToFirstNode() {\n if (this.config.disableFocus) return;\n const focusableNodes = this.getFocusableNodes();\n if (focusableNodes.length) focusableNodes[0].focus();\n }\n\n maintainFocus(event) {\n const focusableNodes = this.getFocusableNodes(); // if disableFocus is true\n\n if (!this.modal.contains(document.activeElement)) {\n focusableNodes[0].focus();\n } else {\n const focusedItemIndex = focusableNodes.indexOf(document.activeElement);\n\n if (event.shiftKey && focusedItemIndex === 0) {\n focusableNodes[focusableNodes.length - 1].focus();\n event.preventDefault();\n }\n\n if (!event.shiftKey && focusedItemIndex === focusableNodes.length - 1) {\n focusableNodes[0].focus();\n event.preventDefault();\n }\n }\n }\n\n }\n /**\n * Modal prototype ends.\n * Here on code is responsible for detecting and\n * auto binding event handlers on modal triggers\n */\n // Keep a reference to the opened modal\n\n\n let activeModal = null;\n /**\n * Generates an associative array of modals and it's\n * respective triggers\n * @param {array} triggers An array of all triggers\n * @param {string} triggerAttr The data-attribute which triggers the module\n * @return {array}\n */\n\n const generateTriggerMap = (triggers, triggerAttr) => {\n const triggerMap = [];\n triggers.forEach(trigger => {\n const targetModal = trigger.attributes[triggerAttr].value;\n if (triggerMap[targetModal] === undefined) triggerMap[targetModal] = [];\n triggerMap[targetModal].push(trigger);\n });\n return triggerMap;\n };\n /**\n * Validates whether a modal of the given id exists\n * in the DOM\n * @param {number} id The id of the modal\n * @return {boolean}\n */\n\n\n const validateModalPresence = id => {\n if (!document.getElementById(id)) {\n console.warn(`MicroModal: \\u2757Seems like you have missed %c'${id}'`, 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', 'ID somewhere in your code. Refer example below to resolve it.');\n console.warn(`%cExample:`, 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', `
    `);\n return false;\n }\n };\n /**\n * Validates if there are modal triggers present\n * in the DOM\n * @param {array} triggers An array of data-triggers\n * @return {boolean}\n */\n\n\n const validateTriggerPresence = triggers => {\n if (triggers.length <= 0) {\n console.warn(`MicroModal: \\u2757Please specify at least one %c'micromodal-trigger'`, 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', 'data attribute.');\n console.warn(`%cExample:`, 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', ``);\n return false;\n }\n };\n /**\n * Checks if triggers and their corresponding modals\n * are present in the DOM\n * @param {array} triggers Array of DOM nodes which have data-triggers\n * @param {array} triggerMap Associative array of modals and their triggers\n * @return {boolean}\n */\n\n\n const validateArgs = (triggers, triggerMap) => {\n validateTriggerPresence(triggers);\n if (!triggerMap) return true;\n\n for (var id in triggerMap) validateModalPresence(id);\n\n return true;\n };\n /**\n * Binds click handlers to all modal triggers\n * @param {object} config [description]\n * @return void\n */\n\n\n const init = config => {\n // Create an config object with default openTrigger\n const options = Object.assign({}, {\n openTrigger: 'data-micromodal-trigger'\n }, config); // Collects all the nodes with the trigger\n\n const triggers = [...document.querySelectorAll(`[${options.openTrigger}]`)]; // Makes a mappings of modals with their trigger nodes\n\n const triggerMap = generateTriggerMap(triggers, options.openTrigger); // Checks if modals and triggers exist in dom\n\n if (options.debugMode === true && validateArgs(triggers, triggerMap) === false) return; // For every target modal creates a new instance\n\n for (var key in triggerMap) {\n let value = triggerMap[key];\n options.targetModal = key;\n options.triggers = [...value];\n activeModal = new Modal(options); // eslint-disable-line no-new\n }\n };\n /**\n * Shows a particular modal\n * @param {string} targetModal [The id of the modal to display]\n * @param {object} config [The configuration object to pass]\n * @return {void}\n */\n\n\n const show = (targetModal, config) => {\n const options = config || {};\n options.targetModal = targetModal; // Checks if modals and triggers exist in dom\n\n if (options.debugMode === true && validateModalPresence(targetModal) === false) return; // stores reference to active modal\n\n activeModal = new Modal(options); // eslint-disable-line no-new\n\n activeModal.showModal();\n };\n /**\n * Closes the active modal\n * @param {string} targetModal [The id of the modal to close]\n * @return {void}\n */\n\n\n const close = targetModal => {\n targetModal ? activeModal.closeModalById(targetModal) : activeModal.closeModal();\n };\n\n return {\n init,\n show,\n close\n };\n})();\n\nexport default MicroModal;\n","import Component, { ComponentProps } from '../Component';\nimport Button from './Button';\nimport listItems from '../helpers/listItems';\nimport extract from '../utils/extract';\nimport * as Mithril from 'mithril';\n\nexport interface AlertProps extends ComponentProps {\n controls?: Mithril.ChildArray;\n type?: string;\n dismissible?: boolean;\n\n ondismiss?: () => any;\n}\n\n/**\n * The `Alert` component represents an alert box, which contains a message,\n * some controls, and may be dismissible.\n *\n * The alert may have the following special props:\n *\n * - `type` The type of alert this is. Will be used to give the alert a class\n * name of `Alert--{type}`.\n * - `controls` An array of controls to show in the alert.\n * - `dismissible` Whether or not the alert can be dismissed.\n * - `ondismiss` A callback to run when the alert is dismissed.\n *\n * All other props will be assigned as attributes on the alert element.\n */\nexport default class Alert extends Component {\n view() {\n const attrs: AlertProps = Object.assign({}, this.props);\n\n const type: string = extract(attrs, 'type');\n attrs.className = `Alert Alert--${type} ${attrs.className || ''}`;\n\n const children: Mithril.Children = extract(attrs, 'children');\n const controls: Mithril.ChildArray = extract(attrs, 'controls') || [];\n\n // If the alert is meant to be dismissible (which is the case by default),\n // then we will create a dismiss button to append as the final control in\n // the alert.\n const dismissible: boolean | undefined = extract(attrs, 'dismissible');\n const ondismiss: () => any = extract(attrs, 'ondismiss');\n const dismissControl = [];\n\n if (dismissible || dismissible === undefined) {\n dismissControl.push(