{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/studbook/websites/beta/shared/node_modules/flickity/dist/flickity.pkgd.js","webpack:///./app/javascript/helpers/index.js","webpack:////home/studbook/websites/beta/shared/node_modules/jquery/dist/jquery.js","webpack:///(webpack)/buildin/module.js","webpack:///./app/javascript/packs/bottom.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","_typeof","iterator","obj","constructor","window","factory","jQuery","arraySlice","Array","slice","console","logError","message","error","jQueryBridget","namespace","PluginClass","$","methodCall","$elems","methodName","args","returnValue","pluginMethodStr","each","elem","instance","data","method","charAt","apply","undefined","plainCall","options","option","_init","opts","isPlainObject","this","extend","fn","arg0","arguments","updateJQuery","bridget","EvEmitter","proto","on","eventName","listener","events","_events","listeners","indexOf","push","once","onceEvents","_onceEvents","off","length","index","splice","emitEvent","onceListeners","allOff","getStyleSize","num","parseFloat","isNaN","measurements","measurementsLength","getStyle","style","getComputedStyle","isBoxSizeOuter","isSetup","getSize","div","document","createElement","width","padding","borderStyle","borderWidth","boxSizing","body","documentElement","appendChild","Math","round","removeChild","setup","querySelector","nodeType","display","size","height","innerWidth","innerHeight","outerWidth","outerHeight","getZeroSize","offsetWidth","offsetHeight","isBorderBox","measurement","paddingWidth","paddingLeft","paddingRight","paddingHeight","paddingTop","paddingBottom","marginWidth","marginLeft","marginRight","marginHeight","marginTop","marginBottom","borderLeftWidth","borderRightWidth","borderHeight","borderTopWidth","borderBottomWidth","isBorderBoxSizeOuter","styleWidth","styleHeight","matchesMethod","ElemProto","Element","matches","matchesSelector","prefixes","selector","utils","a","b","prop","makeArray","isArray","removeFrom","ary","getParent","parentNode","getQueryElement","handleEvent","event","type","filterFindElements","elems","ffElems","forEach","HTMLElement","childElems","querySelectorAll","debounceMethod","_class","threshold","timeoutName","timeout","clearTimeout","_this","setTimeout","docReady","callback","readyState","addEventListener","toDashed","str","replace","match","$1","$2","toLowerCase","htmlInit","WidgetClass","dashedNamespace","dataAttr","dataAttrElems","jsDashElems","concat","dataOptionsAttr","attr","getAttribute","JSON","parse","className","Cell","parent","element","position","setAttribute","x","shift","destroy","unselect","side","originSide","setPosition","updateTarget","renderPosition","setDefaultTarget","marginProperty","target","cellAlign","getPositionValue","select","classList","add","removeAttribute","remove","wrapShift","slideableWidth","Slide","isOriginLeft","cells","addCell","cell","max","beginMargin","firstMargin","endMargin","lastCell","getLastCell","lastMargin","slideWidth","getCellElements","map","isAnimating","restingFrames","animate","applyDragForce","applySelectedAttraction","previousX","integratePhysics","positionSlider","settle","requestAnimationFrame","wrapAround","modulo","shiftWrapCells","setTranslateX","dispatchScrollEvent","is3d","cursorPosition","rightToLeft","translateX","slider","transform","firstSlide","slides","positionX","progress","slidesWidth","dispatchEvent","selectedSlide","velocity","percentPosition","isPointerDown","isFreeScrolling","selectedIndex","beforeGap","_shiftCells","beforeShiftCells","afterGap","afterShiftCells","gap","cellShift","getFrictionFactor","force","isDraggable","dragForce","dragX","applyForce","selectedAttraction","animatePrototype","moveElements","toElem","GUID","instances","Flickity","queryElement","flickityGUID","$element","defaults","_create","accessibility","freeScrollFriction","friction","namespaceJQueryEvents","resize","setGallerySize","createMethods","id","guid","viewport","_createSlider","watchCSS","activate","isActive","_filterFindCellElements","children","reloadCells","tabIndex","selectInitialIndex","isInitActivated","cellSelector","_makeCells","positionCells","_getWrapShiftCells","cellElem","getLastSlide","_sizeCells","_positionCells","maxCellHeight","cellX","startCell","len","updateSlides","_containSlides","slide","nextMargin","canCellFit","_getCanCellFit","updateSelectedSlide","groupCells","number","parseInt","percentMatch","percent","reposition","positionSliderAtSelected","setCellAlign","cellAlignShorthands","center","left","right","shorthand","adaptiveHeight","_unshiftCells","gapX","cellIndex","_getGapCells","increment","contain","isRightToLeft","contentWidth","isContentSmaller","beginBound","endBound","min","emitArgs","$event","jQEvent","Event","trigger","isWrap","isInstant","_wrapSelect","prevIndex","startAnimation","wrapIndex","delta","abs","backWrapDelta","forewardWrapDelta","isDragSelect","previous","next","unselectSelectedSlide","selectedCells","selectedElements","selectedCell","selectedElement","initialIndex","queryCell","selectCell","getCellSlideIndex","getCell","getCells","getParentCell","getAdjacentCellElements","adjCount","cellElems","slideIndex","uiChange","childUIPointerDown","preventDefault","focus","onresize","content","deactivate","onkeydown","isNotFocused","activeElement","handler","keyboardHandlers","keyCode","37","leftMethod","39","rightMethod","prevScrollY","pageYOffset","preventScroll","scrollTo","pageXOffset","removeEventListener","removeData","setJQuery","jq","Unipointer","bindStartEvent","_bindStartEvent","unbindStartEvent","isAdd","bindMethod","startEvent","PointerEvent","getTouch","touches","touch","identifier","pointerIdentifier","onmousedown","button","_pointerDown","ontouchstart","changedTouches","onpointerdown","pointer","pointerId","pointerDown","_bindPostStartEvents","postStartEvents","mousedown","touchstart","pointerdown","_boundPointerEvents","_unbindPostStartEvents","onmousemove","_pointerMove","onpointermove","ontouchmove","pointerMove","onmouseup","_pointerUp","onpointerup","ontouchend","_pointerDone","pointerUp","_pointerReset","pointerDone","onpointercancel","_pointerCancel","ontouchcancel","pointerCancel","getPointerPoint","pageX","y","pageY","Unidragger","bindHandles","_bindHandles","unbindHandles","touchAction","_touchActionValue","handles","handle","okayPointerDown","pointerDownPointer","pointerDownBlur","cursorNodes","TEXTAREA","INPUT","SELECT","OPTION","clickTypes","radio","checkbox","submit","image","file","isCursorNode","nodeName","isClickType","isOkay","focused","blur","moveVector","_dragPointerMove","_dragMove","isDragging","hasDragStarted","_dragStart","_dragPointerUp","_dragEnd","_staticClick","isPreventingClicks","dragStart","dragMove","dragEnd","onclick","isIgnoringMouseUp","staticClick","draggable","dragThreshold","isTouch","isTouchmoveScrollCanceled","_createDrag","onActivateDrag","_uiChangeDrag","onDeactivateDrag","updateDraggable","bindDrag","unbindDrag","_pointerDownPreventDefault","pointerDownFocus","pointerDownScroll","getScrollPosition","_pointerDownDefault","focusNodes","isTouchStart","isTouchPointer","pointerType","isFocusNode","isTouchScrolling","dragStartPosition","previousDragX","direction","originBound","dragMoveTime","Date","freeScroll","dragEndRestingSelect","restingX","getRestingPosition","dragEndBoostSelect","distance","getSlideDistance","positiveResting","_getClosestResting","negativeResting","minDistance","Infinity","condition","md","isWrapAround","wrap","floor","clickedCell","onscroll","scroll","scrollMoveX","scrollMoveY","svgURI","PrevNextButton","isEnabled","isPrevious","leftDirection","isLeft","disable","svg","createSVG","update","createElementNS","shape","path","pathMovements","arrowShape","x0","x1","y1","x2","y2","x3","enable","disabled","lastIndex","boundIndex","prevNextButtons","_createPrevNextButtons","prevButton","nextButton","activatePrevNextButtons","deactivatePrevNextButtons","PageDots","holder","dots","handleClick","onClick","setDots","addDots","removeDots","count","fragment","createDocumentFragment","newDots","dot","updateSelected","selectedDot","onTap","pageDots","_createPageDots","activatePageDots","updateSelectedPageDots","updatePageDots","deactivatePageDots","Player","state","onVisibilityChange","visibilityChange","onVisibilityPlay","visibilityPlay","play","hidden","tick","time","autoPlay","clear","stop","pause","unpause","pauseAutoPlayOnHover","_createPlayer","player","activatePlayer","stopPlayer","deactivatePlayer","playPlayer","pausePlayer","unpausePlayer","onmouseenter","onmouseleave","insert","getCellsFragment","isAppend","insertCellElement","insertBefore","endCells","cellChange","append","prepend","minCellIndex","cellSizeChange","changedCellIndex","isPositioningSlider","prevSelectedElem","LazyLoader","img","flickity","load","_createLazyload","lazyLoad","lazyImages","lazyCellImages","lazyloadAttr","srcAttr","srcsetAttr","imgs","getCellLazyImages","src","srcset","onload","complete","onerror","_createAsNavFor","activateAsNavFor","deactivateAsNavFor","destroyAsNavFor","asNavForOption","asNavFor","setNavCompanion","companion","navCompanion","onNavCompanionSelect","navCompanionSelect","onNavStaticClick","companionCells","firstIndex","selectIndex","removeNavSelectedElements","navSelectedElements","changeNavSelectedClass","navElem","cellElement","ImagesLoaded","onAlways","queryElem","elements","getImages","jqDeferred","Deferred","check","images","addElementImages","addImage","background","addElementBackgroundImages","elementNodeTypes","childImgs","child","1","9","11","LoadingImage","Background","url","Image","reURL","exec","backgroundImage","addBackground","loadingImage","onProgress","progressedCount","hasAnyBroken","isLoaded","notify","debug","log","isComplete","jqMethod","getIsImageComplete","confirm","naturalWidth","proxyImage","unbindEvents","makeJQueryPlugin","imagesLoaded","promise","_createImagesLoaded","getMetaValue","findElement","head","root","removeElement","el","insertAfter","referenceNode","nextSibling","global","w","Error","noGlobal","arr","getProto","getPrototypeOf","_slice","class2type","toString","hasOwn","fnToString","ObjectFunctionString","support","isFunction","isWindow","preservedScriptAttributes","nonce","noModule","DOMEval","code","node","doc","val","script","text","toType","context","init","rtrim","isArrayLike","jquery","toArray","pushStack","ret","merge","prevObject","first","eq","last","j","end","sort","copy","copyIsArray","clone","deep","expando","random","isReady","msg","noop","Ctor","isEmptyObject","globalEval","trim","results","inArray","second","grep","invert","callbackExpect","arg","split","Sizzle","Expr","getText","isXML","tokenize","compile","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","contains","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","pop","push_native","list","booleans","whitespace","attributes","pseudos","rwhitespace","RegExp","rcomma","rcombinators","rdescend","rpseudo","ridentifier","matchExpr","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","_","escaped","escapedWhitespace","high","String","fromCharCode","rcssescape","fcssescape","ch","asCodePoint","charCodeAt","unloadHandler","inDisabledFieldset","addCombinator","dir","childNodes","e","els","seed","nid","groups","newSelector","newContext","ownerDocument","getElementById","getElementsByTagName","getElementsByClassName","qsa","test","toSelector","join","testContext","qsaError","keys","cache","cacheLength","markFunction","assert","addHandle","attrs","attrHandle","siblingCheck","cur","diff","sourceIndex","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","namespaceURI","hasCompare","subWindow","defaultView","top","attachEvent","createComment","getById","getElementsByName","filter","attrId","find","getAttributeNode","tag","tmp","innerHTML","input","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","unshift","expr","specified","escape","sel","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","firstChild","nodeValue","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","result","what","simple","forward","ofType","xml","uniqueCache","outerCache","nodeIndex","start","useCache","lastChild","uniqueID","pseudo","setFilters","idx","matched","matcher","unmatched","lang","elemLang","hash","location","hasFocus","href","checked","selected","password","reset","tokens","combinator","base","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","contexts","multipleContexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","filters","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","token","compiled","defaultValue","unique","isXMLDoc","escapeSelector","_dir","until","truncate","is","_siblings","rneedsContext","needsContext","rsingleTag","winnow","qualifier","not","self","rootjQuery","parseHTML","ready","rparentsprev","guaranteedUnique","contents","prev","sibling","has","targets","closest","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","siblings","contentDocument","reverse","rnothtmlwhite","Identity","v","Thrower","ex","adoptValue","resolve","reject","noValue","fail","then","Callbacks","flag","createOptions","firing","memory","_fired","_locked","queue","firingIndex","fire","stopOnFalse","empty","lock","locked","fireWith","fired","func","tuples","_state","_promise","always","deferred","pipe","fns","newDefer","tuple","returned","onFulfilled","onRejected","maxDepth","depth","special","that","mightThrow","TypeError","notifyWith","resolveWith","process","exceptionHook","stackTrace","rejectWith","getStackHook","stateString","when","singleValue","remaining","resolveContexts","resolveValues","master","updateFunc","rerrorNames","stack","warn","readyException","readyList","completed","readyWait","wait","doScroll","access","chainable","emptyGet","raw","bulk","rmsPrefix","rdashAlpha","fcamelCase","all","letter","toUpperCase","camelCase","string","acceptData","owner","Data","uid","configurable","set","hasData","dataPriv","dataUser","rbrace","rmultiDash","getData","_data","_removeData","dequeue","startLength","hooks","_queueHooks","setter","clearQueue","defer","pnum","source","rcssNum","cssExpand","isAttached","composed","getRootNode","isHiddenWithinTree","css","swap","old","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","initial","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","showHide","show","values","hide","toggle","rcheckableType","rtagName","rscriptType","wrapMap","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","optgroup","tbody","tfoot","colgroup","caption","th","buildFragment","scripts","selection","ignored","attached","nodes","htmlPrefilter","createTextNode","checkClone","cloneNode","noCloneChecked","rkeyEvent","rmouseEvent","rtypenamespace","returnTrue","returnFalse","expectSync","err","safeActiveElement","_on","types","one","origFn","leverageNative","notAsync","saved","isTrigger","delegateType","stopPropagation","stopImmediatePropagation","handleObjIn","eventHandle","handleObj","handlers","namespaces","origType","elemData","triggered","dispatch","bindType","delegateCount","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","postDispatch","_handlers","matchedHandlers","matchedSelectors","addProp","hook","originalEvent","writable","noBubble","click","beforeunload","props","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","now","isSimulated","altKey","bubbles","cancelable","ctrlKey","detail","eventPhase","metaKey","shiftKey","view","charCode","buttons","clientX","clientY","offsetX","offsetY","screenX","screenY","targetTouches","toElement","which","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rxhtmlTag","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","pdataOld","pdataCur","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","valueIsFunction","html","_evalUrl","_remove","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","before","after","replaceWith","replaceChild","appendTo","prependTo","replaceAll","original","rnumnonpx","getStyles","opener","rboxStyle","curCSS","computed","minWidth","maxWidth","getPropertyValue","pixelBoxStyles","addGetHookIf","conditionFn","hookFn","computeStyleTests","container","cssText","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","pixelBoxStylesVal","boxSizingReliableVal","scrollboxSizeVal","measure","backgroundClip","clearCloneStyle","boxSizingReliable","pixelPosition","reliableMarginLeft","scrollboxSize","cssPrefixes","emptyStyle","vendorProps","finalPropName","_final","cssProps","capName","vendorPropName","rdisplayswap","rcustomProp","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","boxModelAdjustment","dimension","box","styles","computedVal","extra","ceil","getWidthOrHeight","valueIsBorderBox","offsetProp","getClientRects","Tween","easing","cssHooks","opacity","origName","isCustomProp","setProperty","isFinite","getBoundingClientRect","scrollboxSizeBuggy","margin","border","prefix","suffix","expand","expanded","parts","propHooks","run","eased","duration","pos","step","fx","scrollTop","scrollLeft","linear","swing","cos","PI","fxNow","inProgress","rfxtypes","rrun","schedule","interval","createFxNow","genFx","includeWidth","createTween","animation","Animation","tweeners","properties","stopped","prefilters","currentTime","startTime","tweens","specialEasing","originalProperties","originalOptions","gotoEnd","propFilter","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","speed","opt","speeds","fadeTo","to","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","delay","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","bool","attrNames","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","classesToArray","removeProp","propFix","tabindex","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","isValidValue","classNames","hasClass","rreturn","valHooks","optionSet","focusin","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","simulate","triggerHandler","attaches","rquery","parseXML","DOMParser","parseFromString","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","param","valueOrFunction","encodeURIComponent","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","transports","allTypes","originAnchor","addToPrefiltersOrTransports","structure","dataTypeExpression","dataType","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","active","lastModified","etag","isLocal","protocol","processData","async","contentType","accepts","json","responseFields","converters","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","urlAnchor","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","_statusCode","statusCode","requestHeaders","requestHeadersNames","strAbort","getResponseHeader","getAllResponseHeaders","setRequestHeader","overrideMimeType","mimeType","status","abort","statusText","finalText","crossDomain","host","hasContent","ifModified","headers","beforeSend","success","send","nativeStatusText","responses","isSuccess","response","modified","ct","finalDataType","firstDataType","ajaxHandleResponses","conv2","current","conv","dataFilter","ajaxConvert","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","xhr","XMLHttpRequest","xhrSuccessStatus","0","1223","xhrSupported","cors","_callback","errorCallback","open","username","xhrFields","onabort","ontimeout","onreadystatechange","responseType","responseText","binary","_callback2","scriptAttrs","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","parsed","params","animated","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","offsetParent","parentOffset","Height","Width","defaultExtra","funcName","hover","fnOver","fnOut","unbind","delegate","undelegate","proxy","holdReady","hold","parseJSON","isNumeric","_jQuery","_$","noConflict","webpackPolyfill","deprecate","paths","change","files","tooltip","magnificPopup","gallery","enabled","flickityElement","clientHeight"],"mappings":"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","file":"js/bottom-bc0fd4555becb490678c.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 95);\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*!\n * Flickity PACKAGED v2.2.1\n * Touch, responsive, flickable carousels\n *\n * Licensed GPLv3 for open source use\n * or Flickity Commercial License for commercial use\n *\n * https://flickity.metafizzy.co\n * Copyright 2015-2019 Metafizzy\n */\n\n/**\n * Bridget makes jQuery widgets\n * v2.0.1\n * MIT license\n */\n\n/* jshint browser: true, strict: true, undef: true, unused: true */\n(function (window, factory) {\n  // universal module definition\n\n  /*jshint strict: false */\n\n  /* globals define, module, require */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('jquery-bridget/jquery-bridget', ['jquery'], function (jQuery) {\n      return factory(window, jQuery);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('jquery'));\n  } else {\n    // browser global\n    window.jQueryBridget = factory(window, window.jQuery);\n  }\n})(window, function factory(window, jQuery) {\n  'use strict'; // ----- utils ----- //\n\n  var arraySlice = Array.prototype.slice; // helper function for logging errors\n  // $.error breaks jQuery chaining\n\n  var console = window.console;\n  var logError = typeof console == 'undefined' ? function () {} : function (message) {\n    console.error(message);\n  }; // ----- jQueryBridget ----- //\n\n  function jQueryBridget(namespace, PluginClass, $) {\n    $ = $ || jQuery || window.jQuery;\n\n    if (!$) {\n      return;\n    } // add option method -> $().plugin('option', {...})\n\n\n    if (!PluginClass.prototype.option) {\n      // option setter\n      PluginClass.prototype.option = function (opts) {\n        // bail out if not an object\n        if (!$.isPlainObject(opts)) {\n          return;\n        }\n\n        this.options = $.extend(true, this.options, opts);\n      };\n    } // make jQuery plugin\n\n\n    $.fn[namespace] = function (arg0\n    /*, arg1 */\n    ) {\n      if (typeof arg0 == 'string') {\n        // method call $().plugin( 'methodName', { options } )\n        // shift arguments by 1\n        var args = arraySlice.call(arguments, 1);\n        return methodCall(this, arg0, args);\n      } // just $().plugin({ options })\n\n\n      plainCall(this, arg0);\n      return this;\n    }; // $().plugin('methodName')\n\n\n    function methodCall($elems, methodName, args) {\n      var returnValue;\n      var pluginMethodStr = '$().' + namespace + '(\"' + methodName + '\")';\n      $elems.each(function (i, elem) {\n        // get instance\n        var instance = $.data(elem, namespace);\n\n        if (!instance) {\n          logError(namespace + ' not initialized. Cannot call methods, i.e. ' + pluginMethodStr);\n          return;\n        }\n\n        var method = instance[methodName];\n\n        if (!method || methodName.charAt(0) == '_') {\n          logError(pluginMethodStr + ' is not a valid method');\n          return;\n        } // apply method, get return value\n\n\n        var value = method.apply(instance, args); // set return value if value is returned, use only first value\n\n        returnValue = returnValue === undefined ? value : returnValue;\n      });\n      return returnValue !== undefined ? returnValue : $elems;\n    }\n\n    function plainCall($elems, options) {\n      $elems.each(function (i, elem) {\n        var instance = $.data(elem, namespace);\n\n        if (instance) {\n          // set options & init\n          instance.option(options);\n\n          instance._init();\n        } else {\n          // initialize new instance\n          instance = new PluginClass(elem, options);\n          $.data(elem, namespace, instance);\n        }\n      });\n    }\n\n    updateJQuery($);\n  } // ----- updateJQuery ----- //\n  // set $.bridget for v1 backwards compatibility\n\n\n  function updateJQuery($) {\n    if (!$ || $ && $.bridget) {\n      return;\n    }\n\n    $.bridget = jQueryBridget;\n  }\n\n  updateJQuery(jQuery || window.jQuery); // -----  ----- //\n\n  return jQueryBridget;\n});\n/**\n * EvEmitter v1.1.0\n * Lil' event emitter\n * MIT License\n */\n\n/* jshint unused: true, undef: true, strict: true */\n\n\n(function (global, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n\n  /* globals define, module, window */\n  if (typeof define == 'function' && define.amd) {\n    // AMD - RequireJS\n    define('ev-emitter/ev-emitter', factory);\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS - Browserify, Webpack\n    module.exports = factory();\n  } else {\n    // Browser globals\n    global.EvEmitter = factory();\n  }\n})(typeof window != 'undefined' ? window : this, function () {\n  function EvEmitter() {}\n\n  var proto = EvEmitter.prototype;\n\n  proto.on = function (eventName, listener) {\n    if (!eventName || !listener) {\n      return;\n    } // set events hash\n\n\n    var events = this._events = this._events || {}; // set listeners array\n\n    var listeners = events[eventName] = events[eventName] || []; // only add once\n\n    if (listeners.indexOf(listener) == -1) {\n      listeners.push(listener);\n    }\n\n    return this;\n  };\n\n  proto.once = function (eventName, listener) {\n    if (!eventName || !listener) {\n      return;\n    } // add event\n\n\n    this.on(eventName, listener); // set once flag\n    // set onceEvents hash\n\n    var onceEvents = this._onceEvents = this._onceEvents || {}; // set onceListeners object\n\n    var onceListeners = onceEvents[eventName] = onceEvents[eventName] || {}; // set flag\n\n    onceListeners[listener] = true;\n    return this;\n  };\n\n  proto.off = function (eventName, listener) {\n    var listeners = this._events && this._events[eventName];\n\n    if (!listeners || !listeners.length) {\n      return;\n    }\n\n    var index = listeners.indexOf(listener);\n\n    if (index != -1) {\n      listeners.splice(index, 1);\n    }\n\n    return this;\n  };\n\n  proto.emitEvent = function (eventName, args) {\n    var listeners = this._events && this._events[eventName];\n\n    if (!listeners || !listeners.length) {\n      return;\n    } // copy over to avoid interference if .off() in listener\n\n\n    listeners = listeners.slice(0);\n    args = args || []; // once stuff\n\n    var onceListeners = this._onceEvents && this._onceEvents[eventName];\n\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      var isOnce = onceListeners && onceListeners[listener];\n\n      if (isOnce) {\n        // remove listener\n        // remove before trigger to prevent recursion\n        this.off(eventName, listener); // unset once flag\n\n        delete onceListeners[listener];\n      } // trigger listener\n\n\n      listener.apply(this, args);\n    }\n\n    return this;\n  };\n\n  proto.allOff = function () {\n    delete this._events;\n    delete this._onceEvents;\n  };\n\n  return EvEmitter;\n});\n/*!\n * getSize v2.0.3\n * measure size of elements\n * MIT license\n */\n\n/* jshint browser: true, strict: true, undef: true, unused: true */\n\n/* globals console: false */\n\n\n(function (window, factory) {\n  /* jshint strict: false */\n\n  /* globals define, module */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('get-size/get-size', factory);\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory();\n  } else {\n    // browser global\n    window.getSize = factory();\n  }\n})(window, function factory() {\n  'use strict'; // -------------------------- helpers -------------------------- //\n  // get a number from a string, not a percentage\n\n  function getStyleSize(value) {\n    var num = parseFloat(value); // not a percent like '100%', and a number\n\n    var isValid = value.indexOf('%') == -1 && !isNaN(num);\n    return isValid && num;\n  }\n\n  function noop() {}\n\n  var logError = typeof console == 'undefined' ? noop : function (message) {\n    console.error(message);\n  }; // -------------------------- measurements -------------------------- //\n\n  var measurements = ['paddingLeft', 'paddingRight', 'paddingTop', 'paddingBottom', 'marginLeft', 'marginRight', 'marginTop', 'marginBottom', 'borderLeftWidth', 'borderRightWidth', 'borderTopWidth', 'borderBottomWidth'];\n  var measurementsLength = measurements.length;\n\n  function getZeroSize() {\n    var size = {\n      width: 0,\n      height: 0,\n      innerWidth: 0,\n      innerHeight: 0,\n      outerWidth: 0,\n      outerHeight: 0\n    };\n\n    for (var i = 0; i < measurementsLength; i++) {\n      var measurement = measurements[i];\n      size[measurement] = 0;\n    }\n\n    return size;\n  } // -------------------------- getStyle -------------------------- //\n\n  /**\n   * getStyle, get style of element, check for Firefox bug\n   * https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n   */\n\n\n  function getStyle(elem) {\n    var style = getComputedStyle(elem);\n\n    if (!style) {\n      logError('Style returned ' + style + '. Are you running this code in a hidden iframe on Firefox? ' + 'See https://bit.ly/getsizebug1');\n    }\n\n    return style;\n  } // -------------------------- setup -------------------------- //\n\n\n  var isSetup = false;\n  var isBoxSizeOuter;\n  /**\n   * setup\n   * check isBoxSizerOuter\n   * do on first getSize() rather than on page load for Firefox bug\n   */\n\n  function setup() {\n    // setup once\n    if (isSetup) {\n      return;\n    }\n\n    isSetup = true; // -------------------------- box sizing -------------------------- //\n\n    /**\n     * Chrome & Safari measure the outer-width on style.width on border-box elems\n     * IE11 & Firefox<29 measures the inner-width\n     */\n\n    var div = document.createElement('div');\n    div.style.width = '200px';\n    div.style.padding = '1px 2px 3px 4px';\n    div.style.borderStyle = 'solid';\n    div.style.borderWidth = '1px 2px 3px 4px';\n    div.style.boxSizing = 'border-box';\n    var body = document.body || document.documentElement;\n    body.appendChild(div);\n    var style = getStyle(div); // round value for browser zoom. desandro/masonry#928\n\n    isBoxSizeOuter = Math.round(getStyleSize(style.width)) == 200;\n    getSize.isBoxSizeOuter = isBoxSizeOuter;\n    body.removeChild(div);\n  } // -------------------------- getSize -------------------------- //\n\n\n  function getSize(elem) {\n    setup(); // use querySeletor if elem is string\n\n    if (typeof elem == 'string') {\n      elem = document.querySelector(elem);\n    } // do not proceed on non-objects\n\n\n    if (!elem || _typeof(elem) != 'object' || !elem.nodeType) {\n      return;\n    }\n\n    var style = getStyle(elem); // if hidden, everything is 0\n\n    if (style.display == 'none') {\n      return getZeroSize();\n    }\n\n    var size = {};\n    size.width = elem.offsetWidth;\n    size.height = elem.offsetHeight;\n    var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box'; // get all measurements\n\n    for (var i = 0; i < measurementsLength; i++) {\n      var measurement = measurements[i];\n      var value = style[measurement];\n      var num = parseFloat(value); // any 'auto', 'medium' value will be 0\n\n      size[measurement] = !isNaN(num) ? num : 0;\n    }\n\n    var paddingWidth = size.paddingLeft + size.paddingRight;\n    var paddingHeight = size.paddingTop + size.paddingBottom;\n    var marginWidth = size.marginLeft + size.marginRight;\n    var marginHeight = size.marginTop + size.marginBottom;\n    var borderWidth = size.borderLeftWidth + size.borderRightWidth;\n    var borderHeight = size.borderTopWidth + size.borderBottomWidth;\n    var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter; // overwrite width and height if we can get it from style\n\n    var styleWidth = getStyleSize(style.width);\n\n    if (styleWidth !== false) {\n      size.width = styleWidth + ( // add padding and border unless it's already including it\n      isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth);\n    }\n\n    var styleHeight = getStyleSize(style.height);\n\n    if (styleHeight !== false) {\n      size.height = styleHeight + ( // add padding and border unless it's already including it\n      isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight);\n    }\n\n    size.innerWidth = size.width - (paddingWidth + borderWidth);\n    size.innerHeight = size.height - (paddingHeight + borderHeight);\n    size.outerWidth = size.width + marginWidth;\n    size.outerHeight = size.height + marginHeight;\n    return size;\n  }\n\n  return getSize;\n});\n/**\n * matchesSelector v2.0.2\n * matchesSelector( element, '.selector' )\n * MIT license\n */\n\n/*jshint browser: true, strict: true, undef: true, unused: true */\n\n\n(function (window, factory) {\n  /*global define: false, module: false */\n  'use strict'; // universal module definition\n\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('desandro-matches-selector/matches-selector', factory);\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory();\n  } else {\n    // browser global\n    window.matchesSelector = factory();\n  }\n})(window, function factory() {\n  'use strict';\n\n  var matchesMethod = function () {\n    var ElemProto = window.Element.prototype; // check for the standard method name first\n\n    if (ElemProto.matches) {\n      return 'matches';\n    } // check un-prefixed\n\n\n    if (ElemProto.matchesSelector) {\n      return 'matchesSelector';\n    } // check vendor prefixes\n\n\n    var prefixes = ['webkit', 'moz', 'ms', 'o'];\n\n    for (var i = 0; i < prefixes.length; i++) {\n      var prefix = prefixes[i];\n      var method = prefix + 'MatchesSelector';\n\n      if (ElemProto[method]) {\n        return method;\n      }\n    }\n  }();\n\n  return function matchesSelector(elem, selector) {\n    return elem[matchesMethod](selector);\n  };\n});\n/**\n * Fizzy UI utils v2.0.7\n * MIT license\n */\n\n/*jshint browser: true, undef: true, unused: true, strict: true */\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /*jshint strict: false */\n\n  /*globals define, module, require */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('fizzy-ui-utils/utils', ['desandro-matches-selector/matches-selector'], function (matchesSelector) {\n      return factory(window, matchesSelector);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('desandro-matches-selector'));\n  } else {\n    // browser global\n    window.fizzyUIUtils = factory(window, window.matchesSelector);\n  }\n})(window, function factory(window, matchesSelector) {\n  var utils = {}; // ----- extend ----- //\n  // extends objects\n\n  utils.extend = function (a, b) {\n    for (var prop in b) {\n      a[prop] = b[prop];\n    }\n\n    return a;\n  }; // ----- modulo ----- //\n\n\n  utils.modulo = function (num, div) {\n    return (num % div + div) % div;\n  }; // ----- makeArray ----- //\n\n\n  var arraySlice = Array.prototype.slice; // turn element or nodeList into an array\n\n  utils.makeArray = function (obj) {\n    if (Array.isArray(obj)) {\n      // use object if already an array\n      return obj;\n    } // return empty array if undefined or null. #6\n\n\n    if (obj === null || obj === undefined) {\n      return [];\n    }\n\n    var isArrayLike = _typeof(obj) == 'object' && typeof obj.length == 'number';\n\n    if (isArrayLike) {\n      // convert nodeList to array\n      return arraySlice.call(obj);\n    } // array of single index\n\n\n    return [obj];\n  }; // ----- removeFrom ----- //\n\n\n  utils.removeFrom = function (ary, obj) {\n    var index = ary.indexOf(obj);\n\n    if (index != -1) {\n      ary.splice(index, 1);\n    }\n  }; // ----- getParent ----- //\n\n\n  utils.getParent = function (elem, selector) {\n    while (elem.parentNode && elem != document.body) {\n      elem = elem.parentNode;\n\n      if (matchesSelector(elem, selector)) {\n        return elem;\n      }\n    }\n  }; // ----- getQueryElement ----- //\n  // use element as selector string\n\n\n  utils.getQueryElement = function (elem) {\n    if (typeof elem == 'string') {\n      return document.querySelector(elem);\n    }\n\n    return elem;\n  }; // ----- handleEvent ----- //\n  // enable .ontype to trigger from .addEventListener( elem, 'type' )\n\n\n  utils.handleEvent = function (event) {\n    var method = 'on' + event.type;\n\n    if (this[method]) {\n      this[method](event);\n    }\n  }; // ----- filterFindElements ----- //\n\n\n  utils.filterFindElements = function (elems, selector) {\n    // make array of elems\n    elems = utils.makeArray(elems);\n    var ffElems = [];\n    elems.forEach(function (elem) {\n      // check that elem is an actual element\n      if (!(elem instanceof HTMLElement)) {\n        return;\n      } // add elem if no selector\n\n\n      if (!selector) {\n        ffElems.push(elem);\n        return;\n      } // filter & find items if we have a selector\n      // filter\n\n\n      if (matchesSelector(elem, selector)) {\n        ffElems.push(elem);\n      } // find children\n\n\n      var childElems = elem.querySelectorAll(selector); // concat childElems to filterFound array\n\n      for (var i = 0; i < childElems.length; i++) {\n        ffElems.push(childElems[i]);\n      }\n    });\n    return ffElems;\n  }; // ----- debounceMethod ----- //\n\n\n  utils.debounceMethod = function (_class, methodName, threshold) {\n    threshold = threshold || 100; // original method\n\n    var method = _class.prototype[methodName];\n    var timeoutName = methodName + 'Timeout';\n\n    _class.prototype[methodName] = function () {\n      var timeout = this[timeoutName];\n      clearTimeout(timeout);\n      var args = arguments;\n\n      var _this = this;\n\n      this[timeoutName] = setTimeout(function () {\n        method.apply(_this, args);\n        delete _this[timeoutName];\n      }, threshold);\n    };\n  }; // ----- docReady ----- //\n\n\n  utils.docReady = function (callback) {\n    var readyState = document.readyState;\n\n    if (readyState == 'complete' || readyState == 'interactive') {\n      // do async to allow for other scripts to run. metafizzy/flickity#441\n      setTimeout(callback);\n    } else {\n      document.addEventListener('DOMContentLoaded', callback);\n    }\n  }; // ----- htmlInit ----- //\n  // http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/\n\n\n  utils.toDashed = function (str) {\n    return str.replace(/(.)([A-Z])/g, function (match, $1, $2) {\n      return $1 + '-' + $2;\n    }).toLowerCase();\n  };\n\n  var console = window.console;\n  /**\n   * allow user to initialize classes via [data-namespace] or .js-namespace class\n   * htmlInit( Widget, 'widgetName' )\n   * options are parsed from data-namespace-options\n   */\n\n  utils.htmlInit = function (WidgetClass, namespace) {\n    utils.docReady(function () {\n      var dashedNamespace = utils.toDashed(namespace);\n      var dataAttr = 'data-' + dashedNamespace;\n      var dataAttrElems = document.querySelectorAll('[' + dataAttr + ']');\n      var jsDashElems = document.querySelectorAll('.js-' + dashedNamespace);\n      var elems = utils.makeArray(dataAttrElems).concat(utils.makeArray(jsDashElems));\n      var dataOptionsAttr = dataAttr + '-options';\n      var jQuery = window.jQuery;\n      elems.forEach(function (elem) {\n        var attr = elem.getAttribute(dataAttr) || elem.getAttribute(dataOptionsAttr);\n        var options;\n\n        try {\n          options = attr && JSON.parse(attr);\n        } catch (error) {\n          // log error, do not initialize\n          if (console) {\n            console.error('Error parsing ' + dataAttr + ' on ' + elem.className + ': ' + error);\n          }\n\n          return;\n        } // initialize\n\n\n        var instance = new WidgetClass(elem, options); // make available via $().data('namespace')\n\n        if (jQuery) {\n          jQuery.data(elem, namespace, instance);\n        }\n      });\n    });\n  }; // -----  ----- //\n\n\n  return utils;\n}); // Flickity.Cell\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/cell', ['get-size/get-size'], function (getSize) {\n      return factory(window, getSize);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('get-size'));\n  } else {\n    // browser global\n    window.Flickity = window.Flickity || {};\n    window.Flickity.Cell = factory(window, window.getSize);\n  }\n})(window, function factory(window, getSize) {\n  function Cell(elem, parent) {\n    this.element = elem;\n    this.parent = parent;\n    this.create();\n  }\n\n  var proto = Cell.prototype;\n\n  proto.create = function () {\n    this.element.style.position = 'absolute';\n    this.element.setAttribute('aria-hidden', 'true');\n    this.x = 0;\n    this.shift = 0;\n  };\n\n  proto.destroy = function () {\n    // reset style\n    this.unselect();\n    this.element.style.position = '';\n    var side = this.parent.originSide;\n    this.element.style[side] = '';\n  };\n\n  proto.getSize = function () {\n    this.size = getSize(this.element);\n  };\n\n  proto.setPosition = function (x) {\n    this.x = x;\n    this.updateTarget();\n    this.renderPosition(x);\n  }; // setDefaultTarget v1 method, backwards compatibility, remove in v3\n\n\n  proto.updateTarget = proto.setDefaultTarget = function () {\n    var marginProperty = this.parent.originSide == 'left' ? 'marginLeft' : 'marginRight';\n    this.target = this.x + this.size[marginProperty] + this.size.width * this.parent.cellAlign;\n  };\n\n  proto.renderPosition = function (x) {\n    // render position of cell with in slider\n    var side = this.parent.originSide;\n    this.element.style[side] = this.parent.getPositionValue(x);\n  };\n\n  proto.select = function () {\n    this.element.classList.add('is-selected');\n    this.element.removeAttribute('aria-hidden');\n  };\n\n  proto.unselect = function () {\n    this.element.classList.remove('is-selected');\n    this.element.setAttribute('aria-hidden', 'true');\n  };\n  /**\n   * @param {Integer} factor - 0, 1, or -1\n  **/\n\n\n  proto.wrapShift = function (shift) {\n    this.shift = shift;\n    this.renderPosition(this.x + this.parent.slideableWidth * shift);\n  };\n\n  proto.remove = function () {\n    this.element.parentNode.removeChild(this.element);\n  };\n\n  return Cell;\n}); // slide\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/slide', factory);\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory();\n  } else {\n    // browser global\n    window.Flickity = window.Flickity || {};\n    window.Flickity.Slide = factory();\n  }\n})(window, function factory() {\n  'use strict';\n\n  function Slide(parent) {\n    this.parent = parent;\n    this.isOriginLeft = parent.originSide == 'left';\n    this.cells = [];\n    this.outerWidth = 0;\n    this.height = 0;\n  }\n\n  var proto = Slide.prototype;\n\n  proto.addCell = function (cell) {\n    this.cells.push(cell);\n    this.outerWidth += cell.size.outerWidth;\n    this.height = Math.max(cell.size.outerHeight, this.height); // first cell stuff\n\n    if (this.cells.length == 1) {\n      this.x = cell.x; // x comes from first cell\n\n      var beginMargin = this.isOriginLeft ? 'marginLeft' : 'marginRight';\n      this.firstMargin = cell.size[beginMargin];\n    }\n  };\n\n  proto.updateTarget = function () {\n    var endMargin = this.isOriginLeft ? 'marginRight' : 'marginLeft';\n    var lastCell = this.getLastCell();\n    var lastMargin = lastCell ? lastCell.size[endMargin] : 0;\n    var slideWidth = this.outerWidth - (this.firstMargin + lastMargin);\n    this.target = this.x + this.firstMargin + slideWidth * this.parent.cellAlign;\n  };\n\n  proto.getLastCell = function () {\n    return this.cells[this.cells.length - 1];\n  };\n\n  proto.select = function () {\n    this.cells.forEach(function (cell) {\n      cell.select();\n    });\n  };\n\n  proto.unselect = function () {\n    this.cells.forEach(function (cell) {\n      cell.unselect();\n    });\n  };\n\n  proto.getCellElements = function () {\n    return this.cells.map(function (cell) {\n      return cell.element;\n    });\n  };\n\n  return Slide;\n}); // animate\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/animate', ['fizzy-ui-utils/utils'], function (utils) {\n      return factory(window, utils);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('fizzy-ui-utils'));\n  } else {\n    // browser global\n    window.Flickity = window.Flickity || {};\n    window.Flickity.animatePrototype = factory(window, window.fizzyUIUtils);\n  }\n})(window, function factory(window, utils) {\n  // -------------------------- animate -------------------------- //\n  var proto = {};\n\n  proto.startAnimation = function () {\n    if (this.isAnimating) {\n      return;\n    }\n\n    this.isAnimating = true;\n    this.restingFrames = 0;\n    this.animate();\n  };\n\n  proto.animate = function () {\n    this.applyDragForce();\n    this.applySelectedAttraction();\n    var previousX = this.x;\n    this.integratePhysics();\n    this.positionSlider();\n    this.settle(previousX); // animate next frame\n\n    if (this.isAnimating) {\n      var _this = this;\n\n      requestAnimationFrame(function animateFrame() {\n        _this.animate();\n      });\n    }\n  };\n\n  proto.positionSlider = function () {\n    var x = this.x; // wrap position around\n\n    if (this.options.wrapAround && this.cells.length > 1) {\n      x = utils.modulo(x, this.slideableWidth);\n      x = x - this.slideableWidth;\n      this.shiftWrapCells(x);\n    }\n\n    this.setTranslateX(x, this.isAnimating);\n    this.dispatchScrollEvent();\n  };\n\n  proto.setTranslateX = function (x, is3d) {\n    x += this.cursorPosition; // reverse if right-to-left and using transform\n\n    x = this.options.rightToLeft ? -x : x;\n    var translateX = this.getPositionValue(x); // use 3D tranforms for hardware acceleration on iOS\n    // but use 2D when settled, for better font-rendering\n\n    this.slider.style.transform = is3d ? 'translate3d(' + translateX + ',0,0)' : 'translateX(' + translateX + ')';\n  };\n\n  proto.dispatchScrollEvent = function () {\n    var firstSlide = this.slides[0];\n\n    if (!firstSlide) {\n      return;\n    }\n\n    var positionX = -this.x - firstSlide.target;\n    var progress = positionX / this.slidesWidth;\n    this.dispatchEvent('scroll', null, [progress, positionX]);\n  };\n\n  proto.positionSliderAtSelected = function () {\n    if (!this.cells.length) {\n      return;\n    }\n\n    this.x = -this.selectedSlide.target;\n    this.velocity = 0; // stop wobble\n\n    this.positionSlider();\n  };\n\n  proto.getPositionValue = function (position) {\n    if (this.options.percentPosition) {\n      // percent position, round to 2 digits, like 12.34%\n      return Math.round(position / this.size.innerWidth * 10000) * 0.01 + '%';\n    } else {\n      // pixel positioning\n      return Math.round(position) + 'px';\n    }\n  };\n\n  proto.settle = function (previousX) {\n    // keep track of frames where x hasn't moved\n    if (!this.isPointerDown && Math.round(this.x * 100) == Math.round(previousX * 100)) {\n      this.restingFrames++;\n    } // stop animating if resting for 3 or more frames\n\n\n    if (this.restingFrames > 2) {\n      this.isAnimating = false;\n      delete this.isFreeScrolling; // render position with translateX when settled\n\n      this.positionSlider();\n      this.dispatchEvent('settle', null, [this.selectedIndex]);\n    }\n  };\n\n  proto.shiftWrapCells = function (x) {\n    // shift before cells\n    var beforeGap = this.cursorPosition + x;\n\n    this._shiftCells(this.beforeShiftCells, beforeGap, -1); // shift after cells\n\n\n    var afterGap = this.size.innerWidth - (x + this.slideableWidth + this.cursorPosition);\n\n    this._shiftCells(this.afterShiftCells, afterGap, 1);\n  };\n\n  proto._shiftCells = function (cells, gap, shift) {\n    for (var i = 0; i < cells.length; i++) {\n      var cell = cells[i];\n      var cellShift = gap > 0 ? shift : 0;\n      cell.wrapShift(cellShift);\n      gap -= cell.size.outerWidth;\n    }\n  };\n\n  proto._unshiftCells = function (cells) {\n    if (!cells || !cells.length) {\n      return;\n    }\n\n    for (var i = 0; i < cells.length; i++) {\n      cells[i].wrapShift(0);\n    }\n  }; // -------------------------- physics -------------------------- //\n\n\n  proto.integratePhysics = function () {\n    this.x += this.velocity;\n    this.velocity *= this.getFrictionFactor();\n  };\n\n  proto.applyForce = function (force) {\n    this.velocity += force;\n  };\n\n  proto.getFrictionFactor = function () {\n    return 1 - this.options[this.isFreeScrolling ? 'freeScrollFriction' : 'friction'];\n  };\n\n  proto.getRestingPosition = function () {\n    // my thanks to Steven Wittens, who simplified this math greatly\n    return this.x + this.velocity / (1 - this.getFrictionFactor());\n  };\n\n  proto.applyDragForce = function () {\n    if (!this.isDraggable || !this.isPointerDown) {\n      return;\n    } // change the position to drag position by applying force\n\n\n    var dragVelocity = this.dragX - this.x;\n    var dragForce = dragVelocity - this.velocity;\n    this.applyForce(dragForce);\n  };\n\n  proto.applySelectedAttraction = function () {\n    // do not attract if pointer down or no slides\n    var dragDown = this.isDraggable && this.isPointerDown;\n\n    if (dragDown || this.isFreeScrolling || !this.slides.length) {\n      return;\n    }\n\n    var distance = this.selectedSlide.target * -1 - this.x;\n    var force = distance * this.options.selectedAttraction;\n    this.applyForce(force);\n  };\n\n  return proto;\n}); // Flickity main\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/flickity', ['ev-emitter/ev-emitter', 'get-size/get-size', 'fizzy-ui-utils/utils', './cell', './slide', './animate'], function (EvEmitter, getSize, utils, Cell, Slide, animatePrototype) {\n      return factory(window, EvEmitter, getSize, utils, Cell, Slide, animatePrototype);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('ev-emitter'), require('get-size'), require('fizzy-ui-utils'), require('./cell'), require('./slide'), require('./animate'));\n  } else {\n    // browser global\n    var _Flickity = window.Flickity;\n    window.Flickity = factory(window, window.EvEmitter, window.getSize, window.fizzyUIUtils, _Flickity.Cell, _Flickity.Slide, _Flickity.animatePrototype);\n  }\n})(window, function factory(window, EvEmitter, getSize, utils, Cell, Slide, animatePrototype) {\n  // vars\n  var jQuery = window.jQuery;\n  var getComputedStyle = window.getComputedStyle;\n  var console = window.console;\n\n  function moveElements(elems, toElem) {\n    elems = utils.makeArray(elems);\n\n    while (elems.length) {\n      toElem.appendChild(elems.shift());\n    }\n  } // -------------------------- Flickity -------------------------- //\n  // globally unique identifiers\n\n\n  var GUID = 0; // internal store of all Flickity intances\n\n  var instances = {};\n\n  function Flickity(element, options) {\n    var queryElement = utils.getQueryElement(element);\n\n    if (!queryElement) {\n      if (console) {\n        console.error('Bad element for Flickity: ' + (queryElement || element));\n      }\n\n      return;\n    }\n\n    this.element = queryElement; // do not initialize twice on same element\n\n    if (this.element.flickityGUID) {\n      var instance = instances[this.element.flickityGUID];\n      instance.option(options);\n      return instance;\n    } // add jQuery\n\n\n    if (jQuery) {\n      this.$element = jQuery(this.element);\n    } // options\n\n\n    this.options = utils.extend({}, this.constructor.defaults);\n    this.option(options); // kick things off\n\n    this._create();\n  }\n\n  Flickity.defaults = {\n    accessibility: true,\n    // adaptiveHeight: false,\n    cellAlign: 'center',\n    // cellSelector: undefined,\n    // contain: false,\n    freeScrollFriction: 0.075,\n    // friction when free-scrolling\n    friction: 0.28,\n    // friction when selecting\n    namespaceJQueryEvents: true,\n    // initialIndex: 0,\n    percentPosition: true,\n    resize: true,\n    selectedAttraction: 0.025,\n    setGallerySize: true // watchCSS: false,\n    // wrapAround: false\n\n  }; // hash of methods triggered on _create()\n\n  Flickity.createMethods = [];\n  var proto = Flickity.prototype; // inherit EventEmitter\n\n  utils.extend(proto, EvEmitter.prototype);\n\n  proto._create = function () {\n    // add id for Flickity.data\n    var id = this.guid = ++GUID;\n    this.element.flickityGUID = id; // expando\n\n    instances[id] = this; // associate via id\n    // initial properties\n\n    this.selectedIndex = 0; // how many frames slider has been in same position\n\n    this.restingFrames = 0; // initial physics properties\n\n    this.x = 0;\n    this.velocity = 0;\n    this.originSide = this.options.rightToLeft ? 'right' : 'left'; // create viewport & slider\n\n    this.viewport = document.createElement('div');\n    this.viewport.className = 'flickity-viewport';\n\n    this._createSlider();\n\n    if (this.options.resize || this.options.watchCSS) {\n      window.addEventListener('resize', this);\n    } // add listeners from on option\n\n\n    for (var eventName in this.options.on) {\n      var listener = this.options.on[eventName];\n      this.on(eventName, listener);\n    }\n\n    Flickity.createMethods.forEach(function (method) {\n      this[method]();\n    }, this);\n\n    if (this.options.watchCSS) {\n      this.watchCSS();\n    } else {\n      this.activate();\n    }\n  };\n  /**\n   * set options\n   * @param {Object} opts\n   */\n\n\n  proto.option = function (opts) {\n    utils.extend(this.options, opts);\n  };\n\n  proto.activate = function () {\n    if (this.isActive) {\n      return;\n    }\n\n    this.isActive = true;\n    this.element.classList.add('flickity-enabled');\n\n    if (this.options.rightToLeft) {\n      this.element.classList.add('flickity-rtl');\n    }\n\n    this.getSize(); // move initial cell elements so they can be loaded as cells\n\n    var cellElems = this._filterFindCellElements(this.element.children);\n\n    moveElements(cellElems, this.slider);\n    this.viewport.appendChild(this.slider);\n    this.element.appendChild(this.viewport); // get cells from children\n\n    this.reloadCells();\n\n    if (this.options.accessibility) {\n      // allow element to focusable\n      this.element.tabIndex = 0; // listen for key presses\n\n      this.element.addEventListener('keydown', this);\n    }\n\n    this.emitEvent('activate');\n    this.selectInitialIndex(); // flag for initial activation, for using initialIndex\n\n    this.isInitActivated = true; // ready event. #493\n\n    this.dispatchEvent('ready');\n  }; // slider positions the cells\n\n\n  proto._createSlider = function () {\n    // slider element does all the positioning\n    var slider = document.createElement('div');\n    slider.className = 'flickity-slider';\n    slider.style[this.originSide] = 0;\n    this.slider = slider;\n  };\n\n  proto._filterFindCellElements = function (elems) {\n    return utils.filterFindElements(elems, this.options.cellSelector);\n  }; // goes through all children\n\n\n  proto.reloadCells = function () {\n    // collection of item elements\n    this.cells = this._makeCells(this.slider.children);\n    this.positionCells();\n\n    this._getWrapShiftCells();\n\n    this.setGallerySize();\n  };\n  /**\n   * turn elements into Flickity.Cells\n   * @param {Array or NodeList or HTMLElement} elems\n   * @returns {Array} items - collection of new Flickity Cells\n   */\n\n\n  proto._makeCells = function (elems) {\n    var cellElems = this._filterFindCellElements(elems); // create new Flickity for collection\n\n\n    var cells = cellElems.map(function (cellElem) {\n      return new Cell(cellElem, this);\n    }, this);\n    return cells;\n  };\n\n  proto.getLastCell = function () {\n    return this.cells[this.cells.length - 1];\n  };\n\n  proto.getLastSlide = function () {\n    return this.slides[this.slides.length - 1];\n  }; // positions all cells\n\n\n  proto.positionCells = function () {\n    // size all cells\n    this._sizeCells(this.cells); // position all cells\n\n\n    this._positionCells(0);\n  };\n  /**\n   * position certain cells\n   * @param {Integer} index - which cell to start with\n   */\n\n\n  proto._positionCells = function (index) {\n    index = index || 0; // also measure maxCellHeight\n    // start 0 if positioning all cells\n\n    this.maxCellHeight = index ? this.maxCellHeight || 0 : 0;\n    var cellX = 0; // get cellX\n\n    if (index > 0) {\n      var startCell = this.cells[index - 1];\n      cellX = startCell.x + startCell.size.outerWidth;\n    }\n\n    var len = this.cells.length;\n\n    for (var i = index; i < len; i++) {\n      var cell = this.cells[i];\n      cell.setPosition(cellX);\n      cellX += cell.size.outerWidth;\n      this.maxCellHeight = Math.max(cell.size.outerHeight, this.maxCellHeight);\n    } // keep track of cellX for wrap-around\n\n\n    this.slideableWidth = cellX; // slides\n\n    this.updateSlides(); // contain slides target\n\n    this._containSlides(); // update slidesWidth\n\n\n    this.slidesWidth = len ? this.getLastSlide().target - this.slides[0].target : 0;\n  };\n  /**\n   * cell.getSize() on multiple cells\n   * @param {Array} cells\n   */\n\n\n  proto._sizeCells = function (cells) {\n    cells.forEach(function (cell) {\n      cell.getSize();\n    });\n  }; // --------------------------  -------------------------- //\n\n\n  proto.updateSlides = function () {\n    this.slides = [];\n\n    if (!this.cells.length) {\n      return;\n    }\n\n    var slide = new Slide(this);\n    this.slides.push(slide);\n    var isOriginLeft = this.originSide == 'left';\n    var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';\n\n    var canCellFit = this._getCanCellFit();\n\n    this.cells.forEach(function (cell, i) {\n      // just add cell if first cell in slide\n      if (!slide.cells.length) {\n        slide.addCell(cell);\n        return;\n      }\n\n      var slideWidth = slide.outerWidth - slide.firstMargin + (cell.size.outerWidth - cell.size[nextMargin]);\n\n      if (canCellFit.call(this, i, slideWidth)) {\n        slide.addCell(cell);\n      } else {\n        // doesn't fit, new slide\n        slide.updateTarget();\n        slide = new Slide(this);\n        this.slides.push(slide);\n        slide.addCell(cell);\n      }\n    }, this); // last slide\n\n    slide.updateTarget(); // update .selectedSlide\n\n    this.updateSelectedSlide();\n  };\n\n  proto._getCanCellFit = function () {\n    var groupCells = this.options.groupCells;\n\n    if (!groupCells) {\n      return function () {\n        return false;\n      };\n    } else if (typeof groupCells == 'number') {\n      // group by number. 3 -> [0,1,2], [3,4,5], ...\n      var number = parseInt(groupCells, 10);\n      return function (i) {\n        return i % number !== 0;\n      };\n    } // default, group by width of slide\n    // parse '75%\n\n\n    var percentMatch = typeof groupCells == 'string' && groupCells.match(/^(\\d+)%$/);\n    var percent = percentMatch ? parseInt(percentMatch[1], 10) / 100 : 1;\n    return function (i, slideWidth) {\n      return slideWidth <= (this.size.innerWidth + 1) * percent;\n    };\n  }; // alias _init for jQuery plugin .flickity()\n\n\n  proto._init = proto.reposition = function () {\n    this.positionCells();\n    this.positionSliderAtSelected();\n  };\n\n  proto.getSize = function () {\n    this.size = getSize(this.element);\n    this.setCellAlign();\n    this.cursorPosition = this.size.innerWidth * this.cellAlign;\n  };\n\n  var cellAlignShorthands = {\n    // cell align, then based on origin side\n    center: {\n      left: 0.5,\n      right: 0.5\n    },\n    left: {\n      left: 0,\n      right: 1\n    },\n    right: {\n      right: 0,\n      left: 1\n    }\n  };\n\n  proto.setCellAlign = function () {\n    var shorthand = cellAlignShorthands[this.options.cellAlign];\n    this.cellAlign = shorthand ? shorthand[this.originSide] : this.options.cellAlign;\n  };\n\n  proto.setGallerySize = function () {\n    if (this.options.setGallerySize) {\n      var height = this.options.adaptiveHeight && this.selectedSlide ? this.selectedSlide.height : this.maxCellHeight;\n      this.viewport.style.height = height + 'px';\n    }\n  };\n\n  proto._getWrapShiftCells = function () {\n    // only for wrap-around\n    if (!this.options.wrapAround) {\n      return;\n    } // unshift previous cells\n\n\n    this._unshiftCells(this.beforeShiftCells);\n\n    this._unshiftCells(this.afterShiftCells); // get before cells\n    // initial gap\n\n\n    var gapX = this.cursorPosition;\n    var cellIndex = this.cells.length - 1;\n    this.beforeShiftCells = this._getGapCells(gapX, cellIndex, -1); // get after cells\n    // ending gap between last cell and end of gallery viewport\n\n    gapX = this.size.innerWidth - this.cursorPosition; // start cloning at first cell, working forwards\n\n    this.afterShiftCells = this._getGapCells(gapX, 0, 1);\n  };\n\n  proto._getGapCells = function (gapX, cellIndex, increment) {\n    // keep adding cells until the cover the initial gap\n    var cells = [];\n\n    while (gapX > 0) {\n      var cell = this.cells[cellIndex];\n\n      if (!cell) {\n        break;\n      }\n\n      cells.push(cell);\n      cellIndex += increment;\n      gapX -= cell.size.outerWidth;\n    }\n\n    return cells;\n  }; // ----- contain ----- //\n  // contain cell targets so no excess sliding\n\n\n  proto._containSlides = function () {\n    if (!this.options.contain || this.options.wrapAround || !this.cells.length) {\n      return;\n    }\n\n    var isRightToLeft = this.options.rightToLeft;\n    var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';\n    var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';\n    var contentWidth = this.slideableWidth - this.getLastCell().size[endMargin]; // content is less than gallery size\n\n    var isContentSmaller = contentWidth < this.size.innerWidth; // bounds\n\n    var beginBound = this.cursorPosition + this.cells[0].size[beginMargin];\n    var endBound = contentWidth - this.size.innerWidth * (1 - this.cellAlign); // contain each cell target\n\n    this.slides.forEach(function (slide) {\n      if (isContentSmaller) {\n        // all cells fit inside gallery\n        slide.target = contentWidth * this.cellAlign;\n      } else {\n        // contain to bounds\n        slide.target = Math.max(slide.target, beginBound);\n        slide.target = Math.min(slide.target, endBound);\n      }\n    }, this);\n  }; // -----  ----- //\n\n  /**\n   * emits events via eventEmitter and jQuery events\n   * @param {String} type - name of event\n   * @param {Event} event - original event\n   * @param {Array} args - extra arguments\n   */\n\n\n  proto.dispatchEvent = function (type, event, args) {\n    var emitArgs = event ? [event].concat(args) : args;\n    this.emitEvent(type, emitArgs);\n\n    if (jQuery && this.$element) {\n      // default trigger with type if no event\n      type += this.options.namespaceJQueryEvents ? '.flickity' : '';\n      var $event = type;\n\n      if (event) {\n        // create jQuery event\n        var jQEvent = jQuery.Event(event);\n        jQEvent.type = type;\n        $event = jQEvent;\n      }\n\n      this.$element.trigger($event, args);\n    }\n  }; // -------------------------- select -------------------------- //\n\n  /**\n   * @param {Integer} index - index of the slide\n   * @param {Boolean} isWrap - will wrap-around to last/first if at the end\n   * @param {Boolean} isInstant - will immediately set position at selected cell\n   */\n\n\n  proto.select = function (index, isWrap, isInstant) {\n    if (!this.isActive) {\n      return;\n    }\n\n    index = parseInt(index, 10);\n\n    this._wrapSelect(index);\n\n    if (this.options.wrapAround || isWrap) {\n      index = utils.modulo(index, this.slides.length);\n    } // bail if invalid index\n\n\n    if (!this.slides[index]) {\n      return;\n    }\n\n    var prevIndex = this.selectedIndex;\n    this.selectedIndex = index;\n    this.updateSelectedSlide();\n\n    if (isInstant) {\n      this.positionSliderAtSelected();\n    } else {\n      this.startAnimation();\n    }\n\n    if (this.options.adaptiveHeight) {\n      this.setGallerySize();\n    } // events\n\n\n    this.dispatchEvent('select', null, [index]); // change event if new index\n\n    if (index != prevIndex) {\n      this.dispatchEvent('change', null, [index]);\n    } // old v1 event name, remove in v3\n\n\n    this.dispatchEvent('cellSelect');\n  }; // wraps position for wrapAround, to move to closest slide. #113\n\n\n  proto._wrapSelect = function (index) {\n    var len = this.slides.length;\n    var isWrapping = this.options.wrapAround && len > 1;\n\n    if (!isWrapping) {\n      return index;\n    }\n\n    var wrapIndex = utils.modulo(index, len); // go to shortest\n\n    var delta = Math.abs(wrapIndex - this.selectedIndex);\n    var backWrapDelta = Math.abs(wrapIndex + len - this.selectedIndex);\n    var forewardWrapDelta = Math.abs(wrapIndex - len - this.selectedIndex);\n\n    if (!this.isDragSelect && backWrapDelta < delta) {\n      index += len;\n    } else if (!this.isDragSelect && forewardWrapDelta < delta) {\n      index -= len;\n    } // wrap position so slider is within normal area\n\n\n    if (index < 0) {\n      this.x -= this.slideableWidth;\n    } else if (index >= len) {\n      this.x += this.slideableWidth;\n    }\n  };\n\n  proto.previous = function (isWrap, isInstant) {\n    this.select(this.selectedIndex - 1, isWrap, isInstant);\n  };\n\n  proto.next = function (isWrap, isInstant) {\n    this.select(this.selectedIndex + 1, isWrap, isInstant);\n  };\n\n  proto.updateSelectedSlide = function () {\n    var slide = this.slides[this.selectedIndex]; // selectedIndex could be outside of slides, if triggered before resize()\n\n    if (!slide) {\n      return;\n    } // unselect previous selected slide\n\n\n    this.unselectSelectedSlide(); // update new selected slide\n\n    this.selectedSlide = slide;\n    slide.select();\n    this.selectedCells = slide.cells;\n    this.selectedElements = slide.getCellElements(); // HACK: selectedCell & selectedElement is first cell in slide, backwards compatibility\n    // Remove in v3?\n\n    this.selectedCell = slide.cells[0];\n    this.selectedElement = this.selectedElements[0];\n  };\n\n  proto.unselectSelectedSlide = function () {\n    if (this.selectedSlide) {\n      this.selectedSlide.unselect();\n    }\n  };\n\n  proto.selectInitialIndex = function () {\n    var initialIndex = this.options.initialIndex; // already activated, select previous selectedIndex\n\n    if (this.isInitActivated) {\n      this.select(this.selectedIndex, false, true);\n      return;\n    } // select with selector string\n\n\n    if (initialIndex && typeof initialIndex == 'string') {\n      var cell = this.queryCell(initialIndex);\n\n      if (cell) {\n        this.selectCell(initialIndex, false, true);\n        return;\n      }\n    }\n\n    var index = 0; // select with number\n\n    if (initialIndex && this.slides[initialIndex]) {\n      index = initialIndex;\n    } // select instantly\n\n\n    this.select(index, false, true);\n  };\n  /**\n   * select slide from number or cell element\n   * @param {Element or Number} elem\n   */\n\n\n  proto.selectCell = function (value, isWrap, isInstant) {\n    // get cell\n    var cell = this.queryCell(value);\n\n    if (!cell) {\n      return;\n    }\n\n    var index = this.getCellSlideIndex(cell);\n    this.select(index, isWrap, isInstant);\n  };\n\n  proto.getCellSlideIndex = function (cell) {\n    // get index of slides that has cell\n    for (var i = 0; i < this.slides.length; i++) {\n      var slide = this.slides[i];\n      var index = slide.cells.indexOf(cell);\n\n      if (index != -1) {\n        return i;\n      }\n    }\n  }; // -------------------------- get cells -------------------------- //\n\n  /**\n   * get Flickity.Cell, given an Element\n   * @param {Element} elem\n   * @returns {Flickity.Cell} item\n   */\n\n\n  proto.getCell = function (elem) {\n    // loop through cells to get the one that matches\n    for (var i = 0; i < this.cells.length; i++) {\n      var cell = this.cells[i];\n\n      if (cell.element == elem) {\n        return cell;\n      }\n    }\n  };\n  /**\n   * get collection of Flickity.Cells, given Elements\n   * @param {Element, Array, NodeList} elems\n   * @returns {Array} cells - Flickity.Cells\n   */\n\n\n  proto.getCells = function (elems) {\n    elems = utils.makeArray(elems);\n    var cells = [];\n    elems.forEach(function (elem) {\n      var cell = this.getCell(elem);\n\n      if (cell) {\n        cells.push(cell);\n      }\n    }, this);\n    return cells;\n  };\n  /**\n   * get cell elements\n   * @returns {Array} cellElems\n   */\n\n\n  proto.getCellElements = function () {\n    return this.cells.map(function (cell) {\n      return cell.element;\n    });\n  };\n  /**\n   * get parent cell from an element\n   * @param {Element} elem\n   * @returns {Flickit.Cell} cell\n   */\n\n\n  proto.getParentCell = function (elem) {\n    // first check if elem is cell\n    var cell = this.getCell(elem);\n\n    if (cell) {\n      return cell;\n    } // try to get parent cell elem\n\n\n    elem = utils.getParent(elem, '.flickity-slider > *');\n    return this.getCell(elem);\n  };\n  /**\n   * get cells adjacent to a slide\n   * @param {Integer} adjCount - number of adjacent slides\n   * @param {Integer} index - index of slide to start\n   * @returns {Array} cells - array of Flickity.Cells\n   */\n\n\n  proto.getAdjacentCellElements = function (adjCount, index) {\n    if (!adjCount) {\n      return this.selectedSlide.getCellElements();\n    }\n\n    index = index === undefined ? this.selectedIndex : index;\n    var len = this.slides.length;\n\n    if (1 + adjCount * 2 >= len) {\n      return this.getCellElements();\n    }\n\n    var cellElems = [];\n\n    for (var i = index - adjCount; i <= index + adjCount; i++) {\n      var slideIndex = this.options.wrapAround ? utils.modulo(i, len) : i;\n      var slide = this.slides[slideIndex];\n\n      if (slide) {\n        cellElems = cellElems.concat(slide.getCellElements());\n      }\n    }\n\n    return cellElems;\n  };\n  /**\n   * select slide from number or cell element\n   * @param {Element, Selector String, or Number} selector\n   */\n\n\n  proto.queryCell = function (selector) {\n    if (typeof selector == 'number') {\n      // use number as index\n      return this.cells[selector];\n    }\n\n    if (typeof selector == 'string') {\n      // do not select invalid selectors from hash: #123, #/. #791\n      if (selector.match(/^[#\\.]?[\\d\\/]/)) {\n        return;\n      } // use string as selector, get element\n\n\n      selector = this.element.querySelector(selector);\n    } // get cell from element\n\n\n    return this.getCell(selector);\n  }; // -------------------------- events -------------------------- //\n\n\n  proto.uiChange = function () {\n    this.emitEvent('uiChange');\n  }; // keep focus on element when child UI elements are clicked\n\n\n  proto.childUIPointerDown = function (event) {\n    // HACK iOS does not allow touch events to bubble up?!\n    if (event.type != 'touchstart') {\n      event.preventDefault();\n    }\n\n    this.focus();\n  }; // ----- resize ----- //\n\n\n  proto.onresize = function () {\n    this.watchCSS();\n    this.resize();\n  };\n\n  utils.debounceMethod(Flickity, 'onresize', 150);\n\n  proto.resize = function () {\n    if (!this.isActive) {\n      return;\n    }\n\n    this.getSize(); // wrap values\n\n    if (this.options.wrapAround) {\n      this.x = utils.modulo(this.x, this.slideableWidth);\n    }\n\n    this.positionCells();\n\n    this._getWrapShiftCells();\n\n    this.setGallerySize();\n    this.emitEvent('resize'); // update selected index for group slides, instant\n    // TODO: position can be lost between groups of various numbers\n\n    var selectedElement = this.selectedElements && this.selectedElements[0];\n    this.selectCell(selectedElement, false, true);\n  }; // watches the :after property, activates/deactivates\n\n\n  proto.watchCSS = function () {\n    var watchOption = this.options.watchCSS;\n\n    if (!watchOption) {\n      return;\n    }\n\n    var afterContent = getComputedStyle(this.element, ':after').content; // activate if :after { content: 'flickity' }\n\n    if (afterContent.indexOf('flickity') != -1) {\n      this.activate();\n    } else {\n      this.deactivate();\n    }\n  }; // ----- keydown ----- //\n  // go previous/next if left/right keys pressed\n\n\n  proto.onkeydown = function (event) {\n    // only work if element is in focus\n    var isNotFocused = document.activeElement && document.activeElement != this.element;\n\n    if (!this.options.accessibility || isNotFocused) {\n      return;\n    }\n\n    var handler = Flickity.keyboardHandlers[event.keyCode];\n\n    if (handler) {\n      handler.call(this);\n    }\n  };\n\n  Flickity.keyboardHandlers = {\n    // left arrow\n    37: function _() {\n      var leftMethod = this.options.rightToLeft ? 'next' : 'previous';\n      this.uiChange();\n      this[leftMethod]();\n    },\n    // right arrow\n    39: function _() {\n      var rightMethod = this.options.rightToLeft ? 'previous' : 'next';\n      this.uiChange();\n      this[rightMethod]();\n    }\n  }; // ----- focus ----- //\n\n  proto.focus = function () {\n    // TODO remove scrollTo once focus options gets more support\n    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#Browser_compatibility\n    var prevScrollY = window.pageYOffset;\n    this.element.focus({\n      preventScroll: true\n    }); // hack to fix scroll jump after focus, #76\n\n    if (window.pageYOffset != prevScrollY) {\n      window.scrollTo(window.pageXOffset, prevScrollY);\n    }\n  }; // -------------------------- destroy -------------------------- //\n  // deactivate all Flickity functionality, but keep stuff available\n\n\n  proto.deactivate = function () {\n    if (!this.isActive) {\n      return;\n    }\n\n    this.element.classList.remove('flickity-enabled');\n    this.element.classList.remove('flickity-rtl');\n    this.unselectSelectedSlide(); // destroy cells\n\n    this.cells.forEach(function (cell) {\n      cell.destroy();\n    });\n    this.element.removeChild(this.viewport); // move child elements back into element\n\n    moveElements(this.slider.children, this.element);\n\n    if (this.options.accessibility) {\n      this.element.removeAttribute('tabIndex');\n      this.element.removeEventListener('keydown', this);\n    } // set flags\n\n\n    this.isActive = false;\n    this.emitEvent('deactivate');\n  };\n\n  proto.destroy = function () {\n    this.deactivate();\n    window.removeEventListener('resize', this);\n    this.allOff();\n    this.emitEvent('destroy');\n\n    if (jQuery && this.$element) {\n      jQuery.removeData(this.element, 'flickity');\n    }\n\n    delete this.element.flickityGUID;\n    delete instances[this.guid];\n  }; // -------------------------- prototype -------------------------- //\n\n\n  utils.extend(proto, animatePrototype); // -------------------------- extras -------------------------- //\n\n  /**\n   * get Flickity instance from element\n   * @param {Element} elem\n   * @returns {Flickity}\n   */\n\n  Flickity.data = function (elem) {\n    elem = utils.getQueryElement(elem);\n    var id = elem && elem.flickityGUID;\n    return id && instances[id];\n  };\n\n  utils.htmlInit(Flickity, 'flickity');\n\n  if (jQuery && jQuery.bridget) {\n    jQuery.bridget('flickity', Flickity);\n  } // set internal jQuery, for Webpack + jQuery v3, #478\n\n\n  Flickity.setJQuery = function (jq) {\n    jQuery = jq;\n  };\n\n  Flickity.Cell = Cell;\n  Flickity.Slide = Slide;\n  return Flickity;\n});\n/*!\n * Unipointer v2.3.0\n * base class for doing one thing with pointer event\n * MIT license\n */\n\n/*jshint browser: true, undef: true, unused: true, strict: true */\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n\n  /*global define, module, require */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('unipointer/unipointer', ['ev-emitter/ev-emitter'], function (EvEmitter) {\n      return factory(window, EvEmitter);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('ev-emitter'));\n  } else {\n    // browser global\n    window.Unipointer = factory(window, window.EvEmitter);\n  }\n})(window, function factory(window, EvEmitter) {\n  function noop() {}\n\n  function Unipointer() {} // inherit EvEmitter\n\n\n  var proto = Unipointer.prototype = Object.create(EvEmitter.prototype);\n\n  proto.bindStartEvent = function (elem) {\n    this._bindStartEvent(elem, true);\n  };\n\n  proto.unbindStartEvent = function (elem) {\n    this._bindStartEvent(elem, false);\n  };\n  /**\n   * Add or remove start event\n   * @param {Boolean} isAdd - remove if falsey\n   */\n\n\n  proto._bindStartEvent = function (elem, isAdd) {\n    // munge isAdd, default to true\n    isAdd = isAdd === undefined ? true : isAdd;\n    var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener'; // default to mouse events\n\n    var startEvent = 'mousedown';\n\n    if (window.PointerEvent) {\n      // Pointer Events\n      startEvent = 'pointerdown';\n    } else if ('ontouchstart' in window) {\n      // Touch Events. iOS Safari\n      startEvent = 'touchstart';\n    }\n\n    elem[bindMethod](startEvent, this);\n  }; // trigger handler methods for events\n\n\n  proto.handleEvent = function (event) {\n    var method = 'on' + event.type;\n\n    if (this[method]) {\n      this[method](event);\n    }\n  }; // returns the touch that we're keeping track of\n\n\n  proto.getTouch = function (touches) {\n    for (var i = 0; i < touches.length; i++) {\n      var touch = touches[i];\n\n      if (touch.identifier == this.pointerIdentifier) {\n        return touch;\n      }\n    }\n  }; // ----- start event ----- //\n\n\n  proto.onmousedown = function (event) {\n    // dismiss clicks from right or middle buttons\n    var button = event.button;\n\n    if (button && button !== 0 && button !== 1) {\n      return;\n    }\n\n    this._pointerDown(event, event);\n  };\n\n  proto.ontouchstart = function (event) {\n    this._pointerDown(event, event.changedTouches[0]);\n  };\n\n  proto.onpointerdown = function (event) {\n    this._pointerDown(event, event);\n  };\n  /**\n   * pointer start\n   * @param {Event} event\n   * @param {Event or Touch} pointer\n   */\n\n\n  proto._pointerDown = function (event, pointer) {\n    // dismiss right click and other pointers\n    // button = 0 is okay, 1-4 not\n    if (event.button || this.isPointerDown) {\n      return;\n    }\n\n    this.isPointerDown = true; // save pointer identifier to match up touch events\n\n    this.pointerIdentifier = pointer.pointerId !== undefined ? // pointerId for pointer events, touch.indentifier for touch events\n    pointer.pointerId : pointer.identifier;\n    this.pointerDown(event, pointer);\n  };\n\n  proto.pointerDown = function (event, pointer) {\n    this._bindPostStartEvents(event);\n\n    this.emitEvent('pointerDown', [event, pointer]);\n  }; // hash of events to be bound after start event\n\n\n  var postStartEvents = {\n    mousedown: ['mousemove', 'mouseup'],\n    touchstart: ['touchmove', 'touchend', 'touchcancel'],\n    pointerdown: ['pointermove', 'pointerup', 'pointercancel']\n  };\n\n  proto._bindPostStartEvents = function (event) {\n    if (!event) {\n      return;\n    } // get proper events to match start event\n\n\n    var events = postStartEvents[event.type]; // bind events to node\n\n    events.forEach(function (eventName) {\n      window.addEventListener(eventName, this);\n    }, this); // save these arguments\n\n    this._boundPointerEvents = events;\n  };\n\n  proto._unbindPostStartEvents = function () {\n    // check for _boundEvents, in case dragEnd triggered twice (old IE8 bug)\n    if (!this._boundPointerEvents) {\n      return;\n    }\n\n    this._boundPointerEvents.forEach(function (eventName) {\n      window.removeEventListener(eventName, this);\n    }, this);\n\n    delete this._boundPointerEvents;\n  }; // ----- move event ----- //\n\n\n  proto.onmousemove = function (event) {\n    this._pointerMove(event, event);\n  };\n\n  proto.onpointermove = function (event) {\n    if (event.pointerId == this.pointerIdentifier) {\n      this._pointerMove(event, event);\n    }\n  };\n\n  proto.ontouchmove = function (event) {\n    var touch = this.getTouch(event.changedTouches);\n\n    if (touch) {\n      this._pointerMove(event, touch);\n    }\n  };\n  /**\n   * pointer move\n   * @param {Event} event\n   * @param {Event or Touch} pointer\n   * @private\n   */\n\n\n  proto._pointerMove = function (event, pointer) {\n    this.pointerMove(event, pointer);\n  }; // public\n\n\n  proto.pointerMove = function (event, pointer) {\n    this.emitEvent('pointerMove', [event, pointer]);\n  }; // ----- end event ----- //\n\n\n  proto.onmouseup = function (event) {\n    this._pointerUp(event, event);\n  };\n\n  proto.onpointerup = function (event) {\n    if (event.pointerId == this.pointerIdentifier) {\n      this._pointerUp(event, event);\n    }\n  };\n\n  proto.ontouchend = function (event) {\n    var touch = this.getTouch(event.changedTouches);\n\n    if (touch) {\n      this._pointerUp(event, touch);\n    }\n  };\n  /**\n   * pointer up\n   * @param {Event} event\n   * @param {Event or Touch} pointer\n   * @private\n   */\n\n\n  proto._pointerUp = function (event, pointer) {\n    this._pointerDone();\n\n    this.pointerUp(event, pointer);\n  }; // public\n\n\n  proto.pointerUp = function (event, pointer) {\n    this.emitEvent('pointerUp', [event, pointer]);\n  }; // ----- pointer done ----- //\n  // triggered on pointer up & pointer cancel\n\n\n  proto._pointerDone = function () {\n    this._pointerReset();\n\n    this._unbindPostStartEvents();\n\n    this.pointerDone();\n  };\n\n  proto._pointerReset = function () {\n    // reset properties\n    this.isPointerDown = false;\n    delete this.pointerIdentifier;\n  };\n\n  proto.pointerDone = noop; // ----- pointer cancel ----- //\n\n  proto.onpointercancel = function (event) {\n    if (event.pointerId == this.pointerIdentifier) {\n      this._pointerCancel(event, event);\n    }\n  };\n\n  proto.ontouchcancel = function (event) {\n    var touch = this.getTouch(event.changedTouches);\n\n    if (touch) {\n      this._pointerCancel(event, touch);\n    }\n  };\n  /**\n   * pointer cancel\n   * @param {Event} event\n   * @param {Event or Touch} pointer\n   * @private\n   */\n\n\n  proto._pointerCancel = function (event, pointer) {\n    this._pointerDone();\n\n    this.pointerCancel(event, pointer);\n  }; // public\n\n\n  proto.pointerCancel = function (event, pointer) {\n    this.emitEvent('pointerCancel', [event, pointer]);\n  }; // -----  ----- //\n  // utility function for getting x/y coords from event\n\n\n  Unipointer.getPointerPoint = function (pointer) {\n    return {\n      x: pointer.pageX,\n      y: pointer.pageY\n    };\n  }; // -----  ----- //\n\n\n  return Unipointer;\n});\n/*!\n * Unidragger v2.3.0\n * Draggable base class\n * MIT license\n */\n\n/*jshint browser: true, unused: true, undef: true, strict: true */\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /*jshint strict: false */\n\n  /*globals define, module, require */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('unidragger/unidragger', ['unipointer/unipointer'], function (Unipointer) {\n      return factory(window, Unipointer);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('unipointer'));\n  } else {\n    // browser global\n    window.Unidragger = factory(window, window.Unipointer);\n  }\n})(window, function factory(window, Unipointer) {\n  // -------------------------- Unidragger -------------------------- //\n  function Unidragger() {} // inherit Unipointer & EvEmitter\n\n\n  var proto = Unidragger.prototype = Object.create(Unipointer.prototype); // ----- bind start ----- //\n\n  proto.bindHandles = function () {\n    this._bindHandles(true);\n  };\n\n  proto.unbindHandles = function () {\n    this._bindHandles(false);\n  };\n  /**\n   * Add or remove start event\n   * @param {Boolean} isAdd\n   */\n\n\n  proto._bindHandles = function (isAdd) {\n    // munge isAdd, default to true\n    isAdd = isAdd === undefined ? true : isAdd; // bind each handle\n\n    var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener';\n    var touchAction = isAdd ? this._touchActionValue : '';\n\n    for (var i = 0; i < this.handles.length; i++) {\n      var handle = this.handles[i];\n\n      this._bindStartEvent(handle, isAdd);\n\n      handle[bindMethod]('click', this); // touch-action: none to override browser touch gestures. metafizzy/flickity#540\n\n      if (window.PointerEvent) {\n        handle.style.touchAction = touchAction;\n      }\n    }\n  }; // prototype so it can be overwriteable by Flickity\n\n\n  proto._touchActionValue = 'none'; // ----- start event ----- //\n\n  /**\n   * pointer start\n   * @param {Event} event\n   * @param {Event or Touch} pointer\n   */\n\n  proto.pointerDown = function (event, pointer) {\n    var isOkay = this.okayPointerDown(event);\n\n    if (!isOkay) {\n      return;\n    } // track start event position\n\n\n    this.pointerDownPointer = pointer;\n    event.preventDefault();\n    this.pointerDownBlur(); // bind move and end events\n\n    this._bindPostStartEvents(event);\n\n    this.emitEvent('pointerDown', [event, pointer]);\n  }; // nodes that have text fields\n\n\n  var cursorNodes = {\n    TEXTAREA: true,\n    INPUT: true,\n    SELECT: true,\n    OPTION: true\n  }; // input types that do not have text fields\n\n  var clickTypes = {\n    radio: true,\n    checkbox: true,\n    button: true,\n    submit: true,\n    image: true,\n    file: true\n  }; // dismiss inputs with text fields. flickity#403, flickity#404\n\n  proto.okayPointerDown = function (event) {\n    var isCursorNode = cursorNodes[event.target.nodeName];\n    var isClickType = clickTypes[event.target.type];\n    var isOkay = !isCursorNode || isClickType;\n\n    if (!isOkay) {\n      this._pointerReset();\n    }\n\n    return isOkay;\n  }; // kludge to blur previously focused input\n\n\n  proto.pointerDownBlur = function () {\n    var focused = document.activeElement; // do not blur body for IE10, metafizzy/flickity#117\n\n    var canBlur = focused && focused.blur && focused != document.body;\n\n    if (canBlur) {\n      focused.blur();\n    }\n  }; // ----- move event ----- //\n\n  /**\n   * drag move\n   * @param {Event} event\n   * @param {Event or Touch} pointer\n   */\n\n\n  proto.pointerMove = function (event, pointer) {\n    var moveVector = this._dragPointerMove(event, pointer);\n\n    this.emitEvent('pointerMove', [event, pointer, moveVector]);\n\n    this._dragMove(event, pointer, moveVector);\n  }; // base pointer move logic\n\n\n  proto._dragPointerMove = function (event, pointer) {\n    var moveVector = {\n      x: pointer.pageX - this.pointerDownPointer.pageX,\n      y: pointer.pageY - this.pointerDownPointer.pageY\n    }; // start drag if pointer has moved far enough to start drag\n\n    if (!this.isDragging && this.hasDragStarted(moveVector)) {\n      this._dragStart(event, pointer);\n    }\n\n    return moveVector;\n  }; // condition if pointer has moved far enough to start drag\n\n\n  proto.hasDragStarted = function (moveVector) {\n    return Math.abs(moveVector.x) > 3 || Math.abs(moveVector.y) > 3;\n  }; // ----- end event ----- //\n\n  /**\n   * pointer up\n   * @param {Event} event\n   * @param {Event or Touch} pointer\n   */\n\n\n  proto.pointerUp = function (event, pointer) {\n    this.emitEvent('pointerUp', [event, pointer]);\n\n    this._dragPointerUp(event, pointer);\n  };\n\n  proto._dragPointerUp = function (event, pointer) {\n    if (this.isDragging) {\n      this._dragEnd(event, pointer);\n    } else {\n      // pointer didn't move enough for drag to start\n      this._staticClick(event, pointer);\n    }\n  }; // -------------------------- drag -------------------------- //\n  // dragStart\n\n\n  proto._dragStart = function (event, pointer) {\n    this.isDragging = true; // prevent clicks\n\n    this.isPreventingClicks = true;\n    this.dragStart(event, pointer);\n  };\n\n  proto.dragStart = function (event, pointer) {\n    this.emitEvent('dragStart', [event, pointer]);\n  }; // dragMove\n\n\n  proto._dragMove = function (event, pointer, moveVector) {\n    // do not drag if not dragging yet\n    if (!this.isDragging) {\n      return;\n    }\n\n    this.dragMove(event, pointer, moveVector);\n  };\n\n  proto.dragMove = function (event, pointer, moveVector) {\n    event.preventDefault();\n    this.emitEvent('dragMove', [event, pointer, moveVector]);\n  }; // dragEnd\n\n\n  proto._dragEnd = function (event, pointer) {\n    // set flags\n    this.isDragging = false; // re-enable clicking async\n\n    setTimeout(function () {\n      delete this.isPreventingClicks;\n    }.bind(this));\n    this.dragEnd(event, pointer);\n  };\n\n  proto.dragEnd = function (event, pointer) {\n    this.emitEvent('dragEnd', [event, pointer]);\n  }; // ----- onclick ----- //\n  // handle all clicks and prevent clicks when dragging\n\n\n  proto.onclick = function (event) {\n    if (this.isPreventingClicks) {\n      event.preventDefault();\n    }\n  }; // ----- staticClick ----- //\n  // triggered after pointer down & up with no/tiny movement\n\n\n  proto._staticClick = function (event, pointer) {\n    // ignore emulated mouse up clicks\n    if (this.isIgnoringMouseUp && event.type == 'mouseup') {\n      return;\n    }\n\n    this.staticClick(event, pointer); // set flag for emulated clicks 300ms after touchend\n\n    if (event.type != 'mouseup') {\n      this.isIgnoringMouseUp = true; // reset flag after 300ms\n\n      setTimeout(function () {\n        delete this.isIgnoringMouseUp;\n      }.bind(this), 400);\n    }\n  };\n\n  proto.staticClick = function (event, pointer) {\n    this.emitEvent('staticClick', [event, pointer]);\n  }; // ----- utils ----- //\n\n\n  Unidragger.getPointerPoint = Unipointer.getPointerPoint; // -----  ----- //\n\n  return Unidragger;\n}); // drag\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/drag', ['./flickity', 'unidragger/unidragger', 'fizzy-ui-utils/utils'], function (Flickity, Unidragger, utils) {\n      return factory(window, Flickity, Unidragger, utils);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('./flickity'), require('unidragger'), require('fizzy-ui-utils'));\n  } else {\n    // browser global\n    window.Flickity = factory(window, window.Flickity, window.Unidragger, window.fizzyUIUtils);\n  }\n})(window, function factory(window, Flickity, Unidragger, utils) {\n  // ----- defaults ----- //\n  utils.extend(Flickity.defaults, {\n    draggable: '>1',\n    dragThreshold: 3\n  }); // ----- create ----- //\n\n  Flickity.createMethods.push('_createDrag'); // -------------------------- drag prototype -------------------------- //\n\n  var proto = Flickity.prototype;\n  utils.extend(proto, Unidragger.prototype);\n  proto._touchActionValue = 'pan-y'; // --------------------------  -------------------------- //\n\n  var isTouch = ('createTouch' in document);\n  var isTouchmoveScrollCanceled = false;\n\n  proto._createDrag = function () {\n    this.on('activate', this.onActivateDrag);\n    this.on('uiChange', this._uiChangeDrag);\n    this.on('deactivate', this.onDeactivateDrag);\n    this.on('cellChange', this.updateDraggable); // TODO updateDraggable on resize? if groupCells & slides change\n    // HACK - add seemingly innocuous handler to fix iOS 10 scroll behavior\n    // #457, RubaXa/Sortable#973\n\n    if (isTouch && !isTouchmoveScrollCanceled) {\n      window.addEventListener('touchmove', function () {});\n      isTouchmoveScrollCanceled = true;\n    }\n  };\n\n  proto.onActivateDrag = function () {\n    this.handles = [this.viewport];\n    this.bindHandles();\n    this.updateDraggable();\n  };\n\n  proto.onDeactivateDrag = function () {\n    this.unbindHandles();\n    this.element.classList.remove('is-draggable');\n  };\n\n  proto.updateDraggable = function () {\n    // disable dragging if less than 2 slides. #278\n    if (this.options.draggable == '>1') {\n      this.isDraggable = this.slides.length > 1;\n    } else {\n      this.isDraggable = this.options.draggable;\n    }\n\n    if (this.isDraggable) {\n      this.element.classList.add('is-draggable');\n    } else {\n      this.element.classList.remove('is-draggable');\n    }\n  }; // backwards compatibility\n\n\n  proto.bindDrag = function () {\n    this.options.draggable = true;\n    this.updateDraggable();\n  };\n\n  proto.unbindDrag = function () {\n    this.options.draggable = false;\n    this.updateDraggable();\n  };\n\n  proto._uiChangeDrag = function () {\n    delete this.isFreeScrolling;\n  }; // -------------------------- pointer events -------------------------- //\n\n\n  proto.pointerDown = function (event, pointer) {\n    if (!this.isDraggable) {\n      this._pointerDownDefault(event, pointer);\n\n      return;\n    }\n\n    var isOkay = this.okayPointerDown(event);\n\n    if (!isOkay) {\n      return;\n    }\n\n    this._pointerDownPreventDefault(event);\n\n    this.pointerDownFocus(event); // blur\n\n    if (document.activeElement != this.element) {\n      // do not blur if already focused\n      this.pointerDownBlur();\n    } // stop if it was moving\n\n\n    this.dragX = this.x;\n    this.viewport.classList.add('is-pointer-down'); // track scrolling\n\n    this.pointerDownScroll = getScrollPosition();\n    window.addEventListener('scroll', this);\n\n    this._pointerDownDefault(event, pointer);\n  }; // default pointerDown logic, used for staticClick\n\n\n  proto._pointerDownDefault = function (event, pointer) {\n    // track start event position\n    // Safari 9 overrides pageX and pageY. These values needs to be copied. #779\n    this.pointerDownPointer = {\n      pageX: pointer.pageX,\n      pageY: pointer.pageY\n    }; // bind move and end events\n\n    this._bindPostStartEvents(event);\n\n    this.dispatchEvent('pointerDown', event, [pointer]);\n  };\n\n  var focusNodes = {\n    INPUT: true,\n    TEXTAREA: true,\n    SELECT: true\n  };\n\n  proto.pointerDownFocus = function (event) {\n    var isFocusNode = focusNodes[event.target.nodeName];\n\n    if (!isFocusNode) {\n      this.focus();\n    }\n  };\n\n  proto._pointerDownPreventDefault = function (event) {\n    var isTouchStart = event.type == 'touchstart';\n    var isTouchPointer = event.pointerType == 'touch';\n    var isFocusNode = focusNodes[event.target.nodeName];\n\n    if (!isTouchStart && !isTouchPointer && !isFocusNode) {\n      event.preventDefault();\n    }\n  }; // ----- move ----- //\n\n\n  proto.hasDragStarted = function (moveVector) {\n    return Math.abs(moveVector.x) > this.options.dragThreshold;\n  }; // ----- up ----- //\n\n\n  proto.pointerUp = function (event, pointer) {\n    delete this.isTouchScrolling;\n    this.viewport.classList.remove('is-pointer-down');\n    this.dispatchEvent('pointerUp', event, [pointer]);\n\n    this._dragPointerUp(event, pointer);\n  };\n\n  proto.pointerDone = function () {\n    window.removeEventListener('scroll', this);\n    delete this.pointerDownScroll;\n  }; // -------------------------- dragging -------------------------- //\n\n\n  proto.dragStart = function (event, pointer) {\n    if (!this.isDraggable) {\n      return;\n    }\n\n    this.dragStartPosition = this.x;\n    this.startAnimation();\n    window.removeEventListener('scroll', this);\n    this.dispatchEvent('dragStart', event, [pointer]);\n  };\n\n  proto.pointerMove = function (event, pointer) {\n    var moveVector = this._dragPointerMove(event, pointer);\n\n    this.dispatchEvent('pointerMove', event, [pointer, moveVector]);\n\n    this._dragMove(event, pointer, moveVector);\n  };\n\n  proto.dragMove = function (event, pointer, moveVector) {\n    if (!this.isDraggable) {\n      return;\n    }\n\n    event.preventDefault();\n    this.previousDragX = this.dragX; // reverse if right-to-left\n\n    var direction = this.options.rightToLeft ? -1 : 1;\n\n    if (this.options.wrapAround) {\n      // wrap around move. #589\n      moveVector.x = moveVector.x % this.slideableWidth;\n    }\n\n    var dragX = this.dragStartPosition + moveVector.x * direction;\n\n    if (!this.options.wrapAround && this.slides.length) {\n      // slow drag\n      var originBound = Math.max(-this.slides[0].target, this.dragStartPosition);\n      dragX = dragX > originBound ? (dragX + originBound) * 0.5 : dragX;\n      var endBound = Math.min(-this.getLastSlide().target, this.dragStartPosition);\n      dragX = dragX < endBound ? (dragX + endBound) * 0.5 : dragX;\n    }\n\n    this.dragX = dragX;\n    this.dragMoveTime = new Date();\n    this.dispatchEvent('dragMove', event, [pointer, moveVector]);\n  };\n\n  proto.dragEnd = function (event, pointer) {\n    if (!this.isDraggable) {\n      return;\n    }\n\n    if (this.options.freeScroll) {\n      this.isFreeScrolling = true;\n    } // set selectedIndex based on where flick will end up\n\n\n    var index = this.dragEndRestingSelect();\n\n    if (this.options.freeScroll && !this.options.wrapAround) {\n      // if free-scroll & not wrap around\n      // do not free-scroll if going outside of bounding slides\n      // so bounding slides can attract slider, and keep it in bounds\n      var restingX = this.getRestingPosition();\n      this.isFreeScrolling = -restingX > this.slides[0].target && -restingX < this.getLastSlide().target;\n    } else if (!this.options.freeScroll && index == this.selectedIndex) {\n      // boost selection if selected index has not changed\n      index += this.dragEndBoostSelect();\n    }\n\n    delete this.previousDragX; // apply selection\n    // TODO refactor this, selecting here feels weird\n    // HACK, set flag so dragging stays in correct direction\n\n    this.isDragSelect = this.options.wrapAround;\n    this.select(index);\n    delete this.isDragSelect;\n    this.dispatchEvent('dragEnd', event, [pointer]);\n  };\n\n  proto.dragEndRestingSelect = function () {\n    var restingX = this.getRestingPosition(); // how far away from selected slide\n\n    var distance = Math.abs(this.getSlideDistance(-restingX, this.selectedIndex)); // get closet resting going up and going down\n\n    var positiveResting = this._getClosestResting(restingX, distance, 1);\n\n    var negativeResting = this._getClosestResting(restingX, distance, -1); // use closer resting for wrap-around\n\n\n    var index = positiveResting.distance < negativeResting.distance ? positiveResting.index : negativeResting.index;\n    return index;\n  };\n  /**\n   * given resting X and distance to selected cell\n   * get the distance and index of the closest cell\n   * @param {Number} restingX - estimated post-flick resting position\n   * @param {Number} distance - distance to selected cell\n   * @param {Integer} increment - +1 or -1, going up or down\n   * @returns {Object} - { distance: {Number}, index: {Integer} }\n   */\n\n\n  proto._getClosestResting = function (restingX, distance, increment) {\n    var index = this.selectedIndex;\n    var minDistance = Infinity;\n    var condition = this.options.contain && !this.options.wrapAround ? // if contain, keep going if distance is equal to minDistance\n    function (d, md) {\n      return d <= md;\n    } : function (d, md) {\n      return d < md;\n    };\n\n    while (condition(distance, minDistance)) {\n      // measure distance to next cell\n      index += increment;\n      minDistance = distance;\n      distance = this.getSlideDistance(-restingX, index);\n\n      if (distance === null) {\n        break;\n      }\n\n      distance = Math.abs(distance);\n    }\n\n    return {\n      distance: minDistance,\n      // selected was previous index\n      index: index - increment\n    };\n  };\n  /**\n   * measure distance between x and a slide target\n   * @param {Number} x\n   * @param {Integer} index - slide index\n   */\n\n\n  proto.getSlideDistance = function (x, index) {\n    var len = this.slides.length; // wrap around if at least 2 slides\n\n    var isWrapAround = this.options.wrapAround && len > 1;\n    var slideIndex = isWrapAround ? utils.modulo(index, len) : index;\n    var slide = this.slides[slideIndex];\n\n    if (!slide) {\n      return null;\n    } // add distance for wrap-around slides\n\n\n    var wrap = isWrapAround ? this.slideableWidth * Math.floor(index / len) : 0;\n    return x - (slide.target + wrap);\n  };\n\n  proto.dragEndBoostSelect = function () {\n    // do not boost if no previousDragX or dragMoveTime\n    if (this.previousDragX === undefined || !this.dragMoveTime || // or if drag was held for 100 ms\n    new Date() - this.dragMoveTime > 100) {\n      return 0;\n    }\n\n    var distance = this.getSlideDistance(-this.dragX, this.selectedIndex);\n    var delta = this.previousDragX - this.dragX;\n\n    if (distance > 0 && delta > 0) {\n      // boost to next if moving towards the right, and positive velocity\n      return 1;\n    } else if (distance < 0 && delta < 0) {\n      // boost to previous if moving towards the left, and negative velocity\n      return -1;\n    }\n\n    return 0;\n  }; // ----- staticClick ----- //\n\n\n  proto.staticClick = function (event, pointer) {\n    // get clickedCell, if cell was clicked\n    var clickedCell = this.getParentCell(event.target);\n    var cellElem = clickedCell && clickedCell.element;\n    var cellIndex = clickedCell && this.cells.indexOf(clickedCell);\n    this.dispatchEvent('staticClick', event, [pointer, cellElem, cellIndex]);\n  }; // ----- scroll ----- //\n\n\n  proto.onscroll = function () {\n    var scroll = getScrollPosition();\n    var scrollMoveX = this.pointerDownScroll.x - scroll.x;\n    var scrollMoveY = this.pointerDownScroll.y - scroll.y; // cancel click/tap if scroll is too much\n\n    if (Math.abs(scrollMoveX) > 3 || Math.abs(scrollMoveY) > 3) {\n      this._pointerDone();\n    }\n  }; // ----- utils ----- //\n\n\n  function getScrollPosition() {\n    return {\n      x: window.pageXOffset,\n      y: window.pageYOffset\n    };\n  } // -----  ----- //\n\n\n  return Flickity;\n}); // prev/next buttons\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/prev-next-button', ['./flickity', 'unipointer/unipointer', 'fizzy-ui-utils/utils'], function (Flickity, Unipointer, utils) {\n      return factory(window, Flickity, Unipointer, utils);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('./flickity'), require('unipointer'), require('fizzy-ui-utils'));\n  } else {\n    // browser global\n    factory(window, window.Flickity, window.Unipointer, window.fizzyUIUtils);\n  }\n})(window, function factory(window, Flickity, Unipointer, utils) {\n  'use strict';\n\n  var svgURI = 'http://www.w3.org/2000/svg'; // -------------------------- PrevNextButton -------------------------- //\n\n  function PrevNextButton(direction, parent) {\n    this.direction = direction;\n    this.parent = parent;\n\n    this._create();\n  }\n\n  PrevNextButton.prototype = Object.create(Unipointer.prototype);\n\n  PrevNextButton.prototype._create = function () {\n    // properties\n    this.isEnabled = true;\n    this.isPrevious = this.direction == -1;\n    var leftDirection = this.parent.options.rightToLeft ? 1 : -1;\n    this.isLeft = this.direction == leftDirection;\n    var element = this.element = document.createElement('button');\n    element.className = 'flickity-button flickity-prev-next-button';\n    element.className += this.isPrevious ? ' previous' : ' next'; // prevent button from submitting form http://stackoverflow.com/a/10836076/182183\n\n    element.setAttribute('type', 'button'); // init as disabled\n\n    this.disable();\n    element.setAttribute('aria-label', this.isPrevious ? 'Previous' : 'Next'); // create arrow\n\n    var svg = this.createSVG();\n    element.appendChild(svg); // events\n\n    this.parent.on('select', this.update.bind(this));\n    this.on('pointerDown', this.parent.childUIPointerDown.bind(this.parent));\n  };\n\n  PrevNextButton.prototype.activate = function () {\n    this.bindStartEvent(this.element);\n    this.element.addEventListener('click', this); // add to DOM\n\n    this.parent.element.appendChild(this.element);\n  };\n\n  PrevNextButton.prototype.deactivate = function () {\n    // remove from DOM\n    this.parent.element.removeChild(this.element); // click events\n\n    this.unbindStartEvent(this.element);\n    this.element.removeEventListener('click', this);\n  };\n\n  PrevNextButton.prototype.createSVG = function () {\n    var svg = document.createElementNS(svgURI, 'svg');\n    svg.setAttribute('class', 'flickity-button-icon');\n    svg.setAttribute('viewBox', '0 0 100 100');\n    var path = document.createElementNS(svgURI, 'path');\n    var pathMovements = getArrowMovements(this.parent.options.arrowShape);\n    path.setAttribute('d', pathMovements);\n    path.setAttribute('class', 'arrow'); // rotate arrow\n\n    if (!this.isLeft) {\n      path.setAttribute('transform', 'translate(100, 100) rotate(180) ');\n    }\n\n    svg.appendChild(path);\n    return svg;\n  }; // get SVG path movmement\n\n\n  function getArrowMovements(shape) {\n    // use shape as movement if string\n    if (typeof shape == 'string') {\n      return shape;\n    } // create movement string\n\n\n    return 'M ' + shape.x0 + ',50' + ' L ' + shape.x1 + ',' + (shape.y1 + 50) + ' L ' + shape.x2 + ',' + (shape.y2 + 50) + ' L ' + shape.x3 + ',50 ' + ' L ' + shape.x2 + ',' + (50 - shape.y2) + ' L ' + shape.x1 + ',' + (50 - shape.y1) + ' Z';\n  }\n\n  PrevNextButton.prototype.handleEvent = utils.handleEvent;\n\n  PrevNextButton.prototype.onclick = function () {\n    if (!this.isEnabled) {\n      return;\n    }\n\n    this.parent.uiChange();\n    var method = this.isPrevious ? 'previous' : 'next';\n    this.parent[method]();\n  }; // -----  ----- //\n\n\n  PrevNextButton.prototype.enable = function () {\n    if (this.isEnabled) {\n      return;\n    }\n\n    this.element.disabled = false;\n    this.isEnabled = true;\n  };\n\n  PrevNextButton.prototype.disable = function () {\n    if (!this.isEnabled) {\n      return;\n    }\n\n    this.element.disabled = true;\n    this.isEnabled = false;\n  };\n\n  PrevNextButton.prototype.update = function () {\n    // index of first or last slide, if previous or next\n    var slides = this.parent.slides; // enable is wrapAround and at least 2 slides\n\n    if (this.parent.options.wrapAround && slides.length > 1) {\n      this.enable();\n      return;\n    }\n\n    var lastIndex = slides.length ? slides.length - 1 : 0;\n    var boundIndex = this.isPrevious ? 0 : lastIndex;\n    var method = this.parent.selectedIndex == boundIndex ? 'disable' : 'enable';\n    this[method]();\n  };\n\n  PrevNextButton.prototype.destroy = function () {\n    this.deactivate();\n    this.allOff();\n  }; // -------------------------- Flickity prototype -------------------------- //\n\n\n  utils.extend(Flickity.defaults, {\n    prevNextButtons: true,\n    arrowShape: {\n      x0: 10,\n      x1: 60,\n      y1: 50,\n      x2: 70,\n      y2: 40,\n      x3: 30\n    }\n  });\n  Flickity.createMethods.push('_createPrevNextButtons');\n  var proto = Flickity.prototype;\n\n  proto._createPrevNextButtons = function () {\n    if (!this.options.prevNextButtons) {\n      return;\n    }\n\n    this.prevButton = new PrevNextButton(-1, this);\n    this.nextButton = new PrevNextButton(1, this);\n    this.on('activate', this.activatePrevNextButtons);\n  };\n\n  proto.activatePrevNextButtons = function () {\n    this.prevButton.activate();\n    this.nextButton.activate();\n    this.on('deactivate', this.deactivatePrevNextButtons);\n  };\n\n  proto.deactivatePrevNextButtons = function () {\n    this.prevButton.deactivate();\n    this.nextButton.deactivate();\n    this.off('deactivate', this.deactivatePrevNextButtons);\n  }; // --------------------------  -------------------------- //\n\n\n  Flickity.PrevNextButton = PrevNextButton;\n  return Flickity;\n}); // page dots\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/page-dots', ['./flickity', 'unipointer/unipointer', 'fizzy-ui-utils/utils'], function (Flickity, Unipointer, utils) {\n      return factory(window, Flickity, Unipointer, utils);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('./flickity'), require('unipointer'), require('fizzy-ui-utils'));\n  } else {\n    // browser global\n    factory(window, window.Flickity, window.Unipointer, window.fizzyUIUtils);\n  }\n})(window, function factory(window, Flickity, Unipointer, utils) {\n  // -------------------------- PageDots -------------------------- //\n  function PageDots(parent) {\n    this.parent = parent;\n\n    this._create();\n  }\n\n  PageDots.prototype = Object.create(Unipointer.prototype);\n\n  PageDots.prototype._create = function () {\n    // create holder element\n    this.holder = document.createElement('ol');\n    this.holder.className = 'flickity-page-dots'; // create dots, array of elements\n\n    this.dots = []; // events\n\n    this.handleClick = this.onClick.bind(this);\n    this.on('pointerDown', this.parent.childUIPointerDown.bind(this.parent));\n  };\n\n  PageDots.prototype.activate = function () {\n    this.setDots();\n    this.holder.addEventListener('click', this.handleClick);\n    this.bindStartEvent(this.holder); // add to DOM\n\n    this.parent.element.appendChild(this.holder);\n  };\n\n  PageDots.prototype.deactivate = function () {\n    this.holder.removeEventListener('click', this.handleClick);\n    this.unbindStartEvent(this.holder); // remove from DOM\n\n    this.parent.element.removeChild(this.holder);\n  };\n\n  PageDots.prototype.setDots = function () {\n    // get difference between number of slides and number of dots\n    var delta = this.parent.slides.length - this.dots.length;\n\n    if (delta > 0) {\n      this.addDots(delta);\n    } else if (delta < 0) {\n      this.removeDots(-delta);\n    }\n  };\n\n  PageDots.prototype.addDots = function (count) {\n    var fragment = document.createDocumentFragment();\n    var newDots = [];\n    var length = this.dots.length;\n    var max = length + count;\n\n    for (var i = length; i < max; i++) {\n      var dot = document.createElement('li');\n      dot.className = 'dot';\n      dot.setAttribute('aria-label', 'Page dot ' + (i + 1));\n      fragment.appendChild(dot);\n      newDots.push(dot);\n    }\n\n    this.holder.appendChild(fragment);\n    this.dots = this.dots.concat(newDots);\n  };\n\n  PageDots.prototype.removeDots = function (count) {\n    // remove from this.dots collection\n    var removeDots = this.dots.splice(this.dots.length - count, count); // remove from DOM\n\n    removeDots.forEach(function (dot) {\n      this.holder.removeChild(dot);\n    }, this);\n  };\n\n  PageDots.prototype.updateSelected = function () {\n    // remove selected class on previous\n    if (this.selectedDot) {\n      this.selectedDot.className = 'dot';\n      this.selectedDot.removeAttribute('aria-current');\n    } // don't proceed if no dots\n\n\n    if (!this.dots.length) {\n      return;\n    }\n\n    this.selectedDot = this.dots[this.parent.selectedIndex];\n    this.selectedDot.className = 'dot is-selected';\n    this.selectedDot.setAttribute('aria-current', 'step');\n  };\n\n  PageDots.prototype.onTap = // old method name, backwards-compatible\n  PageDots.prototype.onClick = function (event) {\n    var target = event.target; // only care about dot clicks\n\n    if (target.nodeName != 'LI') {\n      return;\n    }\n\n    this.parent.uiChange();\n    var index = this.dots.indexOf(target);\n    this.parent.select(index);\n  };\n\n  PageDots.prototype.destroy = function () {\n    this.deactivate();\n    this.allOff();\n  };\n\n  Flickity.PageDots = PageDots; // -------------------------- Flickity -------------------------- //\n\n  utils.extend(Flickity.defaults, {\n    pageDots: true\n  });\n  Flickity.createMethods.push('_createPageDots');\n  var proto = Flickity.prototype;\n\n  proto._createPageDots = function () {\n    if (!this.options.pageDots) {\n      return;\n    }\n\n    this.pageDots = new PageDots(this); // events\n\n    this.on('activate', this.activatePageDots);\n    this.on('select', this.updateSelectedPageDots);\n    this.on('cellChange', this.updatePageDots);\n    this.on('resize', this.updatePageDots);\n    this.on('deactivate', this.deactivatePageDots);\n  };\n\n  proto.activatePageDots = function () {\n    this.pageDots.activate();\n  };\n\n  proto.updateSelectedPageDots = function () {\n    this.pageDots.updateSelected();\n  };\n\n  proto.updatePageDots = function () {\n    this.pageDots.setDots();\n  };\n\n  proto.deactivatePageDots = function () {\n    this.pageDots.deactivate();\n  }; // -----  ----- //\n\n\n  Flickity.PageDots = PageDots;\n  return Flickity;\n}); // player & autoPlay\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/player', ['ev-emitter/ev-emitter', 'fizzy-ui-utils/utils', './flickity'], function (EvEmitter, utils, Flickity) {\n      return factory(EvEmitter, utils, Flickity);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(require('ev-emitter'), require('fizzy-ui-utils'), require('./flickity'));\n  } else {\n    // browser global\n    factory(window.EvEmitter, window.fizzyUIUtils, window.Flickity);\n  }\n})(window, function factory(EvEmitter, utils, Flickity) {\n  // -------------------------- Player -------------------------- //\n  function Player(parent) {\n    this.parent = parent;\n    this.state = 'stopped'; // visibility change event handler\n\n    this.onVisibilityChange = this.visibilityChange.bind(this);\n    this.onVisibilityPlay = this.visibilityPlay.bind(this);\n  }\n\n  Player.prototype = Object.create(EvEmitter.prototype); // start play\n\n  Player.prototype.play = function () {\n    if (this.state == 'playing') {\n      return;\n    } // do not play if page is hidden, start playing when page is visible\n\n\n    var isPageHidden = document.hidden;\n\n    if (isPageHidden) {\n      document.addEventListener('visibilitychange', this.onVisibilityPlay);\n      return;\n    }\n\n    this.state = 'playing'; // listen to visibility change\n\n    document.addEventListener('visibilitychange', this.onVisibilityChange); // start ticking\n\n    this.tick();\n  };\n\n  Player.prototype.tick = function () {\n    // do not tick if not playing\n    if (this.state != 'playing') {\n      return;\n    }\n\n    var time = this.parent.options.autoPlay; // default to 3 seconds\n\n    time = typeof time == 'number' ? time : 3000;\n\n    var _this = this; // HACK: reset ticks if stopped and started within interval\n\n\n    this.clear();\n    this.timeout = setTimeout(function () {\n      _this.parent.next(true);\n\n      _this.tick();\n    }, time);\n  };\n\n  Player.prototype.stop = function () {\n    this.state = 'stopped';\n    this.clear(); // remove visibility change event\n\n    document.removeEventListener('visibilitychange', this.onVisibilityChange);\n  };\n\n  Player.prototype.clear = function () {\n    clearTimeout(this.timeout);\n  };\n\n  Player.prototype.pause = function () {\n    if (this.state == 'playing') {\n      this.state = 'paused';\n      this.clear();\n    }\n  };\n\n  Player.prototype.unpause = function () {\n    // re-start play if paused\n    if (this.state == 'paused') {\n      this.play();\n    }\n  }; // pause if page visibility is hidden, unpause if visible\n\n\n  Player.prototype.visibilityChange = function () {\n    var isPageHidden = document.hidden;\n    this[isPageHidden ? 'pause' : 'unpause']();\n  };\n\n  Player.prototype.visibilityPlay = function () {\n    this.play();\n    document.removeEventListener('visibilitychange', this.onVisibilityPlay);\n  }; // -------------------------- Flickity -------------------------- //\n\n\n  utils.extend(Flickity.defaults, {\n    pauseAutoPlayOnHover: true\n  });\n  Flickity.createMethods.push('_createPlayer');\n  var proto = Flickity.prototype;\n\n  proto._createPlayer = function () {\n    this.player = new Player(this);\n    this.on('activate', this.activatePlayer);\n    this.on('uiChange', this.stopPlayer);\n    this.on('pointerDown', this.stopPlayer);\n    this.on('deactivate', this.deactivatePlayer);\n  };\n\n  proto.activatePlayer = function () {\n    if (!this.options.autoPlay) {\n      return;\n    }\n\n    this.player.play();\n    this.element.addEventListener('mouseenter', this);\n  }; // Player API, don't hate the ... thanks I know where the door is\n\n\n  proto.playPlayer = function () {\n    this.player.play();\n  };\n\n  proto.stopPlayer = function () {\n    this.player.stop();\n  };\n\n  proto.pausePlayer = function () {\n    this.player.pause();\n  };\n\n  proto.unpausePlayer = function () {\n    this.player.unpause();\n  };\n\n  proto.deactivatePlayer = function () {\n    this.player.stop();\n    this.element.removeEventListener('mouseenter', this);\n  }; // ----- mouseenter/leave ----- //\n  // pause auto-play on hover\n\n\n  proto.onmouseenter = function () {\n    if (!this.options.pauseAutoPlayOnHover) {\n      return;\n    }\n\n    this.player.pause();\n    this.element.addEventListener('mouseleave', this);\n  }; // resume auto-play on hover off\n\n\n  proto.onmouseleave = function () {\n    this.player.unpause();\n    this.element.removeEventListener('mouseleave', this);\n  }; // -----  ----- //\n\n\n  Flickity.Player = Player;\n  return Flickity;\n}); // add, remove cell\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/add-remove-cell', ['./flickity', 'fizzy-ui-utils/utils'], function (Flickity, utils) {\n      return factory(window, Flickity, utils);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('./flickity'), require('fizzy-ui-utils'));\n  } else {\n    // browser global\n    factory(window, window.Flickity, window.fizzyUIUtils);\n  }\n})(window, function factory(window, Flickity, utils) {\n  // append cells to a document fragment\n  function getCellsFragment(cells) {\n    var fragment = document.createDocumentFragment();\n    cells.forEach(function (cell) {\n      fragment.appendChild(cell.element);\n    });\n    return fragment;\n  } // -------------------------- add/remove cell prototype -------------------------- //\n\n\n  var proto = Flickity.prototype;\n  /**\n   * Insert, prepend, or append cells\n   * @param {Element, Array, NodeList} elems\n   * @param {Integer} index\n   */\n\n  proto.insert = function (elems, index) {\n    var cells = this._makeCells(elems);\n\n    if (!cells || !cells.length) {\n      return;\n    }\n\n    var len = this.cells.length; // default to append\n\n    index = index === undefined ? len : index; // add cells with document fragment\n\n    var fragment = getCellsFragment(cells); // append to slider\n\n    var isAppend = index == len;\n\n    if (isAppend) {\n      this.slider.appendChild(fragment);\n    } else {\n      var insertCellElement = this.cells[index].element;\n      this.slider.insertBefore(fragment, insertCellElement);\n    } // add to this.cells\n\n\n    if (index === 0) {\n      // prepend, add to start\n      this.cells = cells.concat(this.cells);\n    } else if (isAppend) {\n      // append, add to end\n      this.cells = this.cells.concat(cells);\n    } else {\n      // insert in this.cells\n      var endCells = this.cells.splice(index, len - index);\n      this.cells = this.cells.concat(cells).concat(endCells);\n    }\n\n    this._sizeCells(cells);\n\n    this.cellChange(index, true);\n  };\n\n  proto.append = function (elems) {\n    this.insert(elems, this.cells.length);\n  };\n\n  proto.prepend = function (elems) {\n    this.insert(elems, 0);\n  };\n  /**\n   * Remove cells\n   * @param {Element, Array, NodeList} elems\n   */\n\n\n  proto.remove = function (elems) {\n    var cells = this.getCells(elems);\n\n    if (!cells || !cells.length) {\n      return;\n    }\n\n    var minCellIndex = this.cells.length - 1; // remove cells from collection & DOM\n\n    cells.forEach(function (cell) {\n      cell.remove();\n      var index = this.cells.indexOf(cell);\n      minCellIndex = Math.min(index, minCellIndex);\n      utils.removeFrom(this.cells, cell);\n    }, this);\n    this.cellChange(minCellIndex, true);\n  };\n  /**\n   * logic to be run after a cell's size changes\n   * @param {Element} elem - cell's element\n   */\n\n\n  proto.cellSizeChange = function (elem) {\n    var cell = this.getCell(elem);\n\n    if (!cell) {\n      return;\n    }\n\n    cell.getSize();\n    var index = this.cells.indexOf(cell);\n    this.cellChange(index);\n  };\n  /**\n   * logic any time a cell is changed: added, removed, or size changed\n   * @param {Integer} changedCellIndex - index of the changed cell, optional\n   */\n\n\n  proto.cellChange = function (changedCellIndex, isPositioningSlider) {\n    var prevSelectedElem = this.selectedElement;\n\n    this._positionCells(changedCellIndex);\n\n    this._getWrapShiftCells();\n\n    this.setGallerySize(); // update selectedIndex\n    // try to maintain position & select previous selected element\n\n    var cell = this.getCell(prevSelectedElem);\n\n    if (cell) {\n      this.selectedIndex = this.getCellSlideIndex(cell);\n    }\n\n    this.selectedIndex = Math.min(this.slides.length - 1, this.selectedIndex);\n    this.emitEvent('cellChange', [changedCellIndex]); // position slider\n\n    this.select(this.selectedIndex); // do not position slider after lazy load\n\n    if (isPositioningSlider) {\n      this.positionSliderAtSelected();\n    }\n  }; // -----  ----- //\n\n\n  return Flickity;\n}); // lazyload\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/lazyload', ['./flickity', 'fizzy-ui-utils/utils'], function (Flickity, utils) {\n      return factory(window, Flickity, utils);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('./flickity'), require('fizzy-ui-utils'));\n  } else {\n    // browser global\n    factory(window, window.Flickity, window.fizzyUIUtils);\n  }\n})(window, function factory(window, Flickity, utils) {\n  'use strict';\n\n  Flickity.createMethods.push('_createLazyload');\n  var proto = Flickity.prototype;\n\n  proto._createLazyload = function () {\n    this.on('select', this.lazyLoad);\n  };\n\n  proto.lazyLoad = function () {\n    var lazyLoad = this.options.lazyLoad;\n\n    if (!lazyLoad) {\n      return;\n    } // get adjacent cells, use lazyLoad option for adjacent count\n\n\n    var adjCount = typeof lazyLoad == 'number' ? lazyLoad : 0;\n    var cellElems = this.getAdjacentCellElements(adjCount); // get lazy images in those cells\n\n    var lazyImages = [];\n    cellElems.forEach(function (cellElem) {\n      var lazyCellImages = getCellLazyImages(cellElem);\n      lazyImages = lazyImages.concat(lazyCellImages);\n    }); // load lazy images\n\n    lazyImages.forEach(function (img) {\n      new LazyLoader(img, this);\n    }, this);\n  };\n\n  function getCellLazyImages(cellElem) {\n    // check if cell element is lazy image\n    if (cellElem.nodeName == 'IMG') {\n      var lazyloadAttr = cellElem.getAttribute('data-flickity-lazyload');\n      var srcAttr = cellElem.getAttribute('data-flickity-lazyload-src');\n      var srcsetAttr = cellElem.getAttribute('data-flickity-lazyload-srcset');\n\n      if (lazyloadAttr || srcAttr || srcsetAttr) {\n        return [cellElem];\n      }\n    } // select lazy images in cell\n\n\n    var lazySelector = 'img[data-flickity-lazyload], ' + 'img[data-flickity-lazyload-src], img[data-flickity-lazyload-srcset]';\n    var imgs = cellElem.querySelectorAll(lazySelector);\n    return utils.makeArray(imgs);\n  } // -------------------------- LazyLoader -------------------------- //\n\n  /**\n   * class to handle loading images\n   */\n\n\n  function LazyLoader(img, flickity) {\n    this.img = img;\n    this.flickity = flickity;\n    this.load();\n  }\n\n  LazyLoader.prototype.handleEvent = utils.handleEvent;\n\n  LazyLoader.prototype.load = function () {\n    this.img.addEventListener('load', this);\n    this.img.addEventListener('error', this); // get src & srcset\n\n    var src = this.img.getAttribute('data-flickity-lazyload') || this.img.getAttribute('data-flickity-lazyload-src');\n    var srcset = this.img.getAttribute('data-flickity-lazyload-srcset'); // set src & serset\n\n    this.img.src = src;\n\n    if (srcset) {\n      this.img.setAttribute('srcset', srcset);\n    } // remove attr\n\n\n    this.img.removeAttribute('data-flickity-lazyload');\n    this.img.removeAttribute('data-flickity-lazyload-src');\n    this.img.removeAttribute('data-flickity-lazyload-srcset');\n  };\n\n  LazyLoader.prototype.onload = function (event) {\n    this.complete(event, 'flickity-lazyloaded');\n  };\n\n  LazyLoader.prototype.onerror = function (event) {\n    this.complete(event, 'flickity-lazyerror');\n  };\n\n  LazyLoader.prototype.complete = function (event, className) {\n    // unbind events\n    this.img.removeEventListener('load', this);\n    this.img.removeEventListener('error', this);\n    var cell = this.flickity.getParentCell(this.img);\n    var cellElem = cell && cell.element;\n    this.flickity.cellSizeChange(cellElem);\n    this.img.classList.add(className);\n    this.flickity.dispatchEvent('lazyLoad', event, cellElem);\n  }; // -----  ----- //\n\n\n  Flickity.LazyLoader = LazyLoader;\n  return Flickity;\n});\n/*!\n * Flickity v2.2.1\n * Touch, responsive, flickable carousels\n *\n * Licensed GPLv3 for open source use\n * or Flickity Commercial License for commercial use\n *\n * https://flickity.metafizzy.co\n * Copyright 2015-2019 Metafizzy\n */\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /* jshint strict: false */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity/js/index', ['./flickity', './drag', './prev-next-button', './page-dots', './player', './add-remove-cell', './lazyload'], factory);\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(require('./flickity'), require('./drag'), require('./prev-next-button'), require('./page-dots'), require('./player'), require('./add-remove-cell'), require('./lazyload'));\n  }\n})(window, function factory(Flickity) {\n  /*jshint strict: false*/\n  return Flickity;\n});\n/*!\n * Flickity asNavFor v2.0.2\n * enable asNavFor for Flickity\n */\n\n/*jshint browser: true, undef: true, unused: true, strict: true*/\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /*jshint strict: false */\n\n  /*globals define, module, require */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('flickity-as-nav-for/as-nav-for', ['flickity/js/index', 'fizzy-ui-utils/utils'], factory);\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(require('flickity'), require('fizzy-ui-utils'));\n  } else {\n    // browser global\n    window.Flickity = factory(window.Flickity, window.fizzyUIUtils);\n  }\n})(window, function factory(Flickity, utils) {\n  // -------------------------- asNavFor prototype -------------------------- //\n  // Flickity.defaults.asNavFor = null;\n  Flickity.createMethods.push('_createAsNavFor');\n  var proto = Flickity.prototype;\n\n  proto._createAsNavFor = function () {\n    this.on('activate', this.activateAsNavFor);\n    this.on('deactivate', this.deactivateAsNavFor);\n    this.on('destroy', this.destroyAsNavFor);\n    var asNavForOption = this.options.asNavFor;\n\n    if (!asNavForOption) {\n      return;\n    } // HACK do async, give time for other flickity to be initalized\n\n\n    var _this = this;\n\n    setTimeout(function initNavCompanion() {\n      _this.setNavCompanion(asNavForOption);\n    });\n  };\n\n  proto.setNavCompanion = function (elem) {\n    elem = utils.getQueryElement(elem);\n    var companion = Flickity.data(elem); // stop if no companion or companion is self\n\n    if (!companion || companion == this) {\n      return;\n    }\n\n    this.navCompanion = companion; // companion select\n\n    var _this = this;\n\n    this.onNavCompanionSelect = function () {\n      _this.navCompanionSelect();\n    };\n\n    companion.on('select', this.onNavCompanionSelect); // click\n\n    this.on('staticClick', this.onNavStaticClick);\n    this.navCompanionSelect(true);\n  };\n\n  proto.navCompanionSelect = function (isInstant) {\n    // wait for companion & selectedCells first. #8\n    var companionCells = this.navCompanion && this.navCompanion.selectedCells;\n\n    if (!companionCells) {\n      return;\n    } // select slide that matches first cell of slide\n\n\n    var selectedCell = companionCells[0];\n    var firstIndex = this.navCompanion.cells.indexOf(selectedCell);\n    var lastIndex = firstIndex + companionCells.length - 1;\n    var selectIndex = Math.floor(lerp(firstIndex, lastIndex, this.navCompanion.cellAlign));\n    this.selectCell(selectIndex, false, isInstant); // set nav selected class\n\n    this.removeNavSelectedElements(); // stop if companion has more cells than this one\n\n    if (selectIndex >= this.cells.length) {\n      return;\n    }\n\n    var selectedCells = this.cells.slice(firstIndex, lastIndex + 1);\n    this.navSelectedElements = selectedCells.map(function (cell) {\n      return cell.element;\n    });\n    this.changeNavSelectedClass('add');\n  };\n\n  function lerp(a, b, t) {\n    return (b - a) * t + a;\n  }\n\n  proto.changeNavSelectedClass = function (method) {\n    this.navSelectedElements.forEach(function (navElem) {\n      navElem.classList[method]('is-nav-selected');\n    });\n  };\n\n  proto.activateAsNavFor = function () {\n    this.navCompanionSelect(true);\n  };\n\n  proto.removeNavSelectedElements = function () {\n    if (!this.navSelectedElements) {\n      return;\n    }\n\n    this.changeNavSelectedClass('remove');\n    delete this.navSelectedElements;\n  };\n\n  proto.onNavStaticClick = function (event, pointer, cellElement, cellIndex) {\n    if (typeof cellIndex == 'number') {\n      this.navCompanion.selectCell(cellIndex);\n    }\n  };\n\n  proto.deactivateAsNavFor = function () {\n    this.removeNavSelectedElements();\n  };\n\n  proto.destroyAsNavFor = function () {\n    if (!this.navCompanion) {\n      return;\n    }\n\n    this.navCompanion.off('select', this.onNavCompanionSelect);\n    this.off('staticClick', this.onNavStaticClick);\n    delete this.navCompanion;\n  }; // -----  ----- //\n\n\n  return Flickity;\n});\n/*!\n * imagesLoaded v4.1.4\n * JavaScript is all like \"You images are done yet or what?\"\n * MIT License\n */\n\n\n(function (window, factory) {\n  'use strict'; // universal module definition\n\n  /*global define: false, module: false, require: false */\n\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define('imagesloaded/imagesloaded', ['ev-emitter/ev-emitter'], function (EvEmitter) {\n      return factory(window, EvEmitter);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('ev-emitter'));\n  } else {\n    // browser global\n    window.imagesLoaded = factory(window, window.EvEmitter);\n  }\n})(typeof window !== 'undefined' ? window : this, // --------------------------  factory -------------------------- //\nfunction factory(window, EvEmitter) {\n  var $ = window.jQuery;\n  var console = window.console; // -------------------------- helpers -------------------------- //\n  // extend objects\n\n  function extend(a, b) {\n    for (var prop in b) {\n      a[prop] = b[prop];\n    }\n\n    return a;\n  }\n\n  var arraySlice = Array.prototype.slice; // turn element or nodeList into an array\n\n  function makeArray(obj) {\n    if (Array.isArray(obj)) {\n      // use object if already an array\n      return obj;\n    }\n\n    var isArrayLike = _typeof(obj) == 'object' && typeof obj.length == 'number';\n\n    if (isArrayLike) {\n      // convert nodeList to array\n      return arraySlice.call(obj);\n    } // array of single index\n\n\n    return [obj];\n  } // -------------------------- imagesLoaded -------------------------- //\n\n  /**\n   * @param {Array, Element, NodeList, String} elem\n   * @param {Object or Function} options - if function, use as callback\n   * @param {Function} onAlways - callback function\n   */\n\n\n  function ImagesLoaded(elem, options, onAlways) {\n    // coerce ImagesLoaded() without new, to be new ImagesLoaded()\n    if (!(this instanceof ImagesLoaded)) {\n      return new ImagesLoaded(elem, options, onAlways);\n    } // use elem as selector string\n\n\n    var queryElem = elem;\n\n    if (typeof elem == 'string') {\n      queryElem = document.querySelectorAll(elem);\n    } // bail if bad element\n\n\n    if (!queryElem) {\n      console.error('Bad element for imagesLoaded ' + (queryElem || elem));\n      return;\n    }\n\n    this.elements = makeArray(queryElem);\n    this.options = extend({}, this.options); // shift arguments if no options set\n\n    if (typeof options == 'function') {\n      onAlways = options;\n    } else {\n      extend(this.options, options);\n    }\n\n    if (onAlways) {\n      this.on('always', onAlways);\n    }\n\n    this.getImages();\n\n    if ($) {\n      // add jQuery Deferred object\n      this.jqDeferred = new $.Deferred();\n    } // HACK check async to allow time to bind listeners\n\n\n    setTimeout(this.check.bind(this));\n  }\n\n  ImagesLoaded.prototype = Object.create(EvEmitter.prototype);\n  ImagesLoaded.prototype.options = {};\n\n  ImagesLoaded.prototype.getImages = function () {\n    this.images = []; // filter & find items if we have an item selector\n\n    this.elements.forEach(this.addElementImages, this);\n  };\n  /**\n   * @param {Node} element\n   */\n\n\n  ImagesLoaded.prototype.addElementImages = function (elem) {\n    // filter siblings\n    if (elem.nodeName == 'IMG') {\n      this.addImage(elem);\n    } // get background image on element\n\n\n    if (this.options.background === true) {\n      this.addElementBackgroundImages(elem);\n    } // find children\n    // no non-element nodes, #143\n\n\n    var nodeType = elem.nodeType;\n\n    if (!nodeType || !elementNodeTypes[nodeType]) {\n      return;\n    }\n\n    var childImgs = elem.querySelectorAll('img'); // concat childElems to filterFound array\n\n    for (var i = 0; i < childImgs.length; i++) {\n      var img = childImgs[i];\n      this.addImage(img);\n    } // get child background images\n\n\n    if (typeof this.options.background == 'string') {\n      var children = elem.querySelectorAll(this.options.background);\n\n      for (i = 0; i < children.length; i++) {\n        var child = children[i];\n        this.addElementBackgroundImages(child);\n      }\n    }\n  };\n\n  var elementNodeTypes = {\n    1: true,\n    9: true,\n    11: true\n  };\n\n  ImagesLoaded.prototype.addElementBackgroundImages = function (elem) {\n    var style = getComputedStyle(elem);\n\n    if (!style) {\n      // Firefox returns null if in a hidden iframe https://bugzil.la/548397\n      return;\n    } // get url inside url(\"...\")\n\n\n    var reURL = /url\\((['\"])?(.*?)\\1\\)/gi;\n    var matches = reURL.exec(style.backgroundImage);\n\n    while (matches !== null) {\n      var url = matches && matches[2];\n\n      if (url) {\n        this.addBackground(url, elem);\n      }\n\n      matches = reURL.exec(style.backgroundImage);\n    }\n  };\n  /**\n   * @param {Image} img\n   */\n\n\n  ImagesLoaded.prototype.addImage = function (img) {\n    var loadingImage = new LoadingImage(img);\n    this.images.push(loadingImage);\n  };\n\n  ImagesLoaded.prototype.addBackground = function (url, elem) {\n    var background = new Background(url, elem);\n    this.images.push(background);\n  };\n\n  ImagesLoaded.prototype.check = function () {\n    var _this = this;\n\n    this.progressedCount = 0;\n    this.hasAnyBroken = false; // complete if no images\n\n    if (!this.images.length) {\n      this.complete();\n      return;\n    }\n\n    function onProgress(image, elem, message) {\n      // HACK - Chrome triggers event before object properties have changed. #83\n      setTimeout(function () {\n        _this.progress(image, elem, message);\n      });\n    }\n\n    this.images.forEach(function (loadingImage) {\n      loadingImage.once('progress', onProgress);\n      loadingImage.check();\n    });\n  };\n\n  ImagesLoaded.prototype.progress = function (image, elem, message) {\n    this.progressedCount++;\n    this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded; // progress event\n\n    this.emitEvent('progress', [this, image, elem]);\n\n    if (this.jqDeferred && this.jqDeferred.notify) {\n      this.jqDeferred.notify(this, image);\n    } // check if completed\n\n\n    if (this.progressedCount == this.images.length) {\n      this.complete();\n    }\n\n    if (this.options.debug && console) {\n      console.log('progress: ' + message, image, elem);\n    }\n  };\n\n  ImagesLoaded.prototype.complete = function () {\n    var eventName = this.hasAnyBroken ? 'fail' : 'done';\n    this.isComplete = true;\n    this.emitEvent(eventName, [this]);\n    this.emitEvent('always', [this]);\n\n    if (this.jqDeferred) {\n      var jqMethod = this.hasAnyBroken ? 'reject' : 'resolve';\n      this.jqDeferred[jqMethod](this);\n    }\n  }; // --------------------------  -------------------------- //\n\n\n  function LoadingImage(img) {\n    this.img = img;\n  }\n\n  LoadingImage.prototype = Object.create(EvEmitter.prototype);\n\n  LoadingImage.prototype.check = function () {\n    // If complete is true and browser supports natural sizes,\n    // try to check for image status manually.\n    var isComplete = this.getIsImageComplete();\n\n    if (isComplete) {\n      // report based on naturalWidth\n      this.confirm(this.img.naturalWidth !== 0, 'naturalWidth');\n      return;\n    } // If none of the checks above matched, simulate loading on detached element.\n\n\n    this.proxyImage = new Image();\n    this.proxyImage.addEventListener('load', this);\n    this.proxyImage.addEventListener('error', this); // bind to image as well for Firefox. #191\n\n    this.img.addEventListener('load', this);\n    this.img.addEventListener('error', this);\n    this.proxyImage.src = this.img.src;\n  };\n\n  LoadingImage.prototype.getIsImageComplete = function () {\n    // check for non-zero, non-undefined naturalWidth\n    // fixes Safari+InfiniteScroll+Masonry bug infinite-scroll#671\n    return this.img.complete && this.img.naturalWidth;\n  };\n\n  LoadingImage.prototype.confirm = function (isLoaded, message) {\n    this.isLoaded = isLoaded;\n    this.emitEvent('progress', [this, this.img, message]);\n  }; // ----- events ----- //\n  // trigger specified handler for event type\n\n\n  LoadingImage.prototype.handleEvent = function (event) {\n    var method = 'on' + event.type;\n\n    if (this[method]) {\n      this[method](event);\n    }\n  };\n\n  LoadingImage.prototype.onload = function () {\n    this.confirm(true, 'onload');\n    this.unbindEvents();\n  };\n\n  LoadingImage.prototype.onerror = function () {\n    this.confirm(false, 'onerror');\n    this.unbindEvents();\n  };\n\n  LoadingImage.prototype.unbindEvents = function () {\n    this.proxyImage.removeEventListener('load', this);\n    this.proxyImage.removeEventListener('error', this);\n    this.img.removeEventListener('load', this);\n    this.img.removeEventListener('error', this);\n  }; // -------------------------- Background -------------------------- //\n\n\n  function Background(url, element) {\n    this.url = url;\n    this.element = element;\n    this.img = new Image();\n  } // inherit LoadingImage prototype\n\n\n  Background.prototype = Object.create(LoadingImage.prototype);\n\n  Background.prototype.check = function () {\n    this.img.addEventListener('load', this);\n    this.img.addEventListener('error', this);\n    this.img.src = this.url; // check if image is already complete\n\n    var isComplete = this.getIsImageComplete();\n\n    if (isComplete) {\n      this.confirm(this.img.naturalWidth !== 0, 'naturalWidth');\n      this.unbindEvents();\n    }\n  };\n\n  Background.prototype.unbindEvents = function () {\n    this.img.removeEventListener('load', this);\n    this.img.removeEventListener('error', this);\n  };\n\n  Background.prototype.confirm = function (isLoaded, message) {\n    this.isLoaded = isLoaded;\n    this.emitEvent('progress', [this, this.element, message]);\n  }; // -------------------------- jQuery -------------------------- //\n\n\n  ImagesLoaded.makeJQueryPlugin = function (jQuery) {\n    jQuery = jQuery || window.jQuery;\n\n    if (!jQuery) {\n      return;\n    } // set local variable\n\n\n    $ = jQuery; // $().imagesLoaded()\n\n    $.fn.imagesLoaded = function (options, callback) {\n      var instance = new ImagesLoaded(this, options, callback);\n      return instance.jqDeferred.promise($(this));\n    };\n  }; // try making plugin\n\n\n  ImagesLoaded.makeJQueryPlugin(); // --------------------------  -------------------------- //\n\n  return ImagesLoaded;\n});\n/*!\n * Flickity imagesLoaded v2.0.0\n * enables imagesLoaded option for Flickity\n */\n\n/*jshint browser: true, strict: true, undef: true, unused: true */\n\n\n(function (window, factory) {\n  // universal module definition\n\n  /*jshint strict: false */\n\n  /*globals define, module, require */\n  if (typeof define == 'function' && define.amd) {\n    // AMD\n    define(['flickity/js/index', 'imagesloaded/imagesloaded'], function (Flickity, imagesLoaded) {\n      return factory(window, Flickity, imagesLoaded);\n    });\n  } else if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module.exports) {\n    // CommonJS\n    module.exports = factory(window, require('flickity'), require('imagesloaded'));\n  } else {\n    // browser global\n    window.Flickity = factory(window, window.Flickity, window.imagesLoaded);\n  }\n})(window, function factory(window, Flickity, imagesLoaded) {\n  'use strict';\n\n  Flickity.createMethods.push('_createImagesLoaded');\n  var proto = Flickity.prototype;\n\n  proto._createImagesLoaded = function () {\n    this.on('activate', this.imagesLoaded);\n  };\n\n  proto.imagesLoaded = function () {\n    if (!this.options.imagesLoaded) {\n      return;\n    }\n\n    var _this = this;\n\n    function onImagesLoadedProgress(instance, image) {\n      var cell = _this.getParentCell(image.img);\n\n      _this.cellSizeChange(cell && cell.element);\n\n      if (!_this.options.freeScroll) {\n        _this.positionSliderAtSelected();\n      }\n    }\n\n    imagesLoaded(this.slider).on('progress', onImagesLoadedProgress);\n  };\n\n  return Flickity;\n});","\nexport function getMetaValue(name) {\n    const element = findElement(document.head, `meta[name=\"${name}\"]`);\n    if (element) {\n      return element.getAttribute(\"content\");\n    }\n}\n  \nexport function findElement(root, selector) {\n    if (typeof root == \"string\") {\n        selector = root;\n        root = document;\n    }\n    return root.querySelector(selector);\n}\n\nexport function toArray(value) {\n    if (Array.isArray(value)) {\n        return value;\n    } else if (Array.from) {\n        return Array.from(value);\n    } else {\n        return [].slice.call(value);\n    }\n}\n\nexport function removeElement(el) {\n    if (el && el.parentNode) {\n        el.parentNode.removeChild(el);\n    }\n}\n\nexport function insertAfter(el, referenceNode) {\n    return referenceNode.parentNode.insertBefore(el, referenceNode.nextSibling);\n}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*!\n * jQuery JavaScript Library v3.4.1\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2019-05-01T21:04Z\n */\n(function (global, factory) {\n  \"use strict\";\n\n  if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === \"object\" && _typeof(module.exports) === \"object\") {\n    // For CommonJS and CommonJS-like environments where a proper `window`\n    // is present, execute the factory and get jQuery.\n    // For environments that do not have a `window` with a `document`\n    // (such as Node.js), expose a factory as module.exports.\n    // This accentuates the need for the creation of a real `window`.\n    // e.g. var jQuery = require(\"jquery\")(window);\n    // See ticket #14549 for more info.\n    module.exports = global.document ? factory(global, true) : function (w) {\n      if (!w.document) {\n        throw new Error(\"jQuery requires a window with a document\");\n      }\n\n      return factory(w);\n    };\n  } else {\n    factory(global);\n  } // Pass this if window is not defined yet\n\n})(typeof window !== \"undefined\" ? window : this, function (window, noGlobal) {\n  // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n  // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n  // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n  // enough that all such attempts are guarded in a try block.\n  \"use strict\";\n\n  var arr = [];\n  var document = window.document;\n  var getProto = Object.getPrototypeOf;\n  var _slice = arr.slice;\n  var concat = arr.concat;\n  var push = arr.push;\n  var indexOf = arr.indexOf;\n  var class2type = {};\n  var toString = class2type.toString;\n  var hasOwn = class2type.hasOwnProperty;\n  var fnToString = hasOwn.toString;\n  var ObjectFunctionString = fnToString.call(Object);\n  var support = {};\n\n  var isFunction = function isFunction(obj) {\n    // Support: Chrome <=57, Firefox <=52\n    // In some browsers, typeof returns \"function\" for HTML <object> elements\n    // (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n    // We don't want to classify *any* DOM node as a function.\n    return typeof obj === \"function\" && typeof obj.nodeType !== \"number\";\n  };\n\n  var isWindow = function isWindow(obj) {\n    return obj != null && obj === obj.window;\n  };\n\n  var preservedScriptAttributes = {\n    type: true,\n    src: true,\n    nonce: true,\n    noModule: true\n  };\n\n  function DOMEval(code, node, doc) {\n    doc = doc || document;\n    var i,\n        val,\n        script = doc.createElement(\"script\");\n    script.text = code;\n\n    if (node) {\n      for (i in preservedScriptAttributes) {\n        // Support: Firefox 64+, Edge 18+\n        // Some browsers don't support the \"nonce\" property on scripts.\n        // On the other hand, just using `getAttribute` is not enough as\n        // the `nonce` attribute is reset to an empty string whenever it\n        // becomes browsing-context connected.\n        // See https://github.com/whatwg/html/issues/2369\n        // See https://html.spec.whatwg.org/#nonce-attributes\n        // The `node.getAttribute` check was added for the sake of\n        // `jQuery.globalEval` so that it can fake a nonce-containing node\n        // via an object.\n        val = node[i] || node.getAttribute && node.getAttribute(i);\n\n        if (val) {\n          script.setAttribute(i, val);\n        }\n      }\n    }\n\n    doc.head.appendChild(script).parentNode.removeChild(script);\n  }\n\n  function toType(obj) {\n    if (obj == null) {\n      return obj + \"\";\n    } // Support: Android <=2.3 only (functionish RegExp)\n\n\n    return _typeof(obj) === \"object\" || typeof obj === \"function\" ? class2type[toString.call(obj)] || \"object\" : _typeof(obj);\n  }\n  /* global Symbol */\n  // Defining this global in .eslintrc.json would create a danger of using the global\n  // unguarded in another place, it seems safer to define global only for this module\n\n\n  var version = \"3.4.1\",\n      // Define a local copy of jQuery\n  jQuery = function jQuery(selector, context) {\n    // The jQuery object is actually just the init constructor 'enhanced'\n    // Need init if jQuery is called (just allow error to be thrown if not included)\n    return new jQuery.fn.init(selector, context);\n  },\n      // Support: Android <=4.0 only\n  // Make sure we trim BOM and NBSP\n  rtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;\n\n  jQuery.fn = jQuery.prototype = {\n    // The current version of jQuery being used\n    jquery: version,\n    constructor: jQuery,\n    // The default length of a jQuery object is 0\n    length: 0,\n    toArray: function toArray() {\n      return _slice.call(this);\n    },\n    // Get the Nth element in the matched element set OR\n    // Get the whole matched element set as a clean array\n    get: function get(num) {\n      // Return all the elements in a clean array\n      if (num == null) {\n        return _slice.call(this);\n      } // Return just the one element from the set\n\n\n      return num < 0 ? this[num + this.length] : this[num];\n    },\n    // Take an array of elements and push it onto the stack\n    // (returning the new matched element set)\n    pushStack: function pushStack(elems) {\n      // Build a new jQuery matched element set\n      var ret = jQuery.merge(this.constructor(), elems); // Add the old object onto the stack (as a reference)\n\n      ret.prevObject = this; // Return the newly-formed element set\n\n      return ret;\n    },\n    // Execute a callback for every element in the matched set.\n    each: function each(callback) {\n      return jQuery.each(this, callback);\n    },\n    map: function map(callback) {\n      return this.pushStack(jQuery.map(this, function (elem, i) {\n        return callback.call(elem, i, elem);\n      }));\n    },\n    slice: function slice() {\n      return this.pushStack(_slice.apply(this, arguments));\n    },\n    first: function first() {\n      return this.eq(0);\n    },\n    last: function last() {\n      return this.eq(-1);\n    },\n    eq: function eq(i) {\n      var len = this.length,\n          j = +i + (i < 0 ? len : 0);\n      return this.pushStack(j >= 0 && j < len ? [this[j]] : []);\n    },\n    end: function end() {\n      return this.prevObject || this.constructor();\n    },\n    // For internal use only.\n    // Behaves like an Array's method, not like a jQuery method.\n    push: push,\n    sort: arr.sort,\n    splice: arr.splice\n  };\n\n  jQuery.extend = jQuery.fn.extend = function () {\n    var options,\n        name,\n        src,\n        copy,\n        copyIsArray,\n        clone,\n        target = arguments[0] || {},\n        i = 1,\n        length = arguments.length,\n        deep = false; // Handle a deep copy situation\n\n    if (typeof target === \"boolean\") {\n      deep = target; // Skip the boolean and the target\n\n      target = arguments[i] || {};\n      i++;\n    } // Handle case when target is a string or something (possible in deep copy)\n\n\n    if (_typeof(target) !== \"object\" && !isFunction(target)) {\n      target = {};\n    } // Extend jQuery itself if only one argument is passed\n\n\n    if (i === length) {\n      target = this;\n      i--;\n    }\n\n    for (; i < length; i++) {\n      // Only deal with non-null/undefined values\n      if ((options = arguments[i]) != null) {\n        // Extend the base object\n        for (name in options) {\n          copy = options[name]; // Prevent Object.prototype pollution\n          // Prevent never-ending loop\n\n          if (name === \"__proto__\" || target === copy) {\n            continue;\n          } // Recurse if we're merging plain objects or arrays\n\n\n          if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {\n            src = target[name]; // Ensure proper type for the source value\n\n            if (copyIsArray && !Array.isArray(src)) {\n              clone = [];\n            } else if (!copyIsArray && !jQuery.isPlainObject(src)) {\n              clone = {};\n            } else {\n              clone = src;\n            }\n\n            copyIsArray = false; // Never move original objects, clone them\n\n            target[name] = jQuery.extend(deep, clone, copy); // Don't bring in undefined values\n          } else if (copy !== undefined) {\n            target[name] = copy;\n          }\n        }\n      }\n    } // Return the modified object\n\n\n    return target;\n  };\n\n  jQuery.extend({\n    // Unique for each copy of jQuery on the page\n    expando: \"jQuery\" + (version + Math.random()).replace(/\\D/g, \"\"),\n    // Assume jQuery is ready without the ready module\n    isReady: true,\n    error: function error(msg) {\n      throw new Error(msg);\n    },\n    noop: function noop() {},\n    isPlainObject: function isPlainObject(obj) {\n      var proto, Ctor; // Detect obvious negatives\n      // Use toString instead of jQuery.type to catch host objects\n\n      if (!obj || toString.call(obj) !== \"[object Object]\") {\n        return false;\n      }\n\n      proto = getProto(obj); // Objects with no prototype (e.g., `Object.create( null )`) are plain\n\n      if (!proto) {\n        return true;\n      } // Objects with prototype are plain iff they were constructed by a global Object function\n\n\n      Ctor = hasOwn.call(proto, \"constructor\") && proto.constructor;\n      return typeof Ctor === \"function\" && fnToString.call(Ctor) === ObjectFunctionString;\n    },\n    isEmptyObject: function isEmptyObject(obj) {\n      var name;\n\n      for (name in obj) {\n        return false;\n      }\n\n      return true;\n    },\n    // Evaluates a script in a global context\n    globalEval: function globalEval(code, options) {\n      DOMEval(code, {\n        nonce: options && options.nonce\n      });\n    },\n    each: function each(obj, callback) {\n      var length,\n          i = 0;\n\n      if (isArrayLike(obj)) {\n        length = obj.length;\n\n        for (; i < length; i++) {\n          if (callback.call(obj[i], i, obj[i]) === false) {\n            break;\n          }\n        }\n      } else {\n        for (i in obj) {\n          if (callback.call(obj[i], i, obj[i]) === false) {\n            break;\n          }\n        }\n      }\n\n      return obj;\n    },\n    // Support: Android <=4.0 only\n    trim: function trim(text) {\n      return text == null ? \"\" : (text + \"\").replace(rtrim, \"\");\n    },\n    // results is for internal usage only\n    makeArray: function makeArray(arr, results) {\n      var ret = results || [];\n\n      if (arr != null) {\n        if (isArrayLike(Object(arr))) {\n          jQuery.merge(ret, typeof arr === \"string\" ? [arr] : arr);\n        } else {\n          push.call(ret, arr);\n        }\n      }\n\n      return ret;\n    },\n    inArray: function inArray(elem, arr, i) {\n      return arr == null ? -1 : indexOf.call(arr, elem, i);\n    },\n    // Support: Android <=4.0 only, PhantomJS 1 only\n    // push.apply(_, arraylike) throws on ancient WebKit\n    merge: function merge(first, second) {\n      var len = +second.length,\n          j = 0,\n          i = first.length;\n\n      for (; j < len; j++) {\n        first[i++] = second[j];\n      }\n\n      first.length = i;\n      return first;\n    },\n    grep: function grep(elems, callback, invert) {\n      var callbackInverse,\n          matches = [],\n          i = 0,\n          length = elems.length,\n          callbackExpect = !invert; // Go through the array, only saving the items\n      // that pass the validator function\n\n      for (; i < length; i++) {\n        callbackInverse = !callback(elems[i], i);\n\n        if (callbackInverse !== callbackExpect) {\n          matches.push(elems[i]);\n        }\n      }\n\n      return matches;\n    },\n    // arg is for internal usage only\n    map: function map(elems, callback, arg) {\n      var length,\n          value,\n          i = 0,\n          ret = []; // Go through the array, translating each of the items to their new values\n\n      if (isArrayLike(elems)) {\n        length = elems.length;\n\n        for (; i < length; i++) {\n          value = callback(elems[i], i, arg);\n\n          if (value != null) {\n            ret.push(value);\n          }\n        } // Go through every key on the object,\n\n      } else {\n        for (i in elems) {\n          value = callback(elems[i], i, arg);\n\n          if (value != null) {\n            ret.push(value);\n          }\n        }\n      } // Flatten any nested arrays\n\n\n      return concat.apply([], ret);\n    },\n    // A global GUID counter for objects\n    guid: 1,\n    // jQuery.support is not used in Core but other projects attach their\n    // properties to it so it needs to exist.\n    support: support\n  });\n\n  if (typeof Symbol === \"function\") {\n    jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];\n  } // Populate the class2type map\n\n\n  jQuery.each(\"Boolean Number String Function Array Date RegExp Object Error Symbol\".split(\" \"), function (i, name) {\n    class2type[\"[object \" + name + \"]\"] = name.toLowerCase();\n  });\n\n  function isArrayLike(obj) {\n    // Support: real iOS 8.2 only (not reproducible in simulator)\n    // `in` check used to prevent JIT error (gh-2145)\n    // hasOwn isn't used here due to false negatives\n    // regarding Nodelist length in IE\n    var length = !!obj && \"length\" in obj && obj.length,\n        type = toType(obj);\n\n    if (isFunction(obj) || isWindow(obj)) {\n      return false;\n    }\n\n    return type === \"array\" || length === 0 || typeof length === \"number\" && length > 0 && length - 1 in obj;\n  }\n\n  var Sizzle =\n  /*!\n   * Sizzle CSS Selector Engine v2.3.4\n   * https://sizzlejs.com/\n   *\n   * Copyright JS Foundation and other contributors\n   * Released under the MIT license\n   * https://js.foundation/\n   *\n   * Date: 2019-04-08\n   */\n  function (window) {\n    var i,\n        support,\n        Expr,\n        getText,\n        isXML,\n        tokenize,\n        compile,\n        select,\n        outermostContext,\n        sortInput,\n        hasDuplicate,\n        // Local document vars\n    setDocument,\n        document,\n        docElem,\n        documentIsHTML,\n        rbuggyQSA,\n        rbuggyMatches,\n        matches,\n        contains,\n        // Instance-specific data\n    expando = \"sizzle\" + 1 * new Date(),\n        preferredDoc = window.document,\n        dirruns = 0,\n        done = 0,\n        classCache = createCache(),\n        tokenCache = createCache(),\n        compilerCache = createCache(),\n        nonnativeSelectorCache = createCache(),\n        sortOrder = function sortOrder(a, b) {\n      if (a === b) {\n        hasDuplicate = true;\n      }\n\n      return 0;\n    },\n        // Instance methods\n    hasOwn = {}.hasOwnProperty,\n        arr = [],\n        pop = arr.pop,\n        push_native = arr.push,\n        push = arr.push,\n        slice = arr.slice,\n        // Use a stripped-down indexOf as it's faster than native\n    // https://jsperf.com/thor-indexof-vs-for/5\n    indexOf = function indexOf(list, elem) {\n      var i = 0,\n          len = list.length;\n\n      for (; i < len; i++) {\n        if (list[i] === elem) {\n          return i;\n        }\n      }\n\n      return -1;\n    },\n        booleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped\",\n        // Regular expressions\n    // http://www.w3.org/TR/css3-selectors/#whitespace\n    whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n        // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier\n    identifier = \"(?:\\\\\\\\.|[\\\\w-]|[^\\0-\\\\xa0])+\",\n        // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n    attributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace + // Operator (capture 2)\n    \"*([*^$|!~]?=)\" + whitespace + // \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n    \"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" + whitespace + \"*\\\\]\",\n        pseudos = \":(\" + identifier + \")(?:\\\\((\" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n    // 1. quoted (capture 3; capture 4 or capture 5)\n    \"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" + // 2. simple (capture 6)\n    \"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" + // 3. anything else (capture 2)\n    \".*\" + \")\\\\)|)\",\n        // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n    rwhitespace = new RegExp(whitespace + \"+\", \"g\"),\n        rtrim = new RegExp(\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\"),\n        rcomma = new RegExp(\"^\" + whitespace + \"*,\" + whitespace + \"*\"),\n        rcombinators = new RegExp(\"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace + \"*\"),\n        rdescend = new RegExp(whitespace + \"|>\"),\n        rpseudo = new RegExp(pseudos),\n        ridentifier = new RegExp(\"^\" + identifier + \"$\"),\n        matchExpr = {\n      \"ID\": new RegExp(\"^#(\" + identifier + \")\"),\n      \"CLASS\": new RegExp(\"^\\\\.(\" + identifier + \")\"),\n      \"TAG\": new RegExp(\"^(\" + identifier + \"|[*])\"),\n      \"ATTR\": new RegExp(\"^\" + attributes),\n      \"PSEUDO\": new RegExp(\"^\" + pseudos),\n      \"CHILD\": new RegExp(\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\"),\n      \"bool\": new RegExp(\"^(?:\" + booleans + \")$\", \"i\"),\n      // For use in libraries implementing .is()\n      // We use this for POS matching in `select`\n      \"needsContext\": new RegExp(\"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\")\n    },\n        rhtml = /HTML$/i,\n        rinputs = /^(?:input|select|textarea|button)$/i,\n        rheader = /^h\\d$/i,\n        rnative = /^[^{]+\\{\\s*\\[native \\w/,\n        // Easily-parseable/retrievable ID or TAG or CLASS selectors\n    rquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n        rsibling = /[+~]/,\n        // CSS escapes\n    // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n    runescape = new RegExp(\"\\\\\\\\([\\\\da-f]{1,6}\" + whitespace + \"?|(\" + whitespace + \")|.)\", \"ig\"),\n        funescape = function funescape(_, escaped, escapedWhitespace) {\n      var high = \"0x\" + escaped - 0x10000; // NaN means non-codepoint\n      // Support: Firefox<24\n      // Workaround erroneous numeric interpretation of +\"0x\"\n\n      return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint\n      String.fromCharCode(high + 0x10000) : // Supplemental Plane codepoint (surrogate pair)\n      String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);\n    },\n        // CSS string/identifier serialization\n    // https://drafts.csswg.org/cssom/#common-serializing-idioms\n    rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n        fcssescape = function fcssescape(ch, asCodePoint) {\n      if (asCodePoint) {\n        // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n        if (ch === \"\\0\") {\n          return \"\\uFFFD\";\n        } // Control characters and (dependent upon position) numbers get escaped as code points\n\n\n        return ch.slice(0, -1) + \"\\\\\" + ch.charCodeAt(ch.length - 1).toString(16) + \" \";\n      } // Other potentially-special ASCII characters get backslash-escaped\n\n\n      return \"\\\\\" + ch;\n    },\n        // Used for iframes\n    // See setDocument()\n    // Removing the function wrapper causes a \"Permission Denied\"\n    // error in IE\n    unloadHandler = function unloadHandler() {\n      setDocument();\n    },\n        inDisabledFieldset = addCombinator(function (elem) {\n      return elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\n    }, {\n      dir: \"parentNode\",\n      next: \"legend\"\n    }); // Optimize for push.apply( _, NodeList )\n\n\n    try {\n      push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes); // Support: Android<4.0\n      // Detect silently failing push.apply\n\n      arr[preferredDoc.childNodes.length].nodeType;\n    } catch (e) {\n      push = {\n        apply: arr.length ? // Leverage slice if possible\n        function (target, els) {\n          push_native.apply(target, slice.call(els));\n        } : // Support: IE<9\n        // Otherwise append directly\n        function (target, els) {\n          var j = target.length,\n              i = 0; // Can't trust NodeList.length\n\n          while (target[j++] = els[i++]) {}\n\n          target.length = j - 1;\n        }\n      };\n    }\n\n    function Sizzle(selector, context, results, seed) {\n      var m,\n          i,\n          elem,\n          nid,\n          match,\n          groups,\n          newSelector,\n          newContext = context && context.ownerDocument,\n          // nodeType defaults to 9, since context defaults to document\n      nodeType = context ? context.nodeType : 9;\n      results = results || []; // Return early from calls with invalid selector or context\n\n      if (typeof selector !== \"string\" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {\n        return results;\n      } // Try to shortcut find operations (as opposed to filters) in HTML documents\n\n\n      if (!seed) {\n        if ((context ? context.ownerDocument || context : preferredDoc) !== document) {\n          setDocument(context);\n        }\n\n        context = context || document;\n\n        if (documentIsHTML) {\n          // If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n          // (excepting DocumentFragment context, where the methods don't exist)\n          if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {\n            // ID selector\n            if (m = match[1]) {\n              // Document context\n              if (nodeType === 9) {\n                if (elem = context.getElementById(m)) {\n                  // Support: IE, Opera, Webkit\n                  // TODO: identify versions\n                  // getElementById can match elements by name instead of ID\n                  if (elem.id === m) {\n                    results.push(elem);\n                    return results;\n                  }\n                } else {\n                  return results;\n                } // Element context\n\n              } else {\n                // Support: IE, Opera, Webkit\n                // TODO: identify versions\n                // getElementById can match elements by name instead of ID\n                if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {\n                  results.push(elem);\n                  return results;\n                }\n              } // Type selector\n\n            } else if (match[2]) {\n              push.apply(results, context.getElementsByTagName(selector));\n              return results; // Class selector\n            } else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {\n              push.apply(results, context.getElementsByClassName(m));\n              return results;\n            }\n          } // Take advantage of querySelectorAll\n\n\n          if (support.qsa && !nonnativeSelectorCache[selector + \" \"] && (!rbuggyQSA || !rbuggyQSA.test(selector)) && ( // Support: IE 8 only\n          // Exclude object elements\n          nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\")) {\n            newSelector = selector;\n            newContext = context; // qSA considers elements outside a scoping root when evaluating child or\n            // descendant combinators, which is not what we want.\n            // In such cases, we work around the behavior by prefixing every selector in the\n            // list with an ID selector referencing the scope context.\n            // Thanks to Andrew Dupont for this technique.\n\n            if (nodeType === 1 && rdescend.test(selector)) {\n              // Capture the context ID, setting it first if necessary\n              if (nid = context.getAttribute(\"id\")) {\n                nid = nid.replace(rcssescape, fcssescape);\n              } else {\n                context.setAttribute(\"id\", nid = expando);\n              } // Prefix every selector in the list\n\n\n              groups = tokenize(selector);\n              i = groups.length;\n\n              while (i--) {\n                groups[i] = \"#\" + nid + \" \" + toSelector(groups[i]);\n              }\n\n              newSelector = groups.join(\",\"); // Expand context for sibling selectors\n\n              newContext = rsibling.test(selector) && testContext(context.parentNode) || context;\n            }\n\n            try {\n              push.apply(results, newContext.querySelectorAll(newSelector));\n              return results;\n            } catch (qsaError) {\n              nonnativeSelectorCache(selector, true);\n            } finally {\n              if (nid === expando) {\n                context.removeAttribute(\"id\");\n              }\n            }\n          }\n        }\n      } // All others\n\n\n      return select(selector.replace(rtrim, \"$1\"), context, results, seed);\n    }\n    /**\n     * Create key-value caches of limited size\n     * @returns {function(string, object)} Returns the Object data after storing it on itself with\n     *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n     *\tdeleting the oldest entry\n     */\n\n\n    function createCache() {\n      var keys = [];\n\n      function cache(key, value) {\n        // Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n        if (keys.push(key + \" \") > Expr.cacheLength) {\n          // Only keep the most recent entries\n          delete cache[keys.shift()];\n        }\n\n        return cache[key + \" \"] = value;\n      }\n\n      return cache;\n    }\n    /**\n     * Mark a function for special use by Sizzle\n     * @param {Function} fn The function to mark\n     */\n\n\n    function markFunction(fn) {\n      fn[expando] = true;\n      return fn;\n    }\n    /**\n     * Support testing using an element\n     * @param {Function} fn Passed the created element and returns a boolean result\n     */\n\n\n    function assert(fn) {\n      var el = document.createElement(\"fieldset\");\n\n      try {\n        return !!fn(el);\n      } catch (e) {\n        return false;\n      } finally {\n        // Remove from its parent by default\n        if (el.parentNode) {\n          el.parentNode.removeChild(el);\n        } // release memory in IE\n\n\n        el = null;\n      }\n    }\n    /**\n     * Adds the same handler for all of the specified attrs\n     * @param {String} attrs Pipe-separated list of attributes\n     * @param {Function} handler The method that will be applied\n     */\n\n\n    function addHandle(attrs, handler) {\n      var arr = attrs.split(\"|\"),\n          i = arr.length;\n\n      while (i--) {\n        Expr.attrHandle[arr[i]] = handler;\n      }\n    }\n    /**\n     * Checks document order of two siblings\n     * @param {Element} a\n     * @param {Element} b\n     * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n     */\n\n\n    function siblingCheck(a, b) {\n      var cur = b && a,\n          diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes\n\n      if (diff) {\n        return diff;\n      } // Check if b follows a\n\n\n      if (cur) {\n        while (cur = cur.nextSibling) {\n          if (cur === b) {\n            return -1;\n          }\n        }\n      }\n\n      return a ? 1 : -1;\n    }\n    /**\n     * Returns a function to use in pseudos for input types\n     * @param {String} type\n     */\n\n\n    function createInputPseudo(type) {\n      return function (elem) {\n        var name = elem.nodeName.toLowerCase();\n        return name === \"input\" && elem.type === type;\n      };\n    }\n    /**\n     * Returns a function to use in pseudos for buttons\n     * @param {String} type\n     */\n\n\n    function createButtonPseudo(type) {\n      return function (elem) {\n        var name = elem.nodeName.toLowerCase();\n        return (name === \"input\" || name === \"button\") && elem.type === type;\n      };\n    }\n    /**\n     * Returns a function to use in pseudos for :enabled/:disabled\n     * @param {Boolean} disabled true for :disabled; false for :enabled\n     */\n\n\n    function createDisabledPseudo(disabled) {\n      // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n      return function (elem) {\n        // Only certain elements can match :enabled or :disabled\n        // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n        // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n        if (\"form\" in elem) {\n          // Check for inherited disabledness on relevant non-disabled elements:\n          // * listed form-associated elements in a disabled fieldset\n          //   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n          //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n          // * option elements in a disabled optgroup\n          //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n          // All such elements have a \"form\" property.\n          if (elem.parentNode && elem.disabled === false) {\n            // Option elements defer to a parent optgroup if present\n            if (\"label\" in elem) {\n              if (\"label\" in elem.parentNode) {\n                return elem.parentNode.disabled === disabled;\n              } else {\n                return elem.disabled === disabled;\n              }\n            } // Support: IE 6 - 11\n            // Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\n\n            return elem.isDisabled === disabled || // Where there is no isDisabled, check manually\n\n            /* jshint -W018 */\n            elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled;\n          }\n\n          return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property.\n          // Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n          // even exist on them, let alone have a boolean value.\n        } else if (\"label\" in elem) {\n          return elem.disabled === disabled;\n        } // Remaining elements are neither :enabled nor :disabled\n\n\n        return false;\n      };\n    }\n    /**\n     * Returns a function to use in pseudos for positionals\n     * @param {Function} fn\n     */\n\n\n    function createPositionalPseudo(fn) {\n      return markFunction(function (argument) {\n        argument = +argument;\n        return markFunction(function (seed, matches) {\n          var j,\n              matchIndexes = fn([], seed.length, argument),\n              i = matchIndexes.length; // Match elements found at the specified indexes\n\n          while (i--) {\n            if (seed[j = matchIndexes[i]]) {\n              seed[j] = !(matches[j] = seed[j]);\n            }\n          }\n        });\n      });\n    }\n    /**\n     * Checks a node for validity as a Sizzle context\n     * @param {Element|Object=} context\n     * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n     */\n\n\n    function testContext(context) {\n      return context && typeof context.getElementsByTagName !== \"undefined\" && context;\n    } // Expose support vars for convenience\n\n\n    support = Sizzle.support = {};\n    /**\n     * Detects XML nodes\n     * @param {Element|Object} elem An element or a document\n     * @returns {Boolean} True iff elem is a non-HTML XML node\n     */\n\n    isXML = Sizzle.isXML = function (elem) {\n      var namespace = elem.namespaceURI,\n          docElem = (elem.ownerDocument || elem).documentElement; // Support: IE <=8\n      // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\n      // https://bugs.jquery.com/ticket/4833\n\n      return !rhtml.test(namespace || docElem && docElem.nodeName || \"HTML\");\n    };\n    /**\n     * Sets document-related variables once based on the current document\n     * @param {Element|Object} [doc] An element or document object to use to set the document\n     * @returns {Object} Returns the current document\n     */\n\n\n    setDocument = Sizzle.setDocument = function (node) {\n      var hasCompare,\n          subWindow,\n          doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected\n\n      if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {\n        return document;\n      } // Update global variables\n\n\n      document = doc;\n      docElem = document.documentElement;\n      documentIsHTML = !isXML(document); // Support: IE 9-11, Edge\n      // Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\n      if (preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {\n        // Support: IE 11, Edge\n        if (subWindow.addEventListener) {\n          subWindow.addEventListener(\"unload\", unloadHandler, false); // Support: IE 9 - 10 only\n        } else if (subWindow.attachEvent) {\n          subWindow.attachEvent(\"onunload\", unloadHandler);\n        }\n      }\n      /* Attributes\n      ---------------------------------------------------------------------- */\n      // Support: IE<8\n      // Verify that getAttribute really returns attributes and not properties\n      // (excepting IE8 booleans)\n\n\n      support.attributes = assert(function (el) {\n        el.className = \"i\";\n        return !el.getAttribute(\"className\");\n      });\n      /* getElement(s)By*\n      ---------------------------------------------------------------------- */\n      // Check if getElementsByTagName(\"*\") returns only elements\n\n      support.getElementsByTagName = assert(function (el) {\n        el.appendChild(document.createComment(\"\"));\n        return !el.getElementsByTagName(\"*\").length;\n      }); // Support: IE<9\n\n      support.getElementsByClassName = rnative.test(document.getElementsByClassName); // Support: IE<10\n      // Check if getElementById returns elements by name\n      // The broken getElementById methods don't pick up programmatically-set names,\n      // so use a roundabout getElementsByName test\n\n      support.getById = assert(function (el) {\n        docElem.appendChild(el).id = expando;\n        return !document.getElementsByName || !document.getElementsByName(expando).length;\n      }); // ID filter and find\n\n      if (support.getById) {\n        Expr.filter[\"ID\"] = function (id) {\n          var attrId = id.replace(runescape, funescape);\n          return function (elem) {\n            return elem.getAttribute(\"id\") === attrId;\n          };\n        };\n\n        Expr.find[\"ID\"] = function (id, context) {\n          if (typeof context.getElementById !== \"undefined\" && documentIsHTML) {\n            var elem = context.getElementById(id);\n            return elem ? [elem] : [];\n          }\n        };\n      } else {\n        Expr.filter[\"ID\"] = function (id) {\n          var attrId = id.replace(runescape, funescape);\n          return function (elem) {\n            var node = typeof elem.getAttributeNode !== \"undefined\" && elem.getAttributeNode(\"id\");\n            return node && node.value === attrId;\n          };\n        }; // Support: IE 6 - 7 only\n        // getElementById is not reliable as a find shortcut\n\n\n        Expr.find[\"ID\"] = function (id, context) {\n          if (typeof context.getElementById !== \"undefined\" && documentIsHTML) {\n            var node,\n                i,\n                elems,\n                elem = context.getElementById(id);\n\n            if (elem) {\n              // Verify the id attribute\n              node = elem.getAttributeNode(\"id\");\n\n              if (node && node.value === id) {\n                return [elem];\n              } // Fall back on getElementsByName\n\n\n              elems = context.getElementsByName(id);\n              i = 0;\n\n              while (elem = elems[i++]) {\n                node = elem.getAttributeNode(\"id\");\n\n                if (node && node.value === id) {\n                  return [elem];\n                }\n              }\n            }\n\n            return [];\n          }\n        };\n      } // Tag\n\n\n      Expr.find[\"TAG\"] = support.getElementsByTagName ? function (tag, context) {\n        if (typeof context.getElementsByTagName !== \"undefined\") {\n          return context.getElementsByTagName(tag); // DocumentFragment nodes don't have gEBTN\n        } else if (support.qsa) {\n          return context.querySelectorAll(tag);\n        }\n      } : function (tag, context) {\n        var elem,\n            tmp = [],\n            i = 0,\n            // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n        results = context.getElementsByTagName(tag); // Filter out possible comments\n\n        if (tag === \"*\") {\n          while (elem = results[i++]) {\n            if (elem.nodeType === 1) {\n              tmp.push(elem);\n            }\n          }\n\n          return tmp;\n        }\n\n        return results;\n      }; // Class\n\n      Expr.find[\"CLASS\"] = support.getElementsByClassName && function (className, context) {\n        if (typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML) {\n          return context.getElementsByClassName(className);\n        }\n      };\n      /* QSA/matchesSelector\n      ---------------------------------------------------------------------- */\n      // QSA and matchesSelector support\n      // matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\n\n      rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21)\n      // We allow this because of a bug in IE8/9 that throws an error\n      // whenever `document.activeElement` is accessed on an iframe\n      // So, we allow :focus to pass through QSA all the time to avoid the IE error\n      // See https://bugs.jquery.com/ticket/13378\n\n      rbuggyQSA = [];\n\n      if (support.qsa = rnative.test(document.querySelectorAll)) {\n        // Build QSA regex\n        // Regex strategy adopted from Diego Perini\n        assert(function (el) {\n          // Select is set to empty string on purpose\n          // This is to test IE's treatment of not explicitly\n          // setting a boolean content attribute,\n          // since its presence should be enough\n          // https://bugs.jquery.com/ticket/12359\n          docElem.appendChild(el).innerHTML = \"<a id='\" + expando + \"'></a>\" + \"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" + \"<option selected=''></option></select>\"; // Support: IE8, Opera 11-12.16\n          // Nothing should be selected when empty strings follow ^= or $= or *=\n          // The test attribute must be unknown in Opera but \"safe\" for WinRT\n          // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\n          if (el.querySelectorAll(\"[msallowcapture^='']\").length) {\n            rbuggyQSA.push(\"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\");\n          } // Support: IE8\n          // Boolean attributes and \"value\" are not treated correctly\n\n\n          if (!el.querySelectorAll(\"[selected]\").length) {\n            rbuggyQSA.push(\"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\");\n          } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\n\n          if (!el.querySelectorAll(\"[id~=\" + expando + \"-]\").length) {\n            rbuggyQSA.push(\"~=\");\n          } // Webkit/Opera - :checked should return selected option elements\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n          // IE8 throws error here and will not see later tests\n\n\n          if (!el.querySelectorAll(\":checked\").length) {\n            rbuggyQSA.push(\":checked\");\n          } // Support: Safari 8+, iOS 8+\n          // https://bugs.webkit.org/show_bug.cgi?id=136851\n          // In-page `selector#id sibling-combinator selector` fails\n\n\n          if (!el.querySelectorAll(\"a#\" + expando + \"+*\").length) {\n            rbuggyQSA.push(\".#.+[+~]\");\n          }\n        });\n        assert(function (el) {\n          el.innerHTML = \"<a href='' disabled='disabled'></a>\" + \"<select disabled='disabled'><option/></select>\"; // Support: Windows 8 Native Apps\n          // The type and name attributes are restricted during .innerHTML assignment\n\n          var input = document.createElement(\"input\");\n          input.setAttribute(\"type\", \"hidden\");\n          el.appendChild(input).setAttribute(\"name\", \"D\"); // Support: IE8\n          // Enforce case-sensitivity of name attribute\n\n          if (el.querySelectorAll(\"[name=d]\").length) {\n            rbuggyQSA.push(\"name\" + whitespace + \"*[*^$|!~]?=\");\n          } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n          // IE8 throws error here and will not see later tests\n\n\n          if (el.querySelectorAll(\":enabled\").length !== 2) {\n            rbuggyQSA.push(\":enabled\", \":disabled\");\n          } // Support: IE9-11+\n          // IE's :disabled selector does not pick up the children of disabled fieldsets\n\n\n          docElem.appendChild(el).disabled = true;\n\n          if (el.querySelectorAll(\":disabled\").length !== 2) {\n            rbuggyQSA.push(\":enabled\", \":disabled\");\n          } // Opera 10-11 does not throw on post-comma invalid pseudos\n\n\n          el.querySelectorAll(\"*,:x\");\n          rbuggyQSA.push(\",.*:\");\n        });\n      }\n\n      if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {\n        assert(function (el) {\n          // Check to see if it's possible to do matchesSelector\n          // on a disconnected node (IE 9)\n          support.disconnectedMatch = matches.call(el, \"*\"); // This should fail with an exception\n          // Gecko does not error, returns false instead\n\n          matches.call(el, \"[s!='']:x\");\n          rbuggyMatches.push(\"!=\", pseudos);\n        });\n      }\n\n      rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join(\"|\"));\n      rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join(\"|\"));\n      /* Contains\n      ---------------------------------------------------------------------- */\n\n      hasCompare = rnative.test(docElem.compareDocumentPosition); // Element contains another\n      // Purposefully self-exclusive\n      // As in, an element does not contain itself\n\n      contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {\n        var adown = a.nodeType === 9 ? a.documentElement : a,\n            bup = b && b.parentNode;\n        return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));\n      } : function (a, b) {\n        if (b) {\n          while (b = b.parentNode) {\n            if (b === a) {\n              return true;\n            }\n          }\n        }\n\n        return false;\n      };\n      /* Sorting\n      ---------------------------------------------------------------------- */\n      // Document order sorting\n\n      sortOrder = hasCompare ? function (a, b) {\n        // Flag for duplicate removal\n        if (a === b) {\n          hasDuplicate = true;\n          return 0;\n        } // Sort on method existence if only one input has compareDocumentPosition\n\n\n        var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\n        if (compare) {\n          return compare;\n        } // Calculate position if both inputs belong to the same document\n\n\n        compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : // Otherwise we know they are disconnected\n        1; // Disconnected nodes\n\n        if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {\n          // Choose the first element that is related to our preferred document\n          if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {\n            return -1;\n          }\n\n          if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {\n            return 1;\n          } // Maintain original order\n\n\n          return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;\n        }\n\n        return compare & 4 ? -1 : 1;\n      } : function (a, b) {\n        // Exit early if the nodes are identical\n        if (a === b) {\n          hasDuplicate = true;\n          return 0;\n        }\n\n        var cur,\n            i = 0,\n            aup = a.parentNode,\n            bup = b.parentNode,\n            ap = [a],\n            bp = [b]; // Parentless nodes are either documents or disconnected\n\n        if (!aup || !bup) {\n          return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0; // If the nodes are siblings, we can do a quick check\n        } else if (aup === bup) {\n          return siblingCheck(a, b);\n        } // Otherwise we need full lists of their ancestors for comparison\n\n\n        cur = a;\n\n        while (cur = cur.parentNode) {\n          ap.unshift(cur);\n        }\n\n        cur = b;\n\n        while (cur = cur.parentNode) {\n          bp.unshift(cur);\n        } // Walk down the tree looking for a discrepancy\n\n\n        while (ap[i] === bp[i]) {\n          i++;\n        }\n\n        return i ? // Do a sibling check if the nodes have a common ancestor\n        siblingCheck(ap[i], bp[i]) : // Otherwise nodes in our document sort first\n        ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;\n      };\n      return document;\n    };\n\n    Sizzle.matches = function (expr, elements) {\n      return Sizzle(expr, null, null, elements);\n    };\n\n    Sizzle.matchesSelector = function (elem, expr) {\n      // Set document vars if needed\n      if ((elem.ownerDocument || elem) !== document) {\n        setDocument(elem);\n      }\n\n      if (support.matchesSelector && documentIsHTML && !nonnativeSelectorCache[expr + \" \"] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {\n        try {\n          var ret = matches.call(elem, expr); // IE 9's matchesSelector returns false on disconnected nodes\n\n          if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document\n          // fragment in IE 9\n          elem.document && elem.document.nodeType !== 11) {\n            return ret;\n          }\n        } catch (e) {\n          nonnativeSelectorCache(expr, true);\n        }\n      }\n\n      return Sizzle(expr, document, null, [elem]).length > 0;\n    };\n\n    Sizzle.contains = function (context, elem) {\n      // Set document vars if needed\n      if ((context.ownerDocument || context) !== document) {\n        setDocument(context);\n      }\n\n      return contains(context, elem);\n    };\n\n    Sizzle.attr = function (elem, name) {\n      // Set document vars if needed\n      if ((elem.ownerDocument || elem) !== document) {\n        setDocument(elem);\n      }\n\n      var fn = Expr.attrHandle[name.toLowerCase()],\n          // Don't get fooled by Object.prototype properties (jQuery #13807)\n      val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;\n      return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;\n    };\n\n    Sizzle.escape = function (sel) {\n      return (sel + \"\").replace(rcssescape, fcssescape);\n    };\n\n    Sizzle.error = function (msg) {\n      throw new Error(\"Syntax error, unrecognized expression: \" + msg);\n    };\n    /**\n     * Document sorting and removing duplicates\n     * @param {ArrayLike} results\n     */\n\n\n    Sizzle.uniqueSort = function (results) {\n      var elem,\n          duplicates = [],\n          j = 0,\n          i = 0; // Unless we *know* we can detect duplicates, assume their presence\n\n      hasDuplicate = !support.detectDuplicates;\n      sortInput = !support.sortStable && results.slice(0);\n      results.sort(sortOrder);\n\n      if (hasDuplicate) {\n        while (elem = results[i++]) {\n          if (elem === results[i]) {\n            j = duplicates.push(i);\n          }\n        }\n\n        while (j--) {\n          results.splice(duplicates[j], 1);\n        }\n      } // Clear input after sorting to release objects\n      // See https://github.com/jquery/sizzle/pull/225\n\n\n      sortInput = null;\n      return results;\n    };\n    /**\n     * Utility function for retrieving the text value of an array of DOM nodes\n     * @param {Array|Element} elem\n     */\n\n\n    getText = Sizzle.getText = function (elem) {\n      var node,\n          ret = \"\",\n          i = 0,\n          nodeType = elem.nodeType;\n\n      if (!nodeType) {\n        // If no nodeType, this is expected to be an array\n        while (node = elem[i++]) {\n          // Do not traverse comment nodes\n          ret += getText(node);\n        }\n      } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {\n        // Use textContent for elements\n        // innerText usage removed for consistency of new lines (jQuery #11153)\n        if (typeof elem.textContent === \"string\") {\n          return elem.textContent;\n        } else {\n          // Traverse its children\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\n            ret += getText(elem);\n          }\n        }\n      } else if (nodeType === 3 || nodeType === 4) {\n        return elem.nodeValue;\n      } // Do not include comment or processing instruction nodes\n\n\n      return ret;\n    };\n\n    Expr = Sizzle.selectors = {\n      // Can be adjusted by the user\n      cacheLength: 50,\n      createPseudo: markFunction,\n      match: matchExpr,\n      attrHandle: {},\n      find: {},\n      relative: {\n        \">\": {\n          dir: \"parentNode\",\n          first: true\n        },\n        \" \": {\n          dir: \"parentNode\"\n        },\n        \"+\": {\n          dir: \"previousSibling\",\n          first: true\n        },\n        \"~\": {\n          dir: \"previousSibling\"\n        }\n      },\n      preFilter: {\n        \"ATTR\": function ATTR(match) {\n          match[1] = match[1].replace(runescape, funescape); // Move the given value to match[3] whether quoted or unquoted\n\n          match[3] = (match[3] || match[4] || match[5] || \"\").replace(runescape, funescape);\n\n          if (match[2] === \"~=\") {\n            match[3] = \" \" + match[3] + \" \";\n          }\n\n          return match.slice(0, 4);\n        },\n        \"CHILD\": function CHILD(match) {\n          /* matches from matchExpr[\"CHILD\"]\n          \t1 type (only|nth|...)\n          \t2 what (child|of-type)\n          \t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n          \t4 xn-component of xn+y argument ([+-]?\\d*n|)\n          \t5 sign of xn-component\n          \t6 x of xn-component\n          \t7 sign of y-component\n          \t8 y of y-component\n          */\n          match[1] = match[1].toLowerCase();\n\n          if (match[1].slice(0, 3) === \"nth\") {\n            // nth-* requires argument\n            if (!match[3]) {\n              Sizzle.error(match[0]);\n            } // numeric x and y parameters for Expr.filter.CHILD\n            // remember that false/true cast respectively to 0/1\n\n\n            match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === \"even\" || match[3] === \"odd\"));\n            match[5] = +(match[7] + match[8] || match[3] === \"odd\"); // other types prohibit arguments\n          } else if (match[3]) {\n            Sizzle.error(match[0]);\n          }\n\n          return match;\n        },\n        \"PSEUDO\": function PSEUDO(match) {\n          var excess,\n              unquoted = !match[6] && match[2];\n\n          if (matchExpr[\"CHILD\"].test(match[0])) {\n            return null;\n          } // Accept quoted arguments as-is\n\n\n          if (match[3]) {\n            match[2] = match[4] || match[5] || \"\"; // Strip excess characters from unquoted arguments\n          } else if (unquoted && rpseudo.test(unquoted) && ( // Get excess from tokenize (recursively)\n          excess = tokenize(unquoted, true)) && ( // advance to the next closing parenthesis\n          excess = unquoted.indexOf(\")\", unquoted.length - excess) - unquoted.length)) {\n            // excess is a negative index\n            match[0] = match[0].slice(0, excess);\n            match[2] = unquoted.slice(0, excess);\n          } // Return only captures needed by the pseudo filter method (type and argument)\n\n\n          return match.slice(0, 3);\n        }\n      },\n      filter: {\n        \"TAG\": function TAG(nodeNameSelector) {\n          var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();\n          return nodeNameSelector === \"*\" ? function () {\n            return true;\n          } : function (elem) {\n            return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n          };\n        },\n        \"CLASS\": function CLASS(className) {\n          var pattern = classCache[className + \" \"];\n          return pattern || (pattern = new RegExp(\"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\")) && classCache(className, function (elem) {\n            return pattern.test(typeof elem.className === \"string\" && elem.className || typeof elem.getAttribute !== \"undefined\" && elem.getAttribute(\"class\") || \"\");\n          });\n        },\n        \"ATTR\": function ATTR(name, operator, check) {\n          return function (elem) {\n            var result = Sizzle.attr(elem, name);\n\n            if (result == null) {\n              return operator === \"!=\";\n            }\n\n            if (!operator) {\n              return true;\n            }\n\n            result += \"\";\n            return operator === \"=\" ? result === check : operator === \"!=\" ? result !== check : operator === \"^=\" ? check && result.indexOf(check) === 0 : operator === \"*=\" ? check && result.indexOf(check) > -1 : operator === \"$=\" ? check && result.slice(-check.length) === check : operator === \"~=\" ? (\" \" + result.replace(rwhitespace, \" \") + \" \").indexOf(check) > -1 : operator === \"|=\" ? result === check || result.slice(0, check.length + 1) === check + \"-\" : false;\n          };\n        },\n        \"CHILD\": function CHILD(type, what, argument, first, last) {\n          var simple = type.slice(0, 3) !== \"nth\",\n              forward = type.slice(-4) !== \"last\",\n              ofType = what === \"of-type\";\n          return first === 1 && last === 0 ? // Shortcut for :nth-*(n)\n          function (elem) {\n            return !!elem.parentNode;\n          } : function (elem, context, xml) {\n            var cache,\n                uniqueCache,\n                outerCache,\n                node,\n                nodeIndex,\n                start,\n                dir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n                parent = elem.parentNode,\n                name = ofType && elem.nodeName.toLowerCase(),\n                useCache = !xml && !ofType,\n                diff = false;\n\n            if (parent) {\n              // :(first|last|only)-(child|of-type)\n              if (simple) {\n                while (dir) {\n                  node = elem;\n\n                  while (node = node[dir]) {\n                    if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {\n                      return false;\n                    }\n                  } // Reverse direction for :only-* (if we haven't yet done so)\n\n\n                  start = dir = type === \"only\" && !start && \"nextSibling\";\n                }\n\n                return true;\n              }\n\n              start = [forward ? parent.firstChild : parent.lastChild]; // non-xml :nth-child(...) stores cache data on `parent`\n\n              if (forward && useCache) {\n                // Seek `elem` from a previously-cached index\n                // ...in a gzip-friendly way\n                node = parent;\n                outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only\n                // Defend against cloned attroperties (jQuery gh-1709)\n\n                uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});\n                cache = uniqueCache[type] || [];\n                nodeIndex = cache[0] === dirruns && cache[1];\n                diff = nodeIndex && cache[2];\n                node = nodeIndex && parent.childNodes[nodeIndex];\n\n                while (node = ++nodeIndex && node && node[dir] || ( // Fallback to seeking `elem` from the start\n                diff = nodeIndex = 0) || start.pop()) {\n                  // When found, cache indexes on `parent` and break\n                  if (node.nodeType === 1 && ++diff && node === elem) {\n                    uniqueCache[type] = [dirruns, nodeIndex, diff];\n                    break;\n                  }\n                }\n              } else {\n                // Use previously-cached element index if available\n                if (useCache) {\n                  // ...in a gzip-friendly way\n                  node = elem;\n                  outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only\n                  // Defend against cloned attroperties (jQuery gh-1709)\n\n                  uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});\n                  cache = uniqueCache[type] || [];\n                  nodeIndex = cache[0] === dirruns && cache[1];\n                  diff = nodeIndex;\n                } // xml :nth-child(...)\n                // or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\n\n                if (diff === false) {\n                  // Use the same loop as above to seek `elem` from the start\n                  while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {\n                    if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {\n                      // Cache the index of each encountered element\n                      if (useCache) {\n                        outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only\n                        // Defend against cloned attroperties (jQuery gh-1709)\n\n                        uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});\n                        uniqueCache[type] = [dirruns, diff];\n                      }\n\n                      if (node === elem) {\n                        break;\n                      }\n                    }\n                  }\n                }\n              } // Incorporate the offset, then check against cycle size\n\n\n              diff -= last;\n              return diff === first || diff % first === 0 && diff / first >= 0;\n            }\n          };\n        },\n        \"PSEUDO\": function PSEUDO(pseudo, argument) {\n          // pseudo-class names are case-insensitive\n          // http://www.w3.org/TR/selectors/#pseudo-classes\n          // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n          // Remember that setFilters inherits from pseudos\n          var args,\n              fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error(\"unsupported pseudo: \" + pseudo); // The user may use createPseudo to indicate that\n          // arguments are needed to create the filter function\n          // just as Sizzle does\n\n          if (fn[expando]) {\n            return fn(argument);\n          } // But maintain support for old signatures\n\n\n          if (fn.length > 1) {\n            args = [pseudo, pseudo, \"\", argument];\n            return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {\n              var idx,\n                  matched = fn(seed, argument),\n                  i = matched.length;\n\n              while (i--) {\n                idx = indexOf(seed, matched[i]);\n                seed[idx] = !(matches[idx] = matched[i]);\n              }\n            }) : function (elem) {\n              return fn(elem, 0, args);\n            };\n          }\n\n          return fn;\n        }\n      },\n      pseudos: {\n        // Potentially complex pseudos\n        \"not\": markFunction(function (selector) {\n          // Trim the selector passed to compile\n          // to avoid treating leading and trailing\n          // spaces as combinators\n          var input = [],\n              results = [],\n              matcher = compile(selector.replace(rtrim, \"$1\"));\n          return matcher[expando] ? markFunction(function (seed, matches, context, xml) {\n            var elem,\n                unmatched = matcher(seed, null, xml, []),\n                i = seed.length; // Match elements unmatched by `matcher`\n\n            while (i--) {\n              if (elem = unmatched[i]) {\n                seed[i] = !(matches[i] = elem);\n              }\n            }\n          }) : function (elem, context, xml) {\n            input[0] = elem;\n            matcher(input, null, xml, results); // Don't keep the element (issue #299)\n\n            input[0] = null;\n            return !results.pop();\n          };\n        }),\n        \"has\": markFunction(function (selector) {\n          return function (elem) {\n            return Sizzle(selector, elem).length > 0;\n          };\n        }),\n        \"contains\": markFunction(function (text) {\n          text = text.replace(runescape, funescape);\n          return function (elem) {\n            return (elem.textContent || getText(elem)).indexOf(text) > -1;\n          };\n        }),\n        // \"Whether an element is represented by a :lang() selector\n        // is based solely on the element's language value\n        // being equal to the identifier C,\n        // or beginning with the identifier C immediately followed by \"-\".\n        // The matching of C against the element's language value is performed case-insensitively.\n        // The identifier C does not have to be a valid language name.\"\n        // http://www.w3.org/TR/selectors/#lang-pseudo\n        \"lang\": markFunction(function (lang) {\n          // lang value must be a valid identifier\n          if (!ridentifier.test(lang || \"\")) {\n            Sizzle.error(\"unsupported lang: \" + lang);\n          }\n\n          lang = lang.replace(runescape, funescape).toLowerCase();\n          return function (elem) {\n            var elemLang;\n\n            do {\n              if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) {\n                elemLang = elemLang.toLowerCase();\n                return elemLang === lang || elemLang.indexOf(lang + \"-\") === 0;\n              }\n            } while ((elem = elem.parentNode) && elem.nodeType === 1);\n\n            return false;\n          };\n        }),\n        // Miscellaneous\n        \"target\": function target(elem) {\n          var hash = window.location && window.location.hash;\n          return hash && hash.slice(1) === elem.id;\n        },\n        \"root\": function root(elem) {\n          return elem === docElem;\n        },\n        \"focus\": function focus(elem) {\n          return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\n        },\n        // Boolean properties\n        \"enabled\": createDisabledPseudo(false),\n        \"disabled\": createDisabledPseudo(true),\n        \"checked\": function checked(elem) {\n          // In CSS3, :checked should return both checked and selected elements\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n          var nodeName = elem.nodeName.toLowerCase();\n          return nodeName === \"input\" && !!elem.checked || nodeName === \"option\" && !!elem.selected;\n        },\n        \"selected\": function selected(elem) {\n          // Accessing this property makes selected-by-default\n          // options in Safari work properly\n          if (elem.parentNode) {\n            elem.parentNode.selectedIndex;\n          }\n\n          return elem.selected === true;\n        },\n        // Contents\n        \"empty\": function empty(elem) {\n          // http://www.w3.org/TR/selectors/#empty-pseudo\n          // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n          //   but not by others (comment: 8; processing instruction: 7; etc.)\n          // nodeType < 6 works because attributes (2) do not appear as children\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\n            if (elem.nodeType < 6) {\n              return false;\n            }\n          }\n\n          return true;\n        },\n        \"parent\": function parent(elem) {\n          return !Expr.pseudos[\"empty\"](elem);\n        },\n        // Element/input types\n        \"header\": function header(elem) {\n          return rheader.test(elem.nodeName);\n        },\n        \"input\": function input(elem) {\n          return rinputs.test(elem.nodeName);\n        },\n        \"button\": function button(elem) {\n          var name = elem.nodeName.toLowerCase();\n          return name === \"input\" && elem.type === \"button\" || name === \"button\";\n        },\n        \"text\": function text(elem) {\n          var attr;\n          return elem.nodeName.toLowerCase() === \"input\" && elem.type === \"text\" && ( // Support: IE<8\n          // New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n          (attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === \"text\");\n        },\n        // Position-in-collection\n        \"first\": createPositionalPseudo(function () {\n          return [0];\n        }),\n        \"last\": createPositionalPseudo(function (matchIndexes, length) {\n          return [length - 1];\n        }),\n        \"eq\": createPositionalPseudo(function (matchIndexes, length, argument) {\n          return [argument < 0 ? argument + length : argument];\n        }),\n        \"even\": createPositionalPseudo(function (matchIndexes, length) {\n          var i = 0;\n\n          for (; i < length; i += 2) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        }),\n        \"odd\": createPositionalPseudo(function (matchIndexes, length) {\n          var i = 1;\n\n          for (; i < length; i += 2) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        }),\n        \"lt\": createPositionalPseudo(function (matchIndexes, length, argument) {\n          var i = argument < 0 ? argument + length : argument > length ? length : argument;\n\n          for (; --i >= 0;) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        }),\n        \"gt\": createPositionalPseudo(function (matchIndexes, length, argument) {\n          var i = argument < 0 ? argument + length : argument;\n\n          for (; ++i < length;) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        })\n      }\n    };\n    Expr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"]; // Add button/input type pseudos\n\n    for (i in {\n      radio: true,\n      checkbox: true,\n      file: true,\n      password: true,\n      image: true\n    }) {\n      Expr.pseudos[i] = createInputPseudo(i);\n    }\n\n    for (i in {\n      submit: true,\n      reset: true\n    }) {\n      Expr.pseudos[i] = createButtonPseudo(i);\n    } // Easy API for creating new setFilters\n\n\n    function setFilters() {}\n\n    setFilters.prototype = Expr.filters = Expr.pseudos;\n    Expr.setFilters = new setFilters();\n\n    tokenize = Sizzle.tokenize = function (selector, parseOnly) {\n      var matched,\n          match,\n          tokens,\n          type,\n          soFar,\n          groups,\n          preFilters,\n          cached = tokenCache[selector + \" \"];\n\n      if (cached) {\n        return parseOnly ? 0 : cached.slice(0);\n      }\n\n      soFar = selector;\n      groups = [];\n      preFilters = Expr.preFilter;\n\n      while (soFar) {\n        // Comma and first run\n        if (!matched || (match = rcomma.exec(soFar))) {\n          if (match) {\n            // Don't consume trailing commas as valid\n            soFar = soFar.slice(match[0].length) || soFar;\n          }\n\n          groups.push(tokens = []);\n        }\n\n        matched = false; // Combinators\n\n        if (match = rcombinators.exec(soFar)) {\n          matched = match.shift();\n          tokens.push({\n            value: matched,\n            // Cast descendant combinators to space\n            type: match[0].replace(rtrim, \" \")\n          });\n          soFar = soFar.slice(matched.length);\n        } // Filters\n\n\n        for (type in Expr.filter) {\n          if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {\n            matched = match.shift();\n            tokens.push({\n              value: matched,\n              type: type,\n              matches: match\n            });\n            soFar = soFar.slice(matched.length);\n          }\n        }\n\n        if (!matched) {\n          break;\n        }\n      } // Return the length of the invalid excess\n      // if we're just parsing\n      // Otherwise, throw an error or return tokens\n\n\n      return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : // Cache the tokens\n      tokenCache(selector, groups).slice(0);\n    };\n\n    function toSelector(tokens) {\n      var i = 0,\n          len = tokens.length,\n          selector = \"\";\n\n      for (; i < len; i++) {\n        selector += tokens[i].value;\n      }\n\n      return selector;\n    }\n\n    function addCombinator(matcher, combinator, base) {\n      var dir = combinator.dir,\n          skip = combinator.next,\n          key = skip || dir,\n          checkNonElements = base && key === \"parentNode\",\n          doneName = done++;\n      return combinator.first ? // Check against closest ancestor/preceding element\n      function (elem, context, xml) {\n        while (elem = elem[dir]) {\n          if (elem.nodeType === 1 || checkNonElements) {\n            return matcher(elem, context, xml);\n          }\n        }\n\n        return false;\n      } : // Check against all ancestor/preceding elements\n      function (elem, context, xml) {\n        var oldCache,\n            uniqueCache,\n            outerCache,\n            newCache = [dirruns, doneName]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\n        if (xml) {\n          while (elem = elem[dir]) {\n            if (elem.nodeType === 1 || checkNonElements) {\n              if (matcher(elem, context, xml)) {\n                return true;\n              }\n            }\n          }\n        } else {\n          while (elem = elem[dir]) {\n            if (elem.nodeType === 1 || checkNonElements) {\n              outerCache = elem[expando] || (elem[expando] = {}); // Support: IE <9 only\n              // Defend against cloned attroperties (jQuery gh-1709)\n\n              uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});\n\n              if (skip && skip === elem.nodeName.toLowerCase()) {\n                elem = elem[dir] || elem;\n              } else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {\n                // Assign to newCache so results back-propagate to previous elements\n                return newCache[2] = oldCache[2];\n              } else {\n                // Reuse newcache so results back-propagate to previous elements\n                uniqueCache[key] = newCache; // A match means we're done; a fail means we have to keep checking\n\n                if (newCache[2] = matcher(elem, context, xml)) {\n                  return true;\n                }\n              }\n            }\n          }\n        }\n\n        return false;\n      };\n    }\n\n    function elementMatcher(matchers) {\n      return matchers.length > 1 ? function (elem, context, xml) {\n        var i = matchers.length;\n\n        while (i--) {\n          if (!matchers[i](elem, context, xml)) {\n            return false;\n          }\n        }\n\n        return true;\n      } : matchers[0];\n    }\n\n    function multipleContexts(selector, contexts, results) {\n      var i = 0,\n          len = contexts.length;\n\n      for (; i < len; i++) {\n        Sizzle(selector, contexts[i], results);\n      }\n\n      return results;\n    }\n\n    function condense(unmatched, map, filter, context, xml) {\n      var elem,\n          newUnmatched = [],\n          i = 0,\n          len = unmatched.length,\n          mapped = map != null;\n\n      for (; i < len; i++) {\n        if (elem = unmatched[i]) {\n          if (!filter || filter(elem, context, xml)) {\n            newUnmatched.push(elem);\n\n            if (mapped) {\n              map.push(i);\n            }\n          }\n        }\n      }\n\n      return newUnmatched;\n    }\n\n    function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {\n      if (postFilter && !postFilter[expando]) {\n        postFilter = setMatcher(postFilter);\n      }\n\n      if (postFinder && !postFinder[expando]) {\n        postFinder = setMatcher(postFinder, postSelector);\n      }\n\n      return markFunction(function (seed, results, context, xml) {\n        var temp,\n            i,\n            elem,\n            preMap = [],\n            postMap = [],\n            preexisting = results.length,\n            // Get initial elements from seed or context\n        elems = seed || multipleContexts(selector || \"*\", context.nodeType ? [context] : context, []),\n            // Prefilter to get matcher input, preserving a map for seed-results synchronization\n        matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,\n            matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n        postFinder || (seed ? preFilter : preexisting || postFilter) ? // ...intermediate processing is necessary\n        [] : // ...otherwise use results directly\n        results : matcherIn; // Find primary matches\n\n        if (matcher) {\n          matcher(matcherIn, matcherOut, context, xml);\n        } // Apply postFilter\n\n\n        if (postFilter) {\n          temp = condense(matcherOut, postMap);\n          postFilter(temp, [], context, xml); // Un-match failing elements by moving them back to matcherIn\n\n          i = temp.length;\n\n          while (i--) {\n            if (elem = temp[i]) {\n              matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);\n            }\n          }\n        }\n\n        if (seed) {\n          if (postFinder || preFilter) {\n            if (postFinder) {\n              // Get the final matcherOut by condensing this intermediate into postFinder contexts\n              temp = [];\n              i = matcherOut.length;\n\n              while (i--) {\n                if (elem = matcherOut[i]) {\n                  // Restore matcherIn since elem is not yet a final match\n                  temp.push(matcherIn[i] = elem);\n                }\n              }\n\n              postFinder(null, matcherOut = [], temp, xml);\n            } // Move matched elements from seed to results to keep them synchronized\n\n\n            i = matcherOut.length;\n\n            while (i--) {\n              if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {\n                seed[temp] = !(results[temp] = elem);\n              }\n            }\n          } // Add elements to results, through postFinder if defined\n\n        } else {\n          matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);\n\n          if (postFinder) {\n            postFinder(null, results, matcherOut, xml);\n          } else {\n            push.apply(results, matcherOut);\n          }\n        }\n      });\n    }\n\n    function matcherFromTokens(tokens) {\n      var checkContext,\n          matcher,\n          j,\n          len = tokens.length,\n          leadingRelative = Expr.relative[tokens[0].type],\n          implicitRelative = leadingRelative || Expr.relative[\" \"],\n          i = leadingRelative ? 1 : 0,\n          // The foundational matcher ensures that elements are reachable from top-level context(s)\n      matchContext = addCombinator(function (elem) {\n        return elem === checkContext;\n      }, implicitRelative, true),\n          matchAnyContext = addCombinator(function (elem) {\n        return indexOf(checkContext, elem) > -1;\n      }, implicitRelative, true),\n          matchers = [function (elem, context, xml) {\n        var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml)); // Avoid hanging onto element (issue #299)\n\n        checkContext = null;\n        return ret;\n      }];\n\n      for (; i < len; i++) {\n        if (matcher = Expr.relative[tokens[i].type]) {\n          matchers = [addCombinator(elementMatcher(matchers), matcher)];\n        } else {\n          matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches); // Return special upon seeing a positional matcher\n\n          if (matcher[expando]) {\n            // Find the next relative operator (if any) for proper handling\n            j = ++i;\n\n            for (; j < len; j++) {\n              if (Expr.relative[tokens[j].type]) {\n                break;\n              }\n            }\n\n            return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*`\n            tokens.slice(0, i - 1).concat({\n              value: tokens[i - 2].type === \" \" ? \"*\" : \"\"\n            })).replace(rtrim, \"$1\"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));\n          }\n\n          matchers.push(matcher);\n        }\n      }\n\n      return elementMatcher(matchers);\n    }\n\n    function matcherFromGroupMatchers(elementMatchers, setMatchers) {\n      var bySet = setMatchers.length > 0,\n          byElement = elementMatchers.length > 0,\n          superMatcher = function superMatcher(seed, context, xml, results, outermost) {\n        var elem,\n            j,\n            matcher,\n            matchedCount = 0,\n            i = \"0\",\n            unmatched = seed && [],\n            setMatched = [],\n            contextBackup = outermostContext,\n            // We must always have either seed elements or outermost context\n        elems = seed || byElement && Expr.find[\"TAG\"](\"*\", outermost),\n            // Use integer dirruns iff this is the outermost matcher\n        dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,\n            len = elems.length;\n\n        if (outermost) {\n          outermostContext = context === document || context || outermost;\n        } // Add elements passing elementMatchers directly to results\n        // Support: IE<9, Safari\n        // Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\n\n        for (; i !== len && (elem = elems[i]) != null; i++) {\n          if (byElement && elem) {\n            j = 0;\n\n            if (!context && elem.ownerDocument !== document) {\n              setDocument(elem);\n              xml = !documentIsHTML;\n            }\n\n            while (matcher = elementMatchers[j++]) {\n              if (matcher(elem, context || document, xml)) {\n                results.push(elem);\n                break;\n              }\n            }\n\n            if (outermost) {\n              dirruns = dirrunsUnique;\n            }\n          } // Track unmatched elements for set filters\n\n\n          if (bySet) {\n            // They will have gone through all possible matchers\n            if (elem = !matcher && elem) {\n              matchedCount--;\n            } // Lengthen the array for every element, matched or not\n\n\n            if (seed) {\n              unmatched.push(elem);\n            }\n          }\n        } // `i` is now the count of elements visited above, and adding it to `matchedCount`\n        // makes the latter nonnegative.\n\n\n        matchedCount += i; // Apply set filters to unmatched elements\n        // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n        // equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n        // no element matchers and no seed.\n        // Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n        // case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n        // numerically zero.\n\n        if (bySet && i !== matchedCount) {\n          j = 0;\n\n          while (matcher = setMatchers[j++]) {\n            matcher(unmatched, setMatched, context, xml);\n          }\n\n          if (seed) {\n            // Reintegrate element matches to eliminate the need for sorting\n            if (matchedCount > 0) {\n              while (i--) {\n                if (!(unmatched[i] || setMatched[i])) {\n                  setMatched[i] = pop.call(results);\n                }\n              }\n            } // Discard index placeholder values to get only actual matches\n\n\n            setMatched = condense(setMatched);\n          } // Add matches to results\n\n\n          push.apply(results, setMatched); // Seedless set matches succeeding multiple successful matchers stipulate sorting\n\n          if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {\n            Sizzle.uniqueSort(results);\n          }\n        } // Override manipulation of globals by nested matchers\n\n\n        if (outermost) {\n          dirruns = dirrunsUnique;\n          outermostContext = contextBackup;\n        }\n\n        return unmatched;\n      };\n\n      return bySet ? markFunction(superMatcher) : superMatcher;\n    }\n\n    compile = Sizzle.compile = function (selector, match\n    /* Internal Use Only */\n    ) {\n      var i,\n          setMatchers = [],\n          elementMatchers = [],\n          cached = compilerCache[selector + \" \"];\n\n      if (!cached) {\n        // Generate a function of recursive functions that can be used to check each element\n        if (!match) {\n          match = tokenize(selector);\n        }\n\n        i = match.length;\n\n        while (i--) {\n          cached = matcherFromTokens(match[i]);\n\n          if (cached[expando]) {\n            setMatchers.push(cached);\n          } else {\n            elementMatchers.push(cached);\n          }\n        } // Cache the compiled function\n\n\n        cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers)); // Save selector and tokenization\n\n        cached.selector = selector;\n      }\n\n      return cached;\n    };\n    /**\n     * A low-level selection function that works with Sizzle's compiled\n     *  selector functions\n     * @param {String|Function} selector A selector or a pre-compiled\n     *  selector function built with Sizzle.compile\n     * @param {Element} context\n     * @param {Array} [results]\n     * @param {Array} [seed] A set of elements to match against\n     */\n\n\n    select = Sizzle.select = function (selector, context, results, seed) {\n      var i,\n          tokens,\n          token,\n          type,\n          find,\n          compiled = typeof selector === \"function\" && selector,\n          match = !seed && tokenize(selector = compiled.selector || selector);\n      results = results || []; // Try to minimize operations if there is only one selector in the list and no seed\n      // (the latter of which guarantees us context)\n\n      if (match.length === 1) {\n        // Reduce context if the leading compound selector is an ID\n        tokens = match[0] = match[0].slice(0);\n\n        if (tokens.length > 2 && (token = tokens[0]).type === \"ID\" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {\n          context = (Expr.find[\"ID\"](token.matches[0].replace(runescape, funescape), context) || [])[0];\n\n          if (!context) {\n            return results; // Precompiled matchers will still verify ancestry, so step up a level\n          } else if (compiled) {\n            context = context.parentNode;\n          }\n\n          selector = selector.slice(tokens.shift().value.length);\n        } // Fetch a seed set for right-to-left matching\n\n\n        i = matchExpr[\"needsContext\"].test(selector) ? 0 : tokens.length;\n\n        while (i--) {\n          token = tokens[i]; // Abort if we hit a combinator\n\n          if (Expr.relative[type = token.type]) {\n            break;\n          }\n\n          if (find = Expr.find[type]) {\n            // Search, expanding context for leading sibling combinators\n            if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {\n              // If seed is empty or no tokens remain, we can return early\n              tokens.splice(i, 1);\n              selector = seed.length && toSelector(tokens);\n\n              if (!selector) {\n                push.apply(results, seed);\n                return results;\n              }\n\n              break;\n            }\n          }\n        }\n      } // Compile and execute a filtering function if one is not provided\n      // Provide `match` to avoid retokenization if we modified the selector above\n\n\n      (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);\n      return results;\n    }; // One-time assignments\n    // Sort stability\n\n\n    support.sortStable = expando.split(\"\").sort(sortOrder).join(\"\") === expando; // Support: Chrome 14-35+\n    // Always assume duplicates if they aren't passed to the comparison function\n\n    support.detectDuplicates = !!hasDuplicate; // Initialize against the default document\n\n    setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n    // Detached nodes confoundingly follow *each other*\n\n    support.sortDetached = assert(function (el) {\n      // Should return 1, but returns 4 (following)\n      return el.compareDocumentPosition(document.createElement(\"fieldset\")) & 1;\n    }); // Support: IE<8\n    // Prevent attribute/property \"interpolation\"\n    // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\n\n    if (!assert(function (el) {\n      el.innerHTML = \"<a href='#'></a>\";\n      return el.firstChild.getAttribute(\"href\") === \"#\";\n    })) {\n      addHandle(\"type|href|height|width\", function (elem, name, isXML) {\n        if (!isXML) {\n          return elem.getAttribute(name, name.toLowerCase() === \"type\" ? 1 : 2);\n        }\n      });\n    } // Support: IE<9\n    // Use defaultValue in place of getAttribute(\"value\")\n\n\n    if (!support.attributes || !assert(function (el) {\n      el.innerHTML = \"<input/>\";\n      el.firstChild.setAttribute(\"value\", \"\");\n      return el.firstChild.getAttribute(\"value\") === \"\";\n    })) {\n      addHandle(\"value\", function (elem, name, isXML) {\n        if (!isXML && elem.nodeName.toLowerCase() === \"input\") {\n          return elem.defaultValue;\n        }\n      });\n    } // Support: IE<9\n    // Use getAttributeNode to fetch booleans when getAttribute lies\n\n\n    if (!assert(function (el) {\n      return el.getAttribute(\"disabled\") == null;\n    })) {\n      addHandle(booleans, function (elem, name, isXML) {\n        var val;\n\n        if (!isXML) {\n          return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;\n        }\n      });\n    }\n\n    return Sizzle;\n  }(window);\n\n  jQuery.find = Sizzle;\n  jQuery.expr = Sizzle.selectors; // Deprecated\n\n  jQuery.expr[\":\"] = jQuery.expr.pseudos;\n  jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\n  jQuery.text = Sizzle.getText;\n  jQuery.isXMLDoc = Sizzle.isXML;\n  jQuery.contains = Sizzle.contains;\n  jQuery.escapeSelector = Sizzle.escape;\n\n  var dir = function dir(elem, _dir, until) {\n    var matched = [],\n        truncate = until !== undefined;\n\n    while ((elem = elem[_dir]) && elem.nodeType !== 9) {\n      if (elem.nodeType === 1) {\n        if (truncate && jQuery(elem).is(until)) {\n          break;\n        }\n\n        matched.push(elem);\n      }\n    }\n\n    return matched;\n  };\n\n  var _siblings = function siblings(n, elem) {\n    var matched = [];\n\n    for (; n; n = n.nextSibling) {\n      if (n.nodeType === 1 && n !== elem) {\n        matched.push(n);\n      }\n    }\n\n    return matched;\n  };\n\n  var rneedsContext = jQuery.expr.match.needsContext;\n\n  function nodeName(elem, name) {\n    return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n  }\n\n  ;\n  var rsingleTag = /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i; // Implement the identical functionality for filter and not\n\n  function winnow(elements, qualifier, not) {\n    if (isFunction(qualifier)) {\n      return jQuery.grep(elements, function (elem, i) {\n        return !!qualifier.call(elem, i, elem) !== not;\n      });\n    } // Single element\n\n\n    if (qualifier.nodeType) {\n      return jQuery.grep(elements, function (elem) {\n        return elem === qualifier !== not;\n      });\n    } // Arraylike of elements (jQuery, arguments, Array)\n\n\n    if (typeof qualifier !== \"string\") {\n      return jQuery.grep(elements, function (elem) {\n        return indexOf.call(qualifier, elem) > -1 !== not;\n      });\n    } // Filtered directly for both simple and complex selectors\n\n\n    return jQuery.filter(qualifier, elements, not);\n  }\n\n  jQuery.filter = function (expr, elems, not) {\n    var elem = elems[0];\n\n    if (not) {\n      expr = \":not(\" + expr + \")\";\n    }\n\n    if (elems.length === 1 && elem.nodeType === 1) {\n      return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];\n    }\n\n    return jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {\n      return elem.nodeType === 1;\n    }));\n  };\n\n  jQuery.fn.extend({\n    find: function find(selector) {\n      var i,\n          ret,\n          len = this.length,\n          self = this;\n\n      if (typeof selector !== \"string\") {\n        return this.pushStack(jQuery(selector).filter(function () {\n          for (i = 0; i < len; i++) {\n            if (jQuery.contains(self[i], this)) {\n              return true;\n            }\n          }\n        }));\n      }\n\n      ret = this.pushStack([]);\n\n      for (i = 0; i < len; i++) {\n        jQuery.find(selector, self[i], ret);\n      }\n\n      return len > 1 ? jQuery.uniqueSort(ret) : ret;\n    },\n    filter: function filter(selector) {\n      return this.pushStack(winnow(this, selector || [], false));\n    },\n    not: function not(selector) {\n      return this.pushStack(winnow(this, selector || [], true));\n    },\n    is: function is(selector) {\n      return !!winnow(this, // If this is a positional/relative selector, check membership in the returned set\n      // so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n      typeof selector === \"string\" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;\n    }\n  }); // Initialize a jQuery object\n  // A central reference to the root jQuery(document)\n\n  var rootjQuery,\n      // A simple way to check for HTML strings\n  // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n  // Strict HTML recognition (#11290: must start with <)\n  // Shortcut simple #id case for speed\n  rquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n      init = jQuery.fn.init = function (selector, context, root) {\n    var match, elem; // HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\n    if (!selector) {\n      return this;\n    } // Method init() accepts an alternate rootjQuery\n    // so migrate can support jQuery.sub (gh-2101)\n\n\n    root = root || rootjQuery; // Handle HTML strings\n\n    if (typeof selector === \"string\") {\n      if (selector[0] === \"<\" && selector[selector.length - 1] === \">\" && selector.length >= 3) {\n        // Assume that strings that start and end with <> are HTML and skip the regex check\n        match = [null, selector, null];\n      } else {\n        match = rquickExpr.exec(selector);\n      } // Match html or make sure no context is specified for #id\n\n\n      if (match && (match[1] || !context)) {\n        // HANDLE: $(html) -> $(array)\n        if (match[1]) {\n          context = context instanceof jQuery ? context[0] : context; // Option to run scripts is true for back-compat\n          // Intentionally let the error be thrown if parseHTML is not present\n\n          jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true)); // HANDLE: $(html, props)\n\n          if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {\n            for (match in context) {\n              // Properties of context are called as methods if possible\n              if (isFunction(this[match])) {\n                this[match](context[match]); // ...and otherwise set as attributes\n              } else {\n                this.attr(match, context[match]);\n              }\n            }\n          }\n\n          return this; // HANDLE: $(#id)\n        } else {\n          elem = document.getElementById(match[2]);\n\n          if (elem) {\n            // Inject the element directly into the jQuery object\n            this[0] = elem;\n            this.length = 1;\n          }\n\n          return this;\n        } // HANDLE: $(expr, $(...))\n\n      } else if (!context || context.jquery) {\n        return (context || root).find(selector); // HANDLE: $(expr, context)\n        // (which is just equivalent to: $(context).find(expr)\n      } else {\n        return this.constructor(context).find(selector);\n      } // HANDLE: $(DOMElement)\n\n    } else if (selector.nodeType) {\n      this[0] = selector;\n      this.length = 1;\n      return this; // HANDLE: $(function)\n      // Shortcut for document ready\n    } else if (isFunction(selector)) {\n      return root.ready !== undefined ? root.ready(selector) : // Execute immediately if ready is not present\n      selector(jQuery);\n    }\n\n    return jQuery.makeArray(selector, this);\n  }; // Give the init function the jQuery prototype for later instantiation\n\n\n  init.prototype = jQuery.fn; // Initialize central reference\n\n  rootjQuery = jQuery(document);\n  var rparentsprev = /^(?:parents|prev(?:Until|All))/,\n      // Methods guaranteed to produce a unique set when starting from a unique set\n  guaranteedUnique = {\n    children: true,\n    contents: true,\n    next: true,\n    prev: true\n  };\n  jQuery.fn.extend({\n    has: function has(target) {\n      var targets = jQuery(target, this),\n          l = targets.length;\n      return this.filter(function () {\n        var i = 0;\n\n        for (; i < l; i++) {\n          if (jQuery.contains(this, targets[i])) {\n            return true;\n          }\n        }\n      });\n    },\n    closest: function closest(selectors, context) {\n      var cur,\n          i = 0,\n          l = this.length,\n          matched = [],\n          targets = typeof selectors !== \"string\" && jQuery(selectors); // Positional selectors never match, since there's no _selection_ context\n\n      if (!rneedsContext.test(selectors)) {\n        for (; i < l; i++) {\n          for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {\n            // Always skip document fragments\n            if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : // Don't pass non-elements to Sizzle\n            cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {\n              matched.push(cur);\n              break;\n            }\n          }\n        }\n      }\n\n      return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);\n    },\n    // Determine the position of an element within the set\n    index: function index(elem) {\n      // No argument, return index in parent\n      if (!elem) {\n        return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;\n      } // Index in selector\n\n\n      if (typeof elem === \"string\") {\n        return indexOf.call(jQuery(elem), this[0]);\n      } // Locate the position of the desired element\n\n\n      return indexOf.call(this, // If it receives a jQuery object, the first element is used\n      elem.jquery ? elem[0] : elem);\n    },\n    add: function add(selector, context) {\n      return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))));\n    },\n    addBack: function addBack(selector) {\n      return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));\n    }\n  });\n\n  function sibling(cur, dir) {\n    while ((cur = cur[dir]) && cur.nodeType !== 1) {}\n\n    return cur;\n  }\n\n  jQuery.each({\n    parent: function parent(elem) {\n      var parent = elem.parentNode;\n      return parent && parent.nodeType !== 11 ? parent : null;\n    },\n    parents: function parents(elem) {\n      return dir(elem, \"parentNode\");\n    },\n    parentsUntil: function parentsUntil(elem, i, until) {\n      return dir(elem, \"parentNode\", until);\n    },\n    next: function next(elem) {\n      return sibling(elem, \"nextSibling\");\n    },\n    prev: function prev(elem) {\n      return sibling(elem, \"previousSibling\");\n    },\n    nextAll: function nextAll(elem) {\n      return dir(elem, \"nextSibling\");\n    },\n    prevAll: function prevAll(elem) {\n      return dir(elem, \"previousSibling\");\n    },\n    nextUntil: function nextUntil(elem, i, until) {\n      return dir(elem, \"nextSibling\", until);\n    },\n    prevUntil: function prevUntil(elem, i, until) {\n      return dir(elem, \"previousSibling\", until);\n    },\n    siblings: function siblings(elem) {\n      return _siblings((elem.parentNode || {}).firstChild, elem);\n    },\n    children: function children(elem) {\n      return _siblings(elem.firstChild);\n    },\n    contents: function contents(elem) {\n      if (typeof elem.contentDocument !== \"undefined\") {\n        return elem.contentDocument;\n      } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n      // Treat the template element as a regular one in browsers that\n      // don't support it.\n\n\n      if (nodeName(elem, \"template\")) {\n        elem = elem.content || elem;\n      }\n\n      return jQuery.merge([], elem.childNodes);\n    }\n  }, function (name, fn) {\n    jQuery.fn[name] = function (until, selector) {\n      var matched = jQuery.map(this, fn, until);\n\n      if (name.slice(-5) !== \"Until\") {\n        selector = until;\n      }\n\n      if (selector && typeof selector === \"string\") {\n        matched = jQuery.filter(selector, matched);\n      }\n\n      if (this.length > 1) {\n        // Remove duplicates\n        if (!guaranteedUnique[name]) {\n          jQuery.uniqueSort(matched);\n        } // Reverse order for parents* and prev-derivatives\n\n\n        if (rparentsprev.test(name)) {\n          matched.reverse();\n        }\n      }\n\n      return this.pushStack(matched);\n    };\n  });\n  var rnothtmlwhite = /[^\\x20\\t\\r\\n\\f]+/g; // Convert String-formatted options into Object-formatted ones\n\n  function createOptions(options) {\n    var object = {};\n    jQuery.each(options.match(rnothtmlwhite) || [], function (_, flag) {\n      object[flag] = true;\n    });\n    return object;\n  }\n  /*\n   * Create a callback list using the following parameters:\n   *\n   *\toptions: an optional list of space-separated options that will change how\n   *\t\t\tthe callback list behaves or a more traditional option object\n   *\n   * By default a callback list will act like an event callback list and can be\n   * \"fired\" multiple times.\n   *\n   * Possible options:\n   *\n   *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n   *\n   *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n   *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n   *\t\t\t\t\tvalues (like a Deferred)\n   *\n   *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n   *\n   *\tstopOnFalse:\tinterrupt callings when a callback returns false\n   *\n   */\n\n\n  jQuery.Callbacks = function (options) {\n    // Convert options from String-formatted to Object-formatted if needed\n    // (we check in cache first)\n    options = typeof options === \"string\" ? createOptions(options) : jQuery.extend({}, options);\n\n    var // Flag to know if list is currently firing\n    firing,\n        // Last fire value for non-forgettable lists\n    memory,\n        // Flag to know if list was already fired\n    _fired,\n        // Flag to prevent firing\n    _locked,\n        // Actual callback list\n    list = [],\n        // Queue of execution data for repeatable lists\n    queue = [],\n        // Index of currently firing callback (modified by add/remove as needed)\n    firingIndex = -1,\n        // Fire callbacks\n    fire = function fire() {\n      // Enforce single-firing\n      _locked = _locked || options.once; // Execute callbacks for all pending executions,\n      // respecting firingIndex overrides and runtime changes\n\n      _fired = firing = true;\n\n      for (; queue.length; firingIndex = -1) {\n        memory = queue.shift();\n\n        while (++firingIndex < list.length) {\n          // Run callback and check for early termination\n          if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {\n            // Jump to end and forget the data so .add doesn't re-fire\n            firingIndex = list.length;\n            memory = false;\n          }\n        }\n      } // Forget the data if we're done with it\n\n\n      if (!options.memory) {\n        memory = false;\n      }\n\n      firing = false; // Clean up if we're done firing for good\n\n      if (_locked) {\n        // Keep an empty list if we have data for future add calls\n        if (memory) {\n          list = []; // Otherwise, this object is spent\n        } else {\n          list = \"\";\n        }\n      }\n    },\n        // Actual Callbacks object\n    self = {\n      // Add a callback or a collection of callbacks to the list\n      add: function add() {\n        if (list) {\n          // If we have memory from a past run, we should fire after adding\n          if (memory && !firing) {\n            firingIndex = list.length - 1;\n            queue.push(memory);\n          }\n\n          (function add(args) {\n            jQuery.each(args, function (_, arg) {\n              if (isFunction(arg)) {\n                if (!options.unique || !self.has(arg)) {\n                  list.push(arg);\n                }\n              } else if (arg && arg.length && toType(arg) !== \"string\") {\n                // Inspect recursively\n                add(arg);\n              }\n            });\n          })(arguments);\n\n          if (memory && !firing) {\n            fire();\n          }\n        }\n\n        return this;\n      },\n      // Remove a callback from the list\n      remove: function remove() {\n        jQuery.each(arguments, function (_, arg) {\n          var index;\n\n          while ((index = jQuery.inArray(arg, list, index)) > -1) {\n            list.splice(index, 1); // Handle firing indexes\n\n            if (index <= firingIndex) {\n              firingIndex--;\n            }\n          }\n        });\n        return this;\n      },\n      // Check if a given callback is in the list.\n      // If no argument is given, return whether or not list has callbacks attached.\n      has: function has(fn) {\n        return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0;\n      },\n      // Remove all callbacks from the list\n      empty: function empty() {\n        if (list) {\n          list = [];\n        }\n\n        return this;\n      },\n      // Disable .fire and .add\n      // Abort any current/pending executions\n      // Clear all callbacks and values\n      disable: function disable() {\n        _locked = queue = [];\n        list = memory = \"\";\n        return this;\n      },\n      disabled: function disabled() {\n        return !list;\n      },\n      // Disable .fire\n      // Also disable .add unless we have memory (since it would have no effect)\n      // Abort any pending executions\n      lock: function lock() {\n        _locked = queue = [];\n\n        if (!memory && !firing) {\n          list = memory = \"\";\n        }\n\n        return this;\n      },\n      locked: function locked() {\n        return !!_locked;\n      },\n      // Call all callbacks with the given context and arguments\n      fireWith: function fireWith(context, args) {\n        if (!_locked) {\n          args = args || [];\n          args = [context, args.slice ? args.slice() : args];\n          queue.push(args);\n\n          if (!firing) {\n            fire();\n          }\n        }\n\n        return this;\n      },\n      // Call all the callbacks with the given arguments\n      fire: function fire() {\n        self.fireWith(this, arguments);\n        return this;\n      },\n      // To know if the callbacks have already been called at least once\n      fired: function fired() {\n        return !!_fired;\n      }\n    };\n\n    return self;\n  };\n\n  function Identity(v) {\n    return v;\n  }\n\n  function Thrower(ex) {\n    throw ex;\n  }\n\n  function adoptValue(value, resolve, reject, noValue) {\n    var method;\n\n    try {\n      // Check for promise aspect first to privilege synchronous behavior\n      if (value && isFunction(method = value.promise)) {\n        method.call(value).done(resolve).fail(reject); // Other thenables\n      } else if (value && isFunction(method = value.then)) {\n        method.call(value, resolve, reject); // Other non-thenables\n      } else {\n        // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n        // * false: [ value ].slice( 0 ) => resolve( value )\n        // * true: [ value ].slice( 1 ) => resolve()\n        resolve.apply(undefined, [value].slice(noValue));\n      } // For Promises/A+, convert exceptions into rejections\n      // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n      // Deferred#then to conditionally suppress rejection.\n\n    } catch (value) {\n      // Support: Android 4.0 only\n      // Strict mode functions invoked without .call/.apply get global-object context\n      reject.apply(undefined, [value]);\n    }\n  }\n\n  jQuery.extend({\n    Deferred: function Deferred(func) {\n      var tuples = [// action, add listener, callbacks,\n      // ... .then handlers, argument index, [final state]\n      [\"notify\", \"progress\", jQuery.Callbacks(\"memory\"), jQuery.Callbacks(\"memory\"), 2], [\"resolve\", \"done\", jQuery.Callbacks(\"once memory\"), jQuery.Callbacks(\"once memory\"), 0, \"resolved\"], [\"reject\", \"fail\", jQuery.Callbacks(\"once memory\"), jQuery.Callbacks(\"once memory\"), 1, \"rejected\"]],\n          _state = \"pending\",\n          _promise = {\n        state: function state() {\n          return _state;\n        },\n        always: function always() {\n          deferred.done(arguments).fail(arguments);\n          return this;\n        },\n        \"catch\": function _catch(fn) {\n          return _promise.then(null, fn);\n        },\n        // Keep pipe for back-compat\n        pipe: function pipe()\n        /* fnDone, fnFail, fnProgress */\n        {\n          var fns = arguments;\n          return jQuery.Deferred(function (newDefer) {\n            jQuery.each(tuples, function (i, tuple) {\n              // Map tuples (progress, done, fail) to arguments (done, fail, progress)\n              var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]]; // deferred.progress(function() { bind to newDefer or newDefer.notify })\n              // deferred.done(function() { bind to newDefer or newDefer.resolve })\n              // deferred.fail(function() { bind to newDefer or newDefer.reject })\n\n              deferred[tuple[1]](function () {\n                var returned = fn && fn.apply(this, arguments);\n\n                if (returned && isFunction(returned.promise)) {\n                  returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);\n                } else {\n                  newDefer[tuple[0] + \"With\"](this, fn ? [returned] : arguments);\n                }\n              });\n            });\n            fns = null;\n          }).promise();\n        },\n        then: function then(onFulfilled, onRejected, onProgress) {\n          var maxDepth = 0;\n\n          function resolve(depth, deferred, handler, special) {\n            return function () {\n              var that = this,\n                  args = arguments,\n                  mightThrow = function mightThrow() {\n                var returned, then; // Support: Promises/A+ section 2.3.3.3.3\n                // https://promisesaplus.com/#point-59\n                // Ignore double-resolution attempts\n\n                if (depth < maxDepth) {\n                  return;\n                }\n\n                returned = handler.apply(that, args); // Support: Promises/A+ section 2.3.1\n                // https://promisesaplus.com/#point-48\n\n                if (returned === deferred.promise()) {\n                  throw new TypeError(\"Thenable self-resolution\");\n                } // Support: Promises/A+ sections 2.3.3.1, 3.5\n                // https://promisesaplus.com/#point-54\n                // https://promisesaplus.com/#point-75\n                // Retrieve `then` only once\n\n\n                then = returned && ( // Support: Promises/A+ section 2.3.4\n                // https://promisesaplus.com/#point-64\n                // Only check objects and functions for thenability\n                _typeof(returned) === \"object\" || typeof returned === \"function\") && returned.then; // Handle a returned thenable\n\n                if (isFunction(then)) {\n                  // Special processors (notify) just wait for resolution\n                  if (special) {\n                    then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special)); // Normal processors (resolve) also hook into progress\n                  } else {\n                    // ...and disregard older resolution values\n                    maxDepth++;\n                    then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith));\n                  } // Handle all other returned values\n\n                } else {\n                  // Only substitute handlers pass on context\n                  // and multiple values (non-spec behavior)\n                  if (handler !== Identity) {\n                    that = undefined;\n                    args = [returned];\n                  } // Process the value(s)\n                  // Default process is resolve\n\n\n                  (special || deferred.resolveWith)(that, args);\n                }\n              },\n                  // Only normal processors (resolve) catch and reject exceptions\n              process = special ? mightThrow : function () {\n                try {\n                  mightThrow();\n                } catch (e) {\n                  if (jQuery.Deferred.exceptionHook) {\n                    jQuery.Deferred.exceptionHook(e, process.stackTrace);\n                  } // Support: Promises/A+ section 2.3.3.3.4.1\n                  // https://promisesaplus.com/#point-61\n                  // Ignore post-resolution exceptions\n\n\n                  if (depth + 1 >= maxDepth) {\n                    // Only substitute handlers pass on context\n                    // and multiple values (non-spec behavior)\n                    if (handler !== Thrower) {\n                      that = undefined;\n                      args = [e];\n                    }\n\n                    deferred.rejectWith(that, args);\n                  }\n                }\n              }; // Support: Promises/A+ section 2.3.3.3.1\n              // https://promisesaplus.com/#point-57\n              // Re-resolve promises immediately to dodge false rejection from\n              // subsequent errors\n\n\n              if (depth) {\n                process();\n              } else {\n                // Call an optional hook to record the stack, in case of exception\n                // since it's otherwise lost when execution goes async\n                if (jQuery.Deferred.getStackHook) {\n                  process.stackTrace = jQuery.Deferred.getStackHook();\n                }\n\n                window.setTimeout(process);\n              }\n            };\n          }\n\n          return jQuery.Deferred(function (newDefer) {\n            // progress_handlers.add( ... )\n            tuples[0][3].add(resolve(0, newDefer, isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith)); // fulfilled_handlers.add( ... )\n\n            tuples[1][3].add(resolve(0, newDefer, isFunction(onFulfilled) ? onFulfilled : Identity)); // rejected_handlers.add( ... )\n\n            tuples[2][3].add(resolve(0, newDefer, isFunction(onRejected) ? onRejected : Thrower));\n          }).promise();\n        },\n        // Get a promise for this deferred\n        // If obj is provided, the promise aspect is added to the object\n        promise: function promise(obj) {\n          return obj != null ? jQuery.extend(obj, _promise) : _promise;\n        }\n      },\n          deferred = {}; // Add list-specific methods\n\n      jQuery.each(tuples, function (i, tuple) {\n        var list = tuple[2],\n            stateString = tuple[5]; // promise.progress = list.add\n        // promise.done = list.add\n        // promise.fail = list.add\n\n        _promise[tuple[1]] = list.add; // Handle state\n\n        if (stateString) {\n          list.add(function () {\n            // state = \"resolved\" (i.e., fulfilled)\n            // state = \"rejected\"\n            _state = stateString;\n          }, // rejected_callbacks.disable\n          // fulfilled_callbacks.disable\n          tuples[3 - i][2].disable, // rejected_handlers.disable\n          // fulfilled_handlers.disable\n          tuples[3 - i][3].disable, // progress_callbacks.lock\n          tuples[0][2].lock, // progress_handlers.lock\n          tuples[0][3].lock);\n        } // progress_handlers.fire\n        // fulfilled_handlers.fire\n        // rejected_handlers.fire\n\n\n        list.add(tuple[3].fire); // deferred.notify = function() { deferred.notifyWith(...) }\n        // deferred.resolve = function() { deferred.resolveWith(...) }\n        // deferred.reject = function() { deferred.rejectWith(...) }\n\n        deferred[tuple[0]] = function () {\n          deferred[tuple[0] + \"With\"](this === deferred ? undefined : this, arguments);\n          return this;\n        }; // deferred.notifyWith = list.fireWith\n        // deferred.resolveWith = list.fireWith\n        // deferred.rejectWith = list.fireWith\n\n\n        deferred[tuple[0] + \"With\"] = list.fireWith;\n      }); // Make the deferred a promise\n\n      _promise.promise(deferred); // Call given func if any\n\n\n      if (func) {\n        func.call(deferred, deferred);\n      } // All done!\n\n\n      return deferred;\n    },\n    // Deferred helper\n    when: function when(singleValue) {\n      var // count of uncompleted subordinates\n      remaining = arguments.length,\n          // count of unprocessed arguments\n      i = remaining,\n          // subordinate fulfillment data\n      resolveContexts = Array(i),\n          resolveValues = _slice.call(arguments),\n          // the master Deferred\n      master = jQuery.Deferred(),\n          // subordinate callback factory\n      updateFunc = function updateFunc(i) {\n        return function (value) {\n          resolveContexts[i] = this;\n          resolveValues[i] = arguments.length > 1 ? _slice.call(arguments) : value;\n\n          if (! --remaining) {\n            master.resolveWith(resolveContexts, resolveValues);\n          }\n        };\n      }; // Single- and empty arguments are adopted like Promise.resolve\n\n\n      if (remaining <= 1) {\n        adoptValue(singleValue, master.done(updateFunc(i)).resolve, master.reject, !remaining); // Use .then() to unwrap secondary thenables (cf. gh-3000)\n\n        if (master.state() === \"pending\" || isFunction(resolveValues[i] && resolveValues[i].then)) {\n          return master.then();\n        }\n      } // Multiple arguments are aggregated like Promise.all array elements\n\n\n      while (i--) {\n        adoptValue(resolveValues[i], updateFunc(i), master.reject);\n      }\n\n      return master.promise();\n    }\n  }); // These usually indicate a programmer mistake during development,\n  // warn about them ASAP rather than swallowing them by default.\n\n  var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n  jQuery.Deferred.exceptionHook = function (error, stack) {\n    // Support: IE 8 - 9 only\n    // Console exists when dev tools are open, which can happen at any time\n    if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {\n      window.console.warn(\"jQuery.Deferred exception: \" + error.message, error.stack, stack);\n    }\n  };\n\n  jQuery.readyException = function (error) {\n    window.setTimeout(function () {\n      throw error;\n    });\n  }; // The deferred used on DOM ready\n\n\n  var readyList = jQuery.Deferred();\n\n  jQuery.fn.ready = function (fn) {\n    readyList.then(fn) // Wrap jQuery.readyException in a function so that the lookup\n    // happens at the time of error handling instead of callback\n    // registration.\n    [\"catch\"](function (error) {\n      jQuery.readyException(error);\n    });\n    return this;\n  };\n\n  jQuery.extend({\n    // Is the DOM ready to be used? Set to true once it occurs.\n    isReady: false,\n    // A counter to track how many items to wait for before\n    // the ready event fires. See #6781\n    readyWait: 1,\n    // Handle when the DOM is ready\n    ready: function ready(wait) {\n      // Abort if there are pending holds or we're already ready\n      if (wait === true ? --jQuery.readyWait : jQuery.isReady) {\n        return;\n      } // Remember that the DOM is ready\n\n\n      jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be\n\n      if (wait !== true && --jQuery.readyWait > 0) {\n        return;\n      } // If there are functions bound, to execute\n\n\n      readyList.resolveWith(document, [jQuery]);\n    }\n  });\n  jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method\n\n  function completed() {\n    document.removeEventListener(\"DOMContentLoaded\", completed);\n    window.removeEventListener(\"load\", completed);\n    jQuery.ready();\n  } // Catch cases where $(document).ready() is called\n  // after the browser event has already occurred.\n  // Support: IE <=9 - 10 only\n  // Older IE sometimes signals \"interactive\" too soon\n\n\n  if (document.readyState === \"complete\" || document.readyState !== \"loading\" && !document.documentElement.doScroll) {\n    // Handle it asynchronously to allow scripts the opportunity to delay ready\n    window.setTimeout(jQuery.ready);\n  } else {\n    // Use the handy event callback\n    document.addEventListener(\"DOMContentLoaded\", completed); // A fallback to window.onload, that will always work\n\n    window.addEventListener(\"load\", completed);\n  } // Multifunctional method to get and set values of a collection\n  // The value/s can optionally be executed if it's a function\n\n\n  var access = function access(elems, fn, key, value, chainable, emptyGet, raw) {\n    var i = 0,\n        len = elems.length,\n        bulk = key == null; // Sets many values\n\n    if (toType(key) === \"object\") {\n      chainable = true;\n\n      for (i in key) {\n        access(elems, fn, i, key[i], true, emptyGet, raw);\n      } // Sets one value\n\n    } else if (value !== undefined) {\n      chainable = true;\n\n      if (!isFunction(value)) {\n        raw = true;\n      }\n\n      if (bulk) {\n        // Bulk operations run against the entire set\n        if (raw) {\n          fn.call(elems, value);\n          fn = null; // ...except when executing function values\n        } else {\n          bulk = fn;\n\n          fn = function fn(elem, key, value) {\n            return bulk.call(jQuery(elem), value);\n          };\n        }\n      }\n\n      if (fn) {\n        for (; i < len; i++) {\n          fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));\n        }\n      }\n    }\n\n    if (chainable) {\n      return elems;\n    } // Gets\n\n\n    if (bulk) {\n      return fn.call(elems);\n    }\n\n    return len ? fn(elems[0], key) : emptyGet;\n  }; // Matches dashed string for camelizing\n\n\n  var rmsPrefix = /^-ms-/,\n      rdashAlpha = /-([a-z])/g; // Used by camelCase as callback to replace()\n\n  function fcamelCase(all, letter) {\n    return letter.toUpperCase();\n  } // Convert dashed to camelCase; used by the css and data modules\n  // Support: IE <=9 - 11, Edge 12 - 15\n  // Microsoft forgot to hump their vendor prefix (#9572)\n\n\n  function camelCase(string) {\n    return string.replace(rmsPrefix, \"ms-\").replace(rdashAlpha, fcamelCase);\n  }\n\n  var acceptData = function acceptData(owner) {\n    // Accepts only:\n    //  - Node\n    //    - Node.ELEMENT_NODE\n    //    - Node.DOCUMENT_NODE\n    //  - Object\n    //    - Any\n    return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;\n  };\n\n  function Data() {\n    this.expando = jQuery.expando + Data.uid++;\n  }\n\n  Data.uid = 1;\n  Data.prototype = {\n    cache: function cache(owner) {\n      // Check if the owner object already has a cache\n      var value = owner[this.expando]; // If not, create one\n\n      if (!value) {\n        value = {}; // We can accept data for non-element nodes in modern browsers,\n        // but we should not, see #8335.\n        // Always return an empty object.\n\n        if (acceptData(owner)) {\n          // If it is a node unlikely to be stringify-ed or looped over\n          // use plain assignment\n          if (owner.nodeType) {\n            owner[this.expando] = value; // Otherwise secure it in a non-enumerable property\n            // configurable must be true to allow the property to be\n            // deleted when data is removed\n          } else {\n            Object.defineProperty(owner, this.expando, {\n              value: value,\n              configurable: true\n            });\n          }\n        }\n      }\n\n      return value;\n    },\n    set: function set(owner, data, value) {\n      var prop,\n          cache = this.cache(owner); // Handle: [ owner, key, value ] args\n      // Always use camelCase key (gh-2257)\n\n      if (typeof data === \"string\") {\n        cache[camelCase(data)] = value; // Handle: [ owner, { properties } ] args\n      } else {\n        // Copy the properties one-by-one to the cache object\n        for (prop in data) {\n          cache[camelCase(prop)] = data[prop];\n        }\n      }\n\n      return cache;\n    },\n    get: function get(owner, key) {\n      return key === undefined ? this.cache(owner) : // Always use camelCase key (gh-2257)\n      owner[this.expando] && owner[this.expando][camelCase(key)];\n    },\n    access: function access(owner, key, value) {\n      // In cases where either:\n      //\n      //   1. No key was specified\n      //   2. A string key was specified, but no value provided\n      //\n      // Take the \"read\" path and allow the get method to determine\n      // which value to return, respectively either:\n      //\n      //   1. The entire cache object\n      //   2. The data stored at the key\n      //\n      if (key === undefined || key && typeof key === \"string\" && value === undefined) {\n        return this.get(owner, key);\n      } // When the key is not a string, or both a key and value\n      // are specified, set or extend (existing objects) with either:\n      //\n      //   1. An object of properties\n      //   2. A key and value\n      //\n\n\n      this.set(owner, key, value); // Since the \"set\" path can have two possible entry points\n      // return the expected data based on which path was taken[*]\n\n      return value !== undefined ? value : key;\n    },\n    remove: function remove(owner, key) {\n      var i,\n          cache = owner[this.expando];\n\n      if (cache === undefined) {\n        return;\n      }\n\n      if (key !== undefined) {\n        // Support array or space separated string of keys\n        if (Array.isArray(key)) {\n          // If key is an array of keys...\n          // We always set camelCase keys, so remove that.\n          key = key.map(camelCase);\n        } else {\n          key = camelCase(key); // If a key with the spaces exists, use it.\n          // Otherwise, create an array by matching non-whitespace\n\n          key = key in cache ? [key] : key.match(rnothtmlwhite) || [];\n        }\n\n        i = key.length;\n\n        while (i--) {\n          delete cache[key[i]];\n        }\n      } // Remove the expando if there's no more data\n\n\n      if (key === undefined || jQuery.isEmptyObject(cache)) {\n        // Support: Chrome <=35 - 45\n        // Webkit & Blink performance suffers when deleting properties\n        // from DOM nodes, so set to undefined instead\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n        if (owner.nodeType) {\n          owner[this.expando] = undefined;\n        } else {\n          delete owner[this.expando];\n        }\n      }\n    },\n    hasData: function hasData(owner) {\n      var cache = owner[this.expando];\n      return cache !== undefined && !jQuery.isEmptyObject(cache);\n    }\n  };\n  var dataPriv = new Data();\n  var dataUser = new Data(); //\tImplementation Summary\n  //\n  //\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n  //\t2. Improve the module's maintainability by reducing the storage\n  //\t\tpaths to a single mechanism.\n  //\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n  //\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n  //\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n  //\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\n  var rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n      rmultiDash = /[A-Z]/g;\n\n  function getData(data) {\n    if (data === \"true\") {\n      return true;\n    }\n\n    if (data === \"false\") {\n      return false;\n    }\n\n    if (data === \"null\") {\n      return null;\n    } // Only convert to a number if it doesn't change the string\n\n\n    if (data === +data + \"\") {\n      return +data;\n    }\n\n    if (rbrace.test(data)) {\n      return JSON.parse(data);\n    }\n\n    return data;\n  }\n\n  function dataAttr(elem, key, data) {\n    var name; // If nothing was found internally, try to fetch any\n    // data from the HTML5 data-* attribute\n\n    if (data === undefined && elem.nodeType === 1) {\n      name = \"data-\" + key.replace(rmultiDash, \"-$&\").toLowerCase();\n      data = elem.getAttribute(name);\n\n      if (typeof data === \"string\") {\n        try {\n          data = getData(data);\n        } catch (e) {} // Make sure we set the data so it isn't changed later\n\n\n        dataUser.set(elem, key, data);\n      } else {\n        data = undefined;\n      }\n    }\n\n    return data;\n  }\n\n  jQuery.extend({\n    hasData: function hasData(elem) {\n      return dataUser.hasData(elem) || dataPriv.hasData(elem);\n    },\n    data: function data(elem, name, _data) {\n      return dataUser.access(elem, name, _data);\n    },\n    removeData: function removeData(elem, name) {\n      dataUser.remove(elem, name);\n    },\n    // TODO: Now that all calls to _data and _removeData have been replaced\n    // with direct calls to dataPriv methods, these can be deprecated.\n    _data: function _data(elem, name, data) {\n      return dataPriv.access(elem, name, data);\n    },\n    _removeData: function _removeData(elem, name) {\n      dataPriv.remove(elem, name);\n    }\n  });\n  jQuery.fn.extend({\n    data: function data(key, value) {\n      var i,\n          name,\n          data,\n          elem = this[0],\n          attrs = elem && elem.attributes; // Gets all values\n\n      if (key === undefined) {\n        if (this.length) {\n          data = dataUser.get(elem);\n\n          if (elem.nodeType === 1 && !dataPriv.get(elem, \"hasDataAttrs\")) {\n            i = attrs.length;\n\n            while (i--) {\n              // Support: IE 11 only\n              // The attrs elements can be null (#14894)\n              if (attrs[i]) {\n                name = attrs[i].name;\n\n                if (name.indexOf(\"data-\") === 0) {\n                  name = camelCase(name.slice(5));\n                  dataAttr(elem, name, data[name]);\n                }\n              }\n            }\n\n            dataPriv.set(elem, \"hasDataAttrs\", true);\n          }\n        }\n\n        return data;\n      } // Sets multiple values\n\n\n      if (_typeof(key) === \"object\") {\n        return this.each(function () {\n          dataUser.set(this, key);\n        });\n      }\n\n      return access(this, function (value) {\n        var data; // The calling jQuery object (element matches) is not empty\n        // (and therefore has an element appears at this[ 0 ]) and the\n        // `value` parameter was not undefined. An empty jQuery object\n        // will result in `undefined` for elem = this[ 0 ] which will\n        // throw an exception if an attempt to read a data cache is made.\n\n        if (elem && value === undefined) {\n          // Attempt to get data from the cache\n          // The key will always be camelCased in Data\n          data = dataUser.get(elem, key);\n\n          if (data !== undefined) {\n            return data;\n          } // Attempt to \"discover\" the data in\n          // HTML5 custom data-* attrs\n\n\n          data = dataAttr(elem, key);\n\n          if (data !== undefined) {\n            return data;\n          } // We tried really hard, but the data doesn't exist.\n\n\n          return;\n        } // Set the data...\n\n\n        this.each(function () {\n          // We always store the camelCased key\n          dataUser.set(this, key, value);\n        });\n      }, null, value, arguments.length > 1, null, true);\n    },\n    removeData: function removeData(key) {\n      return this.each(function () {\n        dataUser.remove(this, key);\n      });\n    }\n  });\n  jQuery.extend({\n    queue: function queue(elem, type, data) {\n      var queue;\n\n      if (elem) {\n        type = (type || \"fx\") + \"queue\";\n        queue = dataPriv.get(elem, type); // Speed up dequeue by getting out quickly if this is just a lookup\n\n        if (data) {\n          if (!queue || Array.isArray(data)) {\n            queue = dataPriv.access(elem, type, jQuery.makeArray(data));\n          } else {\n            queue.push(data);\n          }\n        }\n\n        return queue || [];\n      }\n    },\n    dequeue: function dequeue(elem, type) {\n      type = type || \"fx\";\n\n      var queue = jQuery.queue(elem, type),\n          startLength = queue.length,\n          fn = queue.shift(),\n          hooks = jQuery._queueHooks(elem, type),\n          next = function next() {\n        jQuery.dequeue(elem, type);\n      }; // If the fx queue is dequeued, always remove the progress sentinel\n\n\n      if (fn === \"inprogress\") {\n        fn = queue.shift();\n        startLength--;\n      }\n\n      if (fn) {\n        // Add a progress sentinel to prevent the fx queue from being\n        // automatically dequeued\n        if (type === \"fx\") {\n          queue.unshift(\"inprogress\");\n        } // Clear up the last queue stop function\n\n\n        delete hooks.stop;\n        fn.call(elem, next, hooks);\n      }\n\n      if (!startLength && hooks) {\n        hooks.empty.fire();\n      }\n    },\n    // Not public - generate a queueHooks object, or return the current one\n    _queueHooks: function _queueHooks(elem, type) {\n      var key = type + \"queueHooks\";\n      return dataPriv.get(elem, key) || dataPriv.access(elem, key, {\n        empty: jQuery.Callbacks(\"once memory\").add(function () {\n          dataPriv.remove(elem, [type + \"queue\", key]);\n        })\n      });\n    }\n  });\n  jQuery.fn.extend({\n    queue: function queue(type, data) {\n      var setter = 2;\n\n      if (typeof type !== \"string\") {\n        data = type;\n        type = \"fx\";\n        setter--;\n      }\n\n      if (arguments.length < setter) {\n        return jQuery.queue(this[0], type);\n      }\n\n      return data === undefined ? this : this.each(function () {\n        var queue = jQuery.queue(this, type, data); // Ensure a hooks for this queue\n\n        jQuery._queueHooks(this, type);\n\n        if (type === \"fx\" && queue[0] !== \"inprogress\") {\n          jQuery.dequeue(this, type);\n        }\n      });\n    },\n    dequeue: function dequeue(type) {\n      return this.each(function () {\n        jQuery.dequeue(this, type);\n      });\n    },\n    clearQueue: function clearQueue(type) {\n      return this.queue(type || \"fx\", []);\n    },\n    // Get a promise resolved when queues of a certain type\n    // are emptied (fx is the type by default)\n    promise: function promise(type, obj) {\n      var tmp,\n          count = 1,\n          defer = jQuery.Deferred(),\n          elements = this,\n          i = this.length,\n          resolve = function resolve() {\n        if (! --count) {\n          defer.resolveWith(elements, [elements]);\n        }\n      };\n\n      if (typeof type !== \"string\") {\n        obj = type;\n        type = undefined;\n      }\n\n      type = type || \"fx\";\n\n      while (i--) {\n        tmp = dataPriv.get(elements[i], type + \"queueHooks\");\n\n        if (tmp && tmp.empty) {\n          count++;\n          tmp.empty.add(resolve);\n        }\n      }\n\n      resolve();\n      return defer.promise(obj);\n    }\n  });\n  var pnum = /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/.source;\n  var rcssNum = new RegExp(\"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\");\n  var cssExpand = [\"Top\", \"Right\", \"Bottom\", \"Left\"];\n  var documentElement = document.documentElement;\n\n  var isAttached = function isAttached(elem) {\n    return jQuery.contains(elem.ownerDocument, elem);\n  },\n      composed = {\n    composed: true\n  }; // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n  // Check attachment across shadow DOM boundaries when possible (gh-3504)\n  // Support: iOS 10.0-10.2 only\n  // Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n  // leading to errors. We need to check for `getRootNode`.\n\n\n  if (documentElement.getRootNode) {\n    isAttached = function isAttached(elem) {\n      return jQuery.contains(elem.ownerDocument, elem) || elem.getRootNode(composed) === elem.ownerDocument;\n    };\n  }\n\n  var isHiddenWithinTree = function isHiddenWithinTree(elem, el) {\n    // isHiddenWithinTree might be called from jQuery#filter function;\n    // in that case, element will be second argument\n    elem = el || elem; // Inline style trumps all\n\n    return elem.style.display === \"none\" || elem.style.display === \"\" && // Otherwise, check computed style\n    // Support: Firefox <=43 - 45\n    // Disconnected elements can have computed display: none, so first confirm that elem is\n    // in the document.\n    isAttached(elem) && jQuery.css(elem, \"display\") === \"none\";\n  };\n\n  var swap = function swap(elem, options, callback, args) {\n    var ret,\n        name,\n        old = {}; // Remember the old values, and insert the new ones\n\n    for (name in options) {\n      old[name] = elem.style[name];\n      elem.style[name] = options[name];\n    }\n\n    ret = callback.apply(elem, args || []); // Revert the old values\n\n    for (name in options) {\n      elem.style[name] = old[name];\n    }\n\n    return ret;\n  };\n\n  function adjustCSS(elem, prop, valueParts, tween) {\n    var adjusted,\n        scale,\n        maxIterations = 20,\n        currentValue = tween ? function () {\n      return tween.cur();\n    } : function () {\n      return jQuery.css(elem, prop, \"\");\n    },\n        initial = currentValue(),\n        unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? \"\" : \"px\"),\n        // Starting value computation is required for potential unit mismatches\n    initialInUnit = elem.nodeType && (jQuery.cssNumber[prop] || unit !== \"px\" && +initial) && rcssNum.exec(jQuery.css(elem, prop));\n\n    if (initialInUnit && initialInUnit[3] !== unit) {\n      // Support: Firefox <=54\n      // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n      initial = initial / 2; // Trust units reported by jQuery.css\n\n      unit = unit || initialInUnit[3]; // Iteratively approximate from a nonzero starting point\n\n      initialInUnit = +initial || 1;\n\n      while (maxIterations--) {\n        // Evaluate and update our best guess (doubling guesses that zero out).\n        // Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n        jQuery.style(elem, prop, initialInUnit + unit);\n\n        if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) {\n          maxIterations = 0;\n        }\n\n        initialInUnit = initialInUnit / scale;\n      }\n\n      initialInUnit = initialInUnit * 2;\n      jQuery.style(elem, prop, initialInUnit + unit); // Make sure we update the tween properties later on\n\n      valueParts = valueParts || [];\n    }\n\n    if (valueParts) {\n      initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified\n\n      adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];\n\n      if (tween) {\n        tween.unit = unit;\n        tween.start = initialInUnit;\n        tween.end = adjusted;\n      }\n    }\n\n    return adjusted;\n  }\n\n  var defaultDisplayMap = {};\n\n  function getDefaultDisplay(elem) {\n    var temp,\n        doc = elem.ownerDocument,\n        nodeName = elem.nodeName,\n        display = defaultDisplayMap[nodeName];\n\n    if (display) {\n      return display;\n    }\n\n    temp = doc.body.appendChild(doc.createElement(nodeName));\n    display = jQuery.css(temp, \"display\");\n    temp.parentNode.removeChild(temp);\n\n    if (display === \"none\") {\n      display = \"block\";\n    }\n\n    defaultDisplayMap[nodeName] = display;\n    return display;\n  }\n\n  function showHide(elements, show) {\n    var display,\n        elem,\n        values = [],\n        index = 0,\n        length = elements.length; // Determine new display value for elements that need to change\n\n    for (; index < length; index++) {\n      elem = elements[index];\n\n      if (!elem.style) {\n        continue;\n      }\n\n      display = elem.style.display;\n\n      if (show) {\n        // Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n        // check is required in this first loop unless we have a nonempty display value (either\n        // inline or about-to-be-restored)\n        if (display === \"none\") {\n          values[index] = dataPriv.get(elem, \"display\") || null;\n\n          if (!values[index]) {\n            elem.style.display = \"\";\n          }\n        }\n\n        if (elem.style.display === \"\" && isHiddenWithinTree(elem)) {\n          values[index] = getDefaultDisplay(elem);\n        }\n      } else {\n        if (display !== \"none\") {\n          values[index] = \"none\"; // Remember what we're overwriting\n\n          dataPriv.set(elem, \"display\", display);\n        }\n      }\n    } // Set the display of the elements in a second loop to avoid constant reflow\n\n\n    for (index = 0; index < length; index++) {\n      if (values[index] != null) {\n        elements[index].style.display = values[index];\n      }\n    }\n\n    return elements;\n  }\n\n  jQuery.fn.extend({\n    show: function show() {\n      return showHide(this, true);\n    },\n    hide: function hide() {\n      return showHide(this);\n    },\n    toggle: function toggle(state) {\n      if (typeof state === \"boolean\") {\n        return state ? this.show() : this.hide();\n      }\n\n      return this.each(function () {\n        if (isHiddenWithinTree(this)) {\n          jQuery(this).show();\n        } else {\n          jQuery(this).hide();\n        }\n      });\n    }\n  });\n  var rcheckableType = /^(?:checkbox|radio)$/i;\n  var rtagName = /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i;\n  var rscriptType = /^$|^module$|\\/(?:java|ecma)script/i; // We have to close these tags to support XHTML (#13200)\n\n  var wrapMap = {\n    // Support: IE <=9 only\n    option: [1, \"<select multiple='multiple'>\", \"</select>\"],\n    // XHTML parsers do not magically insert elements in the\n    // same way that tag soup parsers do. So we cannot shorten\n    // this by omitting <tbody> or other required elements.\n    thead: [1, \"<table>\", \"</table>\"],\n    col: [2, \"<table><colgroup>\", \"</colgroup></table>\"],\n    tr: [2, \"<table><tbody>\", \"</tbody></table>\"],\n    td: [3, \"<table><tbody><tr>\", \"</tr></tbody></table>\"],\n    _default: [0, \"\", \"\"]\n  }; // Support: IE <=9 only\n\n  wrapMap.optgroup = wrapMap.option;\n  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\n  wrapMap.th = wrapMap.td;\n\n  function getAll(context, tag) {\n    // Support: IE <=9 - 11 only\n    // Use typeof to avoid zero-argument method invocation on host objects (#15151)\n    var ret;\n\n    if (typeof context.getElementsByTagName !== \"undefined\") {\n      ret = context.getElementsByTagName(tag || \"*\");\n    } else if (typeof context.querySelectorAll !== \"undefined\") {\n      ret = context.querySelectorAll(tag || \"*\");\n    } else {\n      ret = [];\n    }\n\n    if (tag === undefined || tag && nodeName(context, tag)) {\n      return jQuery.merge([context], ret);\n    }\n\n    return ret;\n  } // Mark scripts as having already been evaluated\n\n\n  function setGlobalEval(elems, refElements) {\n    var i = 0,\n        l = elems.length;\n\n    for (; i < l; i++) {\n      dataPriv.set(elems[i], \"globalEval\", !refElements || dataPriv.get(refElements[i], \"globalEval\"));\n    }\n  }\n\n  var rhtml = /<|&#?\\w+;/;\n\n  function buildFragment(elems, context, scripts, selection, ignored) {\n    var elem,\n        tmp,\n        tag,\n        wrap,\n        attached,\n        j,\n        fragment = context.createDocumentFragment(),\n        nodes = [],\n        i = 0,\n        l = elems.length;\n\n    for (; i < l; i++) {\n      elem = elems[i];\n\n      if (elem || elem === 0) {\n        // Add nodes directly\n        if (toType(elem) === \"object\") {\n          // Support: Android <=4.0 only, PhantomJS 1 only\n          // push.apply(_, arraylike) throws on ancient WebKit\n          jQuery.merge(nodes, elem.nodeType ? [elem] : elem); // Convert non-html into a text node\n        } else if (!rhtml.test(elem)) {\n          nodes.push(context.createTextNode(elem)); // Convert html into DOM nodes\n        } else {\n          tmp = tmp || fragment.appendChild(context.createElement(\"div\")); // Deserialize a standard representation\n\n          tag = (rtagName.exec(elem) || [\"\", \"\"])[1].toLowerCase();\n          wrap = wrapMap[tag] || wrapMap._default;\n          tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2]; // Descend through wrappers to the right content\n\n          j = wrap[0];\n\n          while (j--) {\n            tmp = tmp.lastChild;\n          } // Support: Android <=4.0 only, PhantomJS 1 only\n          // push.apply(_, arraylike) throws on ancient WebKit\n\n\n          jQuery.merge(nodes, tmp.childNodes); // Remember the top-level container\n\n          tmp = fragment.firstChild; // Ensure the created nodes are orphaned (#12392)\n\n          tmp.textContent = \"\";\n        }\n      }\n    } // Remove wrapper from fragment\n\n\n    fragment.textContent = \"\";\n    i = 0;\n\n    while (elem = nodes[i++]) {\n      // Skip elements already in the context collection (trac-4087)\n      if (selection && jQuery.inArray(elem, selection) > -1) {\n        if (ignored) {\n          ignored.push(elem);\n        }\n\n        continue;\n      }\n\n      attached = isAttached(elem); // Append to fragment\n\n      tmp = getAll(fragment.appendChild(elem), \"script\"); // Preserve script evaluation history\n\n      if (attached) {\n        setGlobalEval(tmp);\n      } // Capture executables\n\n\n      if (scripts) {\n        j = 0;\n\n        while (elem = tmp[j++]) {\n          if (rscriptType.test(elem.type || \"\")) {\n            scripts.push(elem);\n          }\n        }\n      }\n    }\n\n    return fragment;\n  }\n\n  (function () {\n    var fragment = document.createDocumentFragment(),\n        div = fragment.appendChild(document.createElement(\"div\")),\n        input = document.createElement(\"input\"); // Support: Android 4.0 - 4.3 only\n    // Check state lost if the name is set (#11217)\n    // Support: Windows Web Apps (WWA)\n    // `name` and `type` must use .setAttribute for WWA (#14901)\n\n    input.setAttribute(\"type\", \"radio\");\n    input.setAttribute(\"checked\", \"checked\");\n    input.setAttribute(\"name\", \"t\");\n    div.appendChild(input); // Support: Android <=4.1 only\n    // Older WebKit doesn't clone checked state correctly in fragments\n\n    support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; // Support: IE <=11 only\n    // Make sure textarea (and checkbox) defaultValue is properly cloned\n\n    div.innerHTML = \"<textarea>x</textarea>\";\n    support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;\n  })();\n\n  var rkeyEvent = /^key/,\n      rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n      rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\n  function returnTrue() {\n    return true;\n  }\n\n  function returnFalse() {\n    return false;\n  } // Support: IE <=9 - 11+\n  // focus() and blur() are asynchronous, except when they are no-op.\n  // So expect focus to be synchronous when the element is already active,\n  // and blur to be synchronous when the element is not already active.\n  // (focus and blur are always synchronous in other supported browsers,\n  // this just defines when we can count on it).\n\n\n  function expectSync(elem, type) {\n    return elem === safeActiveElement() === (type === \"focus\");\n  } // Support: IE <=9 only\n  // Accessing document.activeElement can throw unexpectedly\n  // https://bugs.jquery.com/ticket/13393\n\n\n  function safeActiveElement() {\n    try {\n      return document.activeElement;\n    } catch (err) {}\n  }\n\n  function _on(elem, types, selector, data, fn, one) {\n    var origFn, type; // Types can be a map of types/handlers\n\n    if (_typeof(types) === \"object\") {\n      // ( types-Object, selector, data )\n      if (typeof selector !== \"string\") {\n        // ( types-Object, data )\n        data = data || selector;\n        selector = undefined;\n      }\n\n      for (type in types) {\n        _on(elem, type, selector, data, types[type], one);\n      }\n\n      return elem;\n    }\n\n    if (data == null && fn == null) {\n      // ( types, fn )\n      fn = selector;\n      data = selector = undefined;\n    } else if (fn == null) {\n      if (typeof selector === \"string\") {\n        // ( types, selector, fn )\n        fn = data;\n        data = undefined;\n      } else {\n        // ( types, data, fn )\n        fn = data;\n        data = selector;\n        selector = undefined;\n      }\n    }\n\n    if (fn === false) {\n      fn = returnFalse;\n    } else if (!fn) {\n      return elem;\n    }\n\n    if (one === 1) {\n      origFn = fn;\n\n      fn = function fn(event) {\n        // Can use an empty set, since event contains the info\n        jQuery().off(event);\n        return origFn.apply(this, arguments);\n      }; // Use same guid so caller can remove using origFn\n\n\n      fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);\n    }\n\n    return elem.each(function () {\n      jQuery.event.add(this, types, fn, data, selector);\n    });\n  }\n  /*\n   * Helper functions for managing events -- not part of the public interface.\n   * Props to Dean Edwards' addEvent library for many of the ideas.\n   */\n\n\n  jQuery.event = {\n    global: {},\n    add: function add(elem, types, handler, data, selector) {\n      var handleObjIn,\n          eventHandle,\n          tmp,\n          events,\n          t,\n          handleObj,\n          special,\n          handlers,\n          type,\n          namespaces,\n          origType,\n          elemData = dataPriv.get(elem); // Don't attach events to noData or text/comment nodes (but allow plain objects)\n\n      if (!elemData) {\n        return;\n      } // Caller can pass in an object of custom data in lieu of the handler\n\n\n      if (handler.handler) {\n        handleObjIn = handler;\n        handler = handleObjIn.handler;\n        selector = handleObjIn.selector;\n      } // Ensure that invalid selectors throw exceptions at attach time\n      // Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\n\n      if (selector) {\n        jQuery.find.matchesSelector(documentElement, selector);\n      } // Make sure that the handler has a unique ID, used to find/remove it later\n\n\n      if (!handler.guid) {\n        handler.guid = jQuery.guid++;\n      } // Init the element's event structure and main handler, if this is the first\n\n\n      if (!(events = elemData.events)) {\n        events = elemData.events = {};\n      }\n\n      if (!(eventHandle = elemData.handle)) {\n        eventHandle = elemData.handle = function (e) {\n          // Discard the second event of a jQuery.event.trigger() and\n          // when an event is called after a page has unloaded\n          return typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined;\n        };\n      } // Handle multiple events separated by a space\n\n\n      types = (types || \"\").match(rnothtmlwhite) || [\"\"];\n      t = types.length;\n\n      while (t--) {\n        tmp = rtypenamespace.exec(types[t]) || [];\n        type = origType = tmp[1];\n        namespaces = (tmp[2] || \"\").split(\".\").sort(); // There *must* be a type, no attaching namespace-only handlers\n\n        if (!type) {\n          continue;\n        } // If event changes its type, use the special event handlers for the changed type\n\n\n        special = jQuery.event.special[type] || {}; // If selector defined, determine special event api type, otherwise given type\n\n        type = (selector ? special.delegateType : special.bindType) || type; // Update special based on newly reset type\n\n        special = jQuery.event.special[type] || {}; // handleObj is passed to all event handlers\n\n        handleObj = jQuery.extend({\n          type: type,\n          origType: origType,\n          data: data,\n          handler: handler,\n          guid: handler.guid,\n          selector: selector,\n          needsContext: selector && jQuery.expr.match.needsContext.test(selector),\n          namespace: namespaces.join(\".\")\n        }, handleObjIn); // Init the event handler queue if we're the first\n\n        if (!(handlers = events[type])) {\n          handlers = events[type] = [];\n          handlers.delegateCount = 0; // Only use addEventListener if the special events handler returns false\n\n          if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {\n            if (elem.addEventListener) {\n              elem.addEventListener(type, eventHandle);\n            }\n          }\n        }\n\n        if (special.add) {\n          special.add.call(elem, handleObj);\n\n          if (!handleObj.handler.guid) {\n            handleObj.handler.guid = handler.guid;\n          }\n        } // Add to the element's handler list, delegates in front\n\n\n        if (selector) {\n          handlers.splice(handlers.delegateCount++, 0, handleObj);\n        } else {\n          handlers.push(handleObj);\n        } // Keep track of which events have ever been used, for event optimization\n\n\n        jQuery.event.global[type] = true;\n      }\n    },\n    // Detach an event or set of events from an element\n    remove: function remove(elem, types, handler, selector, mappedTypes) {\n      var j,\n          origCount,\n          tmp,\n          events,\n          t,\n          handleObj,\n          special,\n          handlers,\n          type,\n          namespaces,\n          origType,\n          elemData = dataPriv.hasData(elem) && dataPriv.get(elem);\n\n      if (!elemData || !(events = elemData.events)) {\n        return;\n      } // Once for each type.namespace in types; type may be omitted\n\n\n      types = (types || \"\").match(rnothtmlwhite) || [\"\"];\n      t = types.length;\n\n      while (t--) {\n        tmp = rtypenamespace.exec(types[t]) || [];\n        type = origType = tmp[1];\n        namespaces = (tmp[2] || \"\").split(\".\").sort(); // Unbind all events (on this namespace, if provided) for the element\n\n        if (!type) {\n          for (type in events) {\n            jQuery.event.remove(elem, type + types[t], handler, selector, true);\n          }\n\n          continue;\n        }\n\n        special = jQuery.event.special[type] || {};\n        type = (selector ? special.delegateType : special.bindType) || type;\n        handlers = events[type] || [];\n        tmp = tmp[2] && new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\"); // Remove matching events\n\n        origCount = j = handlers.length;\n\n        while (j--) {\n          handleObj = handlers[j];\n\n          if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === \"**\" && handleObj.selector)) {\n            handlers.splice(j, 1);\n\n            if (handleObj.selector) {\n              handlers.delegateCount--;\n            }\n\n            if (special.remove) {\n              special.remove.call(elem, handleObj);\n            }\n          }\n        } // Remove generic event handler if we removed something and no more handlers exist\n        // (avoids potential for endless recursion during removal of special event handlers)\n\n\n        if (origCount && !handlers.length) {\n          if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {\n            jQuery.removeEvent(elem, type, elemData.handle);\n          }\n\n          delete events[type];\n        }\n      } // Remove data and the expando if it's no longer used\n\n\n      if (jQuery.isEmptyObject(events)) {\n        dataPriv.remove(elem, \"handle events\");\n      }\n    },\n    dispatch: function dispatch(nativeEvent) {\n      // Make a writable jQuery.Event from the native event object\n      var event = jQuery.event.fix(nativeEvent);\n      var i,\n          j,\n          ret,\n          matched,\n          handleObj,\n          handlerQueue,\n          args = new Array(arguments.length),\n          handlers = (dataPriv.get(this, \"events\") || {})[event.type] || [],\n          special = jQuery.event.special[event.type] || {}; // Use the fix-ed jQuery.Event rather than the (read-only) native event\n\n      args[0] = event;\n\n      for (i = 1; i < arguments.length; i++) {\n        args[i] = arguments[i];\n      }\n\n      event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired\n\n      if (special.preDispatch && special.preDispatch.call(this, event) === false) {\n        return;\n      } // Determine handlers\n\n\n      handlerQueue = jQuery.event.handlers.call(this, event, handlers); // Run delegates first; they may want to stop propagation beneath us\n\n      i = 0;\n\n      while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {\n        event.currentTarget = matched.elem;\n        j = 0;\n\n        while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {\n          // If the event is namespaced, then each handler is only invoked if it is\n          // specially universal or its namespaces are a superset of the event's.\n          if (!event.rnamespace || handleObj.namespace === false || event.rnamespace.test(handleObj.namespace)) {\n            event.handleObj = handleObj;\n            event.data = handleObj.data;\n            ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);\n\n            if (ret !== undefined) {\n              if ((event.result = ret) === false) {\n                event.preventDefault();\n                event.stopPropagation();\n              }\n            }\n          }\n        }\n      } // Call the postDispatch hook for the mapped type\n\n\n      if (special.postDispatch) {\n        special.postDispatch.call(this, event);\n      }\n\n      return event.result;\n    },\n    handlers: function handlers(event, _handlers) {\n      var i,\n          handleObj,\n          sel,\n          matchedHandlers,\n          matchedSelectors,\n          handlerQueue = [],\n          delegateCount = _handlers.delegateCount,\n          cur = event.target; // Find delegate handlers\n\n      if (delegateCount && // Support: IE <=9\n      // Black-hole SVG <use> instance trees (trac-13180)\n      cur.nodeType && // Support: Firefox <=42\n      // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n      // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n      // Support: IE 11 only\n      // ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n      !(event.type === \"click\" && event.button >= 1)) {\n        for (; cur !== this; cur = cur.parentNode || this) {\n          // Don't check non-elements (#13208)\n          // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n          if (cur.nodeType === 1 && !(event.type === \"click\" && cur.disabled === true)) {\n            matchedHandlers = [];\n            matchedSelectors = {};\n\n            for (i = 0; i < delegateCount; i++) {\n              handleObj = _handlers[i]; // Don't conflict with Object.prototype properties (#13203)\n\n              sel = handleObj.selector + \" \";\n\n              if (matchedSelectors[sel] === undefined) {\n                matchedSelectors[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length;\n              }\n\n              if (matchedSelectors[sel]) {\n                matchedHandlers.push(handleObj);\n              }\n            }\n\n            if (matchedHandlers.length) {\n              handlerQueue.push({\n                elem: cur,\n                handlers: matchedHandlers\n              });\n            }\n          }\n        }\n      } // Add the remaining (directly-bound) handlers\n\n\n      cur = this;\n\n      if (delegateCount < _handlers.length) {\n        handlerQueue.push({\n          elem: cur,\n          handlers: _handlers.slice(delegateCount)\n        });\n      }\n\n      return handlerQueue;\n    },\n    addProp: function addProp(name, hook) {\n      Object.defineProperty(jQuery.Event.prototype, name, {\n        enumerable: true,\n        configurable: true,\n        get: isFunction(hook) ? function () {\n          if (this.originalEvent) {\n            return hook(this.originalEvent);\n          }\n        } : function () {\n          if (this.originalEvent) {\n            return this.originalEvent[name];\n          }\n        },\n        set: function set(value) {\n          Object.defineProperty(this, name, {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: value\n          });\n        }\n      });\n    },\n    fix: function fix(originalEvent) {\n      return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);\n    },\n    special: {\n      load: {\n        // Prevent triggered image.load events from bubbling to window.load\n        noBubble: true\n      },\n      click: {\n        // Utilize native event to ensure correct state for checkable inputs\n        setup: function setup(data) {\n          // For mutual compressibility with _default, replace `this` access with a local var.\n          // `|| data` is dead code meant only to preserve the variable through minification.\n          var el = this || data; // Claim the first handler\n\n          if (rcheckableType.test(el.type) && el.click && nodeName(el, \"input\")) {\n            // dataPriv.set( el, \"click\", ... )\n            leverageNative(el, \"click\", returnTrue);\n          } // Return false to allow normal processing in the caller\n\n\n          return false;\n        },\n        trigger: function trigger(data) {\n          // For mutual compressibility with _default, replace `this` access with a local var.\n          // `|| data` is dead code meant only to preserve the variable through minification.\n          var el = this || data; // Force setup before triggering a click\n\n          if (rcheckableType.test(el.type) && el.click && nodeName(el, \"input\")) {\n            leverageNative(el, \"click\");\n          } // Return non-false to allow normal event-path propagation\n\n\n          return true;\n        },\n        // For cross-browser consistency, suppress native .click() on links\n        // Also prevent it if we're currently inside a leveraged native-event stack\n        _default: function _default(event) {\n          var target = event.target;\n          return rcheckableType.test(target.type) && target.click && nodeName(target, \"input\") && dataPriv.get(target, \"click\") || nodeName(target, \"a\");\n        }\n      },\n      beforeunload: {\n        postDispatch: function postDispatch(event) {\n          // Support: Firefox 20+\n          // Firefox doesn't alert if the returnValue field is not set.\n          if (event.result !== undefined && event.originalEvent) {\n            event.originalEvent.returnValue = event.result;\n          }\n        }\n      }\n    }\n  }; // Ensure the presence of an event listener that handles manually-triggered\n  // synthetic events by interrupting progress until reinvoked in response to\n  // *native* events that it fires directly, ensuring that state changes have\n  // already occurred before other listeners are invoked.\n\n  function leverageNative(el, type, expectSync) {\n    // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add\n    if (!expectSync) {\n      if (dataPriv.get(el, type) === undefined) {\n        jQuery.event.add(el, type, returnTrue);\n      }\n\n      return;\n    } // Register the controller as a special universal handler for all event namespaces\n\n\n    dataPriv.set(el, type, false);\n    jQuery.event.add(el, type, {\n      namespace: false,\n      handler: function handler(event) {\n        var notAsync,\n            result,\n            saved = dataPriv.get(this, type);\n\n        if (event.isTrigger & 1 && this[type]) {\n          // Interrupt processing of the outer synthetic .trigger()ed event\n          // Saved data should be false in such cases, but might be a leftover capture object\n          // from an async native handler (gh-4350)\n          if (!saved.length) {\n            // Store arguments for use when handling the inner native event\n            // There will always be at least one argument (an event object), so this array\n            // will not be confused with a leftover capture object.\n            saved = _slice.call(arguments);\n            dataPriv.set(this, type, saved); // Trigger the native event and capture its result\n            // Support: IE <=9 - 11+\n            // focus() and blur() are asynchronous\n\n            notAsync = expectSync(this, type);\n            this[type]();\n            result = dataPriv.get(this, type);\n\n            if (saved !== result || notAsync) {\n              dataPriv.set(this, type, false);\n            } else {\n              result = {};\n            }\n\n            if (saved !== result) {\n              // Cancel the outer synthetic event\n              event.stopImmediatePropagation();\n              event.preventDefault();\n              return result.value;\n            } // If this is an inner synthetic event for an event with a bubbling surrogate\n            // (focus or blur), assume that the surrogate already propagated from triggering the\n            // native event and prevent that from happening again here.\n            // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n            // bubbling surrogate propagates *after* the non-bubbling base), but that seems\n            // less bad than duplication.\n\n          } else if ((jQuery.event.special[type] || {}).delegateType) {\n            event.stopPropagation();\n          } // If this is a native event triggered above, everything is now in order\n          // Fire an inner synthetic event with the original arguments\n\n        } else if (saved.length) {\n          // ...and capture the result\n          dataPriv.set(this, type, {\n            value: jQuery.event.trigger( // Support: IE <=9 - 11+\n            // Extend with the prototype to reset the above stopImmediatePropagation()\n            jQuery.extend(saved[0], jQuery.Event.prototype), saved.slice(1), this)\n          }); // Abort handling of the native event\n\n          event.stopImmediatePropagation();\n        }\n      }\n    });\n  }\n\n  jQuery.removeEvent = function (elem, type, handle) {\n    // This \"if\" is needed for plain objects\n    if (elem.removeEventListener) {\n      elem.removeEventListener(type, handle);\n    }\n  };\n\n  jQuery.Event = function (src, props) {\n    // Allow instantiation without the 'new' keyword\n    if (!(this instanceof jQuery.Event)) {\n      return new jQuery.Event(src, props);\n    } // Event object\n\n\n    if (src && src.type) {\n      this.originalEvent = src;\n      this.type = src.type; // Events bubbling up the document may have been marked as prevented\n      // by a handler lower down the tree; reflect the correct value.\n\n      this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Support: Android <=2.3 only\n      src.returnValue === false ? returnTrue : returnFalse; // Create target properties\n      // Support: Safari <=6 - 7 only\n      // Target should not be a text node (#504, #13143)\n\n      this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target;\n      this.currentTarget = src.currentTarget;\n      this.relatedTarget = src.relatedTarget; // Event type\n    } else {\n      this.type = src;\n    } // Put explicitly provided properties onto the event object\n\n\n    if (props) {\n      jQuery.extend(this, props);\n    } // Create a timestamp if incoming event doesn't have one\n\n\n    this.timeStamp = src && src.timeStamp || Date.now(); // Mark it as fixed\n\n    this[jQuery.expando] = true;\n  }; // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n  // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\n\n\n  jQuery.Event.prototype = {\n    constructor: jQuery.Event,\n    isDefaultPrevented: returnFalse,\n    isPropagationStopped: returnFalse,\n    isImmediatePropagationStopped: returnFalse,\n    isSimulated: false,\n    preventDefault: function preventDefault() {\n      var e = this.originalEvent;\n      this.isDefaultPrevented = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.preventDefault();\n      }\n    },\n    stopPropagation: function stopPropagation() {\n      var e = this.originalEvent;\n      this.isPropagationStopped = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.stopPropagation();\n      }\n    },\n    stopImmediatePropagation: function stopImmediatePropagation() {\n      var e = this.originalEvent;\n      this.isImmediatePropagationStopped = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.stopImmediatePropagation();\n      }\n\n      this.stopPropagation();\n    }\n  }; // Includes all common event props including KeyEvent and MouseEvent specific props\n\n  jQuery.each({\n    altKey: true,\n    bubbles: true,\n    cancelable: true,\n    changedTouches: true,\n    ctrlKey: true,\n    detail: true,\n    eventPhase: true,\n    metaKey: true,\n    pageX: true,\n    pageY: true,\n    shiftKey: true,\n    view: true,\n    \"char\": true,\n    code: true,\n    charCode: true,\n    key: true,\n    keyCode: true,\n    button: true,\n    buttons: true,\n    clientX: true,\n    clientY: true,\n    offsetX: true,\n    offsetY: true,\n    pointerId: true,\n    pointerType: true,\n    screenX: true,\n    screenY: true,\n    targetTouches: true,\n    toElement: true,\n    touches: true,\n    which: function which(event) {\n      var button = event.button; // Add which for key events\n\n      if (event.which == null && rkeyEvent.test(event.type)) {\n        return event.charCode != null ? event.charCode : event.keyCode;\n      } // Add which for click: 1 === left; 2 === middle; 3 === right\n\n\n      if (!event.which && button !== undefined && rmouseEvent.test(event.type)) {\n        if (button & 1) {\n          return 1;\n        }\n\n        if (button & 2) {\n          return 3;\n        }\n\n        if (button & 4) {\n          return 2;\n        }\n\n        return 0;\n      }\n\n      return event.which;\n    }\n  }, jQuery.event.addProp);\n  jQuery.each({\n    focus: \"focusin\",\n    blur: \"focusout\"\n  }, function (type, delegateType) {\n    jQuery.event.special[type] = {\n      // Utilize native event if possible so blur/focus sequence is correct\n      setup: function setup() {\n        // Claim the first handler\n        // dataPriv.set( this, \"focus\", ... )\n        // dataPriv.set( this, \"blur\", ... )\n        leverageNative(this, type, expectSync); // Return false to allow normal processing in the caller\n\n        return false;\n      },\n      trigger: function trigger() {\n        // Force setup before trigger\n        leverageNative(this, type); // Return non-false to allow normal event-path propagation\n\n        return true;\n      },\n      delegateType: delegateType\n    };\n  }); // Create mouseenter/leave events using mouseover/out and event-time checks\n  // so that event delegation works in jQuery.\n  // Do the same for pointerenter/pointerleave and pointerover/pointerout\n  //\n  // Support: Safari 7 only\n  // Safari sends mouseenter too often; see:\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n  // for the description of the bug (it existed in older Chrome versions as well).\n\n  jQuery.each({\n    mouseenter: \"mouseover\",\n    mouseleave: \"mouseout\",\n    pointerenter: \"pointerover\",\n    pointerleave: \"pointerout\"\n  }, function (orig, fix) {\n    jQuery.event.special[orig] = {\n      delegateType: fix,\n      bindType: fix,\n      handle: function handle(event) {\n        var ret,\n            target = this,\n            related = event.relatedTarget,\n            handleObj = event.handleObj; // For mouseenter/leave call the handler if related is outside the target.\n        // NB: No relatedTarget if the mouse left/entered the browser window\n\n        if (!related || related !== target && !jQuery.contains(target, related)) {\n          event.type = handleObj.origType;\n          ret = handleObj.handler.apply(this, arguments);\n          event.type = fix;\n        }\n\n        return ret;\n      }\n    };\n  });\n  jQuery.fn.extend({\n    on: function on(types, selector, data, fn) {\n      return _on(this, types, selector, data, fn);\n    },\n    one: function one(types, selector, data, fn) {\n      return _on(this, types, selector, data, fn, 1);\n    },\n    off: function off(types, selector, fn) {\n      var handleObj, type;\n\n      if (types && types.preventDefault && types.handleObj) {\n        // ( event )  dispatched jQuery.Event\n        handleObj = types.handleObj;\n        jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + \".\" + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);\n        return this;\n      }\n\n      if (_typeof(types) === \"object\") {\n        // ( types-object [, selector] )\n        for (type in types) {\n          this.off(type, selector, types[type]);\n        }\n\n        return this;\n      }\n\n      if (selector === false || typeof selector === \"function\") {\n        // ( types [, fn] )\n        fn = selector;\n        selector = undefined;\n      }\n\n      if (fn === false) {\n        fn = returnFalse;\n      }\n\n      return this.each(function () {\n        jQuery.event.remove(this, types, fn, selector);\n      });\n    }\n  });\n  var\n  /* eslint-disable max-len */\n  // See https://github.com/eslint/eslint/issues/3229\n  rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)[^>]*)\\/>/gi,\n\n  /* eslint-enable */\n  // Support: IE <=10 - 11, Edge 12 - 13 only\n  // In IE/Edge using regex groups here causes severe slowdowns.\n  // See https://connect.microsoft.com/IE/feedback/details/1736512/\n  rnoInnerhtml = /<script|<style|<link/i,\n      // checked=\"checked\" or checked\n  rchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n      rcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g; // Prefer a tbody over its parent table for containing new rows\n\n  function manipulationTarget(elem, content) {\n    if (nodeName(elem, \"table\") && nodeName(content.nodeType !== 11 ? content : content.firstChild, \"tr\")) {\n      return jQuery(elem).children(\"tbody\")[0] || elem;\n    }\n\n    return elem;\n  } // Replace/restore the type attribute of script elements for safe DOM manipulation\n\n\n  function disableScript(elem) {\n    elem.type = (elem.getAttribute(\"type\") !== null) + \"/\" + elem.type;\n    return elem;\n  }\n\n  function restoreScript(elem) {\n    if ((elem.type || \"\").slice(0, 5) === \"true/\") {\n      elem.type = elem.type.slice(5);\n    } else {\n      elem.removeAttribute(\"type\");\n    }\n\n    return elem;\n  }\n\n  function cloneCopyEvent(src, dest) {\n    var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;\n\n    if (dest.nodeType !== 1) {\n      return;\n    } // 1. Copy private data: events, handlers, etc.\n\n\n    if (dataPriv.hasData(src)) {\n      pdataOld = dataPriv.access(src);\n      pdataCur = dataPriv.set(dest, pdataOld);\n      events = pdataOld.events;\n\n      if (events) {\n        delete pdataCur.handle;\n        pdataCur.events = {};\n\n        for (type in events) {\n          for (i = 0, l = events[type].length; i < l; i++) {\n            jQuery.event.add(dest, type, events[type][i]);\n          }\n        }\n      }\n    } // 2. Copy user data\n\n\n    if (dataUser.hasData(src)) {\n      udataOld = dataUser.access(src);\n      udataCur = jQuery.extend({}, udataOld);\n      dataUser.set(dest, udataCur);\n    }\n  } // Fix IE bugs, see support tests\n\n\n  function fixInput(src, dest) {\n    var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button.\n\n    if (nodeName === \"input\" && rcheckableType.test(src.type)) {\n      dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options\n    } else if (nodeName === \"input\" || nodeName === \"textarea\") {\n      dest.defaultValue = src.defaultValue;\n    }\n  }\n\n  function domManip(collection, args, callback, ignored) {\n    // Flatten any nested arrays\n    args = concat.apply([], args);\n    var fragment,\n        first,\n        scripts,\n        hasScripts,\n        node,\n        doc,\n        i = 0,\n        l = collection.length,\n        iNoClone = l - 1,\n        value = args[0],\n        valueIsFunction = isFunction(value); // We can't cloneNode fragments that contain checked, in WebKit\n\n    if (valueIsFunction || l > 1 && typeof value === \"string\" && !support.checkClone && rchecked.test(value)) {\n      return collection.each(function (index) {\n        var self = collection.eq(index);\n\n        if (valueIsFunction) {\n          args[0] = value.call(this, index, self.html());\n        }\n\n        domManip(self, args, callback, ignored);\n      });\n    }\n\n    if (l) {\n      fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);\n      first = fragment.firstChild;\n\n      if (fragment.childNodes.length === 1) {\n        fragment = first;\n      } // Require either new content or an interest in ignored elements to invoke the callback\n\n\n      if (first || ignored) {\n        scripts = jQuery.map(getAll(fragment, \"script\"), disableScript);\n        hasScripts = scripts.length; // Use the original fragment for the last item\n        // instead of the first because it can end up\n        // being emptied incorrectly in certain situations (#8070).\n\n        for (; i < l; i++) {\n          node = fragment;\n\n          if (i !== iNoClone) {\n            node = jQuery.clone(node, true, true); // Keep references to cloned scripts for later restoration\n\n            if (hasScripts) {\n              // Support: Android <=4.0 only, PhantomJS 1 only\n              // push.apply(_, arraylike) throws on ancient WebKit\n              jQuery.merge(scripts, getAll(node, \"script\"));\n            }\n          }\n\n          callback.call(collection[i], node, i);\n        }\n\n        if (hasScripts) {\n          doc = scripts[scripts.length - 1].ownerDocument; // Reenable scripts\n\n          jQuery.map(scripts, restoreScript); // Evaluate executable scripts on first document insertion\n\n          for (i = 0; i < hasScripts; i++) {\n            node = scripts[i];\n\n            if (rscriptType.test(node.type || \"\") && !dataPriv.access(node, \"globalEval\") && jQuery.contains(doc, node)) {\n              if (node.src && (node.type || \"\").toLowerCase() !== \"module\") {\n                // Optional AJAX dependency, but won't run scripts if not present\n                if (jQuery._evalUrl && !node.noModule) {\n                  jQuery._evalUrl(node.src, {\n                    nonce: node.nonce || node.getAttribute(\"nonce\")\n                  });\n                }\n              } else {\n                DOMEval(node.textContent.replace(rcleanScript, \"\"), node, doc);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return collection;\n  }\n\n  function _remove(elem, selector, keepData) {\n    var node,\n        nodes = selector ? jQuery.filter(selector, elem) : elem,\n        i = 0;\n\n    for (; (node = nodes[i]) != null; i++) {\n      if (!keepData && node.nodeType === 1) {\n        jQuery.cleanData(getAll(node));\n      }\n\n      if (node.parentNode) {\n        if (keepData && isAttached(node)) {\n          setGlobalEval(getAll(node, \"script\"));\n        }\n\n        node.parentNode.removeChild(node);\n      }\n    }\n\n    return elem;\n  }\n\n  jQuery.extend({\n    htmlPrefilter: function htmlPrefilter(html) {\n      return html.replace(rxhtmlTag, \"<$1></$2>\");\n    },\n    clone: function clone(elem, dataAndEvents, deepDataAndEvents) {\n      var i,\n          l,\n          srcElements,\n          destElements,\n          clone = elem.cloneNode(true),\n          inPage = isAttached(elem); // Fix IE cloning issues\n\n      if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {\n        // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2\n        destElements = getAll(clone);\n        srcElements = getAll(elem);\n\n        for (i = 0, l = srcElements.length; i < l; i++) {\n          fixInput(srcElements[i], destElements[i]);\n        }\n      } // Copy the events from the original to the clone\n\n\n      if (dataAndEvents) {\n        if (deepDataAndEvents) {\n          srcElements = srcElements || getAll(elem);\n          destElements = destElements || getAll(clone);\n\n          for (i = 0, l = srcElements.length; i < l; i++) {\n            cloneCopyEvent(srcElements[i], destElements[i]);\n          }\n        } else {\n          cloneCopyEvent(elem, clone);\n        }\n      } // Preserve script evaluation history\n\n\n      destElements = getAll(clone, \"script\");\n\n      if (destElements.length > 0) {\n        setGlobalEval(destElements, !inPage && getAll(elem, \"script\"));\n      } // Return the cloned set\n\n\n      return clone;\n    },\n    cleanData: function cleanData(elems) {\n      var data,\n          elem,\n          type,\n          special = jQuery.event.special,\n          i = 0;\n\n      for (; (elem = elems[i]) !== undefined; i++) {\n        if (acceptData(elem)) {\n          if (data = elem[dataPriv.expando]) {\n            if (data.events) {\n              for (type in data.events) {\n                if (special[type]) {\n                  jQuery.event.remove(elem, type); // This is a shortcut to avoid jQuery.event.remove's overhead\n                } else {\n                  jQuery.removeEvent(elem, type, data.handle);\n                }\n              }\n            } // Support: Chrome <=35 - 45+\n            // Assign undefined instead of using delete, see Data#remove\n\n\n            elem[dataPriv.expando] = undefined;\n          }\n\n          if (elem[dataUser.expando]) {\n            // Support: Chrome <=35 - 45+\n            // Assign undefined instead of using delete, see Data#remove\n            elem[dataUser.expando] = undefined;\n          }\n        }\n      }\n    }\n  });\n  jQuery.fn.extend({\n    detach: function detach(selector) {\n      return _remove(this, selector, true);\n    },\n    remove: function remove(selector) {\n      return _remove(this, selector);\n    },\n    text: function text(value) {\n      return access(this, function (value) {\n        return value === undefined ? jQuery.text(this) : this.empty().each(function () {\n          if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n            this.textContent = value;\n          }\n        });\n      }, null, value, arguments.length);\n    },\n    append: function append() {\n      return domManip(this, arguments, function (elem) {\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n          var target = manipulationTarget(this, elem);\n          target.appendChild(elem);\n        }\n      });\n    },\n    prepend: function prepend() {\n      return domManip(this, arguments, function (elem) {\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n          var target = manipulationTarget(this, elem);\n          target.insertBefore(elem, target.firstChild);\n        }\n      });\n    },\n    before: function before() {\n      return domManip(this, arguments, function (elem) {\n        if (this.parentNode) {\n          this.parentNode.insertBefore(elem, this);\n        }\n      });\n    },\n    after: function after() {\n      return domManip(this, arguments, function (elem) {\n        if (this.parentNode) {\n          this.parentNode.insertBefore(elem, this.nextSibling);\n        }\n      });\n    },\n    empty: function empty() {\n      var elem,\n          i = 0;\n\n      for (; (elem = this[i]) != null; i++) {\n        if (elem.nodeType === 1) {\n          // Prevent memory leaks\n          jQuery.cleanData(getAll(elem, false)); // Remove any remaining nodes\n\n          elem.textContent = \"\";\n        }\n      }\n\n      return this;\n    },\n    clone: function clone(dataAndEvents, deepDataAndEvents) {\n      dataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n      deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n      return this.map(function () {\n        return jQuery.clone(this, dataAndEvents, deepDataAndEvents);\n      });\n    },\n    html: function html(value) {\n      return access(this, function (value) {\n        var elem = this[0] || {},\n            i = 0,\n            l = this.length;\n\n        if (value === undefined && elem.nodeType === 1) {\n          return elem.innerHTML;\n        } // See if we can take a shortcut and just use innerHTML\n\n\n        if (typeof value === \"string\" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || [\"\", \"\"])[1].toLowerCase()]) {\n          value = jQuery.htmlPrefilter(value);\n\n          try {\n            for (; i < l; i++) {\n              elem = this[i] || {}; // Remove element nodes and prevent memory leaks\n\n              if (elem.nodeType === 1) {\n                jQuery.cleanData(getAll(elem, false));\n                elem.innerHTML = value;\n              }\n            }\n\n            elem = 0; // If using innerHTML throws an exception, use the fallback method\n          } catch (e) {}\n        }\n\n        if (elem) {\n          this.empty().append(value);\n        }\n      }, null, value, arguments.length);\n    },\n    replaceWith: function replaceWith() {\n      var ignored = []; // Make the changes, replacing each non-ignored context element with the new content\n\n      return domManip(this, arguments, function (elem) {\n        var parent = this.parentNode;\n\n        if (jQuery.inArray(this, ignored) < 0) {\n          jQuery.cleanData(getAll(this));\n\n          if (parent) {\n            parent.replaceChild(elem, this);\n          }\n        } // Force callback invocation\n\n      }, ignored);\n    }\n  });\n  jQuery.each({\n    appendTo: \"append\",\n    prependTo: \"prepend\",\n    insertBefore: \"before\",\n    insertAfter: \"after\",\n    replaceAll: \"replaceWith\"\n  }, function (name, original) {\n    jQuery.fn[name] = function (selector) {\n      var elems,\n          ret = [],\n          insert = jQuery(selector),\n          last = insert.length - 1,\n          i = 0;\n\n      for (; i <= last; i++) {\n        elems = i === last ? this : this.clone(true);\n        jQuery(insert[i])[original](elems); // Support: Android <=4.0 only, PhantomJS 1 only\n        // .get() because push.apply(_, arraylike) throws on ancient WebKit\n\n        push.apply(ret, elems.get());\n      }\n\n      return this.pushStack(ret);\n    };\n  });\n  var rnumnonpx = new RegExp(\"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\");\n\n  var getStyles = function getStyles(elem) {\n    // Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n    // IE throws on elements created in popups\n    // FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n    var view = elem.ownerDocument.defaultView;\n\n    if (!view || !view.opener) {\n      view = window;\n    }\n\n    return view.getComputedStyle(elem);\n  };\n\n  var rboxStyle = new RegExp(cssExpand.join(\"|\"), \"i\");\n\n  (function () {\n    // Executing both pixelPosition & boxSizingReliable tests require only one layout\n    // so they're executed at the same time to save the second computation.\n    function computeStyleTests() {\n      // This is a singleton, we need to execute it only once\n      if (!div) {\n        return;\n      }\n\n      container.style.cssText = \"position:absolute;left:-11111px;width:60px;\" + \"margin-top:1px;padding:0;border:0\";\n      div.style.cssText = \"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" + \"margin:auto;border:1px;padding:1px;\" + \"width:60%;top:1%\";\n      documentElement.appendChild(container).appendChild(div);\n      var divStyle = window.getComputedStyle(div);\n      pixelPositionVal = divStyle.top !== \"1%\"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\n      reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12; // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n      // Some styles come back with percentage values, even though they shouldn't\n\n      div.style.right = \"60%\";\n      pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36; // Support: IE 9 - 11 only\n      // Detect misreporting of content dimensions for box-sizing:border-box elements\n\n      boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36; // Support: IE 9 only\n      // Detect overflow:scroll screwiness (gh-3699)\n      // Support: Chrome <=64\n      // Don't get tricked when zoom affects offsetWidth (gh-4029)\n\n      div.style.position = \"absolute\";\n      scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12;\n      documentElement.removeChild(container); // Nullify the div so it wouldn't be stored in the memory and\n      // it will also be a sign that checks already performed\n\n      div = null;\n    }\n\n    function roundPixelMeasures(measure) {\n      return Math.round(parseFloat(measure));\n    }\n\n    var pixelPositionVal,\n        boxSizingReliableVal,\n        scrollboxSizeVal,\n        pixelBoxStylesVal,\n        reliableMarginLeftVal,\n        container = document.createElement(\"div\"),\n        div = document.createElement(\"div\"); // Finish early in limited (non-browser) environments\n\n    if (!div.style) {\n      return;\n    } // Support: IE <=9 - 11 only\n    // Style of cloned element affects source element cloned (#8908)\n\n\n    div.style.backgroundClip = \"content-box\";\n    div.cloneNode(true).style.backgroundClip = \"\";\n    support.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n    jQuery.extend(support, {\n      boxSizingReliable: function boxSizingReliable() {\n        computeStyleTests();\n        return boxSizingReliableVal;\n      },\n      pixelBoxStyles: function pixelBoxStyles() {\n        computeStyleTests();\n        return pixelBoxStylesVal;\n      },\n      pixelPosition: function pixelPosition() {\n        computeStyleTests();\n        return pixelPositionVal;\n      },\n      reliableMarginLeft: function reliableMarginLeft() {\n        computeStyleTests();\n        return reliableMarginLeftVal;\n      },\n      scrollboxSize: function scrollboxSize() {\n        computeStyleTests();\n        return scrollboxSizeVal;\n      }\n    });\n  })();\n\n  function curCSS(elem, name, computed) {\n    var width,\n        minWidth,\n        maxWidth,\n        ret,\n        // Support: Firefox 51+\n    // Retrieving style before computed somehow\n    // fixes an issue with getting wrong values\n    // on detached elements\n    style = elem.style;\n    computed = computed || getStyles(elem); // getPropertyValue is needed for:\n    //   .css('filter') (IE 9 only, #12537)\n    //   .css('--customProperty) (#3144)\n\n    if (computed) {\n      ret = computed.getPropertyValue(name) || computed[name];\n\n      if (ret === \"\" && !isAttached(elem)) {\n        ret = jQuery.style(elem, name);\n      } // A tribute to the \"awesome hack by Dean Edwards\"\n      // Android Browser returns percentage for some values,\n      // but width seems to be reliably pixels.\n      // This is against the CSSOM draft spec:\n      // https://drafts.csswg.org/cssom/#resolved-values\n\n\n      if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {\n        // Remember the original values\n        width = style.width;\n        minWidth = style.minWidth;\n        maxWidth = style.maxWidth; // Put in the new values to get a computed value out\n\n        style.minWidth = style.maxWidth = style.width = ret;\n        ret = computed.width; // Revert the changed values\n\n        style.width = width;\n        style.minWidth = minWidth;\n        style.maxWidth = maxWidth;\n      }\n    }\n\n    return ret !== undefined ? // Support: IE <=9 - 11 only\n    // IE returns zIndex value as an integer.\n    ret + \"\" : ret;\n  }\n\n  function addGetHookIf(conditionFn, hookFn) {\n    // Define the hook, we'll check on the first run if it's really needed.\n    return {\n      get: function get() {\n        if (conditionFn()) {\n          // Hook not needed (or it's not possible to use it due\n          // to missing dependency), remove it.\n          delete this.get;\n          return;\n        } // Hook needed; redefine it so that the support test is not executed again.\n\n\n        return (this.get = hookFn).apply(this, arguments);\n      }\n    };\n  }\n\n  var cssPrefixes = [\"Webkit\", \"Moz\", \"ms\"],\n      emptyStyle = document.createElement(\"div\").style,\n      vendorProps = {}; // Return a vendor-prefixed property or undefined\n\n  function vendorPropName(name) {\n    // Check for vendor prefixed names\n    var capName = name[0].toUpperCase() + name.slice(1),\n        i = cssPrefixes.length;\n\n    while (i--) {\n      name = cssPrefixes[i] + capName;\n\n      if (name in emptyStyle) {\n        return name;\n      }\n    }\n  } // Return a potentially-mapped jQuery.cssProps or vendor prefixed property\n\n\n  function finalPropName(name) {\n    var _final = jQuery.cssProps[name] || vendorProps[name];\n\n    if (_final) {\n      return _final;\n    }\n\n    if (name in emptyStyle) {\n      return name;\n    }\n\n    return vendorProps[name] = vendorPropName(name) || name;\n  }\n\n  var // Swappable if display is none or starts with table\n  // except \"table\", \"table-cell\", or \"table-caption\"\n  // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n  rdisplayswap = /^(none|table(?!-c[ea]).+)/,\n      rcustomProp = /^--/,\n      cssShow = {\n    position: \"absolute\",\n    visibility: \"hidden\",\n    display: \"block\"\n  },\n      cssNormalTransform = {\n    letterSpacing: \"0\",\n    fontWeight: \"400\"\n  };\n\n  function setPositiveNumber(elem, value, subtract) {\n    // Any relative (+/-) values have already been\n    // normalized at this point\n    var matches = rcssNum.exec(value);\n    return matches ? // Guard against undefined \"subtract\", e.g., when used as in cssHooks\n    Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || \"px\") : value;\n  }\n\n  function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {\n    var i = dimension === \"width\" ? 1 : 0,\n        extra = 0,\n        delta = 0; // Adjustment may not be necessary\n\n    if (box === (isBorderBox ? \"border\" : \"content\")) {\n      return 0;\n    }\n\n    for (; i < 4; i += 2) {\n      // Both box models exclude margin\n      if (box === \"margin\") {\n        delta += jQuery.css(elem, box + cssExpand[i], true, styles);\n      } // If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\n\n      if (!isBorderBox) {\n        // Add padding\n        delta += jQuery.css(elem, \"padding\" + cssExpand[i], true, styles); // For \"border\" or \"margin\", add border\n\n        if (box !== \"padding\") {\n          delta += jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles); // But still keep track of it otherwise\n        } else {\n          extra += jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\n        } // If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n        // \"padding\" or \"margin\"\n\n      } else {\n        // For \"content\", subtract padding\n        if (box === \"content\") {\n          delta -= jQuery.css(elem, \"padding\" + cssExpand[i], true, styles);\n        } // For \"content\" or \"padding\", subtract border\n\n\n        if (box !== \"margin\") {\n          delta -= jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\n        }\n      }\n    } // Account for positive content-box scroll gutter when requested by providing computedVal\n\n\n    if (!isBorderBox && computedVal >= 0) {\n      // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n      // Assuming integer scroll gutter, subtract the rest and round down\n      delta += Math.max(0, Math.ceil(elem[\"offset\" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n      // Use an explicit zero to avoid NaN (gh-3964)\n      )) || 0;\n    }\n\n    return delta;\n  }\n\n  function getWidthOrHeight(elem, dimension, extra) {\n    // Start with computed style\n    var styles = getStyles(elem),\n        // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n    // Fake content-box until we know it's needed to know the true value.\n    boxSizingNeeded = !support.boxSizingReliable() || extra,\n        isBorderBox = boxSizingNeeded && jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\",\n        valueIsBorderBox = isBorderBox,\n        val = curCSS(elem, dimension, styles),\n        offsetProp = \"offset\" + dimension[0].toUpperCase() + dimension.slice(1); // Support: Firefox <=54\n    // Return a confounding non-pixel value or feign ignorance, as appropriate.\n\n    if (rnumnonpx.test(val)) {\n      if (!extra) {\n        return val;\n      }\n\n      val = \"auto\";\n    } // Fall back to offsetWidth/offsetHeight when value is \"auto\"\n    // This happens for inline elements with no explicit setting (gh-3571)\n    // Support: Android <=4.1 - 4.3 only\n    // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n    // Support: IE 9-11 only\n    // Also use offsetWidth/offsetHeight for when box sizing is unreliable\n    // We use getClientRects() to check for hidden/disconnected.\n    // In those cases, the computed value can be trusted to be border-box\n\n\n    if ((!support.boxSizingReliable() && isBorderBox || val === \"auto\" || !parseFloat(val) && jQuery.css(elem, \"display\", false, styles) === \"inline\") && elem.getClientRects().length) {\n      isBorderBox = jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\"; // Where available, offsetWidth/offsetHeight approximate border box dimensions.\n      // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n      // retrieved value as a content box dimension.\n\n      valueIsBorderBox = offsetProp in elem;\n\n      if (valueIsBorderBox) {\n        val = elem[offsetProp];\n      }\n    } // Normalize \"\" and auto\n\n\n    val = parseFloat(val) || 0; // Adjust for the element's box model\n\n    return val + boxModelAdjustment(elem, dimension, extra || (isBorderBox ? \"border\" : \"content\"), valueIsBorderBox, styles, // Provide the current computed size to request scroll gutter calculation (gh-3589)\n    val) + \"px\";\n  }\n\n  jQuery.extend({\n    // Add in style property hooks for overriding the default\n    // behavior of getting and setting a style property\n    cssHooks: {\n      opacity: {\n        get: function get(elem, computed) {\n          if (computed) {\n            // We should always get a number back from opacity\n            var ret = curCSS(elem, \"opacity\");\n            return ret === \"\" ? \"1\" : ret;\n          }\n        }\n      }\n    },\n    // Don't automatically add \"px\" to these possibly-unitless properties\n    cssNumber: {\n      \"animationIterationCount\": true,\n      \"columnCount\": true,\n      \"fillOpacity\": true,\n      \"flexGrow\": true,\n      \"flexShrink\": true,\n      \"fontWeight\": true,\n      \"gridArea\": true,\n      \"gridColumn\": true,\n      \"gridColumnEnd\": true,\n      \"gridColumnStart\": true,\n      \"gridRow\": true,\n      \"gridRowEnd\": true,\n      \"gridRowStart\": true,\n      \"lineHeight\": true,\n      \"opacity\": true,\n      \"order\": true,\n      \"orphans\": true,\n      \"widows\": true,\n      \"zIndex\": true,\n      \"zoom\": true\n    },\n    // Add in properties whose names you wish to fix before\n    // setting or getting the value\n    cssProps: {},\n    // Get and set the style property on a DOM Node\n    style: function style(elem, name, value, extra) {\n      // Don't set styles on text and comment nodes\n      if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {\n        return;\n      } // Make sure that we're working with the right name\n\n\n      var ret,\n          type,\n          hooks,\n          origName = camelCase(name),\n          isCustomProp = rcustomProp.test(name),\n          style = elem.style; // Make sure that we're working with the right name. We don't\n      // want to query the value if it is a CSS custom property\n      // since they are user-defined.\n\n      if (!isCustomProp) {\n        name = finalPropName(origName);\n      } // Gets hook for the prefixed version, then unprefixed version\n\n\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // Check if we're setting a value\n\n      if (value !== undefined) {\n        type = _typeof(value); // Convert \"+=\" or \"-=\" to relative numbers (#7345)\n\n        if (type === \"string\" && (ret = rcssNum.exec(value)) && ret[1]) {\n          value = adjustCSS(elem, name, ret); // Fixes bug #9237\n\n          type = \"number\";\n        } // Make sure that null and NaN values aren't set (#7116)\n\n\n        if (value == null || value !== value) {\n          return;\n        } // If a number was passed in, add the unit (except for certain CSS properties)\n        // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n        // \"px\" to a few hardcoded values.\n\n\n        if (type === \"number\" && !isCustomProp) {\n          value += ret && ret[3] || (jQuery.cssNumber[origName] ? \"\" : \"px\");\n        } // background-* props affect original clone's values\n\n\n        if (!support.clearCloneStyle && value === \"\" && name.indexOf(\"background\") === 0) {\n          style[name] = \"inherit\";\n        } // If a hook was provided, use that value, otherwise just set the specified value\n\n\n        if (!hooks || !(\"set\" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {\n          if (isCustomProp) {\n            style.setProperty(name, value);\n          } else {\n            style[name] = value;\n          }\n        }\n      } else {\n        // If a hook was provided get the non-computed value from there\n        if (hooks && \"get\" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {\n          return ret;\n        } // Otherwise just get the value from the style object\n\n\n        return style[name];\n      }\n    },\n    css: function css(elem, name, extra, styles) {\n      var val,\n          num,\n          hooks,\n          origName = camelCase(name),\n          isCustomProp = rcustomProp.test(name); // Make sure that we're working with the right name. We don't\n      // want to modify the value if it is a CSS custom property\n      // since they are user-defined.\n\n      if (!isCustomProp) {\n        name = finalPropName(origName);\n      } // Try prefixed name followed by the unprefixed name\n\n\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // If a hook was provided get the computed value from there\n\n      if (hooks && \"get\" in hooks) {\n        val = hooks.get(elem, true, extra);\n      } // Otherwise, if a way to get the computed value exists, use that\n\n\n      if (val === undefined) {\n        val = curCSS(elem, name, styles);\n      } // Convert \"normal\" to computed value\n\n\n      if (val === \"normal\" && name in cssNormalTransform) {\n        val = cssNormalTransform[name];\n      } // Make numeric if forced or a qualifier was provided and val looks numeric\n\n\n      if (extra === \"\" || extra) {\n        num = parseFloat(val);\n        return extra === true || isFinite(num) ? num || 0 : val;\n      }\n\n      return val;\n    }\n  });\n  jQuery.each([\"height\", \"width\"], function (i, dimension) {\n    jQuery.cssHooks[dimension] = {\n      get: function get(elem, computed, extra) {\n        if (computed) {\n          // Certain elements can have dimension info if we invisibly show them\n          // but it must have a current display style that would benefit\n          return rdisplayswap.test(jQuery.css(elem, \"display\")) && ( // Support: Safari 8+\n          // Table columns in Safari have non-zero offsetWidth & zero\n          // getBoundingClientRect().width unless display is changed.\n          // Support: IE <=11 only\n          // Running getBoundingClientRect on a disconnected node\n          // in IE throws an error.\n          !elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function () {\n            return getWidthOrHeight(elem, dimension, extra);\n          }) : getWidthOrHeight(elem, dimension, extra);\n        }\n      },\n      set: function set(elem, value, extra) {\n        var matches,\n            styles = getStyles(elem),\n            // Only read styles.position if the test has a chance to fail\n        // to avoid forcing a reflow.\n        scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === \"absolute\",\n            // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n        boxSizingNeeded = scrollboxSizeBuggy || extra,\n            isBorderBox = boxSizingNeeded && jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\",\n            subtract = extra ? boxModelAdjustment(elem, dimension, extra, isBorderBox, styles) : 0; // Account for unreliable border-box dimensions by comparing offset* to computed and\n        // faking a content-box to get border and padding (gh-3699)\n\n        if (isBorderBox && scrollboxSizeBuggy) {\n          subtract -= Math.ceil(elem[\"offset\" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, \"border\", false, styles) - 0.5);\n        } // Convert to pixels if value adjustment is needed\n\n\n        if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || \"px\") !== \"px\") {\n          elem.style[dimension] = value;\n          value = jQuery.css(elem, dimension);\n        }\n\n        return setPositiveNumber(elem, value, subtract);\n      }\n    };\n  });\n  jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {\n    if (computed) {\n      return (parseFloat(curCSS(elem, \"marginLeft\")) || elem.getBoundingClientRect().left - swap(elem, {\n        marginLeft: 0\n      }, function () {\n        return elem.getBoundingClientRect().left;\n      })) + \"px\";\n    }\n  }); // These hooks are used by animate to expand properties\n\n  jQuery.each({\n    margin: \"\",\n    padding: \"\",\n    border: \"Width\"\n  }, function (prefix, suffix) {\n    jQuery.cssHooks[prefix + suffix] = {\n      expand: function expand(value) {\n        var i = 0,\n            expanded = {},\n            // Assumes a single number if not a string\n        parts = typeof value === \"string\" ? value.split(\" \") : [value];\n\n        for (; i < 4; i++) {\n          expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];\n        }\n\n        return expanded;\n      }\n    };\n\n    if (prefix !== \"margin\") {\n      jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;\n    }\n  });\n  jQuery.fn.extend({\n    css: function css(name, value) {\n      return access(this, function (elem, name, value) {\n        var styles,\n            len,\n            map = {},\n            i = 0;\n\n        if (Array.isArray(name)) {\n          styles = getStyles(elem);\n          len = name.length;\n\n          for (; i < len; i++) {\n            map[name[i]] = jQuery.css(elem, name[i], false, styles);\n          }\n\n          return map;\n        }\n\n        return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);\n      }, name, value, arguments.length > 1);\n    }\n  });\n\n  function Tween(elem, options, prop, end, easing) {\n    return new Tween.prototype.init(elem, options, prop, end, easing);\n  }\n\n  jQuery.Tween = Tween;\n  Tween.prototype = {\n    constructor: Tween,\n    init: function init(elem, options, prop, end, easing, unit) {\n      this.elem = elem;\n      this.prop = prop;\n      this.easing = easing || jQuery.easing._default;\n      this.options = options;\n      this.start = this.now = this.cur();\n      this.end = end;\n      this.unit = unit || (jQuery.cssNumber[prop] ? \"\" : \"px\");\n    },\n    cur: function cur() {\n      var hooks = Tween.propHooks[this.prop];\n      return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);\n    },\n    run: function run(percent) {\n      var eased,\n          hooks = Tween.propHooks[this.prop];\n\n      if (this.options.duration) {\n        this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration);\n      } else {\n        this.pos = eased = percent;\n      }\n\n      this.now = (this.end - this.start) * eased + this.start;\n\n      if (this.options.step) {\n        this.options.step.call(this.elem, this.now, this);\n      }\n\n      if (hooks && hooks.set) {\n        hooks.set(this);\n      } else {\n        Tween.propHooks._default.set(this);\n      }\n\n      return this;\n    }\n  };\n  Tween.prototype.init.prototype = Tween.prototype;\n  Tween.propHooks = {\n    _default: {\n      get: function get(tween) {\n        var result; // Use a property on the element directly when it is not a DOM element,\n        // or when there is no matching style property that exists.\n\n        if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {\n          return tween.elem[tween.prop];\n        } // Passing an empty string as a 3rd parameter to .css will automatically\n        // attempt a parseFloat and fallback to a string if the parse fails.\n        // Simple values such as \"10px\" are parsed to Float;\n        // complex values such as \"rotate(1rad)\" are returned as-is.\n\n\n        result = jQuery.css(tween.elem, tween.prop, \"\"); // Empty strings, null, undefined and \"auto\" are converted to 0.\n\n        return !result || result === \"auto\" ? 0 : result;\n      },\n      set: function set(tween) {\n        // Use step hook for back compat.\n        // Use cssHook if its there.\n        // Use .style if available and use plain properties where available.\n        if (jQuery.fx.step[tween.prop]) {\n          jQuery.fx.step[tween.prop](tween);\n        } else if (tween.elem.nodeType === 1 && (jQuery.cssHooks[tween.prop] || tween.elem.style[finalPropName(tween.prop)] != null)) {\n          jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);\n        } else {\n          tween.elem[tween.prop] = tween.now;\n        }\n      }\n    }\n  }; // Support: IE <=9 only\n  // Panic based approach to setting things on disconnected nodes\n\n  Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n    set: function set(tween) {\n      if (tween.elem.nodeType && tween.elem.parentNode) {\n        tween.elem[tween.prop] = tween.now;\n      }\n    }\n  };\n  jQuery.easing = {\n    linear: function linear(p) {\n      return p;\n    },\n    swing: function swing(p) {\n      return 0.5 - Math.cos(p * Math.PI) / 2;\n    },\n    _default: \"swing\"\n  };\n  jQuery.fx = Tween.prototype.init; // Back compat <1.8 extension point\n\n  jQuery.fx.step = {};\n  var fxNow,\n      inProgress,\n      rfxtypes = /^(?:toggle|show|hide)$/,\n      rrun = /queueHooks$/;\n\n  function schedule() {\n    if (inProgress) {\n      if (document.hidden === false && window.requestAnimationFrame) {\n        window.requestAnimationFrame(schedule);\n      } else {\n        window.setTimeout(schedule, jQuery.fx.interval);\n      }\n\n      jQuery.fx.tick();\n    }\n  } // Animations created synchronously will run synchronously\n\n\n  function createFxNow() {\n    window.setTimeout(function () {\n      fxNow = undefined;\n    });\n    return fxNow = Date.now();\n  } // Generate parameters to create a standard animation\n\n\n  function genFx(type, includeWidth) {\n    var which,\n        i = 0,\n        attrs = {\n      height: type\n    }; // If we include width, step value is 1 to do all cssExpand values,\n    // otherwise step value is 2 to skip over Left and Right\n\n    includeWidth = includeWidth ? 1 : 0;\n\n    for (; i < 4; i += 2 - includeWidth) {\n      which = cssExpand[i];\n      attrs[\"margin\" + which] = attrs[\"padding\" + which] = type;\n    }\n\n    if (includeWidth) {\n      attrs.opacity = attrs.width = type;\n    }\n\n    return attrs;\n  }\n\n  function createTween(value, prop, animation) {\n    var tween,\n        collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners[\"*\"]),\n        index = 0,\n        length = collection.length;\n\n    for (; index < length; index++) {\n      if (tween = collection[index].call(animation, prop, value)) {\n        // We're done with this property\n        return tween;\n      }\n    }\n  }\n\n  function defaultPrefilter(elem, props, opts) {\n    var prop,\n        value,\n        toggle,\n        hooks,\n        oldfire,\n        propTween,\n        restoreDisplay,\n        display,\n        isBox = \"width\" in props || \"height\" in props,\n        anim = this,\n        orig = {},\n        style = elem.style,\n        hidden = elem.nodeType && isHiddenWithinTree(elem),\n        dataShow = dataPriv.get(elem, \"fxshow\"); // Queue-skipping animations hijack the fx hooks\n\n    if (!opts.queue) {\n      hooks = jQuery._queueHooks(elem, \"fx\");\n\n      if (hooks.unqueued == null) {\n        hooks.unqueued = 0;\n        oldfire = hooks.empty.fire;\n\n        hooks.empty.fire = function () {\n          if (!hooks.unqueued) {\n            oldfire();\n          }\n        };\n      }\n\n      hooks.unqueued++;\n      anim.always(function () {\n        // Ensure the complete handler is called before this completes\n        anim.always(function () {\n          hooks.unqueued--;\n\n          if (!jQuery.queue(elem, \"fx\").length) {\n            hooks.empty.fire();\n          }\n        });\n      });\n    } // Detect show/hide animations\n\n\n    for (prop in props) {\n      value = props[prop];\n\n      if (rfxtypes.test(value)) {\n        delete props[prop];\n        toggle = toggle || value === \"toggle\";\n\n        if (value === (hidden ? \"hide\" : \"show\")) {\n          // Pretend to be hidden if this is a \"show\" and\n          // there is still data from a stopped show/hide\n          if (value === \"show\" && dataShow && dataShow[prop] !== undefined) {\n            hidden = true; // Ignore all other no-op show/hide data\n          } else {\n            continue;\n          }\n        }\n\n        orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);\n      }\n    } // Bail out if this is a no-op like .hide().hide()\n\n\n    propTween = !jQuery.isEmptyObject(props);\n\n    if (!propTween && jQuery.isEmptyObject(orig)) {\n      return;\n    } // Restrict \"overflow\" and \"display\" styles during box animations\n\n\n    if (isBox && elem.nodeType === 1) {\n      // Support: IE <=9 - 11, Edge 12 - 15\n      // Record all 3 overflow attributes because IE does not infer the shorthand\n      // from identically-valued overflowX and overflowY and Edge just mirrors\n      // the overflowX value there.\n      opts.overflow = [style.overflow, style.overflowX, style.overflowY]; // Identify a display type, preferring old show/hide data over the CSS cascade\n\n      restoreDisplay = dataShow && dataShow.display;\n\n      if (restoreDisplay == null) {\n        restoreDisplay = dataPriv.get(elem, \"display\");\n      }\n\n      display = jQuery.css(elem, \"display\");\n\n      if (display === \"none\") {\n        if (restoreDisplay) {\n          display = restoreDisplay;\n        } else {\n          // Get nonempty value(s) by temporarily forcing visibility\n          showHide([elem], true);\n          restoreDisplay = elem.style.display || restoreDisplay;\n          display = jQuery.css(elem, \"display\");\n          showHide([elem]);\n        }\n      } // Animate inline elements as inline-block\n\n\n      if (display === \"inline\" || display === \"inline-block\" && restoreDisplay != null) {\n        if (jQuery.css(elem, \"float\") === \"none\") {\n          // Restore the original display value at the end of pure show/hide animations\n          if (!propTween) {\n            anim.done(function () {\n              style.display = restoreDisplay;\n            });\n\n            if (restoreDisplay == null) {\n              display = style.display;\n              restoreDisplay = display === \"none\" ? \"\" : display;\n            }\n          }\n\n          style.display = \"inline-block\";\n        }\n      }\n    }\n\n    if (opts.overflow) {\n      style.overflow = \"hidden\";\n      anim.always(function () {\n        style.overflow = opts.overflow[0];\n        style.overflowX = opts.overflow[1];\n        style.overflowY = opts.overflow[2];\n      });\n    } // Implement show/hide animations\n\n\n    propTween = false;\n\n    for (prop in orig) {\n      // General show/hide setup for this element animation\n      if (!propTween) {\n        if (dataShow) {\n          if (\"hidden\" in dataShow) {\n            hidden = dataShow.hidden;\n          }\n        } else {\n          dataShow = dataPriv.access(elem, \"fxshow\", {\n            display: restoreDisplay\n          });\n        } // Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\n\n        if (toggle) {\n          dataShow.hidden = !hidden;\n        } // Show elements before animating them\n\n\n        if (hidden) {\n          showHide([elem], true);\n        }\n        /* eslint-disable no-loop-func */\n\n\n        anim.done(function () {\n          /* eslint-enable no-loop-func */\n          // The final step of a \"hide\" animation is actually hiding the element\n          if (!hidden) {\n            showHide([elem]);\n          }\n\n          dataPriv.remove(elem, \"fxshow\");\n\n          for (prop in orig) {\n            jQuery.style(elem, prop, orig[prop]);\n          }\n        });\n      } // Per-property setup\n\n\n      propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);\n\n      if (!(prop in dataShow)) {\n        dataShow[prop] = propTween.start;\n\n        if (hidden) {\n          propTween.end = propTween.start;\n          propTween.start = 0;\n        }\n      }\n    }\n  }\n\n  function propFilter(props, specialEasing) {\n    var index, name, easing, value, hooks; // camelCase, specialEasing and expand cssHook pass\n\n    for (index in props) {\n      name = camelCase(index);\n      easing = specialEasing[name];\n      value = props[index];\n\n      if (Array.isArray(value)) {\n        easing = value[1];\n        value = props[index] = value[0];\n      }\n\n      if (index !== name) {\n        props[name] = value;\n        delete props[index];\n      }\n\n      hooks = jQuery.cssHooks[name];\n\n      if (hooks && \"expand\" in hooks) {\n        value = hooks.expand(value);\n        delete props[name]; // Not quite $.extend, this won't overwrite existing keys.\n        // Reusing 'index' because we have the correct \"name\"\n\n        for (index in value) {\n          if (!(index in props)) {\n            props[index] = value[index];\n            specialEasing[index] = easing;\n          }\n        }\n      } else {\n        specialEasing[name] = easing;\n      }\n    }\n  }\n\n  function Animation(elem, properties, options) {\n    var result,\n        stopped,\n        index = 0,\n        length = Animation.prefilters.length,\n        deferred = jQuery.Deferred().always(function () {\n      // Don't match elem in the :animated selector\n      delete tick.elem;\n    }),\n        tick = function tick() {\n      if (stopped) {\n        return false;\n      }\n\n      var currentTime = fxNow || createFxNow(),\n          remaining = Math.max(0, animation.startTime + animation.duration - currentTime),\n          // Support: Android 2.3 only\n      // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n      temp = remaining / animation.duration || 0,\n          percent = 1 - temp,\n          index = 0,\n          length = animation.tweens.length;\n\n      for (; index < length; index++) {\n        animation.tweens[index].run(percent);\n      }\n\n      deferred.notifyWith(elem, [animation, percent, remaining]); // If there's more to do, yield\n\n      if (percent < 1 && length) {\n        return remaining;\n      } // If this was an empty animation, synthesize a final progress notification\n\n\n      if (!length) {\n        deferred.notifyWith(elem, [animation, 1, 0]);\n      } // Resolve the animation and report its conclusion\n\n\n      deferred.resolveWith(elem, [animation]);\n      return false;\n    },\n        animation = deferred.promise({\n      elem: elem,\n      props: jQuery.extend({}, properties),\n      opts: jQuery.extend(true, {\n        specialEasing: {},\n        easing: jQuery.easing._default\n      }, options),\n      originalProperties: properties,\n      originalOptions: options,\n      startTime: fxNow || createFxNow(),\n      duration: options.duration,\n      tweens: [],\n      createTween: function createTween(prop, end) {\n        var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);\n        animation.tweens.push(tween);\n        return tween;\n      },\n      stop: function stop(gotoEnd) {\n        var index = 0,\n            // If we are going to the end, we want to run all the tweens\n        // otherwise we skip this part\n        length = gotoEnd ? animation.tweens.length : 0;\n\n        if (stopped) {\n          return this;\n        }\n\n        stopped = true;\n\n        for (; index < length; index++) {\n          animation.tweens[index].run(1);\n        } // Resolve when we played the last frame; otherwise, reject\n\n\n        if (gotoEnd) {\n          deferred.notifyWith(elem, [animation, 1, 0]);\n          deferred.resolveWith(elem, [animation, gotoEnd]);\n        } else {\n          deferred.rejectWith(elem, [animation, gotoEnd]);\n        }\n\n        return this;\n      }\n    }),\n        props = animation.props;\n\n    propFilter(props, animation.opts.specialEasing);\n\n    for (; index < length; index++) {\n      result = Animation.prefilters[index].call(animation, elem, props, animation.opts);\n\n      if (result) {\n        if (isFunction(result.stop)) {\n          jQuery._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result);\n        }\n\n        return result;\n      }\n    }\n\n    jQuery.map(props, createTween, animation);\n\n    if (isFunction(animation.opts.start)) {\n      animation.opts.start.call(elem, animation);\n    } // Attach callbacks from options\n\n\n    animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);\n    jQuery.fx.timer(jQuery.extend(tick, {\n      elem: elem,\n      anim: animation,\n      queue: animation.opts.queue\n    }));\n    return animation;\n  }\n\n  jQuery.Animation = jQuery.extend(Animation, {\n    tweeners: {\n      \"*\": [function (prop, value) {\n        var tween = this.createTween(prop, value);\n        adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);\n        return tween;\n      }]\n    },\n    tweener: function tweener(props, callback) {\n      if (isFunction(props)) {\n        callback = props;\n        props = [\"*\"];\n      } else {\n        props = props.match(rnothtmlwhite);\n      }\n\n      var prop,\n          index = 0,\n          length = props.length;\n\n      for (; index < length; index++) {\n        prop = props[index];\n        Animation.tweeners[prop] = Animation.tweeners[prop] || [];\n        Animation.tweeners[prop].unshift(callback);\n      }\n    },\n    prefilters: [defaultPrefilter],\n    prefilter: function prefilter(callback, prepend) {\n      if (prepend) {\n        Animation.prefilters.unshift(callback);\n      } else {\n        Animation.prefilters.push(callback);\n      }\n    }\n  });\n\n  jQuery.speed = function (speed, easing, fn) {\n    var opt = speed && _typeof(speed) === \"object\" ? jQuery.extend({}, speed) : {\n      complete: fn || !fn && easing || isFunction(speed) && speed,\n      duration: speed,\n      easing: fn && easing || easing && !isFunction(easing) && easing\n    }; // Go to the end state if fx are off\n\n    if (jQuery.fx.off) {\n      opt.duration = 0;\n    } else {\n      if (typeof opt.duration !== \"number\") {\n        if (opt.duration in jQuery.fx.speeds) {\n          opt.duration = jQuery.fx.speeds[opt.duration];\n        } else {\n          opt.duration = jQuery.fx.speeds._default;\n        }\n      }\n    } // Normalize opt.queue - true/undefined/null -> \"fx\"\n\n\n    if (opt.queue == null || opt.queue === true) {\n      opt.queue = \"fx\";\n    } // Queueing\n\n\n    opt.old = opt.complete;\n\n    opt.complete = function () {\n      if (isFunction(opt.old)) {\n        opt.old.call(this);\n      }\n\n      if (opt.queue) {\n        jQuery.dequeue(this, opt.queue);\n      }\n    };\n\n    return opt;\n  };\n\n  jQuery.fn.extend({\n    fadeTo: function fadeTo(speed, to, easing, callback) {\n      // Show any hidden elements after setting opacity to 0\n      return this.filter(isHiddenWithinTree).css(\"opacity\", 0).show() // Animate to the value specified\n      .end().animate({\n        opacity: to\n      }, speed, easing, callback);\n    },\n    animate: function animate(prop, speed, easing, callback) {\n      var empty = jQuery.isEmptyObject(prop),\n          optall = jQuery.speed(speed, easing, callback),\n          doAnimation = function doAnimation() {\n        // Operate on a copy of prop so per-property easing won't be lost\n        var anim = Animation(this, jQuery.extend({}, prop), optall); // Empty animations, or finishing resolves immediately\n\n        if (empty || dataPriv.get(this, \"finish\")) {\n          anim.stop(true);\n        }\n      };\n\n      doAnimation.finish = doAnimation;\n      return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);\n    },\n    stop: function stop(type, clearQueue, gotoEnd) {\n      var stopQueue = function stopQueue(hooks) {\n        var stop = hooks.stop;\n        delete hooks.stop;\n        stop(gotoEnd);\n      };\n\n      if (typeof type !== \"string\") {\n        gotoEnd = clearQueue;\n        clearQueue = type;\n        type = undefined;\n      }\n\n      if (clearQueue && type !== false) {\n        this.queue(type || \"fx\", []);\n      }\n\n      return this.each(function () {\n        var dequeue = true,\n            index = type != null && type + \"queueHooks\",\n            timers = jQuery.timers,\n            data = dataPriv.get(this);\n\n        if (index) {\n          if (data[index] && data[index].stop) {\n            stopQueue(data[index]);\n          }\n        } else {\n          for (index in data) {\n            if (data[index] && data[index].stop && rrun.test(index)) {\n              stopQueue(data[index]);\n            }\n          }\n        }\n\n        for (index = timers.length; index--;) {\n          if (timers[index].elem === this && (type == null || timers[index].queue === type)) {\n            timers[index].anim.stop(gotoEnd);\n            dequeue = false;\n            timers.splice(index, 1);\n          }\n        } // Start the next in the queue if the last step wasn't forced.\n        // Timers currently will call their complete callbacks, which\n        // will dequeue but only if they were gotoEnd.\n\n\n        if (dequeue || !gotoEnd) {\n          jQuery.dequeue(this, type);\n        }\n      });\n    },\n    finish: function finish(type) {\n      if (type !== false) {\n        type = type || \"fx\";\n      }\n\n      return this.each(function () {\n        var index,\n            data = dataPriv.get(this),\n            queue = data[type + \"queue\"],\n            hooks = data[type + \"queueHooks\"],\n            timers = jQuery.timers,\n            length = queue ? queue.length : 0; // Enable finishing flag on private data\n\n        data.finish = true; // Empty the queue first\n\n        jQuery.queue(this, type, []);\n\n        if (hooks && hooks.stop) {\n          hooks.stop.call(this, true);\n        } // Look for any active animations, and finish them\n\n\n        for (index = timers.length; index--;) {\n          if (timers[index].elem === this && timers[index].queue === type) {\n            timers[index].anim.stop(true);\n            timers.splice(index, 1);\n          }\n        } // Look for any animations in the old queue and finish them\n\n\n        for (index = 0; index < length; index++) {\n          if (queue[index] && queue[index].finish) {\n            queue[index].finish.call(this);\n          }\n        } // Turn off finishing flag\n\n\n        delete data.finish;\n      });\n    }\n  });\n  jQuery.each([\"toggle\", \"show\", \"hide\"], function (i, name) {\n    var cssFn = jQuery.fn[name];\n\n    jQuery.fn[name] = function (speed, easing, callback) {\n      return speed == null || typeof speed === \"boolean\" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);\n    };\n  }); // Generate shortcuts for custom animations\n\n  jQuery.each({\n    slideDown: genFx(\"show\"),\n    slideUp: genFx(\"hide\"),\n    slideToggle: genFx(\"toggle\"),\n    fadeIn: {\n      opacity: \"show\"\n    },\n    fadeOut: {\n      opacity: \"hide\"\n    },\n    fadeToggle: {\n      opacity: \"toggle\"\n    }\n  }, function (name, props) {\n    jQuery.fn[name] = function (speed, easing, callback) {\n      return this.animate(props, speed, easing, callback);\n    };\n  });\n  jQuery.timers = [];\n\n  jQuery.fx.tick = function () {\n    var timer,\n        i = 0,\n        timers = jQuery.timers;\n    fxNow = Date.now();\n\n    for (; i < timers.length; i++) {\n      timer = timers[i]; // Run the timer and safely remove it when done (allowing for external removal)\n\n      if (!timer() && timers[i] === timer) {\n        timers.splice(i--, 1);\n      }\n    }\n\n    if (!timers.length) {\n      jQuery.fx.stop();\n    }\n\n    fxNow = undefined;\n  };\n\n  jQuery.fx.timer = function (timer) {\n    jQuery.timers.push(timer);\n    jQuery.fx.start();\n  };\n\n  jQuery.fx.interval = 13;\n\n  jQuery.fx.start = function () {\n    if (inProgress) {\n      return;\n    }\n\n    inProgress = true;\n    schedule();\n  };\n\n  jQuery.fx.stop = function () {\n    inProgress = null;\n  };\n\n  jQuery.fx.speeds = {\n    slow: 600,\n    fast: 200,\n    // Default speed\n    _default: 400\n  }; // Based off of the plugin by Clint Helfers, with permission.\n  // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\n\n  jQuery.fn.delay = function (time, type) {\n    time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;\n    type = type || \"fx\";\n    return this.queue(type, function (next, hooks) {\n      var timeout = window.setTimeout(next, time);\n\n      hooks.stop = function () {\n        window.clearTimeout(timeout);\n      };\n    });\n  };\n\n  (function () {\n    var input = document.createElement(\"input\"),\n        select = document.createElement(\"select\"),\n        opt = select.appendChild(document.createElement(\"option\"));\n    input.type = \"checkbox\"; // Support: Android <=4.3 only\n    // Default value for a checkbox should be \"on\"\n\n    support.checkOn = input.value !== \"\"; // Support: IE <=11 only\n    // Must access selectedIndex to make default options select\n\n    support.optSelected = opt.selected; // Support: IE <=11 only\n    // An input loses its value after becoming a radio\n\n    input = document.createElement(\"input\");\n    input.value = \"t\";\n    input.type = \"radio\";\n    support.radioValue = input.value === \"t\";\n  })();\n\n  var boolHook,\n      attrHandle = jQuery.expr.attrHandle;\n  jQuery.fn.extend({\n    attr: function attr(name, value) {\n      return access(this, jQuery.attr, name, value, arguments.length > 1);\n    },\n    removeAttr: function removeAttr(name) {\n      return this.each(function () {\n        jQuery.removeAttr(this, name);\n      });\n    }\n  });\n  jQuery.extend({\n    attr: function attr(elem, name, value) {\n      var ret,\n          hooks,\n          nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes\n\n      if (nType === 3 || nType === 8 || nType === 2) {\n        return;\n      } // Fallback to prop when attributes are not supported\n\n\n      if (typeof elem.getAttribute === \"undefined\") {\n        return jQuery.prop(elem, name, value);\n      } // Attribute hooks are determined by the lowercase version\n      // Grab necessary hook if one is defined\n\n\n      if (nType !== 1 || !jQuery.isXMLDoc(elem)) {\n        hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined);\n      }\n\n      if (value !== undefined) {\n        if (value === null) {\n          jQuery.removeAttr(elem, name);\n          return;\n        }\n\n        if (hooks && \"set\" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {\n          return ret;\n        }\n\n        elem.setAttribute(name, value + \"\");\n        return value;\n      }\n\n      if (hooks && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\n        return ret;\n      }\n\n      ret = jQuery.find.attr(elem, name); // Non-existent attributes return null, we normalize to undefined\n\n      return ret == null ? undefined : ret;\n    },\n    attrHooks: {\n      type: {\n        set: function set(elem, value) {\n          if (!support.radioValue && value === \"radio\" && nodeName(elem, \"input\")) {\n            var val = elem.value;\n            elem.setAttribute(\"type\", value);\n\n            if (val) {\n              elem.value = val;\n            }\n\n            return value;\n          }\n        }\n      }\n    },\n    removeAttr: function removeAttr(elem, value) {\n      var name,\n          i = 0,\n          // Attribute names can contain non-HTML whitespace characters\n      // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n      attrNames = value && value.match(rnothtmlwhite);\n\n      if (attrNames && elem.nodeType === 1) {\n        while (name = attrNames[i++]) {\n          elem.removeAttribute(name);\n        }\n      }\n    }\n  }); // Hooks for boolean attributes\n\n  boolHook = {\n    set: function set(elem, value, name) {\n      if (value === false) {\n        // Remove boolean attributes when set to false\n        jQuery.removeAttr(elem, name);\n      } else {\n        elem.setAttribute(name, name);\n      }\n\n      return name;\n    }\n  };\n  jQuery.each(jQuery.expr.match.bool.source.match(/\\w+/g), function (i, name) {\n    var getter = attrHandle[name] || jQuery.find.attr;\n\n    attrHandle[name] = function (elem, name, isXML) {\n      var ret,\n          handle,\n          lowercaseName = name.toLowerCase();\n\n      if (!isXML) {\n        // Avoid an infinite loop by temporarily removing this function from the getter\n        handle = attrHandle[lowercaseName];\n        attrHandle[lowercaseName] = ret;\n        ret = getter(elem, name, isXML) != null ? lowercaseName : null;\n        attrHandle[lowercaseName] = handle;\n      }\n\n      return ret;\n    };\n  });\n  var rfocusable = /^(?:input|select|textarea|button)$/i,\n      rclickable = /^(?:a|area)$/i;\n  jQuery.fn.extend({\n    prop: function prop(name, value) {\n      return access(this, jQuery.prop, name, value, arguments.length > 1);\n    },\n    removeProp: function removeProp(name) {\n      return this.each(function () {\n        delete this[jQuery.propFix[name] || name];\n      });\n    }\n  });\n  jQuery.extend({\n    prop: function prop(elem, name, value) {\n      var ret,\n          hooks,\n          nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes\n\n      if (nType === 3 || nType === 8 || nType === 2) {\n        return;\n      }\n\n      if (nType !== 1 || !jQuery.isXMLDoc(elem)) {\n        // Fix name and attach hooks\n        name = jQuery.propFix[name] || name;\n        hooks = jQuery.propHooks[name];\n      }\n\n      if (value !== undefined) {\n        if (hooks && \"set\" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {\n          return ret;\n        }\n\n        return elem[name] = value;\n      }\n\n      if (hooks && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\n        return ret;\n      }\n\n      return elem[name];\n    },\n    propHooks: {\n      tabIndex: {\n        get: function get(elem) {\n          // Support: IE <=9 - 11 only\n          // elem.tabIndex doesn't always return the\n          // correct value when it hasn't been explicitly set\n          // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n          // Use proper attribute retrieval(#12072)\n          var tabindex = jQuery.find.attr(elem, \"tabindex\");\n\n          if (tabindex) {\n            return parseInt(tabindex, 10);\n          }\n\n          if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {\n            return 0;\n          }\n\n          return -1;\n        }\n      }\n    },\n    propFix: {\n      \"for\": \"htmlFor\",\n      \"class\": \"className\"\n    }\n  }); // Support: IE <=11 only\n  // Accessing the selectedIndex property\n  // forces the browser to respect setting selected\n  // on the option\n  // The getter ensures a default option is selected\n  // when in an optgroup\n  // eslint rule \"no-unused-expressions\" is disabled for this code\n  // since it considers such accessions noop\n\n  if (!support.optSelected) {\n    jQuery.propHooks.selected = {\n      get: function get(elem) {\n        /* eslint no-unused-expressions: \"off\" */\n        var parent = elem.parentNode;\n\n        if (parent && parent.parentNode) {\n          parent.parentNode.selectedIndex;\n        }\n\n        return null;\n      },\n      set: function set(elem) {\n        /* eslint no-unused-expressions: \"off\" */\n        var parent = elem.parentNode;\n\n        if (parent) {\n          parent.selectedIndex;\n\n          if (parent.parentNode) {\n            parent.parentNode.selectedIndex;\n          }\n        }\n      }\n    };\n  }\n\n  jQuery.each([\"tabIndex\", \"readOnly\", \"maxLength\", \"cellSpacing\", \"cellPadding\", \"rowSpan\", \"colSpan\", \"useMap\", \"frameBorder\", \"contentEditable\"], function () {\n    jQuery.propFix[this.toLowerCase()] = this;\n  }); // Strip and collapse whitespace according to HTML spec\n  // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\n  function stripAndCollapse(value) {\n    var tokens = value.match(rnothtmlwhite) || [];\n    return tokens.join(\" \");\n  }\n\n  function getClass(elem) {\n    return elem.getAttribute && elem.getAttribute(\"class\") || \"\";\n  }\n\n  function classesToArray(value) {\n    if (Array.isArray(value)) {\n      return value;\n    }\n\n    if (typeof value === \"string\") {\n      return value.match(rnothtmlwhite) || [];\n    }\n\n    return [];\n  }\n\n  jQuery.fn.extend({\n    addClass: function addClass(value) {\n      var classes,\n          elem,\n          cur,\n          curValue,\n          clazz,\n          j,\n          finalValue,\n          i = 0;\n\n      if (isFunction(value)) {\n        return this.each(function (j) {\n          jQuery(this).addClass(value.call(this, j, getClass(this)));\n        });\n      }\n\n      classes = classesToArray(value);\n\n      if (classes.length) {\n        while (elem = this[i++]) {\n          curValue = getClass(elem);\n          cur = elem.nodeType === 1 && \" \" + stripAndCollapse(curValue) + \" \";\n\n          if (cur) {\n            j = 0;\n\n            while (clazz = classes[j++]) {\n              if (cur.indexOf(\" \" + clazz + \" \") < 0) {\n                cur += clazz + \" \";\n              }\n            } // Only assign if different to avoid unneeded rendering.\n\n\n            finalValue = stripAndCollapse(cur);\n\n            if (curValue !== finalValue) {\n              elem.setAttribute(\"class\", finalValue);\n            }\n          }\n        }\n      }\n\n      return this;\n    },\n    removeClass: function removeClass(value) {\n      var classes,\n          elem,\n          cur,\n          curValue,\n          clazz,\n          j,\n          finalValue,\n          i = 0;\n\n      if (isFunction(value)) {\n        return this.each(function (j) {\n          jQuery(this).removeClass(value.call(this, j, getClass(this)));\n        });\n      }\n\n      if (!arguments.length) {\n        return this.attr(\"class\", \"\");\n      }\n\n      classes = classesToArray(value);\n\n      if (classes.length) {\n        while (elem = this[i++]) {\n          curValue = getClass(elem); // This expression is here for better compressibility (see addClass)\n\n          cur = elem.nodeType === 1 && \" \" + stripAndCollapse(curValue) + \" \";\n\n          if (cur) {\n            j = 0;\n\n            while (clazz = classes[j++]) {\n              // Remove *all* instances\n              while (cur.indexOf(\" \" + clazz + \" \") > -1) {\n                cur = cur.replace(\" \" + clazz + \" \", \" \");\n              }\n            } // Only assign if different to avoid unneeded rendering.\n\n\n            finalValue = stripAndCollapse(cur);\n\n            if (curValue !== finalValue) {\n              elem.setAttribute(\"class\", finalValue);\n            }\n          }\n        }\n      }\n\n      return this;\n    },\n    toggleClass: function toggleClass(value, stateVal) {\n      var type = _typeof(value),\n          isValidValue = type === \"string\" || Array.isArray(value);\n\n      if (typeof stateVal === \"boolean\" && isValidValue) {\n        return stateVal ? this.addClass(value) : this.removeClass(value);\n      }\n\n      if (isFunction(value)) {\n        return this.each(function (i) {\n          jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);\n        });\n      }\n\n      return this.each(function () {\n        var className, i, self, classNames;\n\n        if (isValidValue) {\n          // Toggle individual class names\n          i = 0;\n          self = jQuery(this);\n          classNames = classesToArray(value);\n\n          while (className = classNames[i++]) {\n            // Check each className given, space separated list\n            if (self.hasClass(className)) {\n              self.removeClass(className);\n            } else {\n              self.addClass(className);\n            }\n          } // Toggle whole class name\n\n        } else if (value === undefined || type === \"boolean\") {\n          className = getClass(this);\n\n          if (className) {\n            // Store className if set\n            dataPriv.set(this, \"__className__\", className);\n          } // If the element has a class name or if we're passed `false`,\n          // then remove the whole classname (if there was one, the above saved it).\n          // Otherwise bring back whatever was previously saved (if anything),\n          // falling back to the empty string if nothing was stored.\n\n\n          if (this.setAttribute) {\n            this.setAttribute(\"class\", className || value === false ? \"\" : dataPriv.get(this, \"__className__\") || \"\");\n          }\n        }\n      });\n    },\n    hasClass: function hasClass(selector) {\n      var className,\n          elem,\n          i = 0;\n      className = \" \" + selector + \" \";\n\n      while (elem = this[i++]) {\n        if (elem.nodeType === 1 && (\" \" + stripAndCollapse(getClass(elem)) + \" \").indexOf(className) > -1) {\n          return true;\n        }\n      }\n\n      return false;\n    }\n  });\n  var rreturn = /\\r/g;\n  jQuery.fn.extend({\n    val: function val(value) {\n      var hooks,\n          ret,\n          valueIsFunction,\n          elem = this[0];\n\n      if (!arguments.length) {\n        if (elem) {\n          hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];\n\n          if (hooks && \"get\" in hooks && (ret = hooks.get(elem, \"value\")) !== undefined) {\n            return ret;\n          }\n\n          ret = elem.value; // Handle most common string cases\n\n          if (typeof ret === \"string\") {\n            return ret.replace(rreturn, \"\");\n          } // Handle cases where value is null/undef or number\n\n\n          return ret == null ? \"\" : ret;\n        }\n\n        return;\n      }\n\n      valueIsFunction = isFunction(value);\n      return this.each(function (i) {\n        var val;\n\n        if (this.nodeType !== 1) {\n          return;\n        }\n\n        if (valueIsFunction) {\n          val = value.call(this, i, jQuery(this).val());\n        } else {\n          val = value;\n        } // Treat null/undefined as \"\"; convert numbers to string\n\n\n        if (val == null) {\n          val = \"\";\n        } else if (typeof val === \"number\") {\n          val += \"\";\n        } else if (Array.isArray(val)) {\n          val = jQuery.map(val, function (value) {\n            return value == null ? \"\" : value + \"\";\n          });\n        }\n\n        hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]; // If set returns undefined, fall back to normal setting\n\n        if (!hooks || !(\"set\" in hooks) || hooks.set(this, val, \"value\") === undefined) {\n          this.value = val;\n        }\n      });\n    }\n  });\n  jQuery.extend({\n    valHooks: {\n      option: {\n        get: function get(elem) {\n          var val = jQuery.find.attr(elem, \"value\");\n          return val != null ? val : // Support: IE <=10 - 11 only\n          // option.text throws exceptions (#14686, #14858)\n          // Strip and collapse whitespace\n          // https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n          stripAndCollapse(jQuery.text(elem));\n        }\n      },\n      select: {\n        get: function get(elem) {\n          var value,\n              option,\n              i,\n              options = elem.options,\n              index = elem.selectedIndex,\n              one = elem.type === \"select-one\",\n              values = one ? null : [],\n              max = one ? index + 1 : options.length;\n\n          if (index < 0) {\n            i = max;\n          } else {\n            i = one ? index : 0;\n          } // Loop through all the selected options\n\n\n          for (; i < max; i++) {\n            option = options[i]; // Support: IE <=9 only\n            // IE8-9 doesn't update selected after form reset (#2551)\n\n            if ((option.selected || i === index) && // Don't return options that are disabled or in a disabled optgroup\n            !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, \"optgroup\"))) {\n              // Get the specific value for the option\n              value = jQuery(option).val(); // We don't need an array for one selects\n\n              if (one) {\n                return value;\n              } // Multi-Selects return an array\n\n\n              values.push(value);\n            }\n          }\n\n          return values;\n        },\n        set: function set(elem, value) {\n          var optionSet,\n              option,\n              options = elem.options,\n              values = jQuery.makeArray(value),\n              i = options.length;\n\n          while (i--) {\n            option = options[i];\n            /* eslint-disable no-cond-assign */\n\n            if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {\n              optionSet = true;\n            }\n            /* eslint-enable no-cond-assign */\n\n          } // Force browsers to behave consistently when non-matching value is set\n\n\n          if (!optionSet) {\n            elem.selectedIndex = -1;\n          }\n\n          return values;\n        }\n      }\n    }\n  }); // Radios and checkboxes getter/setter\n\n  jQuery.each([\"radio\", \"checkbox\"], function () {\n    jQuery.valHooks[this] = {\n      set: function set(elem, value) {\n        if (Array.isArray(value)) {\n          return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;\n        }\n      }\n    };\n\n    if (!support.checkOn) {\n      jQuery.valHooks[this].get = function (elem) {\n        return elem.getAttribute(\"value\") === null ? \"on\" : elem.value;\n      };\n    }\n  }); // Return jQuery for attributes-only inclusion\n\n  support.focusin = \"onfocusin\" in window;\n\n  var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n      stopPropagationCallback = function stopPropagationCallback(e) {\n    e.stopPropagation();\n  };\n\n  jQuery.extend(jQuery.event, {\n    trigger: function trigger(event, data, elem, onlyHandlers) {\n      var i,\n          cur,\n          tmp,\n          bubbleType,\n          ontype,\n          handle,\n          special,\n          lastElement,\n          eventPath = [elem || document],\n          type = hasOwn.call(event, \"type\") ? event.type : event,\n          namespaces = hasOwn.call(event, \"namespace\") ? event.namespace.split(\".\") : [];\n      cur = lastElement = tmp = elem = elem || document; // Don't do events on text and comment nodes\n\n      if (elem.nodeType === 3 || elem.nodeType === 8) {\n        return;\n      } // focus/blur morphs to focusin/out; ensure we're not firing them right now\n\n\n      if (rfocusMorph.test(type + jQuery.event.triggered)) {\n        return;\n      }\n\n      if (type.indexOf(\".\") > -1) {\n        // Namespaced trigger; create a regexp to match event type in handle()\n        namespaces = type.split(\".\");\n        type = namespaces.shift();\n        namespaces.sort();\n      }\n\n      ontype = type.indexOf(\":\") < 0 && \"on\" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string\n\n      event = event[jQuery.expando] ? event : new jQuery.Event(type, _typeof(event) === \"object\" && event); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\n      event.isTrigger = onlyHandlers ? 2 : 3;\n      event.namespace = namespaces.join(\".\");\n      event.rnamespace = event.namespace ? new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\") : null; // Clean up the event in case it is being reused\n\n      event.result = undefined;\n\n      if (!event.target) {\n        event.target = elem;\n      } // Clone any incoming data and prepend the event, creating the handler arg list\n\n\n      data = data == null ? [event] : jQuery.makeArray(data, [event]); // Allow special events to draw outside the lines\n\n      special = jQuery.event.special[type] || {};\n\n      if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {\n        return;\n      } // Determine event propagation path in advance, per W3C events spec (#9951)\n      // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\n\n      if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {\n        bubbleType = special.delegateType || type;\n\n        if (!rfocusMorph.test(bubbleType + type)) {\n          cur = cur.parentNode;\n        }\n\n        for (; cur; cur = cur.parentNode) {\n          eventPath.push(cur);\n          tmp = cur;\n        } // Only add window if we got to document (e.g., not plain obj or detached DOM)\n\n\n        if (tmp === (elem.ownerDocument || document)) {\n          eventPath.push(tmp.defaultView || tmp.parentWindow || window);\n        }\n      } // Fire handlers on the event path\n\n\n      i = 0;\n\n      while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {\n        lastElement = cur;\n        event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler\n\n        handle = (dataPriv.get(cur, \"events\") || {})[event.type] && dataPriv.get(cur, \"handle\");\n\n        if (handle) {\n          handle.apply(cur, data);\n        } // Native handler\n\n\n        handle = ontype && cur[ontype];\n\n        if (handle && handle.apply && acceptData(cur)) {\n          event.result = handle.apply(cur, data);\n\n          if (event.result === false) {\n            event.preventDefault();\n          }\n        }\n      }\n\n      event.type = type; // If nobody prevented the default action, do it now\n\n      if (!onlyHandlers && !event.isDefaultPrevented()) {\n        if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {\n          // Call a native DOM method on the target with the same name as the event.\n          // Don't do default actions on window, that's where global variables be (#6170)\n          if (ontype && isFunction(elem[type]) && !isWindow(elem)) {\n            // Don't re-trigger an onFOO event when we call its FOO() method\n            tmp = elem[ontype];\n\n            if (tmp) {\n              elem[ontype] = null;\n            } // Prevent re-triggering of the same event, since we already bubbled it above\n\n\n            jQuery.event.triggered = type;\n\n            if (event.isPropagationStopped()) {\n              lastElement.addEventListener(type, stopPropagationCallback);\n            }\n\n            elem[type]();\n\n            if (event.isPropagationStopped()) {\n              lastElement.removeEventListener(type, stopPropagationCallback);\n            }\n\n            jQuery.event.triggered = undefined;\n\n            if (tmp) {\n              elem[ontype] = tmp;\n            }\n          }\n        }\n      }\n\n      return event.result;\n    },\n    // Piggyback on a donor event to simulate a different one\n    // Used only for `focus(in | out)` events\n    simulate: function simulate(type, elem, event) {\n      var e = jQuery.extend(new jQuery.Event(), event, {\n        type: type,\n        isSimulated: true\n      });\n      jQuery.event.trigger(e, null, elem);\n    }\n  });\n  jQuery.fn.extend({\n    trigger: function trigger(type, data) {\n      return this.each(function () {\n        jQuery.event.trigger(type, data, this);\n      });\n    },\n    triggerHandler: function triggerHandler(type, data) {\n      var elem = this[0];\n\n      if (elem) {\n        return jQuery.event.trigger(type, data, elem, true);\n      }\n    }\n  }); // Support: Firefox <=44\n  // Firefox doesn't have focus(in | out) events\n  // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n  //\n  // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n  // focus(in | out) events fire after focus & blur events,\n  // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n  // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\n\n  if (!support.focusin) {\n    jQuery.each({\n      focus: \"focusin\",\n      blur: \"focusout\"\n    }, function (orig, fix) {\n      // Attach a single capturing handler on the document while someone wants focusin/focusout\n      var handler = function handler(event) {\n        jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));\n      };\n\n      jQuery.event.special[fix] = {\n        setup: function setup() {\n          var doc = this.ownerDocument || this,\n              attaches = dataPriv.access(doc, fix);\n\n          if (!attaches) {\n            doc.addEventListener(orig, handler, true);\n          }\n\n          dataPriv.access(doc, fix, (attaches || 0) + 1);\n        },\n        teardown: function teardown() {\n          var doc = this.ownerDocument || this,\n              attaches = dataPriv.access(doc, fix) - 1;\n\n          if (!attaches) {\n            doc.removeEventListener(orig, handler, true);\n            dataPriv.remove(doc, fix);\n          } else {\n            dataPriv.access(doc, fix, attaches);\n          }\n        }\n      };\n    });\n  }\n\n  var location = window.location;\n  var nonce = Date.now();\n  var rquery = /\\?/; // Cross-browser xml parsing\n\n  jQuery.parseXML = function (data) {\n    var xml;\n\n    if (!data || typeof data !== \"string\") {\n      return null;\n    } // Support: IE 9 - 11 only\n    // IE throws on parseFromString with invalid input.\n\n\n    try {\n      xml = new window.DOMParser().parseFromString(data, \"text/xml\");\n    } catch (e) {\n      xml = undefined;\n    }\n\n    if (!xml || xml.getElementsByTagName(\"parsererror\").length) {\n      jQuery.error(\"Invalid XML: \" + data);\n    }\n\n    return xml;\n  };\n\n  var rbracket = /\\[\\]$/,\n      rCRLF = /\\r?\\n/g,\n      rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n      rsubmittable = /^(?:input|select|textarea|keygen)/i;\n\n  function buildParams(prefix, obj, traditional, add) {\n    var name;\n\n    if (Array.isArray(obj)) {\n      // Serialize array item.\n      jQuery.each(obj, function (i, v) {\n        if (traditional || rbracket.test(prefix)) {\n          // Treat each array item as a scalar.\n          add(prefix, v);\n        } else {\n          // Item is non-scalar (array or object), encode its numeric index.\n          buildParams(prefix + \"[\" + (_typeof(v) === \"object\" && v != null ? i : \"\") + \"]\", v, traditional, add);\n        }\n      });\n    } else if (!traditional && toType(obj) === \"object\") {\n      // Serialize object item.\n      for (name in obj) {\n        buildParams(prefix + \"[\" + name + \"]\", obj[name], traditional, add);\n      }\n    } else {\n      // Serialize scalar item.\n      add(prefix, obj);\n    }\n  } // Serialize an array of form elements or a set of\n  // key/values into a query string\n\n\n  jQuery.param = function (a, traditional) {\n    var prefix,\n        s = [],\n        add = function add(key, valueOrFunction) {\n      // If value is a function, invoke it and use its return value\n      var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;\n      s[s.length] = encodeURIComponent(key) + \"=\" + encodeURIComponent(value == null ? \"\" : value);\n    };\n\n    if (a == null) {\n      return \"\";\n    } // If an array was passed in, assume that it is an array of form elements.\n\n\n    if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {\n      // Serialize the form elements\n      jQuery.each(a, function () {\n        add(this.name, this.value);\n      });\n    } else {\n      // If traditional, encode the \"old\" way (the way 1.3.2 or older\n      // did it), otherwise encode params recursively.\n      for (prefix in a) {\n        buildParams(prefix, a[prefix], traditional, add);\n      }\n    } // Return the resulting serialization\n\n\n    return s.join(\"&\");\n  };\n\n  jQuery.fn.extend({\n    serialize: function serialize() {\n      return jQuery.param(this.serializeArray());\n    },\n    serializeArray: function serializeArray() {\n      return this.map(function () {\n        // Can add propHook for \"elements\" to filter or add form elements\n        var elements = jQuery.prop(this, \"elements\");\n        return elements ? jQuery.makeArray(elements) : this;\n      }).filter(function () {\n        var type = this.type; // Use .is( \":disabled\" ) so that fieldset[disabled] works\n\n        return this.name && !jQuery(this).is(\":disabled\") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));\n      }).map(function (i, elem) {\n        var val = jQuery(this).val();\n\n        if (val == null) {\n          return null;\n        }\n\n        if (Array.isArray(val)) {\n          return jQuery.map(val, function (val) {\n            return {\n              name: elem.name,\n              value: val.replace(rCRLF, \"\\r\\n\")\n            };\n          });\n        }\n\n        return {\n          name: elem.name,\n          value: val.replace(rCRLF, \"\\r\\n\")\n        };\n      }).get();\n    }\n  });\n  var r20 = /%20/g,\n      rhash = /#.*$/,\n      rantiCache = /([?&])_=[^&]*/,\n      rheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n      // #7653, #8125, #8152: local protocol detection\n  rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n      rnoContent = /^(?:GET|HEAD)$/,\n      rprotocol = /^\\/\\//,\n\n  /* Prefilters\n   * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n   * 2) These are called:\n   *    - BEFORE asking for a transport\n   *    - AFTER param serialization (s.data is a string if s.processData is true)\n   * 3) key is the dataType\n   * 4) the catchall symbol \"*\" can be used\n   * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n   */\n  prefilters = {},\n\n  /* Transports bindings\n   * 1) key is the dataType\n   * 2) the catchall symbol \"*\" can be used\n   * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n   */\n  transports = {},\n      // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n  allTypes = \"*/\".concat(\"*\"),\n      // Anchor tag for parsing the document origin\n  originAnchor = document.createElement(\"a\");\n  originAnchor.href = location.href; // Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\n\n  function addToPrefiltersOrTransports(structure) {\n    // dataTypeExpression is optional and defaults to \"*\"\n    return function (dataTypeExpression, func) {\n      if (typeof dataTypeExpression !== \"string\") {\n        func = dataTypeExpression;\n        dataTypeExpression = \"*\";\n      }\n\n      var dataType,\n          i = 0,\n          dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];\n\n      if (isFunction(func)) {\n        // For each dataType in the dataTypeExpression\n        while (dataType = dataTypes[i++]) {\n          // Prepend if requested\n          if (dataType[0] === \"+\") {\n            dataType = dataType.slice(1) || \"*\";\n            (structure[dataType] = structure[dataType] || []).unshift(func); // Otherwise append\n          } else {\n            (structure[dataType] = structure[dataType] || []).push(func);\n          }\n        }\n      }\n    };\n  } // Base inspection function for prefilters and transports\n\n\n  function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {\n    var inspected = {},\n        seekingTransport = structure === transports;\n\n    function inspect(dataType) {\n      var selected;\n      inspected[dataType] = true;\n      jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {\n        var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);\n\n        if (typeof dataTypeOrTransport === \"string\" && !seekingTransport && !inspected[dataTypeOrTransport]) {\n          options.dataTypes.unshift(dataTypeOrTransport);\n          inspect(dataTypeOrTransport);\n          return false;\n        } else if (seekingTransport) {\n          return !(selected = dataTypeOrTransport);\n        }\n      });\n      return selected;\n    }\n\n    return inspect(options.dataTypes[0]) || !inspected[\"*\"] && inspect(\"*\");\n  } // A special extend for ajax options\n  // that takes \"flat\" options (not to be deep extended)\n  // Fixes #9887\n\n\n  function ajaxExtend(target, src) {\n    var key,\n        deep,\n        flatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n    for (key in src) {\n      if (src[key] !== undefined) {\n        (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];\n      }\n    }\n\n    if (deep) {\n      jQuery.extend(true, target, deep);\n    }\n\n    return target;\n  }\n  /* Handles responses to an ajax request:\n   * - finds the right dataType (mediates between content-type and expected dataType)\n   * - returns the corresponding response\n   */\n\n\n  function ajaxHandleResponses(s, jqXHR, responses) {\n    var ct,\n        type,\n        finalDataType,\n        firstDataType,\n        contents = s.contents,\n        dataTypes = s.dataTypes; // Remove auto dataType and get content-type in the process\n\n    while (dataTypes[0] === \"*\") {\n      dataTypes.shift();\n\n      if (ct === undefined) {\n        ct = s.mimeType || jqXHR.getResponseHeader(\"Content-Type\");\n      }\n    } // Check if we're dealing with a known content-type\n\n\n    if (ct) {\n      for (type in contents) {\n        if (contents[type] && contents[type].test(ct)) {\n          dataTypes.unshift(type);\n          break;\n        }\n      }\n    } // Check to see if we have a response for the expected dataType\n\n\n    if (dataTypes[0] in responses) {\n      finalDataType = dataTypes[0];\n    } else {\n      // Try convertible dataTypes\n      for (type in responses) {\n        if (!dataTypes[0] || s.converters[type + \" \" + dataTypes[0]]) {\n          finalDataType = type;\n          break;\n        }\n\n        if (!firstDataType) {\n          firstDataType = type;\n        }\n      } // Or just use first one\n\n\n      finalDataType = finalDataType || firstDataType;\n    } // If we found a dataType\n    // We add the dataType to the list if needed\n    // and return the corresponding response\n\n\n    if (finalDataType) {\n      if (finalDataType !== dataTypes[0]) {\n        dataTypes.unshift(finalDataType);\n      }\n\n      return responses[finalDataType];\n    }\n  }\n  /* Chain conversions given the request and the original response\n   * Also sets the responseXXX fields on the jqXHR instance\n   */\n\n\n  function ajaxConvert(s, response, jqXHR, isSuccess) {\n    var conv2,\n        current,\n        conv,\n        tmp,\n        prev,\n        converters = {},\n        // Work with a copy of dataTypes in case we need to modify it for conversion\n    dataTypes = s.dataTypes.slice(); // Create converters map with lowercased keys\n\n    if (dataTypes[1]) {\n      for (conv in s.converters) {\n        converters[conv.toLowerCase()] = s.converters[conv];\n      }\n    }\n\n    current = dataTypes.shift(); // Convert to each sequential dataType\n\n    while (current) {\n      if (s.responseFields[current]) {\n        jqXHR[s.responseFields[current]] = response;\n      } // Apply the dataFilter if provided\n\n\n      if (!prev && isSuccess && s.dataFilter) {\n        response = s.dataFilter(response, s.dataType);\n      }\n\n      prev = current;\n      current = dataTypes.shift();\n\n      if (current) {\n        // There's only work to do if current dataType is non-auto\n        if (current === \"*\") {\n          current = prev; // Convert response if prev dataType is non-auto and differs from current\n        } else if (prev !== \"*\" && prev !== current) {\n          // Seek a direct converter\n          conv = converters[prev + \" \" + current] || converters[\"* \" + current]; // If none found, seek a pair\n\n          if (!conv) {\n            for (conv2 in converters) {\n              // If conv2 outputs current\n              tmp = conv2.split(\" \");\n\n              if (tmp[1] === current) {\n                // If prev can be converted to accepted input\n                conv = converters[prev + \" \" + tmp[0]] || converters[\"* \" + tmp[0]];\n\n                if (conv) {\n                  // Condense equivalence converters\n                  if (conv === true) {\n                    conv = converters[conv2]; // Otherwise, insert the intermediate dataType\n                  } else if (converters[conv2] !== true) {\n                    current = tmp[0];\n                    dataTypes.unshift(tmp[1]);\n                  }\n\n                  break;\n                }\n              }\n            }\n          } // Apply converter (if not an equivalence)\n\n\n          if (conv !== true) {\n            // Unless errors are allowed to bubble, catch and return them\n            if (conv && s[\"throws\"]) {\n              response = conv(response);\n            } else {\n              try {\n                response = conv(response);\n              } catch (e) {\n                return {\n                  state: \"parsererror\",\n                  error: conv ? e : \"No conversion from \" + prev + \" to \" + current\n                };\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return {\n      state: \"success\",\n      data: response\n    };\n  }\n\n  jQuery.extend({\n    // Counter for holding the number of active queries\n    active: 0,\n    // Last-Modified header cache for next request\n    lastModified: {},\n    etag: {},\n    ajaxSettings: {\n      url: location.href,\n      type: \"GET\",\n      isLocal: rlocalProtocol.test(location.protocol),\n      global: true,\n      processData: true,\n      async: true,\n      contentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n      /*\n      timeout: 0,\n      data: null,\n      dataType: null,\n      username: null,\n      password: null,\n      cache: null,\n      throws: false,\n      traditional: false,\n      headers: {},\n      */\n      accepts: {\n        \"*\": allTypes,\n        text: \"text/plain\",\n        html: \"text/html\",\n        xml: \"application/xml, text/xml\",\n        json: \"application/json, text/javascript\"\n      },\n      contents: {\n        xml: /\\bxml\\b/,\n        html: /\\bhtml/,\n        json: /\\bjson\\b/\n      },\n      responseFields: {\n        xml: \"responseXML\",\n        text: \"responseText\",\n        json: \"responseJSON\"\n      },\n      // Data converters\n      // Keys separate source (or catchall \"*\") and destination types with a single space\n      converters: {\n        // Convert anything to text\n        \"* text\": String,\n        // Text to html (true = no transformation)\n        \"text html\": true,\n        // Evaluate text as a json expression\n        \"text json\": JSON.parse,\n        // Parse text as xml\n        \"text xml\": jQuery.parseXML\n      },\n      // For options that shouldn't be deep extended:\n      // you can add your own custom options here if\n      // and when you create one that shouldn't be\n      // deep extended (see ajaxExtend)\n      flatOptions: {\n        url: true,\n        context: true\n      }\n    },\n    // Creates a full fledged settings object into target\n    // with both ajaxSettings and settings fields.\n    // If target is omitted, writes into ajaxSettings.\n    ajaxSetup: function ajaxSetup(target, settings) {\n      return settings ? // Building a settings object\n      ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : // Extending ajaxSettings\n      ajaxExtend(jQuery.ajaxSettings, target);\n    },\n    ajaxPrefilter: addToPrefiltersOrTransports(prefilters),\n    ajaxTransport: addToPrefiltersOrTransports(transports),\n    // Main method\n    ajax: function ajax(url, options) {\n      // If url is an object, simulate pre-1.5 signature\n      if (_typeof(url) === \"object\") {\n        options = url;\n        url = undefined;\n      } // Force options to be an object\n\n\n      options = options || {};\n\n      var transport,\n          // URL without anti-cache param\n      cacheURL,\n          // Response headers\n      responseHeadersString,\n          responseHeaders,\n          // timeout handle\n      timeoutTimer,\n          // Url cleanup var\n      urlAnchor,\n          // Request state (becomes false upon send and true upon completion)\n      completed,\n          // To know if global events are to be dispatched\n      fireGlobals,\n          // Loop variable\n      i,\n          // uncached part of the url\n      uncached,\n          // Create the final options object\n      s = jQuery.ajaxSetup({}, options),\n          // Callbacks context\n      callbackContext = s.context || s,\n          // Context for global events is callbackContext if it is a DOM node or jQuery collection\n      globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event,\n          // Deferreds\n      deferred = jQuery.Deferred(),\n          completeDeferred = jQuery.Callbacks(\"once memory\"),\n          // Status-dependent callbacks\n      _statusCode = s.statusCode || {},\n          // Headers (they are sent all at once)\n      requestHeaders = {},\n          requestHeadersNames = {},\n          // Default abort message\n      strAbort = \"canceled\",\n          // Fake xhr\n      jqXHR = {\n        readyState: 0,\n        // Builds headers hashtable if needed\n        getResponseHeader: function getResponseHeader(key) {\n          var match;\n\n          if (completed) {\n            if (!responseHeaders) {\n              responseHeaders = {};\n\n              while (match = rheaders.exec(responseHeadersString)) {\n                responseHeaders[match[1].toLowerCase() + \" \"] = (responseHeaders[match[1].toLowerCase() + \" \"] || []).concat(match[2]);\n              }\n            }\n\n            match = responseHeaders[key.toLowerCase() + \" \"];\n          }\n\n          return match == null ? null : match.join(\", \");\n        },\n        // Raw string\n        getAllResponseHeaders: function getAllResponseHeaders() {\n          return completed ? responseHeadersString : null;\n        },\n        // Caches the header\n        setRequestHeader: function setRequestHeader(name, value) {\n          if (completed == null) {\n            name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name;\n            requestHeaders[name] = value;\n          }\n\n          return this;\n        },\n        // Overrides response content-type header\n        overrideMimeType: function overrideMimeType(type) {\n          if (completed == null) {\n            s.mimeType = type;\n          }\n\n          return this;\n        },\n        // Status-dependent callbacks\n        statusCode: function statusCode(map) {\n          var code;\n\n          if (map) {\n            if (completed) {\n              // Execute the appropriate callbacks\n              jqXHR.always(map[jqXHR.status]);\n            } else {\n              // Lazy-add the new callbacks in a way that preserves old ones\n              for (code in map) {\n                _statusCode[code] = [_statusCode[code], map[code]];\n              }\n            }\n          }\n\n          return this;\n        },\n        // Cancel the request\n        abort: function abort(statusText) {\n          var finalText = statusText || strAbort;\n\n          if (transport) {\n            transport.abort(finalText);\n          }\n\n          done(0, finalText);\n          return this;\n        }\n      }; // Attach deferreds\n\n\n      deferred.promise(jqXHR); // Add protocol if not provided (prefilters might expect it)\n      // Handle falsy url in the settings object (#10093: consistency with old signature)\n      // We also use the url parameter if available\n\n      s.url = ((url || s.url || location.href) + \"\").replace(rprotocol, location.protocol + \"//\"); // Alias method option to type as per ticket #12004\n\n      s.type = options.method || options.type || s.method || s.type; // Extract dataTypes list\n\n      s.dataTypes = (s.dataType || \"*\").toLowerCase().match(rnothtmlwhite) || [\"\"]; // A cross-domain request is in order when the origin doesn't match the current origin.\n\n      if (s.crossDomain == null) {\n        urlAnchor = document.createElement(\"a\"); // Support: IE <=8 - 11, Edge 12 - 15\n        // IE throws exception on accessing the href property if url is malformed,\n        // e.g. http://example.com:80x/\n\n        try {\n          urlAnchor.href = s.url; // Support: IE <=8 - 11 only\n          // Anchor's host property isn't correctly set when s.url is relative\n\n          urlAnchor.href = urlAnchor.href;\n          s.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !== urlAnchor.protocol + \"//\" + urlAnchor.host;\n        } catch (e) {\n          // If there is an error parsing the URL, assume it is crossDomain,\n          // it can be rejected by the transport if it is invalid\n          s.crossDomain = true;\n        }\n      } // Convert data if not already a string\n\n\n      if (s.data && s.processData && typeof s.data !== \"string\") {\n        s.data = jQuery.param(s.data, s.traditional);\n      } // Apply prefilters\n\n\n      inspectPrefiltersOrTransports(prefilters, s, options, jqXHR); // If request was aborted inside a prefilter, stop there\n\n      if (completed) {\n        return jqXHR;\n      } // We can fire global events as of now if asked to\n      // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n\n\n      fireGlobals = jQuery.event && s.global; // Watch for a new set of requests\n\n      if (fireGlobals && jQuery.active++ === 0) {\n        jQuery.event.trigger(\"ajaxStart\");\n      } // Uppercase the type\n\n\n      s.type = s.type.toUpperCase(); // Determine if request has content\n\n      s.hasContent = !rnoContent.test(s.type); // Save the URL in case we're toying with the If-Modified-Since\n      // and/or If-None-Match header later on\n      // Remove hash to simplify url manipulation\n\n      cacheURL = s.url.replace(rhash, \"\"); // More options handling for requests with no content\n\n      if (!s.hasContent) {\n        // Remember the hash so we can put it back\n        uncached = s.url.slice(cacheURL.length); // If data is available and should be processed, append data to url\n\n        if (s.data && (s.processData || typeof s.data === \"string\")) {\n          cacheURL += (rquery.test(cacheURL) ? \"&\" : \"?\") + s.data; // #9682: remove data so that it's not used in an eventual retry\n\n          delete s.data;\n        } // Add or update anti-cache param if needed\n\n\n        if (s.cache === false) {\n          cacheURL = cacheURL.replace(rantiCache, \"$1\");\n          uncached = (rquery.test(cacheURL) ? \"&\" : \"?\") + \"_=\" + nonce++ + uncached;\n        } // Put hash and anti-cache on the URL that will be requested (gh-1732)\n\n\n        s.url = cacheURL + uncached; // Change '%20' to '+' if this is encoded form body content (gh-2658)\n      } else if (s.data && s.processData && (s.contentType || \"\").indexOf(\"application/x-www-form-urlencoded\") === 0) {\n        s.data = s.data.replace(r20, \"+\");\n      } // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\n\n      if (s.ifModified) {\n        if (jQuery.lastModified[cacheURL]) {\n          jqXHR.setRequestHeader(\"If-Modified-Since\", jQuery.lastModified[cacheURL]);\n        }\n\n        if (jQuery.etag[cacheURL]) {\n          jqXHR.setRequestHeader(\"If-None-Match\", jQuery.etag[cacheURL]);\n        }\n      } // Set the correct header, if data is being sent\n\n\n      if (s.data && s.hasContent && s.contentType !== false || options.contentType) {\n        jqXHR.setRequestHeader(\"Content-Type\", s.contentType);\n      } // Set the Accepts header for the server, depending on the dataType\n\n\n      jqXHR.setRequestHeader(\"Accept\", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\") : s.accepts[\"*\"]); // Check for headers option\n\n      for (i in s.headers) {\n        jqXHR.setRequestHeader(i, s.headers[i]);\n      } // Allow custom headers/mimetypes and early abort\n\n\n      if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {\n        // Abort if not done already and return\n        return jqXHR.abort();\n      } // Aborting is no longer a cancellation\n\n\n      strAbort = \"abort\"; // Install callbacks on deferreds\n\n      completeDeferred.add(s.complete);\n      jqXHR.done(s.success);\n      jqXHR.fail(s.error); // Get transport\n\n      transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR); // If no transport, we auto-abort\n\n      if (!transport) {\n        done(-1, \"No Transport\");\n      } else {\n        jqXHR.readyState = 1; // Send global event\n\n        if (fireGlobals) {\n          globalEventContext.trigger(\"ajaxSend\", [jqXHR, s]);\n        } // If request was aborted inside ajaxSend, stop there\n\n\n        if (completed) {\n          return jqXHR;\n        } // Timeout\n\n\n        if (s.async && s.timeout > 0) {\n          timeoutTimer = window.setTimeout(function () {\n            jqXHR.abort(\"timeout\");\n          }, s.timeout);\n        }\n\n        try {\n          completed = false;\n          transport.send(requestHeaders, done);\n        } catch (e) {\n          // Rethrow post-completion exceptions\n          if (completed) {\n            throw e;\n          } // Propagate others as results\n\n\n          done(-1, e);\n        }\n      } // Callback for when everything is done\n\n\n      function done(status, nativeStatusText, responses, headers) {\n        var isSuccess,\n            success,\n            error,\n            response,\n            modified,\n            statusText = nativeStatusText; // Ignore repeat invocations\n\n        if (completed) {\n          return;\n        }\n\n        completed = true; // Clear timeout if it exists\n\n        if (timeoutTimer) {\n          window.clearTimeout(timeoutTimer);\n        } // Dereference transport for early garbage collection\n        // (no matter how long the jqXHR object will be used)\n\n\n        transport = undefined; // Cache response headers\n\n        responseHeadersString = headers || \"\"; // Set readyState\n\n        jqXHR.readyState = status > 0 ? 4 : 0; // Determine if successful\n\n        isSuccess = status >= 200 && status < 300 || status === 304; // Get response data\n\n        if (responses) {\n          response = ajaxHandleResponses(s, jqXHR, responses);\n        } // Convert no matter what (that way responseXXX fields are always set)\n\n\n        response = ajaxConvert(s, response, jqXHR, isSuccess); // If successful, handle type chaining\n\n        if (isSuccess) {\n          // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n          if (s.ifModified) {\n            modified = jqXHR.getResponseHeader(\"Last-Modified\");\n\n            if (modified) {\n              jQuery.lastModified[cacheURL] = modified;\n            }\n\n            modified = jqXHR.getResponseHeader(\"etag\");\n\n            if (modified) {\n              jQuery.etag[cacheURL] = modified;\n            }\n          } // if no content\n\n\n          if (status === 204 || s.type === \"HEAD\") {\n            statusText = \"nocontent\"; // if not modified\n          } else if (status === 304) {\n            statusText = \"notmodified\"; // If we have data, let's convert it\n          } else {\n            statusText = response.state;\n            success = response.data;\n            error = response.error;\n            isSuccess = !error;\n          }\n        } else {\n          // Extract error from statusText and normalize for non-aborts\n          error = statusText;\n\n          if (status || !statusText) {\n            statusText = \"error\";\n\n            if (status < 0) {\n              status = 0;\n            }\n          }\n        } // Set data for the fake xhr object\n\n\n        jqXHR.status = status;\n        jqXHR.statusText = (nativeStatusText || statusText) + \"\"; // Success/Error\n\n        if (isSuccess) {\n          deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);\n        } else {\n          deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);\n        } // Status-dependent callbacks\n\n\n        jqXHR.statusCode(_statusCode);\n        _statusCode = undefined;\n\n        if (fireGlobals) {\n          globalEventContext.trigger(isSuccess ? \"ajaxSuccess\" : \"ajaxError\", [jqXHR, s, isSuccess ? success : error]);\n        } // Complete\n\n\n        completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);\n\n        if (fireGlobals) {\n          globalEventContext.trigger(\"ajaxComplete\", [jqXHR, s]); // Handle the global AJAX counter\n\n          if (! --jQuery.active) {\n            jQuery.event.trigger(\"ajaxStop\");\n          }\n        }\n      }\n\n      return jqXHR;\n    },\n    getJSON: function getJSON(url, data, callback) {\n      return jQuery.get(url, data, callback, \"json\");\n    },\n    getScript: function getScript(url, callback) {\n      return jQuery.get(url, undefined, callback, \"script\");\n    }\n  });\n  jQuery.each([\"get\", \"post\"], function (i, method) {\n    jQuery[method] = function (url, data, callback, type) {\n      // Shift arguments if data argument was omitted\n      if (isFunction(data)) {\n        type = type || callback;\n        callback = data;\n        data = undefined;\n      } // The url can be an options object (which then must have .url)\n\n\n      return jQuery.ajax(jQuery.extend({\n        url: url,\n        type: method,\n        dataType: type,\n        data: data,\n        success: callback\n      }, jQuery.isPlainObject(url) && url));\n    };\n  });\n\n  jQuery._evalUrl = function (url, options) {\n    return jQuery.ajax({\n      url: url,\n      // Make this explicit, since user can override this through ajaxSetup (#11264)\n      type: \"GET\",\n      dataType: \"script\",\n      cache: true,\n      async: false,\n      global: false,\n      // Only evaluate the response if it is successful (gh-4126)\n      // dataFilter is not invoked for failure responses, so using it instead\n      // of the default converter is kludgy but it works.\n      converters: {\n        \"text script\": function textScript() {}\n      },\n      dataFilter: function dataFilter(response) {\n        jQuery.globalEval(response, options);\n      }\n    });\n  };\n\n  jQuery.fn.extend({\n    wrapAll: function wrapAll(html) {\n      var wrap;\n\n      if (this[0]) {\n        if (isFunction(html)) {\n          html = html.call(this[0]);\n        } // The elements to wrap the target around\n\n\n        wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);\n\n        if (this[0].parentNode) {\n          wrap.insertBefore(this[0]);\n        }\n\n        wrap.map(function () {\n          var elem = this;\n\n          while (elem.firstElementChild) {\n            elem = elem.firstElementChild;\n          }\n\n          return elem;\n        }).append(this);\n      }\n\n      return this;\n    },\n    wrapInner: function wrapInner(html) {\n      if (isFunction(html)) {\n        return this.each(function (i) {\n          jQuery(this).wrapInner(html.call(this, i));\n        });\n      }\n\n      return this.each(function () {\n        var self = jQuery(this),\n            contents = self.contents();\n\n        if (contents.length) {\n          contents.wrapAll(html);\n        } else {\n          self.append(html);\n        }\n      });\n    },\n    wrap: function wrap(html) {\n      var htmlIsFunction = isFunction(html);\n      return this.each(function (i) {\n        jQuery(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);\n      });\n    },\n    unwrap: function unwrap(selector) {\n      this.parent(selector).not(\"body\").each(function () {\n        jQuery(this).replaceWith(this.childNodes);\n      });\n      return this;\n    }\n  });\n\n  jQuery.expr.pseudos.hidden = function (elem) {\n    return !jQuery.expr.pseudos.visible(elem);\n  };\n\n  jQuery.expr.pseudos.visible = function (elem) {\n    return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);\n  };\n\n  jQuery.ajaxSettings.xhr = function () {\n    try {\n      return new window.XMLHttpRequest();\n    } catch (e) {}\n  };\n\n  var xhrSuccessStatus = {\n    // File protocol always yields status code 0, assume 200\n    0: 200,\n    // Support: IE <=9 only\n    // #1450: sometimes IE returns 1223 when it should be 204\n    1223: 204\n  },\n      xhrSupported = jQuery.ajaxSettings.xhr();\n  support.cors = !!xhrSupported && \"withCredentials\" in xhrSupported;\n  support.ajax = xhrSupported = !!xhrSupported;\n  jQuery.ajaxTransport(function (options) {\n    var _callback, errorCallback; // Cross domain only allowed if supported through XMLHttpRequest\n\n\n    if (support.cors || xhrSupported && !options.crossDomain) {\n      return {\n        send: function send(headers, complete) {\n          var i,\n              xhr = options.xhr();\n          xhr.open(options.type, options.url, options.async, options.username, options.password); // Apply custom fields if provided\n\n          if (options.xhrFields) {\n            for (i in options.xhrFields) {\n              xhr[i] = options.xhrFields[i];\n            }\n          } // Override mime type if needed\n\n\n          if (options.mimeType && xhr.overrideMimeType) {\n            xhr.overrideMimeType(options.mimeType);\n          } // X-Requested-With header\n          // For cross-domain requests, seeing as conditions for a preflight are\n          // akin to a jigsaw puzzle, we simply never set it to be sure.\n          // (it can always be set on a per-request basis or even using ajaxSetup)\n          // For same-domain requests, won't change header if already provided.\n\n\n          if (!options.crossDomain && !headers[\"X-Requested-With\"]) {\n            headers[\"X-Requested-With\"] = \"XMLHttpRequest\";\n          } // Set headers\n\n\n          for (i in headers) {\n            xhr.setRequestHeader(i, headers[i]);\n          } // Callback\n\n\n          _callback = function callback(type) {\n            return function () {\n              if (_callback) {\n                _callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;\n\n                if (type === \"abort\") {\n                  xhr.abort();\n                } else if (type === \"error\") {\n                  // Support: IE <=9 only\n                  // On a manual native abort, IE9 throws\n                  // errors on any property access that is not readyState\n                  if (typeof xhr.status !== \"number\") {\n                    complete(0, \"error\");\n                  } else {\n                    complete( // File: protocol always yields status 0; see #8605, #14207\n                    xhr.status, xhr.statusText);\n                  }\n                } else {\n                  complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, // Support: IE <=9 only\n                  // IE9 has no XHR2 but throws on binary (trac-11426)\n                  // For XHR2 non-text, let the caller handle it (gh-2498)\n                  (xhr.responseType || \"text\") !== \"text\" || typeof xhr.responseText !== \"string\" ? {\n                    binary: xhr.response\n                  } : {\n                    text: xhr.responseText\n                  }, xhr.getAllResponseHeaders());\n                }\n              }\n            };\n          }; // Listen to events\n\n\n          xhr.onload = _callback();\n          errorCallback = xhr.onerror = xhr.ontimeout = _callback(\"error\"); // Support: IE 9 only\n          // Use onreadystatechange to replace onabort\n          // to handle uncaught aborts\n\n          if (xhr.onabort !== undefined) {\n            xhr.onabort = errorCallback;\n          } else {\n            xhr.onreadystatechange = function () {\n              // Check readyState before timeout as it changes\n              if (xhr.readyState === 4) {\n                // Allow onerror to be called first,\n                // but that will not handle a native abort\n                // Also, save errorCallback to a variable\n                // as xhr.onerror cannot be accessed\n                window.setTimeout(function () {\n                  if (_callback) {\n                    errorCallback();\n                  }\n                });\n              }\n            };\n          } // Create the abort callback\n\n\n          _callback = _callback(\"abort\");\n\n          try {\n            // Do send the request (this may raise an exception)\n            xhr.send(options.hasContent && options.data || null);\n          } catch (e) {\n            // #14683: Only rethrow if this hasn't been notified as an error yet\n            if (_callback) {\n              throw e;\n            }\n          }\n        },\n        abort: function abort() {\n          if (_callback) {\n            _callback();\n          }\n        }\n      };\n    }\n  }); // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\n\n  jQuery.ajaxPrefilter(function (s) {\n    if (s.crossDomain) {\n      s.contents.script = false;\n    }\n  }); // Install script dataType\n\n  jQuery.ajaxSetup({\n    accepts: {\n      script: \"text/javascript, application/javascript, \" + \"application/ecmascript, application/x-ecmascript\"\n    },\n    contents: {\n      script: /\\b(?:java|ecma)script\\b/\n    },\n    converters: {\n      \"text script\": function textScript(text) {\n        jQuery.globalEval(text);\n        return text;\n      }\n    }\n  }); // Handle cache's special case and crossDomain\n\n  jQuery.ajaxPrefilter(\"script\", function (s) {\n    if (s.cache === undefined) {\n      s.cache = false;\n    }\n\n    if (s.crossDomain) {\n      s.type = \"GET\";\n    }\n  }); // Bind script tag hack transport\n\n  jQuery.ajaxTransport(\"script\", function (s) {\n    // This transport only deals with cross domain or forced-by-attrs requests\n    if (s.crossDomain || s.scriptAttrs) {\n      var script, _callback2;\n\n      return {\n        send: function send(_, complete) {\n          script = jQuery(\"<script>\").attr(s.scriptAttrs || {}).prop({\n            charset: s.scriptCharset,\n            src: s.url\n          }).on(\"load error\", _callback2 = function callback(evt) {\n            script.remove();\n            _callback2 = null;\n\n            if (evt) {\n              complete(evt.type === \"error\" ? 404 : 200, evt.type);\n            }\n          }); // Use native DOM manipulation to avoid our domManip AJAX trickery\n\n          document.head.appendChild(script[0]);\n        },\n        abort: function abort() {\n          if (_callback2) {\n            _callback2();\n          }\n        }\n      };\n    }\n  });\n  var oldCallbacks = [],\n      rjsonp = /(=)\\?(?=&|$)|\\?\\?/; // Default jsonp settings\n\n  jQuery.ajaxSetup({\n    jsonp: \"callback\",\n    jsonpCallback: function jsonpCallback() {\n      var callback = oldCallbacks.pop() || jQuery.expando + \"_\" + nonce++;\n      this[callback] = true;\n      return callback;\n    }\n  }); // Detect, normalize options and install callbacks for jsonp requests\n\n  jQuery.ajaxPrefilter(\"json jsonp\", function (s, originalSettings, jqXHR) {\n    var callbackName,\n        overwritten,\n        responseContainer,\n        jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? \"url\" : typeof s.data === \"string\" && (s.contentType || \"\").indexOf(\"application/x-www-form-urlencoded\") === 0 && rjsonp.test(s.data) && \"data\"); // Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\n    if (jsonProp || s.dataTypes[0] === \"jsonp\") {\n      // Get callback name, remembering preexisting value associated with it\n      callbackName = s.jsonpCallback = isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback; // Insert callback into url or form data\n\n      if (jsonProp) {\n        s[jsonProp] = s[jsonProp].replace(rjsonp, \"$1\" + callbackName);\n      } else if (s.jsonp !== false) {\n        s.url += (rquery.test(s.url) ? \"&\" : \"?\") + s.jsonp + \"=\" + callbackName;\n      } // Use data converter to retrieve json after script execution\n\n\n      s.converters[\"script json\"] = function () {\n        if (!responseContainer) {\n          jQuery.error(callbackName + \" was not called\");\n        }\n\n        return responseContainer[0];\n      }; // Force json dataType\n\n\n      s.dataTypes[0] = \"json\"; // Install callback\n\n      overwritten = window[callbackName];\n\n      window[callbackName] = function () {\n        responseContainer = arguments;\n      }; // Clean-up function (fires after converters)\n\n\n      jqXHR.always(function () {\n        // If previous value didn't exist - remove it\n        if (overwritten === undefined) {\n          jQuery(window).removeProp(callbackName); // Otherwise restore preexisting value\n        } else {\n          window[callbackName] = overwritten;\n        } // Save back as free\n\n\n        if (s[callbackName]) {\n          // Make sure that re-using the options doesn't screw things around\n          s.jsonpCallback = originalSettings.jsonpCallback; // Save the callback name for future use\n\n          oldCallbacks.push(callbackName);\n        } // Call if it was a function and we have a response\n\n\n        if (responseContainer && isFunction(overwritten)) {\n          overwritten(responseContainer[0]);\n        }\n\n        responseContainer = overwritten = undefined;\n      }); // Delegate to script\n\n      return \"script\";\n    }\n  }); // Support: Safari 8 only\n  // In Safari 8 documents created via document.implementation.createHTMLDocument\n  // collapse sibling forms: the second one becomes a child of the first one.\n  // Because of that, this security measure has to be disabled in Safari 8.\n  // https://bugs.webkit.org/show_bug.cgi?id=137337\n\n  support.createHTMLDocument = function () {\n    var body = document.implementation.createHTMLDocument(\"\").body;\n    body.innerHTML = \"<form></form><form></form>\";\n    return body.childNodes.length === 2;\n  }(); // Argument \"data\" should be string of html\n  // context (optional): If specified, the fragment will be created in this context,\n  // defaults to document\n  // keepScripts (optional): If true, will include scripts passed in the html string\n\n\n  jQuery.parseHTML = function (data, context, keepScripts) {\n    if (typeof data !== \"string\") {\n      return [];\n    }\n\n    if (typeof context === \"boolean\") {\n      keepScripts = context;\n      context = false;\n    }\n\n    var base, parsed, scripts;\n\n    if (!context) {\n      // Stop scripts or inline event handlers from being executed immediately\n      // by using document.implementation\n      if (support.createHTMLDocument) {\n        context = document.implementation.createHTMLDocument(\"\"); // Set the base href for the created document\n        // so any parsed elements with URLs\n        // are based on the document's URL (gh-2965)\n\n        base = context.createElement(\"base\");\n        base.href = document.location.href;\n        context.head.appendChild(base);\n      } else {\n        context = document;\n      }\n    }\n\n    parsed = rsingleTag.exec(data);\n    scripts = !keepScripts && []; // Single tag\n\n    if (parsed) {\n      return [context.createElement(parsed[1])];\n    }\n\n    parsed = buildFragment([data], context, scripts);\n\n    if (scripts && scripts.length) {\n      jQuery(scripts).remove();\n    }\n\n    return jQuery.merge([], parsed.childNodes);\n  };\n  /**\n   * Load a url into a page\n   */\n\n\n  jQuery.fn.load = function (url, params, callback) {\n    var selector,\n        type,\n        response,\n        self = this,\n        off = url.indexOf(\" \");\n\n    if (off > -1) {\n      selector = stripAndCollapse(url.slice(off));\n      url = url.slice(0, off);\n    } // If it's a function\n\n\n    if (isFunction(params)) {\n      // We assume that it's the callback\n      callback = params;\n      params = undefined; // Otherwise, build a param string\n    } else if (params && _typeof(params) === \"object\") {\n      type = \"POST\";\n    } // If we have elements to modify, make the request\n\n\n    if (self.length > 0) {\n      jQuery.ajax({\n        url: url,\n        // If \"type\" variable is undefined, then \"GET\" method will be used.\n        // Make value of this field explicit since\n        // user can override it through ajaxSetup method\n        type: type || \"GET\",\n        dataType: \"html\",\n        data: params\n      }).done(function (responseText) {\n        // Save response for use in complete callback\n        response = arguments;\n        self.html(selector ? // If a selector was specified, locate the right elements in a dummy div\n        // Exclude scripts to avoid IE 'Permission Denied' errors\n        jQuery(\"<div>\").append(jQuery.parseHTML(responseText)).find(selector) : // Otherwise use the full result\n        responseText); // If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n        // but they are ignored because response was set above.\n        // If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n      }).always(callback && function (jqXHR, status) {\n        self.each(function () {\n          callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);\n        });\n      });\n    }\n\n    return this;\n  }; // Attach a bunch of functions for handling common AJAX events\n\n\n  jQuery.each([\"ajaxStart\", \"ajaxStop\", \"ajaxComplete\", \"ajaxError\", \"ajaxSuccess\", \"ajaxSend\"], function (i, type) {\n    jQuery.fn[type] = function (fn) {\n      return this.on(type, fn);\n    };\n  });\n\n  jQuery.expr.pseudos.animated = function (elem) {\n    return jQuery.grep(jQuery.timers, function (fn) {\n      return elem === fn.elem;\n    }).length;\n  };\n\n  jQuery.offset = {\n    setOffset: function setOffset(elem, options, i) {\n      var curPosition,\n          curLeft,\n          curCSSTop,\n          curTop,\n          curOffset,\n          curCSSLeft,\n          calculatePosition,\n          position = jQuery.css(elem, \"position\"),\n          curElem = jQuery(elem),\n          props = {}; // Set position first, in-case top/left are set even on static elem\n\n      if (position === \"static\") {\n        elem.style.position = \"relative\";\n      }\n\n      curOffset = curElem.offset();\n      curCSSTop = jQuery.css(elem, \"top\");\n      curCSSLeft = jQuery.css(elem, \"left\");\n      calculatePosition = (position === \"absolute\" || position === \"fixed\") && (curCSSTop + curCSSLeft).indexOf(\"auto\") > -1; // Need to be able to calculate position if either\n      // top or left is auto and position is either absolute or fixed\n\n      if (calculatePosition) {\n        curPosition = curElem.position();\n        curTop = curPosition.top;\n        curLeft = curPosition.left;\n      } else {\n        curTop = parseFloat(curCSSTop) || 0;\n        curLeft = parseFloat(curCSSLeft) || 0;\n      }\n\n      if (isFunction(options)) {\n        // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n        options = options.call(elem, i, jQuery.extend({}, curOffset));\n      }\n\n      if (options.top != null) {\n        props.top = options.top - curOffset.top + curTop;\n      }\n\n      if (options.left != null) {\n        props.left = options.left - curOffset.left + curLeft;\n      }\n\n      if (\"using\" in options) {\n        options.using.call(elem, props);\n      } else {\n        curElem.css(props);\n      }\n    }\n  };\n  jQuery.fn.extend({\n    // offset() relates an element's border box to the document origin\n    offset: function offset(options) {\n      // Preserve chaining for setter\n      if (arguments.length) {\n        return options === undefined ? this : this.each(function (i) {\n          jQuery.offset.setOffset(this, options, i);\n        });\n      }\n\n      var rect,\n          win,\n          elem = this[0];\n\n      if (!elem) {\n        return;\n      } // Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n      // Support: IE <=11 only\n      // Running getBoundingClientRect on a\n      // disconnected node in IE throws an error\n\n\n      if (!elem.getClientRects().length) {\n        return {\n          top: 0,\n          left: 0\n        };\n      } // Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\n\n      rect = elem.getBoundingClientRect();\n      win = elem.ownerDocument.defaultView;\n      return {\n        top: rect.top + win.pageYOffset,\n        left: rect.left + win.pageXOffset\n      };\n    },\n    // position() relates an element's margin box to its offset parent's padding box\n    // This corresponds to the behavior of CSS absolute positioning\n    position: function position() {\n      if (!this[0]) {\n        return;\n      }\n\n      var offsetParent,\n          offset,\n          doc,\n          elem = this[0],\n          parentOffset = {\n        top: 0,\n        left: 0\n      }; // position:fixed elements are offset from the viewport, which itself always has zero offset\n\n      if (jQuery.css(elem, \"position\") === \"fixed\") {\n        // Assume position:fixed implies availability of getBoundingClientRect\n        offset = elem.getBoundingClientRect();\n      } else {\n        offset = this.offset(); // Account for the *real* offset parent, which can be the document or its root element\n        // when a statically positioned element is identified\n\n        doc = elem.ownerDocument;\n        offsetParent = elem.offsetParent || doc.documentElement;\n\n        while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && jQuery.css(offsetParent, \"position\") === \"static\") {\n          offsetParent = offsetParent.parentNode;\n        }\n\n        if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) {\n          // Incorporate borders into its offset, since they are outside its content origin\n          parentOffset = jQuery(offsetParent).offset();\n          parentOffset.top += jQuery.css(offsetParent, \"borderTopWidth\", true);\n          parentOffset.left += jQuery.css(offsetParent, \"borderLeftWidth\", true);\n        }\n      } // Subtract parent offsets and element margins\n\n\n      return {\n        top: offset.top - parentOffset.top - jQuery.css(elem, \"marginTop\", true),\n        left: offset.left - parentOffset.left - jQuery.css(elem, \"marginLeft\", true)\n      };\n    },\n    // This method will return documentElement in the following cases:\n    // 1) For the element inside the iframe without offsetParent, this method will return\n    //    documentElement of the parent window\n    // 2) For the hidden or detached element\n    // 3) For body or html element, i.e. in case of the html node - it will return itself\n    //\n    // but those exceptions were never presented as a real life use-cases\n    // and might be considered as more preferable results.\n    //\n    // This logic, however, is not guaranteed and can change at any point in the future\n    offsetParent: function offsetParent() {\n      return this.map(function () {\n        var offsetParent = this.offsetParent;\n\n        while (offsetParent && jQuery.css(offsetParent, \"position\") === \"static\") {\n          offsetParent = offsetParent.offsetParent;\n        }\n\n        return offsetParent || documentElement;\n      });\n    }\n  }); // Create scrollLeft and scrollTop methods\n\n  jQuery.each({\n    scrollLeft: \"pageXOffset\",\n    scrollTop: \"pageYOffset\"\n  }, function (method, prop) {\n    var top = \"pageYOffset\" === prop;\n\n    jQuery.fn[method] = function (val) {\n      return access(this, function (elem, method, val) {\n        // Coalesce documents and windows\n        var win;\n\n        if (isWindow(elem)) {\n          win = elem;\n        } else if (elem.nodeType === 9) {\n          win = elem.defaultView;\n        }\n\n        if (val === undefined) {\n          return win ? win[prop] : elem[method];\n        }\n\n        if (win) {\n          win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset);\n        } else {\n          elem[method] = val;\n        }\n      }, method, val, arguments.length);\n    };\n  }); // Support: Safari <=7 - 9.1, Chrome <=37 - 49\n  // Add the top/left cssHooks using jQuery.fn.position\n  // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n  // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n  // getComputedStyle returns percent when specified for top/left/bottom/right;\n  // rather than make the css module depend on the offset module, just check for it here\n\n  jQuery.each([\"top\", \"left\"], function (i, prop) {\n    jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) {\n      if (computed) {\n        computed = curCSS(elem, prop); // If curCSS returns percentage, fallback to offset\n\n        return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + \"px\" : computed;\n      }\n    });\n  }); // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\n\n  jQuery.each({\n    Height: \"height\",\n    Width: \"width\"\n  }, function (name, type) {\n    jQuery.each({\n      padding: \"inner\" + name,\n      content: type,\n      \"\": \"outer\" + name\n    }, function (defaultExtra, funcName) {\n      // Margin is only for outerHeight, outerWidth\n      jQuery.fn[funcName] = function (margin, value) {\n        var chainable = arguments.length && (defaultExtra || typeof margin !== \"boolean\"),\n            extra = defaultExtra || (margin === true || value === true ? \"margin\" : \"border\");\n        return access(this, function (elem, type, value) {\n          var doc;\n\n          if (isWindow(elem)) {\n            // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n            return funcName.indexOf(\"outer\") === 0 ? elem[\"inner\" + name] : elem.document.documentElement[\"client\" + name];\n          } // Get document width or height\n\n\n          if (elem.nodeType === 9) {\n            doc = elem.documentElement; // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n            // whichever is greatest\n\n            return Math.max(elem.body[\"scroll\" + name], doc[\"scroll\" + name], elem.body[\"offset\" + name], doc[\"offset\" + name], doc[\"client\" + name]);\n          }\n\n          return value === undefined ? // Get width or height on the element, requesting but not forcing parseFloat\n          jQuery.css(elem, type, extra) : // Set width or height on the element\n          jQuery.style(elem, type, value, extra);\n        }, type, chainable ? margin : undefined, chainable);\n      };\n    });\n  });\n  jQuery.each((\"blur focus focusin focusout resize scroll click dblclick \" + \"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" + \"change select submit keydown keypress keyup contextmenu\").split(\" \"), function (i, name) {\n    // Handle event binding\n    jQuery.fn[name] = function (data, fn) {\n      return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);\n    };\n  });\n  jQuery.fn.extend({\n    hover: function hover(fnOver, fnOut) {\n      return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);\n    }\n  });\n  jQuery.fn.extend({\n    bind: function bind(types, data, fn) {\n      return this.on(types, null, data, fn);\n    },\n    unbind: function unbind(types, fn) {\n      return this.off(types, null, fn);\n    },\n    delegate: function delegate(selector, types, data, fn) {\n      return this.on(types, selector, data, fn);\n    },\n    undelegate: function undelegate(selector, types, fn) {\n      // ( namespace ) or ( selector, types [, fn] )\n      return arguments.length === 1 ? this.off(selector, \"**\") : this.off(types, selector || \"**\", fn);\n    }\n  }); // Bind a function to a context, optionally partially applying any\n  // arguments.\n  // jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n  // However, it is not slated for removal any time soon\n\n  jQuery.proxy = function (fn, context) {\n    var tmp, args, proxy;\n\n    if (typeof context === \"string\") {\n      tmp = fn[context];\n      context = fn;\n      fn = tmp;\n    } // Quick check to determine if target is callable, in the spec\n    // this throws a TypeError, but we will just return undefined.\n\n\n    if (!isFunction(fn)) {\n      return undefined;\n    } // Simulated bind\n\n\n    args = _slice.call(arguments, 2);\n\n    proxy = function proxy() {\n      return fn.apply(context || this, args.concat(_slice.call(arguments)));\n    }; // Set the guid of unique handler to the same of original handler, so it can be removed\n\n\n    proxy.guid = fn.guid = fn.guid || jQuery.guid++;\n    return proxy;\n  };\n\n  jQuery.holdReady = function (hold) {\n    if (hold) {\n      jQuery.readyWait++;\n    } else {\n      jQuery.ready(true);\n    }\n  };\n\n  jQuery.isArray = Array.isArray;\n  jQuery.parseJSON = JSON.parse;\n  jQuery.nodeName = nodeName;\n  jQuery.isFunction = isFunction;\n  jQuery.isWindow = isWindow;\n  jQuery.camelCase = camelCase;\n  jQuery.type = toType;\n  jQuery.now = Date.now;\n\n  jQuery.isNumeric = function (obj) {\n    // As of jQuery 3.0, isNumeric is limited to\n    // strings and numbers (primitives or objects)\n    // that can be coerced to finite numbers (gh-2662)\n    var type = jQuery.type(obj);\n    return (type === \"number\" || type === \"string\") && // parseFloat NaNs numeric-cast false positives (\"\")\n    // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n    // subtraction forces infinities to NaN\n    !isNaN(obj - parseFloat(obj));\n  }; // Register as a named AMD module, since jQuery can be concatenated with other\n  // files that may use define, but not via a proper concatenation script that\n  // understands anonymous AMD modules. A named AMD is safest and most robust\n  // way to register. Lowercase jquery is used because AMD module names are\n  // derived from file names, and jQuery is normally delivered in a lowercase\n  // file name. Do this after creating the global so that if an AMD module wants\n  // to call noConflict to hide this version of jQuery, it will work.\n  // Note that for maximum portability, libraries that are not jQuery should\n  // declare themselves as anonymous modules, and avoid setting a global if an\n  // AMD loader is present. jQuery is a special case. For more information, see\n  // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\n\n  if (typeof define === \"function\" && define.amd) {\n    define(\"jquery\", [], function () {\n      return jQuery;\n    });\n  }\n\n  var // Map over jQuery in case of overwrite\n  _jQuery = window.jQuery,\n      // Map over the $ in case of overwrite\n  _$ = window.$;\n\n  jQuery.noConflict = function (deep) {\n    if (window.$ === jQuery) {\n      window.$ = _$;\n    }\n\n    if (deep && window.jQuery === jQuery) {\n      window.jQuery = _jQuery;\n    }\n\n    return jQuery;\n  }; // Expose jQuery and $ identifiers, even in AMD\n  // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n  // and CommonJS for browser emulators (#13566)\n\n\n  if (!noGlobal) {\n    window.jQuery = window.$ = jQuery;\n  }\n\n  return jQuery;\n});","module.exports = function (module) {\n  if (!module.webpackPolyfill) {\n    module.deprecate = function () {};\n\n    module.paths = []; // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","\n\n// import Swiper from 'swiper/js/swiper'\n// import 'swiper/css/swiper.css'\n\n// function orangutan(callback) {\n//     callback(swiper)\n// }\n\n// let swiper = new Swiper('.swiper-container', {\n//     slidesPerView: 2,\n//     spaceBetween: 30,\n//     // centeredSlides: true,\n//     // watchOverflow: true,\n//     lazy: true,\n//     // slidesPerGroup: 3,\n//     pagination: {\n//         el: '.swiper-pagination',\n//         clickable: true,\n//     },\n//     navigation: {\n//         nextEl: '.swiper-button-next',\n//         prevEl: '.swiper-button-prev',\n//     },\n// });\n\n// function beerme() {\n//     swiper.update()\n// }\n\n// // orangutan(beerme)\n\n// setTimeout(beerme, 100)\n\n\n// import {tns} from 'tiny-slider/src/tiny-slider'\n// import 'tiny-slider/dist/tiny-slider.css'\n\n// var slider = tns({\n//   container: '.slider-container',\n//   autoWidth: true,\n//   items: 3,\n//   slideBy: 1,\n//   gutter: 5,\n// //   loop: false,\n//   controlsContainer: '.controls-container',\n//   prevButton: '#prev',\n//   nextButton: '#next',\n//   nav: false\n// });\n\nimport Flickity from 'flickity/dist/flickity.pkgd'\nimport 'flickity/dist/flickity.css'\n\nimport { findElement } from '../helpers'\n\ndocument.addEventListener('turbolinks:load', () => {\n    $('.custom-file input').change(function (e) {\n        $(this).next('.custom-file-label').html(e.target.files[0].name);\n    });\n    \n    $(function () {\n        $('[data-toggle=\"tooltip\"]').tooltip()\n    })\n    \n    $('.popup-group').each(function() {\n        $(this).find('a').magnificPopup({\n            type: 'image',\n            gallery: {\n                enabled: true\n            }\n        });\n    })\n    \n    $('.popup-item').magnificPopup({\n        type: 'image'\n    })\n\n\n\n    let flickityElement = findElement('.flickity-container')\n\n    if (flickityElement)\n    {\n        let cellSize = document.querySelector(\".flickity-container div a img\").clientHeight\n\n        var flkty = new Flickity( flickityElement, {\n            // options\n            cellAlign: 'left',\n            contain: true\n        });\n\n        console.log('Flickity Loaded')\n    }\n})\n\n\n\nconsole.log('Bottom scripts loaded.')"],"sourceRoot":""}