{"version":3,"sources":["webpack:///manifest.js","webpack:///webpack/bootstrap d2f75300c2db1f97d54a","webpack:///./node_modules/underscore/underscore-umd.js","webpack:///./node_modules/bluebird/js/release/util.js","webpack:///./node_modules/dada-rest-api/src/api.js","webpack:///./node_modules/bluebird/js/release/bluebird.js","webpack:///./node_modules/jquery/dist/jquery.js","webpack:///./node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js","webpack:///./node_modules/bluebird/js/release/errors.js","webpack:///./node_modules/dada-deferred/src/deferred.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/bluebird/js/release/es5.js","webpack:///./node_modules/dada-class/src/class.js","webpack:///./node_modules/bluebird/js/release/catch_filter.js","webpack:///./node_modules/bluebird/js/release/nodeback.js","webpack:///./node_modules/bluebird/js/release/promise.js","webpack:///./node_modules/bluebird/js/release/async.js","webpack:///./node_modules/bluebird/js/release/schedule.js","webpack:///./node_modules/.pnpm/timers-browserify@2.0.12/node_modules/timers-browserify/main.js","webpack:///./node_modules/.pnpm/timers-browserify@2.0.12/node_modules/setimmediate/setImmediate.js","webpack:///./node_modules/bluebird/js/release/queue.js","webpack:///./node_modules/bluebird/js/release/thenables.js","webpack:///./node_modules/bluebird/js/release/promise_array.js","webpack:///./node_modules/bluebird/js/release/context.js","webpack:///./node_modules/bluebird/js/release/debuggability.js","webpack:///./node_modules/bluebird/js/release/finally.js","webpack:///./node_modules/bluebird/js/release/method.js","webpack:///./node_modules/bluebird/js/release/bind.js","webpack:///./node_modules/bluebird/js/release/cancel.js","webpack:///./node_modules/bluebird/js/release/direct_resolve.js","webpack:///./node_modules/bluebird/js/release/synchronous_inspection.js","webpack:///./node_modules/bluebird/js/release/join.js","webpack:///./node_modules/bluebird/js/release/call_get.js","webpack:///./node_modules/bluebird/js/release/generators.js","webpack:///./node_modules/bluebird/js/release/map.js","webpack:///./node_modules/bluebird/js/release/nodeify.js","webpack:///./node_modules/bluebird/js/release/promisify.js","webpack:///./node_modules/bluebird/js/release/props.js","webpack:///./node_modules/bluebird/js/release/race.js","webpack:///./node_modules/bluebird/js/release/reduce.js","webpack:///./node_modules/bluebird/js/release/settle.js","webpack:///./node_modules/bluebird/js/release/some.js","webpack:///./node_modules/bluebird/js/release/timers.js","webpack:///./node_modules/bluebird/js/release/using.js","webpack:///./node_modules/bluebird/js/release/any.js","webpack:///./node_modules/bluebird/js/release/each.js","webpack:///./node_modules/bluebird/js/release/filter.js","webpack:///./node_modules/jquery.cookie/jquery.cookie.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","parentJsonpFunction","window","chunkIds","moreModules","executeModules","chunkId","result","resolves","length","installedChunks","push","Object","prototype","hasOwnProperty","shift","s","4","m","c","d","name","getter","o","defineProperty","configurable","enumerable","get","n","__esModule","object","property","p","oe","err","console","error","factory","this","restArguments","func","startIndex","Math","max","arguments","rest","Array","index","args","apply","isObject","obj","type","isNull","isUndefined","isBoolean","toString","isElement","nodeType","tagTester","tag","alternateIsDataView","isFunction$1","getInt8","isArrayBuffer","buffer","has$1","key","isFinite$1","isSymbol","_isFinite","isNaN","parseFloat","isNaN$1","isNumber","_isNaN","constant","value","createSizePropertyCheck","getSizeProperty","collection","sizeProperty","MAX_ARRAY_INDEX","shallowProperty","isTypedArray","nativeIsView","isDataView$1","isBufferLike","typedArrayPattern","test","emulatedSet","keys","hash","contains","collectNonEnumProps","nonEnumIdx","nonEnumerableProps","constructor","proto","ObjProto","prop","nativeKeys","hasEnumBug","isEmpty","getLength","isArray","isString","isArguments$1","isMatch","attrs","_keys","_$1","_wrapped","toBufferView","bufferSource","Uint8Array","byteOffset","getByteLength","isEqual","a","b","todo","aStack","bStack","frame","pop","className","hasDataViewBug","tagDataView","SymbolProto","valueOf","areArrays","isTypedArray$1","aCtor","bCtor","allKeys","ie11fingerprint","methods","weakMapMethods","forEachName","values","pairs","invert","functions","names","sort","createAssigner","keysFunc","defaults","source","ctor","baseCreate","nativeCreate","Ctor","create","props","extendOwn","clone","slice","extend","tap","interceptor","toPath$1","path","toPath","deepGet","defaultValue","has","identity","matcher","optimizeCb","context","argCount","accumulator","baseIteratee","iteratee","Infinity","cb","mapObject","results","currentKey","noop","propertyOf","times","accum","random","min","floor","createEscaper","map","escaper","match","join","testRegexp","RegExp","replaceRegexp","string","replace","escapeChar","escapes","template","text","settings","oldSettings","templateSettings","escape","noMatch","interpolate","evaluate","offset","escapeRegExp","argument","variable","bareIdentifier","Error","render","Function","e","data","fallback","uniqueId","prefix","id","idCounter","chain","instance","_chain","executeBound","sourceFunc","boundFunc","callingContext","self","flatten$1","input","depth","strict","output","idx","stack","v","isArrayLike","memoize","hasher","cache","address","throttle","wait","options","timeout","previous","later","leading","now","throttled","_now","remaining","clearTimeout","trailing","setTimeout","cancel","debounce","immediate","passed","debounced","_args","wrap","wrapper","partial","negate","predicate","compose","start","after","before","memo","findKey","createPredicateIndexFinder","dir","array","sortedIndex","low","high","mid","createIndexFinder","predicateFind","item","find","keyFinder","findIndex","findWhere","each","createReduce","reducer","initial","filter","list","reject","every","some","fromIndex","guard","indexOf","pluck","where","computed","lastComputed","toArray","reStrSymbol","sample","last","rand","temp","shuffle","sortBy","criteria","left","right","group","behavior","partition","size","keyInObj","first","compact","Boolean","flatten","uniq","isSorted","seen","intersection","argsLength","j","unzip","range","stop","step","ceil","chunk","count","chainResult","mixin","root","global","ArrayProto","Symbol","supportsArrayBuffer","ArrayBuffer","supportsDataView","DataView","nativeIsArray","isView","isFinite","propertyIsEnumerable","pow","isDate","isRegExp","isError","isFunction","nodelist","document","childNodes","Int8Array","hasObjectTag","String","isIE11","Map","isDataView","isArguments","VERSION","toJSON","commonInit","mapTail","mapMethods","concat","setMethods","isMap","isWeakMap","isSet","isWeakSet","Date","getTime","escapeMap","_escape","unescapeMap","_unescape","boundArgs","placeholder","bound","position","bind","TypeError","callArgs","bindAll","delay","defer","once","findLastIndex","lastIndexOf","reduce","reduceRight","invoke","contextPath","method","groupBy","indexBy","countBy","pass","pick","omit","difference","without","otherArrays","union","arrays","zip","allExports","__proto__","assign","matches","unescape","detect","forEach","collect","foldl","inject","foldr","select","all","any","includes","include","head","take","tail","drop","unique","transpose","_","tryCatcher","target","tryCatchTarget","errorObj","tryCatch","fn","isPrimitive","val","maybeWrapAsError","maybeError","safeToString","withAppended","appendee","len","ret","getDataPropertyOrDefault","es5","isES5","undefined","desc","getOwnPropertyDescriptor","set","notEnumerableProp","descriptor","writable","thrower","r","isClass","hasMethods","hasMethodsOtherThanConstructor","hasThisAssignmentAndStaticMethods","thisAssignmentPattern","toFastProperties","FakeConstructor","ic","receiver","foo","isIdentifier","str","rident","filledRange","suffix","message","markAsOriginatingFromRejection","ignore","originatesFromRejection","OperationalError","canAttachTrace","propertyIsWritable","classString","copyDescriptors","from","to","getDescriptor","env","hasEnvVariables","process","getNativePromise","Promise","promise","domainBind","canEvaluate","navigator","globalObject","inherits","Child","Parent","T","constructor$","propertyName","hasProp","charAt","inheritedDataKeys","excludedPrototypes","isExcludedProto","getKeys","getOwnPropertyNames","visitedKeys","getPrototypeOf","enumeration","ensureErrorObject","asArray","iterator","ArrayFrom","itResult","it","next","isNode","toLowerCase","hasDevTools","chrome","loadTimes","isRecentNode","version","versions","node","split","Number","lastLineError","appState","jQuery","Class","Deferred","normalizeEndpointProfile","profile","profileUrlRoot","endpointRoot","urlRoot","getClientParams","withAuthentication","apiKey","dataType","urlKey","params","fetchSingleton","getJwtHeader","then","authHeader","headers","resolve","buildQueryString","qs","includeEmbedded","noChildren","allowedOpts","customerId","customerHash","filters","includeMultiDomain","productUids","scanId","serviceUids","setupId","setupSite","traits","optName","optVal","encodeURIComponent","setConnectionDetails","details","endpointName","cacheKey","profileAwareEndpoints","singletons","apiStore","useSecureCookies","location","protocol","ApiError","httpStatus","other","Api","initialize","lastResponse","fetch","fetchSome","fetchAll","destroy","update","fetchForCustomer","setupPostParams","url","JSON","stringify","setupGetParams","setupPatchParams","processData","setupDeleteParams","setupHeadParams","dispatch","XDomainRequest","xdr","ontimeout","statusText","onerror","processAjaxErrorResponse","onprogress","onload","responseText","parse","describedBy","actualRequestType","open","send","jqXHR","ajax","done","fail","response","title","status","ApiSuffix","_super","promises","deferTriggered","fetchDetails","customer","suffixes","_makeRequests","actionedPromises","suffixesQueryString","queryString","locale","suffixData","_embedded","_links","href","curies","ApiDomainSuffix","authenticate","useAuthentication","setCustomerDetails","domainSuffix","ApiDomainSuffixOffers","domainSuffixOffers","ApiDomainValidation","resendEmail","serviceUid","action","domainValidation","ApiOrder","orderId","cookie","orderRef","promiseOrderId","validAddActions","getCachedOrderIdentifiers","getOrderId","fetchItems","fetchProducts","getUnprocessed","addToOrder","createNewOrder","_validate","canReuseExistingOrder","order","onHold","processed","getNewOrderId","origin","ignoreCustomerDetails","orderOrigin","customerDetails","uid","secure","removeItem","orderItemId","productType","removeAllItems","changes","applyVoucher","voucherCode","toUpperCase","useCredit","amount","creditAmount","updateItem","fetchSavedOrderCountForCustomer","getResponseHeader","clear","removeCookie","productId","renewalMethod","actions","packageId","serviceId","ApiDomainSearchStream","check","domain","requestedSuffixes","quality","autoSearchPrimarySuffix","eventSource","EventSource","domainSearchStream","ApiDomainWhoisStream","lookup","keyword","domainWhoisStream","ApiDomainSearchReport","report","domainSearchReport","ApiDomainSuggestions","domainSuggestions","ApiDomainSearch","searchId","pollPeriod","maximumPollRequests","searchingFor","willSearchFor","nextSearchPromise","runningSearchPromise","setDomain","addToSearch","autoTrigger","deferred","doSearch","pickUpPreheatSearch","_checkForResults","_startSearch","search","pollCounter","_rejectRemainingPromises","_fetchResults","domainSearch","ApiProduct","productUid","fetchForServices","fetchDomainProductsForSuffixes","baseQueryString","partialQueryString","privacyType","period","currency","productFamiliesForCustomer","products","relationships","familyForProduct","families","fetchForPackageUpgrade","productsQueryString","familyData","family","familyProductUid","product","ApiPackage","pendingUpdates","updateTriggered","emailAlias","packageUid","deferredPromise","_updateAll","patch","toUpdate","operations","unprocessed","firstPage","pages","packageCount","fetchRenewalCountForCustomer","fetchUpgrades","package","ApiPackageActivation","activate","packageActivation","ApiPackageAllocation","allocate","packageAllocation","ApiConsumerWithdrawal","fetchEligibleServices","consumerWithdrawal","ApiTicket","fetchTicketCountForCustomer","ticket","ApiCustomer","ApiAccessControlRule","accessControlRule","ApiAddressBookEntry","withAccount","addressBookEntry","ApiInvoice","invoice","ApiLcnInvoice","lcnInvoice","ApiCreditReceipt","creditReceipt","ApiCard","cardId","card","ApiDirectDebit","directDebitId","directDebit","ApiBandwidthCharge","bandwidthChargeId","bandwidthCharge","ApiRebill","rebill","rebillId","rebillsForCustomer","ApiForwarding","domainName","forwarding","ApiForwardingDomain","removeFirstPage","forwardingDomain","ApiForwardingEmail","aliasUid","fetchForService","forwardingEmail","ApiLogos","post","setupDataPostParams","logos","ApiService","fetchCpanelDomainInfo","fetchUpsellProducts","service","ApiBasekit","fetchLoginUrl","basekit","ApiDuda","fetchTemplates","reset","templateId","duda","ApiEcommerce","ecommerce","ApiSimplyBook","simplybook","ApiMacaly","itemId","fetchProvisionedList","fetchOrphanedAccountList","fetchWebsiteList","fetchHostnameList","websiteId","addHostname","removeHostname","changePlan","updateAppName","appName","macaly","ApiSitemaker","sitemaker","ApiDomainRegistration","serviceModel","domainRegistration","ApiEmail","email","ApiEmailUser","userUid","emailUser","ApiOffice365","office365","ApiOnlineCompliance","onlineCompliance","ApiWebAccessibility","webAccessibility","ApiOnlineComplianceScanner","onlineComplianceScanner","ApiQuota","quota","ApiMailbox","userName","mailbox","ApiHosting","hosting","ApiHubspot","orderPush","customerPush","hubspot","ApiSetup","setup","ApiResellerHostingData","includeLiteMail","resellerHostingData","AddressFinder","query","country","singlesummary","maximumresults","enablefacets","URLSearchParams","encodedQueryString","addtags","identifier","lines","queryParams","addressFinder","ApiAuth","defaultKey","fetchAuthDetails","jwtHeader","setAuthenticationCallback","callback","mode","btoa","username","password","toBase64","token","auth","getClientParameters","accessControlRuleEndpoint","addressBookEntryEndpoint","authEndpoint","bandwidthChargeEndpoint","basekitEndpoint","cardEndpoint","consumerWithdrawalEndpoint","creditreceiptEndpoint","customerEndpoint","directDebitEndpoint","domainSearchStreamEndpoint","domainWhoisStreamEndpoint","domainSuffixEndpoint","domainSuffixOffersEndpoint","domainValidationEndpoint","domainRegistrationEndpoint","dudaEndpoint","emailEndpoint","emailUserEndpoint","ecommerceEndpoint","forwardingEndpoint","hostingEndpoint","hubspotEndpoint","invoiceEndpoint","lcnInvoiceEndpoint","logosEndpoint","macalyEndpoint","office365Endpoint","onlineComplianceEndpoint","onlineComplianceScannerEndpoint","orderEndpoint","packageEndpoint","packageActivationEndpoint","packageAllocationEndpoint","productEndpoint","quotaEndpoint","mailboxEndpoint","resellerHostingDataEndpoint","serviceEndpoint","setupEndpoint","simplybookEndpoint","sitemakerEndpoint","suffixEndpoint","ticketEndpoint","webAccessibilityEndpoint","noConflict","bluebird","old","w","noGlobal","DOMEval","code","doc","script","createElement","preservedScriptAttributes","getAttribute","setAttribute","appendChild","parentNode","removeChild","toType","class2type","isWindow","nodeName","elem","fcssescape","ch","asCodePoint","charCodeAt","winnow","elements","qualifier","not","grep","sibling","cur","createOptions","rnothtmlwhite","flag","Identity","Thrower","ex","adoptValue","noValue","completed","removeEventListener","ready","fcamelCase","_all","letter","camelCase","rmsPrefix","rdashAlpha","Data","expando","getData","rbrace","dataAttr","rmultiDash","dataUser","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","css","unit","cssNumber","initialInUnit","rcssNum","exec","style","end","getDefaultDisplay","ownerDocument","display","defaultDisplayMap","body","showHide","show","dataPriv","isHiddenWithinTree","getAll","getElementsByTagName","querySelectorAll","merge","setGlobalEval","elems","refElements","buildFragment","scripts","selection","ignored","tmp","attached","fragment","createDocumentFragment","nodes","rhtml","rtagName","wrapMap","_default","innerHTML","htmlPrefilter","lastChild","firstChild","textContent","createTextNode","inArray","isAttached","rscriptType","returnTrue","returnFalse","on","types","selector","one","origFn","event","off","guid","add","leverageNative","el","isSetup","namespace","handler","saved","isTrigger","special","delegateType","stopPropagation","stopImmediatePropagation","preventDefault","trigger","isImmediatePropagationStopped","manipulationTarget","content","children","disableScript","restoreScript","removeAttribute","cloneCopyEvent","src","dest","pdataOld","udataOld","udataCur","events","hasData","remove","access","fixInput","rcheckableType","checked","domManip","flat","hasScripts","iNoClone","valueIsFunction","support","checkClone","rchecked","eq","html","_evalUrl","noModule","nonce","rcleanScript","keepData","cleanData","curCSS","width","minWidth","maxWidth","isCustomProp","rcustomProp","getStyles","getPropertyValue","rtrimCSS","pixelBoxStyles","rnumnonpx","rboxStyle","addGetHookIf","conditionFn","hookFn","vendorPropName","capName","cssPrefixes","emptyStyle","finalPropName","final","cssProps","vendorProps","setPositiveNumber","_elem","subtract","boxModelAdjustment","dimension","box","isBorderBox","styles","computedVal","extra","delta","marginDelta","cssExpand","getWidthOrHeight","boxSizingNeeded","boxSizingReliable","valueIsBorderBox","offsetProp","reliableTrDimensions","getClientRects","Tween","easing","init","schedule","inProgress","hidden","requestAnimationFrame","fx","interval","tick","createFxNow","fxNow","genFx","includeWidth","which","height","opacity","createTween","animation","Animation","tweeners","defaultPrefilter","opts","toggle","hooks","oldfire","propTween","restoreDisplay","isBox","anim","orig","dataShow","queue","_queueHooks","unqueued","empty","fire","always","rfxtypes","isEmptyObject","overflow","overflowX","overflowY","propFilter","specialEasing","cssHooks","expand","properties","stopped","prefilters","currentTime","startTime","duration","percent","tweens","run","notifyWith","resolveWith","originalProperties","originalOptions","gotoEnd","rejectWith","progress","complete","timer","stripAndCollapse","getClass","classesToArray","buildParams","traditional","rbracket","addToPrefiltersOrTransports","structure","dataTypeExpression","dataTypes","unshift","inspectPrefiltersOrTransports","inspect","selected","inspected","prefilterOrFactory","dataTypeOrTransport","seekingTransport","transports","ajaxExtend","deep","flatOptions","ajaxSettings","ajaxHandleResponses","responses","ct","finalDataType","firstDataType","contents","mimeType","converters","ajaxConvert","isSuccess","conv2","current","conv","prev","responseFields","dataFilter","throws","state","arr","getProto","hasOwn","fnToString","ObjectFunctionString","rhtmlSuffix","jquery","num","pushStack","prevObject","even","odd","splice","copy","copyIsArray","isPlainObject","isReady","msg","globalEval","documentElement","nodeValue","makeArray","isXMLDoc","namespaceURI","docElem","second","callbackExpect","arg","_i","whitespace","bup","compareDocumentPosition","rcssescape","escapeSelector","sel","preferredDoc","pushNative","safeActiveElement","activeElement","seed","nid","groups","newSelector","newContext","setDocument","documentIsHTML","rquickExpr","getElementById","getElementsByClassName","nonnativeSelectorCache","rbuggyQSA","rdescend","rleadingCombinator","rsibling","testContext","scope","tokenize","toSelector","qsaError","createCache","Expr","cacheLength","markFunction","assert","createDisabledPseudo","disabled","isDisabled","inDisabledFieldset","createPositionalPseudo","matchIndexes","subWindow","webkitMatchesSelector","msMatchesSelector","defaultView","top","addEventListener","unloadHandler","getById","getElementsByName","disconnectedMatch","cssHas","querySelector","ID","attrId","runescape","funescape","getAttributeNode","TAG","CLASS","booleans","sortOrder","hasDuplicate","compare","sortDetached","sortInput","setFilters","parseOnly","matched","tokens","soFar","preFilters","cached","tokenCache","preFilter","rcomma","matchExpr","addCombinator","combinator","base","skip","checkNonElements","doneName","xml","oldCache","outerCache","newCache","dirruns","elementMatcher","matchers","multipleContexts","contexts","condense","unmatched","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","matcherOut","preMap","postMap","preexisting","matcherIn","matcherFromTokens","checkContext","leadingRelative","relative","implicitRelative","matchContext","matchAnyContext","outermostContext","matcherFromGroupMatchers","elementMatchers","setMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","uniqueSort","compile","compilerCache","compiled","needsContext","classCache","attributes","pseudos","rwhitespace","rpseudo","ridentifier","ATTR","PSEUDO","CHILD","bool","rinputs","rheader","nonHex","fromCharCode","els","expr","matchesSelector","attr","attrHandle","duplicates","sortStable","createPseudo","excess","unquoted","nodeNameSelector","expectedNodeName","pattern","operator","what","_argument","simple","forward","ofType","_context","nodeIndex","parent","useCache","diff","pseudo","lang","elemLang","focus","hasFocus","tabIndex","enabled","selectedIndex","nextSibling","header","button","_matchIndexes","lt","gt","nth","radio","checkbox","file","image","submit","getText","isXML","selectors","until","truncate","is","siblings","rneedsContext","rsingleTag","rootjQuery","parseHTML","rparentsprev","guaranteedUnique","targets","closest","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","reverse","Callbacks","firing","memory","fired","locked","firingIndex","stopOnFalse","disable","lock","fireWith","tuples","pipe","fns","newDefer","tuple","returned","notify","onFulfilled","onRejected","onProgress","that","mightThrow","maxDepth","exceptionHook","getErrorHook","getStackHook","stateString","when","singleValue","resolveContexts","resolveValues","primary","updateFunc","rerrorNames","asyncError","warn","readyException","readyList","catch","readyWait","readyState","doScroll","chainable","emptyGet","raw","bulk","_key","acceptData","owner","removeData","_data","_removeData","dequeue","startLength","setter","clearQueue","pnum","composed","getRootNode","hide","div","cloneNode","noCloneChecked","option","thead","col","tr","td","tbody","tfoot","colgroup","caption","th","optgroup","rtypenamespace","handleObjIn","eventHandle","t","handleObj","handlers","namespaces","origType","elemData","handle","triggered","bindType","delegateCount","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","rnamespace","postDispatch","matchedHandlers","matchedSelectors","addProp","hook","Event","originalEvent","load","noBubble","click","beforeunload","returnValue","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","isSimulated","altKey","bubbles","cancelable","changedTouches","ctrlKey","detail","eventPhase","metaKey","pageX","pageY","shiftKey","view","charCode","keyCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","blur","focusMappedHandler","documentMode","simulate","attaches","dataHolder","mouseenter","mouseleave","pointerenter","pointerleave","related","rnoInnerhtml","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","append","prepend","insertBefore","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","original","insert","opener","getComputedStyle","swap","computeStyleTests","container","cssText","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","marginLeft","pixelBoxStylesVal","boxSizingReliableVal","scrollboxSizeVal","offsetWidth","measure","round","reliableTrDimensionsVal","backgroundClip","clearCloneStyle","pixelPosition","reliableMarginLeft","scrollboxSize","table","trChild","trStyle","parseInt","borderTopWidth","borderBottomWidth","offsetHeight","rdisplayswap","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","animationIterationCount","aspectRatio","borderImageSlice","columnCount","flexGrow","flexShrink","gridArea","gridColumn","gridColumnEnd","gridColumnStart","gridRow","gridRowEnd","gridRowStart","lineHeight","orphans","widows","zIndex","zoom","fillOpacity","floodOpacity","stopOpacity","strokeMiterlimit","strokeOpacity","origName","setProperty","getBoundingClientRect","scrollboxSizeBuggy","margin","padding","border","expanded","parts","propHooks","eased","pos","scrollTop","scrollLeft","linear","swing","cos","PI","rrun","tweener","prefilter","speed","opt","speeds","fadeTo","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","time","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","attrNames","lowercaseName","rfocusable","rclickable","removeProp","propFix","tabindex","addClass","classNames","curValue","finalValue","removeClass","toggleClass","stateVal","isValidValue","hasClass","rreturn","valHooks","optionSet","rquery","parseXML","parserErrorElem","DOMParser","parseFromString","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","triggerHandler","rCRLF","rsubmitterTypes","rsubmittable","param","valueOrFunction","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rlocalProtocol","rnoContent","rprotocol","allTypes","originAnchor","active","lastModified","etag","isLocal","async","contentType","accepts","json","ajaxSetup","ajaxPrefilter","ajaxTransport","nativeStatusText","success","modified","timeoutTimer","transport","responseHeadersString","ifModified","cacheURL","callbackContext","statusCode","fireGlobals","globalEventContext","completeDeferred","responseHeaders","urlAnchor","uncached","requestHeaders","requestHeadersNames","strAbort","getAllResponseHeaders","setRequestHeader","overrideMimeType","abort","finalText","crossDomain","host","hasContent","beforeSend","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","xhr","XMLHttpRequest","xhrSuccessStatus","0","1223","xhrSupported","cors","errorCallback","xhrFields","onabort","onreadystatechange","responseType","binary","scriptAttrs","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","parsed","animated","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","calculatePosition","curElem","using","rect","win","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","unbind","delegate","undelegate","hover","fnOver","fnOut","rtrim","proxy","holdReady","hold","parseJSON","isNumeric","trim","_jQuery","_$","$","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","runClearTimeout","marker","cachedClearTimeout","cleanUpNextTick","draining","currentQueue","queueIndex","drainQueue","Item","nextTick","browser","argv","addListener","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","subError","nameProperty","defaultMessage","SubError","captureStackTrace","cause","_TypeError","_RangeError","Objectfreeze","freeze","util","Warning","CancellationError","TimeoutError","AggregateError","RangeError","level","indent","errorTypes","RejectionError","g","eval","ObjectKeys","ObjectGetDescriptor","ObjectDefineProperty","ObjectFreeze","ObjectGetPrototypeOf","ArrayIsArray","statics","child","unImplementedSuper","fnTest","Surrogate","__super__","NEXT_FILTER","catchFilter","instances","boundTo","_boundValue","predicateLoop","matchesPredicate","isUntypedError","wrapAsOperationalError","rErrorKey","nodebackForPromise","multiArgs","wrapped","_attachExtraTrace","_reject","$_len","$_i","_fulfill","errors","Proxyable","executor","INTERNAL","_bitField","_fulfillmentHandler0","_rejectionHandler0","_promise0","_receiver0","_resolveFromExecutor","_promiseCreated","_fireEvent","deferResolve","_resolveCallback","deferReject","_rejectCallback","fillTypes","getDomain","makeSelfResolutionError","reflectHandler","PromiseInspection","_target","apiRejection","UNDEFINED_BINDING","Async","APPLY","tryConvertToPromise","PromiseArray","Context","createContext","debug","PassThroughHandlerContext","CapturedTrace","caught","catchInstances","reflect","_then","didFulfill","didReject","warnings","_warn","_setIsFinal","spread","isFulfilled","isRejected","fulfillmentValue","rejectionReason","reason","getNewLibraryCopy","fromNode","fromCallback","_captureStackTrace","_isFateSealed","_setAsyncGuaranteed","cast","_setFulfilled","fulfilled","rejected","setScheduler","internalData","haveInternalData","bitField","_propagateFrom","_boundTo","settler","_settlePromiseCtx","_unsetRejectionIsUnhandled","_settlePromiseLateCancellationObserver","_addCallbacks","_length","_isFollowing","_setLength","_setRejected","_setFollowing","_isFinal","_unsetCancelled","_setCancelled","_setWillBeCancelled","hasCustomScheduler","_receiverAt","_isBound","_promiseAt","_fulfillmentHandlerAt","_rejectionHandlerAt","_migrateCallback0","follower","fulfill","_migrateCallbackAt","_proxy","proxyable","shouldBind","maybePromise","_setFollowee","_value","_reason","synchronous","ignoreNonErrorWarnings","trace","hasStack","_pushContext","_execute","_popContext","_settlePromiseFromHandler","x","promiseCreated","checkForgottenReturns","_followee","_settlePromise","isPromise","asyncGuaranteed","_invokeInternalOnCancel","isFinallyHandler","cancelPromise","_promiseCancelled","_cancel","_isResolved","_promiseFulfilled","_promiseRejected","ctx","_settlePromise0","_clearCallbackDataAtIndex","_settlePromises","settlePromises","_dereferenceTrace","fatalError","_ensurePossibleRejectionHandled","_fulfillPromises","_rejectPromises","_clearCancellationData","_settledValue","toStringTag","pending","deprecated","setBounds","firstLineError","_customScheduler","_isTickUsed","_lateQueue","Queue","_normalQueue","_haveDrainedQueues","_trampolineEnabled","drainQueues","_drainQueues","_schedule","AsyncInvokeLater","_queueTick","AsyncInvoke","AsyncSettlePromises","_pushOne","_drainQueue","_drainQueueStep","enableTrampoline","disableTrampolineIfNecessary","haveItemsQueued","stderr","write","exit","throwLater","invokeLater","_reset","noAsyncScheduler","NativePromise","MutationObserver","GlobalSetImmediate","setImmediate","ProcessNextTick","nativePromise","standalone","cordova","toggleScheduled","div2","classList","observe","scheduleToggle","disconnect","Timeout","clearFn","_id","_clearFn","setInterval","clearInterval","close","unref","ref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","_onTimeout","clearImmediate","task","tasksByHandle","nextHandle","registerImmediate","runIfPresent","currentlyRunningATask","attachTo","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","onGlobalMessage","attachEvent","MessageChannel","channel","port1","port2","arrayMove","srcIndex","dst","dstIndex","capacity","_capacity","_front","_willBeOverCapacity","_checkCapacity","wrapMask","front","_resizeTo","oldCapacity","getThen","isAnyBluebirdPromise","doThenable","doGetThen","toResolutionValue","_promise","_setOnCancel","_values","_totalResolved","_init","resolveValueIfEmpty","_resolveEmptyArray","_resolve","_iterate","getActualLength","shouldCopyValues","isResolved","suppressUnhandledRejections","_isCancellable","_resultCancelled","_trace","peekContext","longStackTraces","lastIndex","contextStack","_peekContext","deactivateLongStackTraces","activateLongStackTraces","Promise_pushContext","Promise_popContext","Promise_PeekContext","Promise_peekContext","Promise_promiseCreated","generatePromiseLifecycleEventObject","defaultFireEvent","cancellationExecute","onCancel","_attachCancellationCallback","cancellationAttachCancellationCallback","previousOnCancel","_onCancel","cancellationOnCancel","_onCancelField","cancellationSetOnCancel","cancellationClearCancellationData","_cancellationParent","cancellationPropagateFrom","flags","branchesRemainingToCancel","_branchesRemainingToCancel","_setBoundTo","bindingPropagateFrom","boundValueFunction","longStackTracesCaptureStackTrace","longStackTracesAttachExtraTrace","ignoreSelf","_parent","attachExtraTrace","__stackCleaned__","parseStackAndMessage","longStackTracesDereferenceTrace","wForgottenReturn","_returnedNonUndefined","handlerLine","creatorLine","traceLines","cleanStack","line","nodeFramePattern","lineMatches","parseLinePattern","firstUserLine","replacement","shouldUseOwnTrace","config","warning","activeFireEvent","formatAndLogError","reconstructStack","stacks","removeDuplicateOrEmptyJumps","removeCommonRoots","currentLastIndex","currentLastLine","commonRootMeetPoint","isTraceLine","stackFramePattern","isInternalFrame","shouldIgnore","indentStackFrames","stackFramesAsArray","isSoft","formatStack","printWarning","log","fireRejectionEvent","localHandler","localEventFired","formatNonError","snip","substr","maxChars","longStackTracesIsSupported","parseLineInfo","parseLineInfoRegex","fileName","firstFileName","lastFileName","firstStackLines","lastStackLines","firstIndex","bluebirdFramePattern","info","_promisesCreated","uncycle","unhandledRejectionHandled","possiblyUnhandledRejection","_getDomain","_async","debugging","_setRejectionIsUnhandled","_notifyUnhandledRejection","_notifyUnhandledRejectionIsHandled","_setReturnedNonUndefined","_isRejectionUnhandled","_setUnhandledRejectionIsNotified","_unsetUnhandledRejectionIsNotified","_isUnhandledRejectionNotified","onPossiblyUnhandledRejection","onUnhandledRejectionHandled","disableLongStackTraces","Promise_captureStackTrace","Promise_attachExtraTrace","Promise_dereferenceTrace","hasLongStackTraces","fireDomEvent","CustomEvent","dispatchEvent","eventData","domEvent","createEvent","initCustomEvent","fireGlobalEvent","methodName","eventToObjectGenerator","promiseFulfilled","promiseRejected","promiseResolved","promiseCancelled","promiseChained","unhandledRejection","rejectionHandled","globalEventFired","domEventFired","warningsOption","cancellation","propagateFromFunction","monitoring","stackToIndex","currentStack","cycleEdgeNode","currentChildLength","v8stackFramePattern","v8stackFormatter","stackTraceLimit","ignoreUntil","hasStackAfterThrow","isTTY","color","called","FinallyHandlerCancelReaction","finallyHandler","checkCancel","succeed","reasonOrValue","_isCancelled","isPending","_passThrough","lastly","tapCatch","handlerOrPredicate","_resolveFromSyncValue","attempt","calledBind","rejectThis","targetRejected","promiseRejectionQueued","bindingPromise","bindingResolved","thisArg","bindingRejected","_cancelBy","_cancelBranched","_branchHasCancelled","_enoughBranchesHaveCancelled","canceller","_invokeOnCancel","_cancelPromises","_unsetOnCancel","isCancellable","isCancelled","_doInvokeOnCancel","onCancelCallback","internalOnly","returner","thenReturn","thenThrow","catchThrow","catchReturn","_settledValueField","__isCancelled","holderClasses","thenCallbacks","promiseSetters","total","assignment","cancellationCode","passedArguments","HolderClass","holder","callbacks","asyncNeeded","cr","callerCache","getterCache","ensureMethod","caller","namedGetter","indexedGetter","getMethodCaller","getGetter","makeMethodCaller","makeGetter","getCompiled","compiler","maybeCaller","isIndex","maybeGetter","promiseFromYieldHandler","yieldHandlers","traceParent","PromiseSpawn","generatorFunction","yieldHandler","internal","_finallyPromise","_stack","_generatorFunction","_receiver","_generator","_yieldHandlers","_yieldedPromise","_cancellationPhase","_cleanup","implementsReturn","coroutine","returnSentinel","_continue","_run","PromiseSpawn$","generator","spawn","addYieldHandler","MappingPromiseArray","limit","_filter","_callback","_preservedValues","_limit","_inFlight","_queue","_asyncInit","concurrency","_init$","preservedValues","spreadAdapter","nodeback","successAdapter","errorAdapter","newReason","asCallback","nodeify","adapter","propsFilter","noCopyPropsPattern","isPromisified","__isPromisified__","hasPromisified","defaultPromisified","checkValid","suffixRegexp","keyWithoutAsyncSuffix","promisifiableMethods","passesDefaultFilter","defaultFilter","makeNodePromisifiedClosure","__","promisified","THIS","defaultThis","promisifyAll","promisifier","escapeIdentRegex","promisifiedKey","makeNodePromisified","promisify","makeNodePromisifiedEval","noCopyProps","switchCaseArgumentOrder","likelyArgumentCount","argumentSequence","argumentCount","parameterDeclaration","parameterCount","originalName","generateCallForArgumentCount","comma","shouldProxyThis","newParameterCount","argumentOrder","getFunctionCode","PropertiesPromiseArray","entries","Es6Map","mapToEntries","_isMap","castValue","extractEntry","entriesToMap","keyOffset","race","raceLater","ReductionPromiseArray","initialValue","_each","_fn","_initialValue","_currentCancellable","_eachValues","valueOrReason","gotAccum","_gotAccum","gotValue","_eachComplete","sender","_resultCancelled$","SettledPromiseArray","_promiseResolved","inspection","settle","SomePromiseArray","_howMany","_unwrap","_initialized","howMany","setHowMany","CANCELLATION","isArrayResolved","_canPossiblyFulfill","_getRangeError","setUnwrap","_addFulfilled","_fulfilled","_addRejected","_checkOutcome","_rejected","_SomePromiseArray","HandleWrapper","successClear","failureClear","afterValue","ms","afterTimeout","handleWrapper","castPreservingDisposable","thenable","_isDisposable","_getDisposer","_setDisposable","dispose","resources","tryDispose","Disposer","FunctionDisposer","maybeUnwrapDisposer","isDisposer","ResourceList","NULL","resource","doDispose","_unsetDisposable","spreadArgs","disposer","reflectedResources","resultPromise","inspections","_disposer","promiseAllThis","PromiseAll","PromiseMapSeries","PromiseReduce","mapSeries","PromiseMap","encode","decode","decodeURIComponent","stringifyCookieValue","parseCookieValue","pluses","read","converter","expires","days","setTime","toUTCString","cookies"],"mappings":"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","file":"manifest.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// install a JSONP callback for chunk loading\n/******/ \tvar parentJsonpFunction = window[\"webpackJsonp\"];\n/******/ \twindow[\"webpackJsonp\"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {\n/******/ \t\t// add \"moreModules\" to the modules object,\n/******/ \t\t// then flag all \"chunkIds\" as loaded and fire callback\n/******/ \t\tvar moduleId, chunkId, i = 0, resolves = [], result;\n/******/ \t\tfor(;i < chunkIds.length; i++) {\n/******/ \t\t\tchunkId = chunkIds[i];\n/******/ \t\t\tif(installedChunks[chunkId]) {\n/******/ \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n/******/ \t\t\t}\n/******/ \t\t\tinstalledChunks[chunkId] = 0;\n/******/ \t\t}\n/******/ \t\tfor(moduleId in moreModules) {\n/******/ \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n/******/ \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n/******/ \t\t\t}\n/******/ \t\t}\n/******/ \t\tif(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);\n/******/ \t\twhile(resolves.length) {\n/******/ \t\t\tresolves.shift()();\n/******/ \t\t}\n/******/ \t\tif(executeModules) {\n/******/ \t\t\tfor(i=0; i < executeModules.length; i++) {\n/******/ \t\t\t\tresult = __webpack_require__(__webpack_require__.s = executeModules[i]);\n/******/ \t\t\t}\n/******/ \t\t}\n/******/ \t\treturn result;\n/******/ \t};\n/******/\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// objects to store loaded and loading chunks\n/******/ \tvar installedChunks = {\n/******/ \t\t4: 0\n/******/ \t};\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, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\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 = \"\";\n/******/\n/******/ \t// on error function for async loading\n/******/ \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */,\n/* 1 */,\n/* 2 */,\n/* 3 */,\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {(function (global, factory) {\n   true ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define('underscore', factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {\n    var current = global._;\n    var exports = global._ = factory();\n    exports.noConflict = function () { global._ = current; return exports; };\n  }()));\n}(this, (function () {\n  //     Underscore.js 1.13.8\n  //     https://underscorejs.org\n  //     (c) 2009-2026 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors\n  //     Underscore may be freely distributed under the MIT license.\n\n  // Current version.\n  var VERSION = '1.13.8';\n\n  // Establish the root object, `window` (`self`) in the browser, `global`\n  // on the server, or `this` in some virtual machines. We use `self`\n  // instead of `window` for `WebWorker` support.\n  var root = (typeof self == 'object' && self.self === self && self) ||\n            (typeof global == 'object' && global.global === global && global) ||\n            Function('return this')() ||\n            {};\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype;\n  var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var push = ArrayProto.push,\n      slice = ArrayProto.slice,\n      toString = ObjProto.toString,\n      hasOwnProperty = ObjProto.hasOwnProperty;\n\n  // Modern feature detection.\n  var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',\n      supportsDataView = typeof DataView !== 'undefined';\n\n  // All **ECMAScript 5+** native function implementations that we hope to use\n  // are declared here.\n  var nativeIsArray = Array.isArray,\n      nativeKeys = Object.keys,\n      nativeCreate = Object.create,\n      nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;\n\n  // Create references to these builtin functions because we override them.\n  var _isNaN = isNaN,\n      _isFinite = isFinite;\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n    'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  // The largest integer that can be represented exactly.\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n\n  // Some functions take a variable number of arguments, or a few expected\n  // arguments at the beginning and then a variable number of values to operate\n  // on. This helper accumulates all remaining arguments past the function’s\n  // argument length (or an explicit `startIndex`), into an array that becomes\n  // the last argument. Similar to ES6’s \"rest parameter\".\n  function restArguments(func, startIndex) {\n    startIndex = startIndex == null ? func.length - 1 : +startIndex;\n    return function() {\n      var length = Math.max(arguments.length - startIndex, 0),\n          rest = Array(length),\n          index = 0;\n      for (; index < length; index++) {\n        rest[index] = arguments[index + startIndex];\n      }\n      switch (startIndex) {\n        case 0: return func.call(this, rest);\n        case 1: return func.call(this, arguments[0], rest);\n        case 2: return func.call(this, arguments[0], arguments[1], rest);\n      }\n      var args = Array(startIndex + 1);\n      for (index = 0; index < startIndex; index++) {\n        args[index] = arguments[index];\n      }\n      args[startIndex] = rest;\n      return func.apply(this, args);\n    };\n  }\n\n  // Is a given variable an object?\n  function isObject(obj) {\n    var type = typeof obj;\n    return type === 'function' || (type === 'object' && !!obj);\n  }\n\n  // Is a given value equal to null?\n  function isNull(obj) {\n    return obj === null;\n  }\n\n  // Is a given variable undefined?\n  function isUndefined(obj) {\n    return obj === void 0;\n  }\n\n  // Is a given value a boolean?\n  function isBoolean(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  }\n\n  // Is a given value a DOM element?\n  function isElement(obj) {\n    return !!(obj && obj.nodeType === 1);\n  }\n\n  // Internal function for creating a `toString`-based type tester.\n  function tagTester(name) {\n    var tag = '[object ' + name + ']';\n    return function(obj) {\n      return toString.call(obj) === tag;\n    };\n  }\n\n  var isString = tagTester('String');\n\n  var isNumber = tagTester('Number');\n\n  var isDate = tagTester('Date');\n\n  var isRegExp = tagTester('RegExp');\n\n  var isError = tagTester('Error');\n\n  var isSymbol = tagTester('Symbol');\n\n  var isArrayBuffer = tagTester('ArrayBuffer');\n\n  var isFunction = tagTester('Function');\n\n  // Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old\n  // v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\n  var nodelist = root.document && root.document.childNodes;\n  if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n    isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  var isFunction$1 = isFunction;\n\n  var hasObjectTag = tagTester('Object');\n\n  // In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.\n  // In IE 11, the most common among them, this problem also applies to\n  // `Map`, `WeakMap` and `Set`.\n  // Also, there are cases where an application can override the native\n  // `DataView` object, in cases like that we can't use the constructor\n  // safely and should just rely on alternate `DataView` checks\n  var hasDataViewBug = (\n        supportsDataView && (!/\\[native code\\]/.test(String(DataView)) || hasObjectTag(new DataView(new ArrayBuffer(8))))\n      ),\n      isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));\n\n  var isDataView = tagTester('DataView');\n\n  // In IE 10 - Edge 13, we need a different heuristic\n  // to determine whether an object is a `DataView`.\n  // Also, in cases where the native `DataView` is\n  // overridden we can't rely on the tag itself.\n  function alternateIsDataView(obj) {\n    return obj != null && isFunction$1(obj.getInt8) && isArrayBuffer(obj.buffer);\n  }\n\n  var isDataView$1 = (hasDataViewBug ? alternateIsDataView : isDataView);\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native `Array.isArray`.\n  var isArray = nativeIsArray || tagTester('Array');\n\n  // Internal function to check whether `key` is an own property name of `obj`.\n  function has$1(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  }\n\n  var isArguments = tagTester('Arguments');\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  (function() {\n    if (!isArguments(arguments)) {\n      isArguments = function(obj) {\n        return has$1(obj, 'callee');\n      };\n    }\n  }());\n\n  var isArguments$1 = isArguments;\n\n  // Is a given object a finite number?\n  function isFinite$1(obj) {\n    return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));\n  }\n\n  // Is the given value `NaN`?\n  function isNaN$1(obj) {\n    return isNumber(obj) && _isNaN(obj);\n  }\n\n  // Predicate-generating function. Often useful outside of Underscore.\n  function constant(value) {\n    return function() {\n      return value;\n    };\n  }\n\n  // Common internal logic for `isArrayLike` and `isBufferLike`.\n  function createSizePropertyCheck(getSizeProperty) {\n    return function(collection) {\n      var sizeProperty = getSizeProperty(collection);\n      return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;\n    }\n  }\n\n  // Internal helper to generate a function to obtain property `key` from `obj`.\n  function shallowProperty(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  }\n\n  // Internal helper to obtain the `byteLength` property of an object.\n  var getByteLength = shallowProperty('byteLength');\n\n  // Internal helper to determine whether we should spend extensive checks against\n  // `ArrayBuffer` et al.\n  var isBufferLike = createSizePropertyCheck(getByteLength);\n\n  // Is a given value a typed array?\n  var typedArrayPattern = /\\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\\]/;\n  function isTypedArray(obj) {\n    // `ArrayBuffer.isView` is the most future-proof, so use it when available.\n    // Otherwise, fall back on the above regular expression.\n    return nativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) :\n                  isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));\n  }\n\n  var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false);\n\n  // Internal helper to obtain the `length` property of an object.\n  var getLength = shallowProperty('length');\n\n  // Internal helper to create a simple lookup structure.\n  // `collectNonEnumProps` used to depend on `_.contains`, but this led to\n  // circular imports. `emulatedSet` is a one-off solution that only works for\n  // arrays of strings.\n  function emulatedSet(keys) {\n    var hash = {};\n    for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;\n    return {\n      contains: function(key) { return hash[key] === true; },\n      push: function(key) {\n        hash[key] = true;\n        return keys.push(key);\n      }\n    };\n  }\n\n  // Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't\n  // be iterated by `for key in ...` and thus missed. Extends `keys` in place if\n  // needed.\n  function collectNonEnumProps(obj, keys) {\n    keys = emulatedSet(keys);\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (isFunction$1(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (has$1(obj, prop) && !keys.contains(prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`.\n  function keys(obj) {\n    if (!isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (has$1(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  }\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  function isEmpty(obj) {\n    if (obj == null) return true;\n    // Skip the more expensive `toString`-based type checks if `obj` has no\n    // `.length`.\n    var length = getLength(obj);\n    if (typeof length == 'number' && (\n      isArray(obj) || isString(obj) || isArguments$1(obj)\n    )) return length === 0;\n    return getLength(keys(obj)) === 0;\n  }\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  function isMatch(object, attrs) {\n    var _keys = keys(attrs), length = _keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = _keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  }\n\n  // If Underscore is called as a function, it returns a wrapped object that can\n  // be used OO-style. This wrapper holds altered versions of all functions added\n  // through `_.mixin`. Wrapped objects may be chained.\n  function _$1(obj) {\n    if (obj instanceof _$1) return obj;\n    if (!(this instanceof _$1)) return new _$1(obj);\n    this._wrapped = obj;\n  }\n\n  _$1.VERSION = VERSION;\n\n  // Extracts the result from a wrapped and chained object.\n  _$1.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxies for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _$1.prototype.valueOf = _$1.prototype.toJSON = _$1.prototype.value;\n\n  _$1.prototype.toString = function() {\n    return String(this._wrapped);\n  };\n\n  // Internal function to wrap or shallow-copy an ArrayBuffer,\n  // typed array or DataView to a new view, reusing the buffer.\n  function toBufferView(bufferSource) {\n    return new Uint8Array(\n      bufferSource.buffer || bufferSource,\n      bufferSource.byteOffset || 0,\n      getByteLength(bufferSource)\n    );\n  }\n\n  // We use this string twice, so give it a name for minification.\n  var tagDataView = '[object DataView]';\n\n  // Perform a deep comparison to check if two objects are equal.\n  function isEqual(a, b) {\n    var todo = [{a: a, b: b}];\n    // Initializing stacks of traversed objects for cycle detection.\n    var aStack = [], bStack = [];\n\n    while (todo.length) {\n      var frame = todo.pop();\n      if (frame === true) {\n        // Remove the first object from the stack of traversed objects.\n        aStack.pop();\n        bStack.pop();\n        continue;\n      }\n      a = frame.a;\n      b = frame.b;\n\n      // Identical objects are equal. `0 === -0`, but they aren't identical.\n      // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).\n      if (a === b) {\n        if (a !== 0 || 1 / a === 1 / b) continue;\n        return false;\n      }\n      // `null` or `undefined` only equal to itself (strict comparison).\n      if (a == null || b == null) return false;\n      // `NaN`s are equivalent, but non-reflexive.\n      if (a !== a) {\n        if (b !== b) continue;\n        return false;\n      }\n      // Exhaust primitive checks\n      var type = typeof a;\n      if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n\n  // Internal recursive comparison function for `_.isEqual`.\n      // Unwrap any wrapped objects.\n      if (a instanceof _$1) a = a._wrapped;\n      if (b instanceof _$1) b = b._wrapped;\n      // Compare `[[Class]]` names.\n      var className = toString.call(a);\n      if (className !== toString.call(b)) return false;\n      // Work around a bug in IE 10 - Edge 13.\n      if (hasDataViewBug && className == '[object Object]' && isDataView$1(a)) {\n        if (!isDataView$1(b)) return false;\n        className = tagDataView;\n      }\n      switch (className) {\n        // These types are compared by value.\n      case '[object RegExp]':\n        // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        if ('' + a === '' + b) continue;\n        return false;\n      case '[object Number]':\n        todo.push({a: +a, b: +b});\n        continue;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        if (+a === +b) continue;\n        return false;\n      case '[object Symbol]':\n        if (SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b)) continue;\n        return false;\n      case '[object ArrayBuffer]':\n      case tagDataView:\n        // Coerce to typed array so we can fall through.\n        todo.push({a: toBufferView(a), b: toBufferView(b)});\n        continue;\n      }\n\n      var areArrays = className === '[object Array]';\n      if (!areArrays && isTypedArray$1(a)) {\n        var byteLength = getByteLength(a);\n        if (byteLength !== getByteLength(b)) return false;\n        if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) continue;\n        areArrays = true;\n      }\n      if (!areArrays) {\n        if (typeof a != 'object' || typeof b != 'object') return false;\n\n        // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n        // from different frames are.\n        var aCtor = a.constructor, bCtor = b.constructor;\n        if (aCtor !== bCtor && !(isFunction$1(aCtor) && aCtor instanceof aCtor &&\n                                 isFunction$1(bCtor) && bCtor instanceof bCtor)\n            && ('constructor' in a && 'constructor' in b)) {\n          return false;\n        }\n      }\n\n      // Assume equality for cyclic structures. The algorithm for detecting cyclic\n      // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n      var length = aStack.length;\n      while (length--) {\n        // Linear search. Performance is inversely proportional to the number of\n        // unique nested structures.\n        if (aStack[length] === a) {\n          if (bStack[length] === b) break;\n          return false;\n        }\n      }\n      if (length >= 0) continue;\n\n      // Add the first object to the stack of traversed objects.\n      aStack.push(a);\n      bStack.push(b);\n      todo.push(true);\n\n      // Recursively compare objects and arrays.\n      if (areArrays) {\n        // Compare array lengths to determine if a deep comparison is necessary.\n        length = a.length;\n        if (length !== b.length) return false;\n        // Deep compare the contents, ignoring non-numeric properties.\n        while (length--) {\n          todo.push({a: a[length], b: b[length]});\n        }\n      } else {\n        // Deep compare objects.\n        var _keys = keys(a), key;\n        length = _keys.length;\n        // Ensure that both objects contain the same number of properties before comparing deep equality.\n        if (keys(b).length !== length) return false;\n        while (length--) {\n          // Deep compare each member\n          key = _keys[length];\n          if (!has$1(b, key)) return false;\n          todo.push({a: a[key], b: b[key]});\n        }\n      }\n    }\n    return true;\n  }\n\n  // Retrieve all the enumerable property names of an object.\n  function allKeys(obj) {\n    if (!isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  }\n\n  // Since the regular `Object.prototype.toString` type tests don't work for\n  // some types in IE 11, we use a fingerprinting heuristic instead, based\n  // on the methods. It's not great, but it's the best we got.\n  // The fingerprint method lists are defined below.\n  function ie11fingerprint(methods) {\n    var length = getLength(methods);\n    return function(obj) {\n      if (obj == null) return false;\n      // `Map`, `WeakMap` and `Set` have no enumerable keys.\n      var keys = allKeys(obj);\n      if (getLength(keys)) return false;\n      for (var i = 0; i < length; i++) {\n        if (!isFunction$1(obj[methods[i]])) return false;\n      }\n      // If we are testing against `WeakMap`, we need to ensure that\n      // `obj` doesn't have a `forEach` method in order to distinguish\n      // it from a regular `Map`.\n      return methods !== weakMapMethods || !isFunction$1(obj[forEachName]);\n    };\n  }\n\n  // In the interest of compact minification, we write\n  // each string in the fingerprints only once.\n  var forEachName = 'forEach',\n      hasName = 'has',\n      commonInit = ['clear', 'delete'],\n      mapTail = ['get', hasName, 'set'];\n\n  // `Map`, `WeakMap` and `Set` each have slightly different\n  // combinations of the above sublists.\n  var mapMethods = commonInit.concat(forEachName, mapTail),\n      weakMapMethods = commonInit.concat(mapTail),\n      setMethods = ['add'].concat(commonInit, forEachName, hasName);\n\n  var isMap = isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');\n\n  var isWeakMap = isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');\n\n  var isSet = isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');\n\n  var isWeakSet = tagTester('WeakSet');\n\n  // Retrieve the values of an object's properties.\n  function values(obj) {\n    var _keys = keys(obj);\n    var length = _keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[_keys[i]];\n    }\n    return values;\n  }\n\n  // Convert an object into a list of `[key, value]` pairs.\n  // The opposite of `_.object` with one argument.\n  function pairs(obj) {\n    var _keys = keys(obj);\n    var length = _keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [_keys[i], obj[_keys[i]]];\n    }\n    return pairs;\n  }\n\n  // Invert the keys and values of an object. The values must be serializable.\n  function invert(obj) {\n    var result = {};\n    var _keys = keys(obj);\n    for (var i = 0, length = _keys.length; i < length; i++) {\n      result[obj[_keys[i]]] = _keys[i];\n    }\n    return result;\n  }\n\n  // Return a sorted list of the function names available on the object.\n  function functions(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (isFunction$1(obj[key])) names.push(key);\n    }\n    return names.sort();\n  }\n\n  // An internal function for creating assigner functions.\n  function createAssigner(keysFunc, defaults) {\n    return function(obj) {\n      var length = arguments.length;\n      if (defaults) obj = Object(obj);\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!defaults || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  }\n\n  // Extend a given object with all the properties in passed-in object(s).\n  var extend = createAssigner(allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in\n  // object(s).\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  var extendOwn = createAssigner(keys);\n\n  // Fill in a given object with default properties.\n  var defaults = createAssigner(allKeys, true);\n\n  // Create a naked function reference for surrogate-prototype-swapping.\n  function ctor() {\n    return function(){};\n  }\n\n  // An internal function for creating a new object that inherits from another.\n  function baseCreate(prototype) {\n    if (!isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    var Ctor = ctor();\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  }\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  function create(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) extendOwn(result, props);\n    return result;\n  }\n\n  // Create a (shallow-cloned) duplicate of an object.\n  function clone(obj) {\n    if (!isObject(obj)) return obj;\n    return isArray(obj) ? obj.slice() : extend({}, obj);\n  }\n\n  // Invokes `interceptor` with the `obj` and then returns `obj`.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  function tap(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  }\n\n  // Normalize a (deep) property `path` to array.\n  // Like `_.iteratee`, this function can be customized.\n  function toPath$1(path) {\n    return isArray(path) ? path : [path];\n  }\n  _$1.toPath = toPath$1;\n\n  // Internal wrapper for `_.toPath` to enable minification.\n  // Similar to `cb` for `_.iteratee`.\n  function toPath(path) {\n    return _$1.toPath(path);\n  }\n\n  // Internal function to obtain a nested property in `obj` along `path`.\n  function deepGet(obj, path) {\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      if (obj == null) return void 0;\n      obj = obj[path[i]];\n    }\n    return length ? obj : void 0;\n  }\n\n  // Get the value of the (deep) property on `path` from `object`.\n  // If any property in `path` does not exist or if the value is\n  // `undefined`, return `defaultValue` instead.\n  // The `path` is normalized through `_.toPath`.\n  function get(object, path, defaultValue) {\n    var value = deepGet(object, toPath(path));\n    return isUndefined(value) ? defaultValue : value;\n  }\n\n  // Shortcut function for checking if an object has a given property directly on\n  // itself (in other words, not on a prototype). Unlike the internal `has`\n  // function, this public version can also traverse nested properties.\n  function has(obj, path) {\n    path = toPath(path);\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      var key = path[i];\n      if (!has$1(obj, key)) return false;\n      obj = obj[key];\n    }\n    return !!length;\n  }\n\n  // Keep the identity function around for default iteratees.\n  function identity(value) {\n    return value;\n  }\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  function matcher(attrs) {\n    attrs = extendOwn({}, attrs);\n    return function(obj) {\n      return isMatch(obj, attrs);\n    };\n  }\n\n  // Creates a function that, when passed an object, will traverse that object’s\n  // properties down the given `path`, specified as an array of keys or indices.\n  function property(path) {\n    path = toPath(path);\n    return function(obj) {\n      return deepGet(obj, path);\n    };\n  }\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  function optimizeCb(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      // The 2-argument case is omitted because we’re not using it.\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  }\n\n  // An internal function to generate callbacks that can be applied to each\n  // element in a collection, returning the desired result — either `_.identity`,\n  // an arbitrary callback, a property matcher, or a property accessor.\n  function baseIteratee(value, context, argCount) {\n    if (value == null) return identity;\n    if (isFunction$1(value)) return optimizeCb(value, context, argCount);\n    if (isObject(value) && !isArray(value)) return matcher(value);\n    return property(value);\n  }\n\n  // External wrapper for our callback generator. Users may customize\n  // `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n  // This abstraction hides the internal-only `argCount` argument.\n  function iteratee(value, context) {\n    return baseIteratee(value, context, Infinity);\n  }\n  _$1.iteratee = iteratee;\n\n  // The function we call internally to generate a callback. It invokes\n  // `_.iteratee` if overridden, otherwise `baseIteratee`.\n  function cb(value, context, argCount) {\n    if (_$1.iteratee !== iteratee) return _$1.iteratee(value, context);\n    return baseIteratee(value, context, argCount);\n  }\n\n  // Returns the results of applying the `iteratee` to each element of `obj`.\n  // In contrast to `_.map` it returns an object.\n  function mapObject(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var _keys = keys(obj),\n        length = _keys.length,\n        results = {};\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys[index];\n      results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  }\n\n  // Predicate-generating function. Often useful outside of Underscore.\n  function noop(){}\n\n  // Generates a function for a given object that returns a given property.\n  function propertyOf(obj) {\n    if (obj == null) return noop;\n    return function(path) {\n      return get(obj, path);\n    };\n  }\n\n  // Run a function **n** times.\n  function times(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  }\n\n  // Return a random integer between `min` and `max` (inclusive).\n  function random(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  }\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  var now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n  // Internal helper to generate functions for escaping and unescaping strings\n  // to/from HTML interpolation.\n  function createEscaper(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped.\n    var source = '(?:' + keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  }\n\n  // Internal list of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n\n  // Function for escaping strings to HTML interpolation.\n  var _escape = createEscaper(escapeMap);\n\n  // Internal list of HTML entities for unescaping.\n  var unescapeMap = invert(escapeMap);\n\n  // Function for unescaping strings from HTML interpolation.\n  var _unescape = createEscaper(unescapeMap);\n\n  // By default, Underscore uses ERB-style template delimiters. Change the\n  // following template settings to use alternative delimiters.\n  var templateSettings = _$1.templateSettings = {\n    evaluate: /<%([\\s\\S]+?)%>/g,\n    interpolate: /<%=([\\s\\S]+?)%>/g,\n    escape: /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `_.templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\": \"'\",\n    '\\\\': '\\\\',\n    '\\r': 'r',\n    '\\n': 'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  function escapeChar(match) {\n    return '\\\\' + escapes[match];\n  }\n\n  // In order to prevent third-party code injection through\n  // `_.templateSettings.variable`, we test it against the following regular\n  // expression. It is intentionally a bit more liberal than just matching valid\n  // identifiers, but still prevents possible loopholes through defaults or\n  // destructuring assignment.\n  var bareIdentifier = /^\\s*(\\w|\\$)+\\s*$/;\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  function template(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = defaults({}, settings, _$1.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offset.\n      return match;\n    });\n    source += \"';\\n\";\n\n    var argument = settings.variable;\n    if (argument) {\n      // Insure against third-party code injection. (CVE-2021-23358)\n      if (!bareIdentifier.test(argument)) throw new Error(\n        'variable is not a bare identifier: ' + argument\n      );\n    } else {\n      // If a variable is not specified, place data values in local scope.\n      source = 'with(obj||{}){\\n' + source + '}\\n';\n      argument = 'obj';\n    }\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    var render;\n    try {\n      render = new Function(argument, '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _$1);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  }\n\n  // Traverses the children of `obj` along `path`. If a child is a function, it\n  // is invoked with its parent as context. Returns the value of the final\n  // child, or `fallback` if any child is undefined.\n  function result(obj, path, fallback) {\n    path = toPath(path);\n    var length = path.length;\n    if (!length) {\n      return isFunction$1(fallback) ? fallback.call(obj) : fallback;\n    }\n    for (var i = 0; i < length; i++) {\n      var prop = obj == null ? void 0 : obj[path[i]];\n      if (prop === void 0) {\n        prop = fallback;\n        i = length; // Ensure we don't continue iterating.\n      }\n      obj = isFunction$1(prop) ? prop.call(obj) : prop;\n    }\n    return obj;\n  }\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  function uniqueId(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  }\n\n  // Start chaining a wrapped Underscore object.\n  function chain(obj) {\n    var instance = _$1(obj);\n    instance._chain = true;\n    return instance;\n  }\n\n  // Internal function to execute `sourceFunc` bound to `context` with optional\n  // `args`. Determines whether to execute a function as a constructor or as a\n  // normal function.\n  function executeBound(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (isObject(result)) return result;\n    return self;\n  }\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. `_` acts\n  // as a placeholder by default, allowing any combination of arguments to be\n  // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\n  var partial = restArguments(function(func, boundArgs) {\n    var placeholder = partial.placeholder;\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  });\n\n  partial.placeholder = _$1;\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally).\n  var bind = restArguments(function(func, context, args) {\n    if (!isFunction$1(func)) throw new TypeError('Bind must be called on a function');\n    var bound = restArguments(function(callArgs) {\n      return executeBound(func, bound, context, this, args.concat(callArgs));\n    });\n    return bound;\n  });\n\n  // Internal helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object.\n  // Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var isArrayLike = createSizePropertyCheck(getLength);\n\n  // Internal implementation of a recursive `flatten` function.\n  function flatten$1(input, depth, strict) {\n    if (!depth && depth !== 0) depth = Infinity;\n    var output = [], idx = 0, i = 0, length = getLength(input) || 0, stack = [];\n    while (true) {\n      if (i >= length) {\n        if (!stack.length) break;\n        var frame = stack.pop();\n        i = frame.i;\n        input = frame.v;\n        length = getLength(input);\n        continue;\n      }\n      var value = input[i++];\n      if (stack.length >= depth) {\n        output[idx++] = value;\n      } else if (isArrayLike(value) && (isArray(value) || isArguments$1(value))) {\n        // Flatten current level of array or arguments object.\n        stack.push({i: i, v: input});\n        i = 0;\n        input = value;\n        length = getLength(input);\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  }\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  var bindAll = restArguments(function(obj, keys) {\n    keys = flatten$1(keys, false, false);\n    var index = keys.length;\n    if (index < 1) throw new Error('bindAll must be passed function names');\n    while (index--) {\n      var key = keys[index];\n      obj[key] = bind(obj[key], obj);\n    }\n    return obj;\n  });\n\n  // Memoize an expensive function by storing its results.\n  function memoize(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!has$1(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  }\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  var delay = restArguments(function(func, wait, args) {\n    return setTimeout(function() {\n      return func.apply(null, args);\n    }, wait);\n  });\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  var defer = partial(delay, _$1, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  function throttle(func, wait, options) {\n    var timeout, context, args, result;\n    var previous = 0;\n    if (!options) options = {};\n\n    var later = function() {\n      previous = options.leading === false ? 0 : now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n\n    var throttled = function() {\n      var _now = now();\n      if (!previous && options.leading === false) previous = _now;\n      var remaining = wait - (_now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = _now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n\n    throttled.cancel = function() {\n      clearTimeout(timeout);\n      previous = 0;\n      timeout = context = args = null;\n    };\n\n    return throttled;\n  }\n\n  // When a sequence of calls of the returned function ends, the argument\n  // function is triggered. The end of a sequence is defined by the `wait`\n  // parameter. If `immediate` is passed, the argument function will be\n  // triggered at the beginning of the sequence instead of at the end.\n  function debounce(func, wait, immediate) {\n    var timeout, previous, args, result, context;\n\n    var later = function() {\n      var passed = now() - previous;\n      if (wait > passed) {\n        timeout = setTimeout(later, wait - passed);\n      } else {\n        timeout = null;\n        if (!immediate) result = func.apply(context, args);\n        // This check is needed because `func` can recursively invoke `debounced`.\n        if (!timeout) args = context = null;\n      }\n    };\n\n    var debounced = restArguments(function(_args) {\n      context = this;\n      args = _args;\n      previous = now();\n      if (!timeout) {\n        timeout = setTimeout(later, wait);\n        if (immediate) result = func.apply(context, args);\n      }\n      return result;\n    });\n\n    debounced.cancel = function() {\n      clearTimeout(timeout);\n      timeout = args = context = null;\n    };\n\n    return debounced;\n  }\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  function wrap(func, wrapper) {\n    return partial(wrapper, func);\n  }\n\n  // Returns a negated version of the passed-in predicate.\n  function negate(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  }\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  function compose() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  }\n\n  // Returns a function that will only be executed on and after the Nth call.\n  function after(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  }\n\n  // Returns a function that will only be executed up to (but not including) the\n  // Nth call.\n  function before(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  }\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  var once = partial(before, 2);\n\n  // Returns the first key on an object that passes a truth test.\n  function findKey(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = keys(obj), key;\n    for (var i = 0, length = _keys.length; i < length; i++) {\n      key = _keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  }\n\n  // Internal function to generate `_.findIndex` and `_.findLastIndex`.\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a truth test.\n  var findIndex = createPredicateIndexFinder(1);\n\n  // Returns the last index on an array-like that passes a truth test.\n  var findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  function sortedIndex(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  }\n\n  // Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n          i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n          length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), isNaN$1);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  var indexOf = createIndexFinder(1, findIndex, sortedIndex);\n\n  // Return the position of the last occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  var lastIndexOf = createIndexFinder(-1, findLastIndex);\n\n  // Return the first value which passes a truth test.\n  function find(obj, predicate, context) {\n    var keyFinder = isArrayLike(obj) ? findIndex : findKey;\n    var key = keyFinder(obj, predicate, context);\n    if (key !== void 0 && key !== -1) return obj[key];\n  }\n\n  // Convenience version of a common use case of `_.find`: getting the first\n  // object containing specific `key:value` pairs.\n  function findWhere(obj, attrs) {\n    return find(obj, matcher(attrs));\n  }\n\n  // The cornerstone for collection functions, an `each`\n  // implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  function each(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var _keys = keys(obj);\n      for (i = 0, length = _keys.length; i < length; i++) {\n        iteratee(obj[_keys[i]], _keys[i], obj);\n      }\n    }\n    return obj;\n  }\n\n  // Return the results of applying the iteratee to each element.\n  function map(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  }\n\n  // Internal helper to create a reducing function, iterating left or right.\n  function createReduce(dir) {\n    // Wrap code that reassigns argument variables in a separate function than\n    // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n    var reducer = function(obj, iteratee, memo, initial) {\n      var _keys = !isArrayLike(obj) && keys(obj),\n          length = (_keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      if (!initial) {\n        memo = obj[_keys ? _keys[index] : index];\n        index += dir;\n      }\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = _keys ? _keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    };\n\n    return function(obj, iteratee, memo, context) {\n      var initial = arguments.length >= 3;\n      return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  var reduce = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  var reduceRight = createReduce(-1);\n\n  // Return all the elements that pass a truth test.\n  function filter(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  }\n\n  // Return all the elements for which a truth test fails.\n  function reject(obj, predicate, context) {\n    return filter(obj, negate(cb(predicate)), context);\n  }\n\n  // Determine whether all of the elements pass a truth test.\n  function every(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  }\n\n  // Determine if at least one element in the object passes a truth test.\n  function some(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  }\n\n  // Determine if the array or object contains a given item (using `===`).\n  function contains(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return indexOf(obj, item, fromIndex) >= 0;\n  }\n\n  // Invoke a method (with arguments) on every item in a collection.\n  var invoke = restArguments(function(obj, path, args) {\n    var contextPath, func;\n    if (isFunction$1(path)) {\n      func = path;\n    } else {\n      path = toPath(path);\n      contextPath = path.slice(0, -1);\n      path = path[path.length - 1];\n    }\n    return map(obj, function(context) {\n      var method = func;\n      if (!method) {\n        if (contextPath && contextPath.length) {\n          context = deepGet(context, contextPath);\n        }\n        if (context == null) return void 0;\n        method = context[path];\n      }\n      return method == null ? method : method.apply(context, args);\n    });\n  });\n\n  // Convenience version of a common use case of `_.map`: fetching a property.\n  function pluck(obj, key) {\n    return map(obj, property(key));\n  }\n\n  // Convenience version of a common use case of `_.filter`: selecting only\n  // objects containing specific `key:value` pairs.\n  function where(obj, attrs) {\n    return filter(obj, matcher(attrs));\n  }\n\n  // Return the maximum element (or element-based computation).\n  function max(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n      obj = isArrayLike(obj) ? obj : values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  }\n\n  // Return the minimum element (or element-based computation).\n  function min(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n      obj = isArrayLike(obj) ? obj : values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed < lastComputed || (computed === Infinity && result === Infinity)) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  }\n\n  // Safely create a real, live array from anything iterable.\n  var reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\n  function toArray(obj) {\n    if (!obj) return [];\n    if (isArray(obj)) return slice.call(obj);\n    if (isString(obj)) {\n      // Keep surrogate pair characters together.\n      return obj.match(reStrSymbol);\n    }\n    if (isArrayLike(obj)) return map(obj, identity);\n    return values(obj);\n  }\n\n  // Sample **n** random values from a collection using the modern version of the\n  // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `_.map`.\n  function sample(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = values(obj);\n      return obj[random(obj.length - 1)];\n    }\n    var sample = toArray(obj);\n    var length = getLength(sample);\n    n = Math.max(Math.min(n, length), 0);\n    var last = length - 1;\n    for (var index = 0; index < n; index++) {\n      var rand = random(index, last);\n      var temp = sample[index];\n      sample[index] = sample[rand];\n      sample[rand] = temp;\n    }\n    return sample.slice(0, n);\n  }\n\n  // Shuffle a collection.\n  function shuffle(obj) {\n    return sample(obj, Infinity);\n  }\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  function sortBy(obj, iteratee, context) {\n    var index = 0;\n    iteratee = cb(iteratee, context);\n    return pluck(map(obj, function(value, key, list) {\n      return {\n        value: value,\n        index: index++,\n        criteria: iteratee(value, key, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  }\n\n  // An internal function used for aggregate \"group by\" operations.\n  function group(behavior, partition) {\n    return function(obj, iteratee, context) {\n      var result = partition ? [[], []] : {};\n      iteratee = cb(iteratee, context);\n      each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  }\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  var groupBy = group(function(result, value, key) {\n    if (has$1(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `_.groupBy`, but for\n  // when you know that your index values will be unique.\n  var indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  var countBy = group(function(result, value, key) {\n    if (has$1(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Split a collection into two arrays: one whose elements all pass the given\n  // truth test, and one whose elements all do not pass the truth test.\n  var partition = group(function(result, value, pass) {\n    result[pass ? 0 : 1].push(value);\n  }, true);\n\n  // Return the number of elements in a collection.\n  function size(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : keys(obj).length;\n  }\n\n  // Internal `_.pick` helper function to determine whether `key` is an enumerable\n  // property name of `obj`.\n  function keyInObj(value, key, obj) {\n    return key in obj;\n  }\n\n  // Return a copy of the object only containing the allowed properties.\n  var pick = restArguments(function(obj, keys) {\n    var result = {}, iteratee = keys[0];\n    if (obj == null) return result;\n    if (isFunction$1(iteratee)) {\n      if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n      keys = allKeys(obj);\n    } else {\n      iteratee = keyInObj;\n      keys = flatten$1(keys, false, false);\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  });\n\n  // Return a copy of the object without the disallowed properties.\n  var omit = restArguments(function(obj, keys) {\n    var iteratee = keys[0], context;\n    if (isFunction$1(iteratee)) {\n      iteratee = negate(iteratee);\n      if (keys.length > 1) context = keys[1];\n    } else {\n      keys = map(flatten$1(keys, false, false), String);\n      iteratee = function(value, key) {\n        return !contains(keys, key);\n      };\n    }\n    return pick(obj, iteratee, context);\n  });\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  function initial(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  }\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. The **guard** check allows it to work with `_.map`.\n  function first(array, n, guard) {\n    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n    if (n == null || guard) return array[0];\n    return initial(array, array.length - n);\n  }\n\n  // Returns everything but the first entry of the `array`. Especially useful on\n  // the `arguments` object. Passing an **n** will return the rest N values in the\n  // `array`.\n  function rest(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  }\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  function last(array, n, guard) {\n    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n    if (n == null || guard) return array[array.length - 1];\n    return rest(array, Math.max(0, array.length - n));\n  }\n\n  // Trim out all falsy values from an array.\n  function compact(array) {\n    return filter(array, Boolean);\n  }\n\n  // Flatten out an array, either recursively (by default), or up to `depth`.\n  // Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.\n  function flatten(array, depth) {\n    return flatten$1(array, depth, false);\n  }\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  var difference = restArguments(function(array, rest) {\n    rest = flatten$1(rest, true, true);\n    return filter(array, function(value){\n      return !contains(rest, value);\n    });\n  });\n\n  // Return a version of the array that does not contain the specified value(s).\n  var without = restArguments(function(array, otherArrays) {\n    return difference(array, otherArrays);\n  });\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // The faster algorithm will not work with an iteratee if the iteratee\n  // is not a one-to-one function, so providing an iteratee will disable\n  // the faster algorithm.\n  function uniq(array, isSorted, iteratee, context) {\n    if (!isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted && !iteratee) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  }\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  var union = restArguments(function(arrays) {\n    return uniq(flatten$1(arrays, true, true));\n  });\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  function intersection(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (contains(result, item)) continue;\n      var j;\n      for (j = 1; j < argsLength; j++) {\n        if (!contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  }\n\n  // Complement of zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices.\n  function unzip(array) {\n    var length = (array && max(array, getLength).length) || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = pluck(array, index);\n    }\n    return result;\n  }\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  var zip = restArguments(unzip);\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values. Passing by pairs is the reverse of `_.pairs`.\n  function object(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  }\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](https://docs.python.org/library/functions.html#range).\n  function range(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    if (!step) {\n      step = stop < start ? -1 : 1;\n    }\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  }\n\n  // Chunk a single array into multiple arrays, each containing `count` or fewer\n  // items.\n  function chunk(array, count) {\n    if (count == null || count < 1) return [];\n    var result = [];\n    var i = 0, length = array.length;\n    while (i < length) {\n      result.push(slice.call(array, i, i += count));\n    }\n    return result;\n  }\n\n  // Helper function to continue chaining intermediate results.\n  function chainResult(instance, obj) {\n    return instance._chain ? _$1(obj).chain() : obj;\n  }\n\n  // Add your own custom functions to the Underscore object.\n  function mixin(obj) {\n    each(functions(obj), function(name) {\n      var func = _$1[name] = obj[name];\n      _$1.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return chainResult(this, func.apply(_$1, args));\n      };\n    });\n    return _$1;\n  }\n\n  // Add all mutator `Array` functions to the wrapper.\n  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _$1.prototype[name] = function() {\n      var obj = this._wrapped;\n      if (obj != null) {\n        method.apply(obj, arguments);\n        if ((name === 'shift' || name === 'splice') && obj.length === 0) {\n          delete obj[0];\n        }\n      }\n      return chainResult(this, obj);\n    };\n  });\n\n  // Add all accessor `Array` functions to the wrapper.\n  each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _$1.prototype[name] = function() {\n      var obj = this._wrapped;\n      if (obj != null) obj = method.apply(obj, arguments);\n      return chainResult(this, obj);\n    };\n  });\n\n  // Named Exports\n\n  var allExports = {\n    __proto__: null,\n    VERSION: VERSION,\n    restArguments: restArguments,\n    isObject: isObject,\n    isNull: isNull,\n    isUndefined: isUndefined,\n    isBoolean: isBoolean,\n    isElement: isElement,\n    isString: isString,\n    isNumber: isNumber,\n    isDate: isDate,\n    isRegExp: isRegExp,\n    isError: isError,\n    isSymbol: isSymbol,\n    isArrayBuffer: isArrayBuffer,\n    isDataView: isDataView$1,\n    isArray: isArray,\n    isFunction: isFunction$1,\n    isArguments: isArguments$1,\n    isFinite: isFinite$1,\n    isNaN: isNaN$1,\n    isTypedArray: isTypedArray$1,\n    isEmpty: isEmpty,\n    isMatch: isMatch,\n    isEqual: isEqual,\n    isMap: isMap,\n    isWeakMap: isWeakMap,\n    isSet: isSet,\n    isWeakSet: isWeakSet,\n    keys: keys,\n    allKeys: allKeys,\n    values: values,\n    pairs: pairs,\n    invert: invert,\n    functions: functions,\n    methods: functions,\n    extend: extend,\n    extendOwn: extendOwn,\n    assign: extendOwn,\n    defaults: defaults,\n    create: create,\n    clone: clone,\n    tap: tap,\n    get: get,\n    has: has,\n    mapObject: mapObject,\n    identity: identity,\n    constant: constant,\n    noop: noop,\n    toPath: toPath$1,\n    property: property,\n    propertyOf: propertyOf,\n    matcher: matcher,\n    matches: matcher,\n    times: times,\n    random: random,\n    now: now,\n    escape: _escape,\n    unescape: _unescape,\n    templateSettings: templateSettings,\n    template: template,\n    result: result,\n    uniqueId: uniqueId,\n    chain: chain,\n    iteratee: iteratee,\n    partial: partial,\n    bind: bind,\n    bindAll: bindAll,\n    memoize: memoize,\n    delay: delay,\n    defer: defer,\n    throttle: throttle,\n    debounce: debounce,\n    wrap: wrap,\n    negate: negate,\n    compose: compose,\n    after: after,\n    before: before,\n    once: once,\n    findKey: findKey,\n    findIndex: findIndex,\n    findLastIndex: findLastIndex,\n    sortedIndex: sortedIndex,\n    indexOf: indexOf,\n    lastIndexOf: lastIndexOf,\n    find: find,\n    detect: find,\n    findWhere: findWhere,\n    each: each,\n    forEach: each,\n    map: map,\n    collect: map,\n    reduce: reduce,\n    foldl: reduce,\n    inject: reduce,\n    reduceRight: reduceRight,\n    foldr: reduceRight,\n    filter: filter,\n    select: filter,\n    reject: reject,\n    every: every,\n    all: every,\n    some: some,\n    any: some,\n    contains: contains,\n    includes: contains,\n    include: contains,\n    invoke: invoke,\n    pluck: pluck,\n    where: where,\n    max: max,\n    min: min,\n    shuffle: shuffle,\n    sample: sample,\n    sortBy: sortBy,\n    groupBy: groupBy,\n    indexBy: indexBy,\n    countBy: countBy,\n    partition: partition,\n    toArray: toArray,\n    size: size,\n    pick: pick,\n    omit: omit,\n    first: first,\n    head: first,\n    take: first,\n    initial: initial,\n    last: last,\n    rest: rest,\n    tail: rest,\n    drop: rest,\n    compact: compact,\n    flatten: flatten,\n    without: without,\n    uniq: uniq,\n    unique: uniq,\n    union: union,\n    intersection: intersection,\n    difference: difference,\n    unzip: unzip,\n    transpose: unzip,\n    zip: zip,\n    object: object,\n    range: range,\n    chunk: chunk,\n    mixin: mixin,\n    'default': _$1\n  };\n\n  // Default Export\n\n  // Add all of the Underscore functions to the wrapper object.\n  var _ = mixin(allExports);\n  // Legacy Node.js API.\n  _._ = _;\n\n  return _;\n\n})));\n//# sourceMappingURL=underscore-umd.js.map\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31)))\n\n/***/ }),\n/* 5 */,\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, process) {\nvar es5 = __webpack_require__(32);\nvar canEvaluate = typeof navigator == \"undefined\";\n\nvar errorObj = {e: {}};\nvar tryCatchTarget;\nvar globalObject = typeof self !== \"undefined\" ? self :\n    typeof window !== \"undefined\" ? window :\n    typeof global !== \"undefined\" ? global :\n    this !== undefined ? this : null;\n\nfunction tryCatcher() {\n    try {\n        var target = tryCatchTarget;\n        tryCatchTarget = null;\n        return target.apply(this, arguments);\n    } catch (e) {\n        errorObj.e = e;\n        return errorObj;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\n\nvar inherits = function(Child, Parent) {\n    var hasProp = {}.hasOwnProperty;\n\n    function T() {\n        this.constructor = Child;\n        this.constructor$ = Parent;\n        for (var propertyName in Parent.prototype) {\n            if (hasProp.call(Parent.prototype, propertyName) &&\n                propertyName.charAt(propertyName.length-1) !== \"$\"\n           ) {\n                this[propertyName + \"$\"] = Parent.prototype[propertyName];\n            }\n        }\n    }\n    T.prototype = Parent.prototype;\n    Child.prototype = new T();\n    return Child.prototype;\n};\n\n\nfunction isPrimitive(val) {\n    return val == null || val === true || val === false ||\n        typeof val === \"string\" || typeof val === \"number\";\n\n}\n\nfunction isObject(value) {\n    return typeof value === \"function\" ||\n           typeof value === \"object\" && value !== null;\n}\n\nfunction maybeWrapAsError(maybeError) {\n    if (!isPrimitive(maybeError)) return maybeError;\n\n    return new Error(safeToString(maybeError));\n}\n\nfunction withAppended(target, appendee) {\n    var len = target.length;\n    var ret = new Array(len + 1);\n    var i;\n    for (i = 0; i < len; ++i) {\n        ret[i] = target[i];\n    }\n    ret[i] = appendee;\n    return ret;\n}\n\nfunction getDataPropertyOrDefault(obj, key, defaultValue) {\n    if (es5.isES5) {\n        var desc = Object.getOwnPropertyDescriptor(obj, key);\n\n        if (desc != null) {\n            return desc.get == null && desc.set == null\n                    ? desc.value\n                    : defaultValue;\n        }\n    } else {\n        return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;\n    }\n}\n\nfunction notEnumerableProp(obj, name, value) {\n    if (isPrimitive(obj)) return obj;\n    var descriptor = {\n        value: value,\n        configurable: true,\n        enumerable: false,\n        writable: true\n    };\n    es5.defineProperty(obj, name, descriptor);\n    return obj;\n}\n\nfunction thrower(r) {\n    throw r;\n}\n\nvar inheritedDataKeys = (function() {\n    var excludedPrototypes = [\n        Array.prototype,\n        Object.prototype,\n        Function.prototype\n    ];\n\n    var isExcludedProto = function(val) {\n        for (var i = 0; i < excludedPrototypes.length; ++i) {\n            if (excludedPrototypes[i] === val) {\n                return true;\n            }\n        }\n        return false;\n    };\n\n    if (es5.isES5) {\n        var getKeys = Object.getOwnPropertyNames;\n        return function(obj) {\n            var ret = [];\n            var visitedKeys = Object.create(null);\n            while (obj != null && !isExcludedProto(obj)) {\n                var keys;\n                try {\n                    keys = getKeys(obj);\n                } catch (e) {\n                    return ret;\n                }\n                for (var i = 0; i < keys.length; ++i) {\n                    var key = keys[i];\n                    if (visitedKeys[key]) continue;\n                    visitedKeys[key] = true;\n                    var desc = Object.getOwnPropertyDescriptor(obj, key);\n                    if (desc != null && desc.get == null && desc.set == null) {\n                        ret.push(key);\n                    }\n                }\n                obj = es5.getPrototypeOf(obj);\n            }\n            return ret;\n        };\n    } else {\n        var hasProp = {}.hasOwnProperty;\n        return function(obj) {\n            if (isExcludedProto(obj)) return [];\n            var ret = [];\n\n            /*jshint forin:false */\n            enumeration: for (var key in obj) {\n                if (hasProp.call(obj, key)) {\n                    ret.push(key);\n                } else {\n                    for (var i = 0; i < excludedPrototypes.length; ++i) {\n                        if (hasProp.call(excludedPrototypes[i], key)) {\n                            continue enumeration;\n                        }\n                    }\n                    ret.push(key);\n                }\n            }\n            return ret;\n        };\n    }\n\n})();\n\nvar thisAssignmentPattern = /this\\s*\\.\\s*\\S+\\s*=/;\nfunction isClass(fn) {\n    try {\n        if (typeof fn === \"function\") {\n            var keys = es5.names(fn.prototype);\n\n            var hasMethods = es5.isES5 && keys.length > 1;\n            var hasMethodsOtherThanConstructor = keys.length > 0 &&\n                !(keys.length === 1 && keys[0] === \"constructor\");\n            var hasThisAssignmentAndStaticMethods =\n                thisAssignmentPattern.test(fn + \"\") && es5.names(fn).length > 0;\n\n            if (hasMethods || hasMethodsOtherThanConstructor ||\n                hasThisAssignmentAndStaticMethods) {\n                return true;\n            }\n        }\n        return false;\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction toFastProperties(obj) {\n    /*jshint -W027,-W055,-W031*/\n    function FakeConstructor() {}\n    FakeConstructor.prototype = obj;\n    var receiver = new FakeConstructor();\n    function ic() {\n        return typeof receiver.foo;\n    }\n    ic();\n    ic();\n    return obj;\n    eval(obj);\n}\n\nvar rident = /^[a-z$_][a-z$_0-9]*$/i;\nfunction isIdentifier(str) {\n    return rident.test(str);\n}\n\nfunction filledRange(count, prefix, suffix) {\n    var ret = new Array(count);\n    for(var i = 0; i < count; ++i) {\n        ret[i] = prefix + i + suffix;\n    }\n    return ret;\n}\n\nfunction safeToString(obj) {\n    try {\n        return obj + \"\";\n    } catch (e) {\n        return \"[no string representation]\";\n    }\n}\n\nfunction isError(obj) {\n    return obj instanceof Error ||\n        (obj !== null &&\n           typeof obj === \"object\" &&\n           typeof obj.message === \"string\" &&\n           typeof obj.name === \"string\");\n}\n\nfunction markAsOriginatingFromRejection(e) {\n    try {\n        notEnumerableProp(e, \"isOperational\", true);\n    }\n    catch(ignore) {}\n}\n\nfunction originatesFromRejection(e) {\n    if (e == null) return false;\n    return ((e instanceof Error[\"__BluebirdErrorTypes__\"].OperationalError) ||\n        e[\"isOperational\"] === true);\n}\n\nfunction canAttachTrace(obj) {\n    return isError(obj) && es5.propertyIsWritable(obj, \"stack\");\n}\n\nvar ensureErrorObject = (function() {\n    if (!(\"stack\" in new Error())) {\n        return function(value) {\n            if (canAttachTrace(value)) return value;\n            try {throw new Error(safeToString(value));}\n            catch(err) {return err;}\n        };\n    } else {\n        return function(value) {\n            if (canAttachTrace(value)) return value;\n            return new Error(safeToString(value));\n        };\n    }\n})();\n\nfunction classString(obj) {\n    return {}.toString.call(obj);\n}\n\nfunction copyDescriptors(from, to, filter) {\n    var keys = es5.names(from);\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        if (filter(key)) {\n            try {\n                es5.defineProperty(to, key, es5.getDescriptor(from, key));\n            } catch (ignore) {}\n        }\n    }\n}\n\nvar asArray = function(v) {\n    if (es5.isArray(v)) {\n        return v;\n    }\n    return null;\n};\n\nif (typeof Symbol !== \"undefined\" && Symbol.iterator) {\n    var ArrayFrom = typeof Array.from === \"function\" ? function(v) {\n        return Array.from(v);\n    } : function(v) {\n        var ret = [];\n        var it = v[Symbol.iterator]();\n        var itResult;\n        while (!((itResult = it.next()).done)) {\n            ret.push(itResult.value);\n        }\n        return ret;\n    };\n\n    asArray = function(v) {\n        if (es5.isArray(v)) {\n            return v;\n        } else if (v != null && typeof v[Symbol.iterator] === \"function\") {\n            return ArrayFrom(v);\n        }\n        return null;\n    };\n}\n\nvar isNode = typeof process !== \"undefined\" &&\n        classString(process).toLowerCase() === \"[object process]\";\n\nvar hasEnvVariables = typeof process !== \"undefined\" &&\n    typeof process.env !== \"undefined\";\n\nfunction env(key) {\n    return hasEnvVariables ? process.env[key] : undefined;\n}\n\nfunction getNativePromise() {\n    if (typeof Promise === \"function\") {\n        try {\n            var promise = new Promise(function(){});\n            if ({}.toString.call(promise) === \"[object Promise]\") {\n                return Promise;\n            }\n        } catch (e) {}\n    }\n}\n\nfunction domainBind(self, cb) {\n    return self.bind(cb);\n}\n\nvar ret = {\n    isClass: isClass,\n    isIdentifier: isIdentifier,\n    inheritedDataKeys: inheritedDataKeys,\n    getDataPropertyOrDefault: getDataPropertyOrDefault,\n    thrower: thrower,\n    isArray: es5.isArray,\n    asArray: asArray,\n    notEnumerableProp: notEnumerableProp,\n    isPrimitive: isPrimitive,\n    isObject: isObject,\n    isError: isError,\n    canEvaluate: canEvaluate,\n    errorObj: errorObj,\n    tryCatch: tryCatch,\n    inherits: inherits,\n    withAppended: withAppended,\n    maybeWrapAsError: maybeWrapAsError,\n    toFastProperties: toFastProperties,\n    filledRange: filledRange,\n    toString: safeToString,\n    canAttachTrace: canAttachTrace,\n    ensureErrorObject: ensureErrorObject,\n    originatesFromRejection: originatesFromRejection,\n    markAsOriginatingFromRejection: markAsOriginatingFromRejection,\n    classString: classString,\n    copyDescriptors: copyDescriptors,\n    hasDevTools: typeof chrome !== \"undefined\" && chrome &&\n                 typeof chrome.loadTimes === \"function\",\n    isNode: isNode,\n    hasEnvVariables: hasEnvVariables,\n    env: env,\n    global: globalObject,\n    getNativePromise: getNativePromise,\n    domainBind: domainBind\n};\nret.isRecentNode = ret.isNode && (function() {\n    var version;\n    if (process.versions && process.versions.node) {    \n        version = process.versions.node.split(\".\").map(Number);\n    } else if (process.version) {\n        version = process.version.split(\".\").map(Number);\n    }\n    return (version[0] === 0 && version[1] > 10) || (version[0] > 0);\n})();\n\nif (ret.isNode) ret.toFastProperties(process);\n\ntry {throw new Error(); } catch (e) {ret.lastLineError = e;}\nmodule.exports = ret;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31), __webpack_require__(25)))\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* globals define, XDomainRequest, EventSource */\n// noinspection JSVoidFunctionReturnValueUsed\n\n\n/**\n * API objects and subclasses\n */\n\nvar appState = window.appState;\n\n/**\n * UMD Loader from https://github.com/umdjs/umd/blob/master/amdWeb.js\n */\n(function (root, factory) {\n\tif (true) {\n\t\t// AMD. Register as an anonymous module.\n\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(4), __webpack_require__(18), __webpack_require__(64), __webpack_require__(27), __webpack_require__(173)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else {\n\t\t// Browser globals\n\t\troot.NamescoRest = factory(root._, root.jQuery, root.Class, root.Deferred);\n\t}\n}(this, function (_, jQuery, Class, Deferred) {\n\t/**\n\t * @typedef {('legacy'|'v2')} DomainEndpointProfile\n\t */\n\n\tvar apiStore = {};\n\tvar useSecureCookies = document.location.protocol === 'https:' ? true : false;\n\n\t// Extend the standard error to expose the http status returned.\n\tvar ApiError = function (message, httpStatus, other) {\n\t\tthis.name = 'ApiError';\n\t\tthis.message = message || 'Unknown Error';\n\t\tthis.httpStatus = httpStatus || 400;\n\t\tthis.stack = (new Error()).stack;\n\n\t\tif (typeof other !== undefined) {\n\t\t\t_.extend(this, other);\n\t\t}\n\t};\n\n\tApiError.prototype = Object.create(Error.prototype);\n\tApiError.prototype.constructor = ApiError;\n\n\t/**\n\t * Base API class extended by each of the API classes.\n\t *\n\t * Provides basic shared functionality.\n\t */\n\tvar Api = Class.extend({\n\n\t\tinitialize: function () {\n\t\t\tthis.lastResponse = null;\n\t\t},\n\n\t\tfetch: function () { throw new ApiError('Not implemented'); },\n\t\tfetchSome: function () { throw new ApiError('Not implemented'); },\n\t\tfetchAll: function () { throw new ApiError('Not implemented'); },\n\t\tcreate: function () { throw new ApiError('Not implemented'); },\n\t\tdestroy: function () { throw new ApiError('Not implemented'); },\n\t\tupdate: function () { throw new ApiError('Not implemented'); },\n\t\tfetchForCustomer: function () { throw new ApiError('Not implemented'); },\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a POST with json content.\n\t\t *\n\t\t * @param {string} url                The URL.\n\t\t * @param {object} data               The data to json encode as the POST content.\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t * @param {string} apiKey             Optional override of the default X-APIKEY value.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupPostParams: function (url, data, withAuthentication, apiKey) {\n\t\t\treturn getClientParams(withAuthentication, apiKey)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\t'url': url,\n\t\t\t\t\t'data': JSON.stringify(data),\n\t\t\t\t\t'processData': false\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a GET.\n\t\t *\n\t\t * @param {string} url                The URL\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupGetParams: function (url, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\ttype: 'GET'\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a GET.\n\t\t *\n\t\t * @param {string} url                The URL\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupPatchParams: function (url, data, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\tdata: JSON.stringify(data),\n\t\t\t\t\ttype: 'PATCH',\n\t\t\t\t\tprocessData: false\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a DELETE.\n\t\t *\n\t\t * @param {string} url                The URL.\n\t\t * @param {array}  data               The data.\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} Returning the param object for jQuery\n\t\t */\n\t\tsetupDeleteParams: function (url, data, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\ttype: 'DELETE',\n\t\t\t\t\tdata: JSON.stringify(data),\n\t\t\t\t\tprocessData: false\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a HEAD.\n\t\t *\n\t\t * @param {string} url                The URL\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupHeadParams: function (url, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\ttype: 'HEAD'\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return an ajax handler that supports basic promises.\n\t\t */\n\t\tdispatch: function (params) {\n\t\t\tvar self = this;\n\n\t\t\tif (_.isUndefined(self)) {\n\t\t\t\tthrow new ApiError('self not bound in api.dispatch');\n\t\t\t}\n\n\t\t\tif (window.XDomainRequest) {\n\t\t\t\t// IE 9 support\n\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\tvar xdr = new XDomainRequest();\n\t\t\t\t\txdr.ontimeout = function () { reject({statusText: 'Timeout'}); };\n\t\t\t\t\txdr.onerror = function () { reject(self.processAjaxErrorResponse(xdr)); };\n\t\t\t\t\txdr.onprogress = function () {};\n\t\t\t\t\txdr.onload = function () {\n\t\t\t\t\t\tvar data = '';\n\t\t\t\t\t\tif (xdr.responseText.length > 0) {\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tdata = JSON.parse(xdr.responseText);\n\t\t\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\t\t\tdata = false;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (data === false) {\n\t\t\t\t\t\t\treject({statusText: 'Unable to parse response'});\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (!_.isUndefined(data.describedBy)) {\n\t\t\t\t\t\t\treject(self.processAjaxErrorResponse(xdr, data));\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tresolve(data);\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\n\t\t\t\t\tvar actualRequestType = params.type;\n\t\t\t\t\tvar url = window.location.protocol + params.url.replace(/^http(s)?:/, '');\n\t\t\t\t\txdr.open('post', url);\n\t\t\t\t\tif (!_.isUndefined(params.data) && params.data !== '') {\n\t\t\t\t\t\tparams.data = JSON.parse(params.data);\n\t\t\t\t\t}\n\t\t\t\t\tvar data = JSON.stringify(\n\t\t\t\t\t\t{'IE9Headers': params.headers, 'IE9Type': actualRequestType, 'wrappedData': params.data}\n\t\t\t\t\t);\n\t\t\t\t\txdr.send(data);\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\tvar jqXHR = jQuery.ajax(params)\n\t\t\t\t\t.done(function (data) {\n\t\t\t\t\t\tif (_.isUndefined(data)) {\n\t\t\t\t\t\t\tdata = {};\n\t\t\t\t\t\t}\n\t\t\t\t\t\tself.lastResponse = jqXHR;\n\n\t\t\t\t\t\t// In situations where there are issue with CORS and\n\t\t\t\t\t\t// http error codes, a backup is to send back a http 200 code\n\t\t\t\t\t\t// with the application/api-problem+json body content so we\n\t\t\t\t\t\t// do a check for the httpStatus attribute to catch this.\n\t\t\t\t\t\tif (_.has(data, 'httpStatus')) {\n\t\t\t\t\t\t\treject(self.processAjaxErrorResponse(jqXHR, data));\n\t\t\t\t\t\t}\n\t\t\t\t\t\t_.defer(resolve, data);\n\t\t\t\t\t})\n\t\t\t\t\t.fail(function () {\n\t\t\t\t\t\treject(self.processAjaxErrorResponse(jqXHR, null));\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Process an jqXHR from a jQuery ajax fail callback into an Error object.\n\t\t *\n\t\t * The optional data parameter is for if issues with CORS mean a 200 response\n\t\t * needs to be returned but with a application/api-problem+json body content.\n\t\t *\n\t\t * @param {jqXHR}  jqXHR The XHR object passed to the jQuery.ajax.fail callback.\n\t\t * @param {Object} data  Optional. The data passed back from jQuery.\n\t\t *\n\t\t * @returns {Error}\n\t\t */\n\t\tprocessAjaxErrorResponse: function (jqXHR, data) {\n\t\t\ttry {\n\t\t\t\tvar response = data || JSON.parse(jqXHR.responseText);\n\t\t\t\tvar message = response.title;\n\t\t\t\tvar status = response.httpStatus;\n\n\t\t\t\tdelete response.title;\n\t\t\t\tdelete response.httpStatus;\n\n\t\t\t\treturn new ApiError(message, status, response);\n\t\t\t} catch (err) {\n\t\t\t\treturn new ApiError(jqXHR.statusText, jqXHR.status);\n\t\t\t}\n\t\t}\n\t});\n\n\t// Begin API endpoint definitions -----\n\n\t/**\n\t * API client for suffix detail requests.\n\t *\n\t * This class allows you to fetch info for a suffix and the\n\t * period / price / product details for the suffix.\n\t * The class is Promise based and the response datastructure is\n\t * supplied on fullfillment. On error an Error object is provided.\n\t */\n\tvar ApiSuffix = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/suffixes/';\n\n\t\t\t// An array of objects of type {customerId, suffixes, hash}\n\t\t\t// where customer is the customerId, hash is the customer hash\n\t\t\t// and suffixes is an object with keys being the suffix and\n\t\t\t// the value being a deferred promise.\n\t\t\t// Done this way because of a bug in iOS8 safari that\n\t\t\t// means integer keys on an object can screw up the\n\t\t\t// length calculation on that object.\n\t\t\tthis.promises = [];\n\n\t\t\tthis.deferTriggered = false;\n\t\t},\n\n\t\t/**\n\t\t * Return details for the requested suffix.\n\t\t *\n\t\t * If a customer Id is supplied, the pricing details returned will\n\t\t * take customer-specific custom prices into consideration.\n\t\t *\n\t\t * @param {string} suffix       The suffix of interest (e.g. '.com')\n\t\t * @param {int}    customerId   Optional. A customerId.\n\t\t * @param {string} customerHash Required if a customerId is supplied.\n\t\t *\n\t\t * @returns {Promise} - data on fulfillment, Error on reject.\n\t\t */\n\t\tfetchDetails: function (suffix, customerId, customerHash) {\n\t\t\tif (_.isUndefined(customerId)) {\n\t\t\t\tcustomerId = 0;\n\t\t\t}\n\t\t\tvar customer = _.findWhere(this.promises, {customerId: customerId});\n\t\t\tif (_.isUndefined(customer)) {\n\t\t\t\tcustomer = {customerId: customerId, customerHash: customerHash, suffixes: {}};\n\t\t\t\tthis.promises.push(customer);\n\t\t\t}\n\t\t\tif (_.isUndefined(customer.suffixes[suffix])) {\n\t\t\t\tcustomer.suffixes[suffix] = new Deferred();\n\t\t\t}\n\t\t\tif (!this.deferTriggered) {\n\t\t\t\t_.delay(_.bind(this._makeRequests, this), 10);\n\t\t\t\tthis.deferTriggered = true;\n\t\t\t}\n\t\t\treturn customer.suffixes[suffix].promise;\n\t\t},\n\n\t\t/**\n\t\t * Actually make the async requests for suffix data.\n\t\t *\n\t\t * Called via a delay and processes the content of this.promises.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_makeRequests: function () {\n\t\t\tthis.deferTriggered = false;\n\t\t\tif (this.promises.length < 1) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hold a local version of the promises we will be working with\n\t\t\t// and clear the list so new requests can be gathered.\n\t\t\tvar actionedPromises = this.promises;\n\t\t\tthis.promises = [];\n\n\t\t\t// Make a request per customerId\n\t\t\t_.each(actionedPromises, function (customer) {\n\t\t\t\tif (_.isUndefined(customer.suffixes) || customer.suffixes.length < 1) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar customerId = customer.customerId;\n\t\t\t\tvar customerHash = customer.customerHash;\n\n\t\t\t\t// Reduce the suffixes into a queryString\n\t\t\t\tvar suffixesQueryString = _.reduce(customer.suffixes, function (queryString, promise, suffix) {\n\t\t\t\t\treturn queryString + '&suffixes[]=' + suffix;\n\t\t\t\t}, '', this);\n\n\t\t\t\t// Build the full url\n\t\t\t\tvar url = this.urlRoot + '?euroLocale=' + appState.locale + suffixesQueryString;\n\t\t\t\tif (customerId !== 0) {\n\t\t\t\t\turl += '&customerId=' + customerId + '&customerHash=' + customerHash;\n\t\t\t\t}\n\t\t\t\tvar self = this;\n\t\t\t\tthis.setupGetParams(url, true)\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\t// Loop through each suffix, build the data needed for each and resolve the\n\t\t\t\t\t// promise. If no data for the suffix exists, reject with an error.\n\t\t\t\t\t_.each(customer.suffixes, function (promise, suffix) {\n\t\t\t\t\t\tif (_.isUndefined(data[suffix])) {\n\t\t\t\t\t\t\tpromise.reject(new Error('no data'));\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Build the data structure for the individual suffix to match what\n\t\t\t\t\t\t// would have been returned if only a single suffix was requested.\n\t\t\t\t\t\tvar suffixData = {_embedded: {'suffix:periods': {}}};\n\t\t\t\t\t\tsuffixData._links = {self: {href: '/suffixes/' + suffix}, curies: data._links.curies};\n\t\t\t\t\t\tsuffixData[suffix] = data[suffix];\n\t\t\t\t\t\tsuffixData._embedded['suffix:periods']._links = data._embedded['suffix:periods']._links;\n\t\t\t\t\t\tsuffixData._embedded['suffix:periods'][suffix] = data._embedded['suffix:periods'][suffix];\n\t\t\t\t\t\tpromise.resolve(suffixData);\n\t\t\t\t\t}, self);\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\t// On error, reject all suffix promises with the error\n\t\t\t\t\t_.each(customer.suffixes, function (promise) { promise.reject(error); }, self);\n\t\t\t\t});\n\t\t\t}, this);\n\t\t}\n\t});\n\n\tapiStore.suffix = ApiSuffix;\n\n\t/**\n\t * API Client class for fetching Domain Suffix information.\n\t */\n\tvar ApiDomainSuffix = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-suffixes';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with domain suffixes.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed to return customer pricing.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for a single domain suffix.\n\t\t *\n\t\t * @param {string} id      Suffix identifier.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options),\n\t\t\t\tthis.authenticate\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for all domain suffixes (or subset thereof).\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchAll: function (options) {\n\t\t\tvar url = this.urlRoot + '/';\n\n\t\t\tif (options.suffixes) {\n\t\t\t\turl += '?suffixes=' + encodeURIComponent(options.suffixes.toString());\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainSuffix = ApiDomainSuffix;\n\n\t/**\n\t * API Client class for fetching Domain Suffix Offers information.\n\t */\n\tvar ApiDomainSuffixOffers = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-suffixes/offers';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with domain suffixes.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed to return customer pricing.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for a single domain suffix.\n\t\t *\n\t\t * @param {string} id      Suffix identifier.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id),\n\t\t\t\toptions\n\t\t\t), this.authenticate)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for all domain suffixes (or subset thereof).\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchAll: function (options) {\n\t\t\tvar url = this.urlRoot + '/';\n\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainSuffixOffers = ApiDomainSuffixOffers;\n\n\t/**\n\t * API: Basekit.\n\t */\n\tvar ApiDomainValidation = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/services';\n\t\t},\n\n\t\t/**\n\t\t * Trigger resending of domain-validation email validation email.\n\t\t *\n\t\t * To clarify, this is the email that the customer recieves from ICANN\n\t\t * asking them to verify their email address.\n\t\t *\n\t\t * @param {string} serviceUid A service Uid.\n\t\t * @param {object} options    Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tresendEmail: function (serviceUid, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain-validation',\n\t\t\t\toptions\n\t\t\t), {action: 'resendEmail'}, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainValidation = ApiDomainValidation;\n\n\t/**\n\t * API client for working with orders (carts).\n\t *\n\t * This class provides functions to work with an Order (cart).\n\t * The class design is Promise-based and multiple requests are non-blocking.\n\t * Order ID fetching is cached and only done once.\n\t *\n\t * Note that as one of the older classes, this class has some legacy methods\n\t * and is in a state of refactoring so is a little messy in places. In general,\n\t * fetch methods are designed to work with the Nested Types models while\n\t * the get and other methods are more for direct calling. Direct call methods\n\t * tend to auto-create orders where needed while the fetch methods won't.\n\t * Fetch methods also use authentication.\n\t */\n\tvar ApiOrder = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.orderId = jQuery.cookie('orderId') || false;\n\t\t\tthis.orderRef = jQuery.cookie('orderRef') || false;\n\t\t\tthis.promiseOrderId = null;\n\t\t\tthis.urlRoot = urlRoot + '/orders/';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t\tthis.authenticate = false;\n\t\t\tthis.validAddActions = ['new', 'renew', 'upgrade'];\n\t\t},\n\n\t\t/**\n\t\t * Return cached orderId and orderRef.\n\t\t */\n\t\tgetCachedOrderIdentifiers: function () {\n\t\t\treturn {\n\t\t\t\torderId: this.orderId,\n\t\t\t\torderRef: this.orderRef,\n\t\t\t};\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with orders.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed for an order to be owned by a customer.\n\t\t *\n\t\t * Used when we don't have an auth token such as before a customer logs into the cart.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Get the details of a single order.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tget: function (options) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\tvar url = self.urlRoot + encodeURIComponent(orderId);\n\t\t\t\tif (self.authenticate === false) {\n\t\t\t\t\turl += '?orderRef=' + encodeURIComponent(self.orderRef);\n\t\t\t\t}\n\t\t\t\treturn self.setupGetParams(buildQueryString (url, options), self.authenticate)\n\t\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Get details of a single order.\n\t\t *\n\t\t * @param {Number} orderId The order Id.\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tfetch: function (orderId, options) {\n\t\t\tvar url = this.urlRoot + encodeURIComponent(orderId);\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get details of the items in an order.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tfetchItems: function (options) {\n\t\t\tvar url = this.urlRoot + encodeURIComponent(options.orderId) + '/items';\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get details of the products in an order.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tfetchProducts: function (options) {\n\t\t\tvar url = this.urlRoot + encodeURIComponent(options.orderId) + '/products';\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get the details of all unprocessed (saved) orders for customer.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tgetUnprocessed: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Add an item to the order.\n\t\t *\n\t\t * Creates the order if needed. Internally calls getOrderId so there is\n\t\t * no need to call this first. Multiple calls can be made in parallel\n\t\t * and are non-conflicting and no-blocking. However, multiple requests\n\t\t * to add the same product but with different parameters are not\n\t\t * guaranteed to complete in request-sequence.\n\t\t *\n\t\t * @param {Object} data The keyed data structure.\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} - no value on fulfillment, Error on reject.\n\t\t */\n\t\taddToOrder: function (data, options) {\n\t\t\tvar self = this;\n\n\t\t\toptions = _.defaults(\n\t\t\t\t{},\n\t\t\t\toptions,\n\t\t\t\t{\n\t\t\t\t\tcreateNewOrder: false,\n\t\t\t\t\twithAuthentication: this.authenticate\n\t\t\t\t}\n\t\t\t);\n\n\t\t\treturn self._validate(data)\n\t\t\t.then(function () { return self.getOrderId(options); })\n\t\t\t.then(function (orderId) {\n\t\t\t\tdata.orderRef = self.orderRef;\n\t\t\t\treturn self.setupPostParams(\n\t\t\t\t\tself.urlRoot + encodeURIComponent(orderId) + '/items',\n\t\t\t\t\tdata,\n\t\t\t\t\toptions.withAuthentication\n\t\t\t\t).then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Get the orderId.\n\t\t *\n\t\t * Will create a new order id if one doesn't exist in the cookie.\n\t\t *\n\t\t * If 'withAuthentication' is passed as an option then checking the order (if one already exists)\n\t\t * will also include checking the order is owned by the correct customer. If not, a 401 not authorized\n\t\t * is returned and a new orderId is generated for the current customer.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} - orderId on fulfill, Error on reject\n\t\t */\n\t\tgetOrderId: function (options) {\n\t\t\tvar self = this;\n\t\t\toptions = _.defaults(\n\t\t\t\t{},\n\t\t\t\toptions,\n\t\t\t\t{\n\t\t\t\t\tcreateNewOrder: false,\n\t\t\t\t\twithAuthentication: this.authenticate\n\t\t\t\t}\n\t\t\t);\n\n\t\t\tvar canReuseExistingOrder = options.createNewOrder === false;\n\n\t\t\t// Firstly, try to use any previously created promise to get the order ID\n\t\t\tif (canReuseExistingOrder\n\t\t\t\t&& self.promiseOrderId !== null\n\t\t\t) {\n\t\t\t\treturn self.promiseOrderId;\n\t\t\t}\n\n\t\t\t// Failing that, try the existing cached order ID, or simply create a new order\n\t\t\tif (canReuseExistingOrder\n\t\t\t\t&& !_.isUndefined(self.orderId)\n\t\t\t\t&& self.orderId !== false\n\t\t\t) {\n\t\t\t\t// We have an existing orderId\n\t\t\t\tvar url = self.urlRoot + encodeURIComponent(self.orderId) +\n\t\t\t\t\t'?noChildren=true&orderRef=' + encodeURIComponent(self.orderRef);\n\t\t\t\tself.promiseOrderId = self.setupGetParams(url, options.withAuthentication)\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(\n\t\t\t\t\tfunction (order) {\n\t\t\t\t\t\tif (order.onHold || order.processed) {\n\t\t\t\t\t\t\treturn self.getNewOrderId(false, options.origin);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn Promise.resolve(self.orderId);\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\tfunction () { return self.getNewOrderId(false, options.origin); }\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\t// Fall back to creating a new order\n\t\t\t\tself.promiseOrderId = self.getNewOrderId(false, options.origin);\n\t\t\t}\n\n\t\t\treturn self.promiseOrderId;\n\t\t},\n\n\t\t/**\n\t\t * Create and return a new order id.\n\t\t *\n\t\t * By default, if a customerId and customerHash are available, will create an order for the customer.\n\t\t * If there is an error with this data (e.g. hash doesn't match) then we just create an order\n\t\t * without linking it to the customer.\n\t\t *\n\t\t * @param {bool}   ignoreCustomerDetails Optional. Skip specifying the customer when creating the order.\n\t\t * @param {string} orderOrigin          Optional origin for the new order.\n\t\t *\n\t\t * @returns {Promise} - orderId on fulfill, Error on reject\n\t\t */\n\t\tgetNewOrderId: function (ignoreCustomerDetails, orderOrigin) {\n\t\t\tif (_.isUndefined(ignoreCustomerDetails)) {\n\t\t\t\tignoreCustomerDetails = false;\n\t\t\t}\n\n\t\t\tvar withAuthentication;\n\t\t\tif (ignoreCustomerDetails) {\n\t\t\t\twithAuthentication = false;\n\t\t\t} else {\n\t\t\t\twithAuthentication = this.authenticate;\n\t\t\t}\n\t\t\tvar self = this;\n\n\t\t\tself.promiseOrderId = new Promise(function (resolve, reject) {\n\t\t\t\tvar customerDetails = {};\n\t\t\t\tif (!ignoreCustomerDetails && !self.authenticate) {\n\t\t\t\t\tcustomerDetails = {\n\t\t\t\t\t\t'customerId': self.customerId || 0,\n\t\t\t\t\t\t'customerHash': self.customerHash || ''\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\tcustomerDetails.origin = typeof orderOrigin === 'string'\n\t\t\t\t\t&& /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,19}$/.test(orderOrigin)\n\t\t\t\t\t? orderOrigin\n\t\t\t\t\t: '';\n\t\t\t\tself.setupPostParams(self.urlRoot, customerDetails, withAuthentication)\n\t\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t\t.then(function (data) {\n\t\t\t\t\t\tself.orderId = data.uid;\n\t\t\t\t\t\tself.orderRef = data.orderRef;\n\t\t\t\t\t\tdelete data.orderRef;\n\t\t\t\t\t\tjQuery.cookie('orderId', self.orderId, {path: '/', secure: useSecureCookies});\n\t\t\t\t\t\tjQuery.cookie('orderRef', self.orderRef, {path: '/', secure: useSecureCookies});\n\t\t\t\t\t\tresolve(self.orderId);\n\t\t\t\t\t},\n\t\t\t\t\tfunction (error) {\n\t\t\t\t\t\tif (!ignoreCustomerDetails &&\n\t\t\t\t\t\t\t(self.authenticate || (error.httpStatus === 403 && error.message === 'Mismatched customerHash'))\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\tself.getNewOrderId(true, orderOrigin).then(\n\t\t\t\t\t\t\t\tfunction (data) { resolve(data); },\n\t\t\t\t\t\t\t\tfunction (error) { reject(error); }\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treject(error);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t});\n\n\t\t\treturn self.promiseOrderId;\n\t\t},\n\n\t\t/**\n\t\t * Remove a single order item from the cart.\n\t\t *\n\t\t * @param {string|int} orderItemId Either an order item UID or backoffice id.\n\t\t * @param {string}     productType Product type. Required if a backoffice id is supplied.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tremoveItem: function (orderItemId, productType) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\treturn self.setupDeleteParams(self.urlRoot + encodeURIComponent(orderId) + '/items/' +\n\t\t\t\tencodeURIComponent(orderItemId) + '?orderRef=' + encodeURIComponent(self.orderRef) +\n\t\t\t\t(productType ? '&productType=' + encodeURIComponent(productType) : ''), null, self.authenticate)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Clear an order (remove all items under it).\n\t\t *\n\t\t * @returns {Promise} - resolve/reject.\n\t\t */\n\t\tremoveAllItems: function () {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\treturn self.setupDeleteParams(\n\t\t\t\t\tself.urlRoot + encodeURIComponent(orderId) + '/items?orderRef=' + encodeURIComponent(self.orderRef),\n\t\t\t\t\tnull,\n\t\t\t\t\tself.authenticate\n\t\t\t\t)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Update the order.\n\t\t *\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (changes) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\tchanges.orderRef = self.orderRef;\n\t\t\t\treturn self.setupPostParams(self.urlRoot + encodeURIComponent(orderId), changes, self.authenticate)\n\t\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Apply a voucher, optionally only if there is not already one applied.\n\t\t *\n\t\t * @param {string}  voucher The voucher code to apply.\n\t\t * @param {boolean} replace Whether to replace an existing voucher.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tapplyVoucher: function (voucherCode, replace) {\n\t\t\treplace = (typeof (replace) === 'undefined' ? true : replace);\n\t\t\tvoucherCode = {voucherCode: voucherCode.replace(/\\s/g, \"\").toUpperCase(), replace: replace};\n\t\t\tvar params = { voucherCode: voucherCode };\n\t\t\tif (\n\t\t\t\t!_.isUndefined(appState.customerId)\n\t\t\t\t&& appState.customerId !== 0\n\t\t\t\t&& !_.isUndefined(appState.customerHash)\n\t\t\t\t&& appState.customerHash.length > 0\n\t\t\t) {\n\t\t\t\tparams.customerId = String(appState.customerId);\n\t\t\t\tparams.customerHash = appState.customerHash;\n\t\t\t}\n\n\t\t\treturn this.update(params);\n\t\t},\n\n\t\t/**\n\t\t * Mark the order as being partially paid by credit.\n\t\t *\n\t\t * @param {float} amount The amount of credit to use or -1 for all available credit.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tuseCredit: function (amount) {\n\t\t\tif (amount < 0 && amount !== -1) {\n\t\t\t\treturn Promise.reject(new Error('Invalid credit amount'));\n\t\t\t}\n\t\t\treturn this.update({creditAmount: amount});\n\t\t},\n\n\t\t/**\n\t\t * Update an item.\n\t\t *\n\t\t * @param {int}    uid     Id of the order item.\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdateItem: function (uid, changes) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\tif (!self.authenticate) {\n\t\t\t\t\tchanges.orderRef = self.orderRef;\n\t\t\t\t}\n\t\t\t\treturn self.setupPostParams(\n\t\t\t\t\tself.urlRoot + encodeURIComponent(orderId) + '/items/' + encodeURIComponent(uid),\n\t\t\t\t\tchanges,\n\t\t\t\t\tself.authenticate\n\t\t\t\t).then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Force an order to process. Uses the customer id and hash.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tprocess: function () {\n\t\t\treturn this.update({\n\t\t\t\tprocess: true,\n\t\t\t\tcustomerId: this.customerId,\n\t\t\t\tcustomerHash: this.customerHash\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch the count of renewals for a customer.\n\t\t *\n\t\t * @param {number} customerId A customerId\n\t\t *\n\t\t * @returns {Promise} Returning the renewal count.\n\t\t */\n\t\tfetchSavedOrderCountForCustomer: function (customerId) {\n\t\t\tvar self = this;\n\t\t\treturn this.setupHeadParams(this.urlRoot + encodeURIComponent(customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function () {\n\t\t\t\t\tif (self.lastResponse) {\n\t\t\t\t\t\treturn self.lastResponse.getResponseHeader('X-Saved-Orders-Total') || 0;\n\t\t\t\t\t}\n\t\t\t\t\treturn 0;\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Clear out a processed order.\n\t\t *\n\t\t * For use after an order's processed to force this api to\n\t\t * create a new one for subsequent operations.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\tclear: function () {\n\t\t\tjQuery.removeCookie('orderId', {path: '/', secure: useSecureCookies});\n\t\t\tjQuery.removeCookie('orderRef', {path: '/', secure: useSecureCookies});\n\t\t\tthis.promiseOrderId = null;\n\t\t},\n\n\t\t/**\n\t\t * Basic validation of the data structure for adding an item to an order.\n\t\t *\n\t\t * Written to use Promises in case we want to do some async stuff in future.\n\t\t *\n\t\t * @param {object} data The data structure to check.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\t_validate: function (data) {\n\t\t\tif (!_.has(data, 'productId')) {\n\t\t\t\treturn Promise.reject(Error('Missing product Id'));\n\t\t\t}\n\n\t\t\tif (!data.productId.match(/^[a-z]/i)) {\n\t\t\t\tif (!_.has(data, 'productType')) {\n\t\t\t\t\treturn Promise.reject(Error('No product type supplied'));\n\t\t\t\t}\n\t\t\t\tif (!(_.contains(['hosting', 'mx', 'other', 'domain', 'server'], data.productType))) {\n\t\t\t\t\treturn Promise.reject(Error('Invalid product type \"' + data.productType + '\"'));\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (!_.has(data, 'serviceName') && !_.has(data, 'serviceId')) {\n\t\t\t\treturn Promise.reject(Error('No service name or ID supplied'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'renewalMethod') &&\n\t\t\t\tdata.renewalMethod !== '' &&\n\t\t\t\t!(_.contains(['rebills', 'auto'], data.renewalMethod))\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid renewal method \"' + data.renewalMethod + '\"'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'actions') &&\n\t\t\t\tdata.actions.length > this.validAddActions.length\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid action data provided (too many actions)'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'actions') &&\n\t\t\t\tdata.actions.includes('renew') &&\n\t\t\t\t(!(_.has(data, 'packageId')) || data.packageId === null)\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid renewal data, packageId missing'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'actions') &&\n\t\t\t\tdata.actions.includes('upgrade') &&\n\t\t\t\t(!(_.has(data, 'serviceId')) || data.serviceId === null)\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid upgrade data, serviceId missing'));\n\t\t\t}\n\n\t\t\treturn Promise.resolve();\n\t\t}\n\t});\n\n\tapiStore.order = ApiOrder;\n\n\t/**\n\t * API Client for the new, stream-based domain search system.\n\t *\n\t * Check for availability for a domain prefix and a set of suffixes\n\t * using the check() method. Receive results by requesting an\n\t * EventListener for the domain you are interested in using newEventStream().\n\t *\n\t * You can create as many event streams as you wish and you can check\n\t * for availability at any time without collision. Note, however, that the\n\t * domain you request a check for may not be the domain the searches are\n\t * performed on because the Rest API will strip illegal chars, lower-case the\n\t * string and try to identify and strip any suffixes on the passed domain string\n\t * so it is recommended to wait for the check promise to return before requesting\n\t * a stream unless you know the domain string won't change (e.g. if you've\n\t * used the string returned from a previous call).\n\t */\n\tvar ApiDomainSearchStream = Api.extend({\n\t\tinitialize: function (profile) {\n\t\t\tthis._super();\n\t\t\tthis.profile = normalizeEndpointProfile(profile);\n\t\t\tthis.urlRoot = profileUrlRoot('domain-search', this.profile);\n\t\t},\n\n\t\t/**\n\t\t * Request a check for availability of a domain prefix and a set of suffixes.\n\t\t *\n\t\t * The suffixes parameter can be one of the following:\n\t\t *   An array of strings where each string is a suffix with or without the leading period.\n\t\t *   An object of properties with each property key being a suffix without the leading period\n\t\t *    and with the value for each key being a comma-separated list of qualities.\n\t\t *\n\t\t * Qualities control what type of search is performed. Options are:\n\t\t *  local - only check the local ban list and whether a domain registration already exists in backoffice.\n\t\t *  dns - perform a DNS request for NameServer details and consider the domain available if there are no results.\n\t\t *  registrar - query the actual domain registrar.\n\t\t *\n\t\t * When passing an array of strings, the default is to check all qualities (i.e. 'registrar,dns,local').\n\t\t *\n\t\t * @param {string} domain   The domain prefix to use for the checks (i.e. the foo part of foo.com).\n\t\t * @param {Array}  suffixes A structure of suffixes to check for availability.\n\t\t * @param {object} options  Options object.\n\t\t *\n\t\t * @returns {Promise<{domain: string, suffix: string}>} The actual domain prefixed used for searching\n\t\t *                                                    after sanitisation and the identified primary suffix.\n\t\t */\n\t\tcheck: function (domain, suffixes, options) {\n\t\t\toptions = options || {};\n\t\t\tvar requestedSuffixes = [];\n\t\t\tif (_.size(suffixes) === 0) {\n\t\t\t\treturn Promise.reject(new Error('No suffixes provided'));\n\t\t\t}\n\n\t\t\t_.each(suffixes, function (value, index) {\n\t\t\t\tif (isNaN(index)) {\n\t\t\t\t\trequestedSuffixes.push({suffix: index, quality: value});\n\t\t\t\t} else {\n\t\t\t\t\trequestedSuffixes.push({suffix: value, quality: 'registrar,dns,local'});\n\t\t\t\t}\n\t\t\t});\n\t\t\tvar queryString = buildQueryString(this.urlRoot + '/start/' +\n\t\t\t\tencodeURIComponent(domain.replace(/\\/|\\?|&/g, '')), options);\n\n\t\t\tif (options.autoSearchPrimarySuffix !== undefined) {\n\t\t\t\tqueryString += '&autoSearchPrimarySuffix=1';\n\t\t\t}\n\t\t\treturn this.setupPostParams(\n\t\t\t\tqueryString,\n\t\t\t\t{suffixes: requestedSuffixes},\n\t\t\t\tfalse\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this))\n\t\t\t.then(function (results) {\n\t\t\t\tif (_.has(results, 'domain')) {\n\t\t\t\t\treturn {domain: results.domain, suffix: results.suffix};\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error('No domain returned');\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return a new Event Source for the specified domain.\n\t\t *\n\t\t * @param {string} domain The domain prefix. Usually the one returned from check().\n\t\t *\n\t\t * @returns {EventSource}\n\t\t */\n\t\teventSource: function (domain) {\n\t\t\tvar url = this.urlRoot + '/result-stream/' + domain;\n\t\t\treturn new EventSource(url);\n\t\t}\n\t});\n\n\tapiStore.domainSearchStream = ApiDomainSearchStream;\n\n\t/**\n\t * API Client for the new, stream-based domain whois system.\n\t *\n\t * Perform a whois lookup for a domain using the check() method. Receive results\n\t * by requesting an EventListener for the domain you are interested in using\n\t * newEventStream().\n\t *\n\t * Note, the same caveats that apply to ApiDomainSearchStream also apply here.\n\t */\n\tvar ApiDomainWhoisStream = Api.extend({\n\t\tinitialize: function (profile) {\n\t\t\tthis._super();\n\t\t\tthis.profile = normalizeEndpointProfile(profile);\n\t\t\tthis.urlRoot = profileUrlRoot('domain-whois', this.profile);\n\t\t},\n\n\t\t/**\n\t\t * Request a whois lookup for a keyword + suffix.\n\t\t *\n\t\t * @param {string} keyword The keyword part to use for the lookup (e.g. foo from foo.com).\n\t\t * @param {string} suffix  The suffix to use for the lookup (e.g. com from foo.com).\n\t\t *\n\t\t * @returns {Promise<{keyword: string, suffix: string}>} The keyword & suffix used for the lookup.\n\t\t */\n\t\tlookup: function (keyword, suffix) {\n\t\t\tif (!keyword || !suffix) {\n\t\t\t\treturn Promise.reject(new Error('No keyword or suffix provided'));\n\t\t\t}\n\n\t\t\tvar queryString = buildQueryString(this.urlRoot + '/start/' +\n\t\t\t\tencodeURIComponent((keyword + '.' + suffix).replace(/\\/|\\?|&/g, '')));\n\n\t\t\treturn this.setupPostParams(\n\t\t\t\tqueryString,\n\t\t\t\t{keyword: keyword, suffix: suffix},\n\t\t\t\tfalse\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this))\n\t\t\t.then(function (results) {\n\t\t\t\tif (_.has(results, 'keyword')) {\n\t\t\t\t\treturn {keyword: results.keyword, suffix: results.suffix};\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error('No result returned');\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return a new Event Source for the specified keyword.\n\t\t *\n\t\t * @param {string} keyword The keyword.\n\t\t *\n\t\t *\n\t\t * @returns {EventSource}\n\t\t */\n\t\teventSource: function (keyword) {\n\t\t\tvar url = this.urlRoot + '/result-stream/' + keyword;\n\t\t\treturn new EventSource(url);\n\t\t}\n\t});\n\n\tapiStore.domainWhoisStream = ApiDomainWhoisStream;\n\n\tvar ApiDomainSearchReport = Api.extend({\n\t\tinitialize: function (profile) {\n\t\t\tthis._super();\n\t\t\tthis.profile = normalizeEndpointProfile(profile);\n\t\t\tthis.urlRoot = profileUrlRoot('domain-search', this.profile) + '/report';\n\t\t},\n\t\treport: function (data, options) {\n\t\t\tvar self = this;\n\n\t\t\treturn Promise.resolve()\n\t\t\t.then(function () {\n\t\t\t\treturn self.setupPostParams(\n\t\t\t\t\tself.urlRoot,\n\t\t\t\t\tdata,\n\t\t\t\t\tfalse\n\t\t\t\t)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.domainSearchReport = ApiDomainSearchReport\n\n\tvar ApiDomainSuggestions = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-suggestions';\n\t\t},\n\t\tfetch: function(id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id),\n\t\t\t\toptions\n\t\t\t), this.authenticate).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainSuggestions = ApiDomainSuggestions;\n\n\t/**\n\t * Legacy API client for domain searches (deprecated).\n\t *\n\t * This class allows you to initiate or extend a domain search. It uses\n\t * Promises and can handle starting a new search when another is already\n\t * in progress. Suffix availability is communicated via fulfilling promises.\n\t * Overall status of the search is communicated via promises.\n\t *\n\t * General usage pattern:\n\t *  Add suffixes to a search using adToSearch, passing the suffix e.g. '.com'\n\t *  Link the returned promise to the behaviour you want to perform.\n\t *  Call doSearch\n\t */\n\tvar ApiDomainSearch = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.searchId = '';\n\t\t\tthis.domain = '';\n\t\t\tthis.pollPeriod = 500;\n\t\t\tthis.maximumPollRequests = 20;\n\t\t\tthis.urlRoot = urlRoot + '/domain-search/';\n\t\t\tthis.searchingFor = {};\n\t\t\tthis.willSearchFor = {};\n\t\t\tthis.nextSearchPromise = false;\n\t\t\tthis.runningSearchPromise = false;\n\t\t},\n\n\t\t/**\n\t\t * Set the domain for which we want suffix availability.\n\t\t *\n\t\t * @param {string} domain The domain.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\tsetDomain: function (domain) {\n\t\t\tthis.domain = domain;\n\t\t},\n\n\t\t/**\n\t\t * Add a suffix into a pending search set.\n\t\t *\n\t\t * @param {string} suffix The suffix to add (including preceeding '.')\n\t\t *\n\t\t * @returns {Promise} - suffix status on resolve, Error object on reject\n\t\t*/\n\t\taddToSearch: function (suffix, autoTrigger) {\n\t\t\tvar deferred = new Deferred();\n\t\t\tthis.willSearchFor[suffix] = deferred;\n\t\t\tif (autoTrigger !== false) {\n\t\t\t\t_.delay(this.doSearch.bind(this), 20);\n\t\t\t}\n\t\t\treturn deferred.promise;\n\t\t},\n\n\t\t/**\n\t\t * Pick up the results from an existing preheat search.\n\t\t *\n\t\t * Similar to doSearch except we skip the _startSearch() call.\n\t\t *\n\t\t * You can only call this method if there is no running search\n\t\t * and no next search configured. Basically, best to run this asap\n\t\t * on app load. If a search is already running, this method returns\n\t\t * the running search promise.\n\t\t *\n\t\t * Assumes the preheated suffixes have already been added to the search\n\t\t * using addToSearch like normal.\n\t\t *\n\t\t * @returns {Promise} - search id on resolve, Error object on reject\n\t\t */\n\t\tpickUpPreheatSearch: function () {\n\t\t\tvar self = this;\n\t\t\tif (this.runningSearchPromise !== false) {\n\t\t\t\t// If there's a search running already\n\t\t\t\treturn this.runningSearchPromise;\n\t\t\t}\n\t\t\tthis.searchId = jQuery.cookie('searchId');\n\t\t\tvar promise = Promise.resolve(this.searchId);\n\t\t\tthis.runningSearchPromise = promise;\n\n\t\t\tpromise.then(function (searchId) {\n\t\t\t\tself.searchingFor = self.willSearchFor;\n\t\t\t\tself.willSearchFor = {};\n\t\t\t\treturn self._checkForResults();\n\t\t\t}).then(function () {\n\t\t\t\tif (self.nextSearchPromise !== false) {\n\t\t\t\t\tself.runningSearchPromise = self.nextSearchPromise.promise;\n\t\t\t\t\tself.nextSearchPromise.resolve();\n\t\t\t\t} else {\n\t\t\t\t\tself.runningSearchPromise = false;\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn promise;\n\t\t},\n\n\t\t/**\n\t\t * Trigger a search\n\t\t *\n\t\t * @returns {Promise} - search id, reject on error\n\t\t */\n\t\tdoSearch: function () {\n\t\t\tvar self = this;\n\t\t\tvar promise;\n\t\t\tif (this.runningSearchPromise !== false) {\n\t\t\t\t// If there's a search running already\n\t\t\t\tif (this.nextSearchPromise !== false) {\n\t\t\t\t\t// If there's already a pending Promise for the next search, return it\n\t\t\t\t\treturn this.nextSearchPromise.promise;\n\t\t\t\t} else {\n\t\t\t\t\t// Create a new deferred promise and resolve it when the\n\t\t\t\t\t// current search finishes.\n\t\t\t\t\tthis.nextSearchPromise = new Deferred();\n\t\t\t\t\tpromise = this.nextSearchPromise.promise;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// create a pre-resolved starting promise\n\t\t\t\tpromise = this.runningSearchPromise = Promise.resolve();\n\t\t\t}\n\n\t\t\tpromise = promise.then(function () {\n\t\t\t\tself.nextSearchPromise = false;\n\t\t\t\treturn self._startSearch();\n\t\t\t});\n\n\t\t\tpromise.then(function (searchId) {\n\t\t\t\treturn self._checkForResults();\n\t\t\t}).then(function () {\n\t\t\t\tif (self.nextSearchPromise !== false) {\n\t\t\t\t\tself.runningSearchPromise = self.nextSearchPromise.promise;\n\t\t\t\t\tself.nextSearchPromise.resolve();\n\t\t\t\t} else {\n\t\t\t\t\tself.runningSearchPromise = false;\n\t\t\t\t}\n\t\t\t});\n\n\t\t\treturn promise;\n\t\t},\n\n\t\t/**\n\t\t * Internal method to setup a new search or extend an existing one.\n\t\t *\n\t\t * @returns {Promise} - search id (new search), empty (extend) on resolve,\n\t\t*/\n\t\t_startSearch: function () {\n\t\t\tvar self = this;\n\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t// When the promise runs we want to grab all the pending suffixes\n\t\t\t\t// and move them over to the active list, resetting the pending\n\t\t\t\t// list to allow for more suffixes to be added\n\t\t\t\tself.searchingFor = self.willSearchFor;\n\t\t\t\tself.willSearchFor = {};\n\n\t\t\t\tgetClientParams()\n\t\t\t\t.then(function (params) {\n\t\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\t\turl: self.urlRoot + encodeURIComponent(self.searchId),\n\t\t\t\t\t\tdata: JSON.stringify({suffixes: _.keys(self.searchingFor), search: self.domain}),\n\t\t\t\t\t\tprocessData: false\n\t\t\t\t\t});\n\t\t\t\t})\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\tif (data && !_.isUndefined(data.id)) {\n\t\t\t\t\t\tself.searchId = data.id;\n\t\t\t\t\t\tjQuery.cookie('searchId', self.searchId, {path: '/', secure: useSecureCookies});\n\t\t\t\t\t}\n\t\t\t\t\tresolve(self.searchId);\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\treject(error);\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Internal method to poll for search results.\n\t\t *\n\t\t * @returns {Promise} - 'searching' or 'completed' on resolve, Error object on reject\n\t\t */\n\t\t_checkForResults: function () {\n\t\t\tvar self = this;\n\t\t\tvar pollCounter = this.maximumPollRequests;\n\n\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t/**\n\t\t\t\t * Helper function to reject all pending suffix Promises.\n\t\t\t\t */\n\t\t\t\tfunction _rejectRemainingPromises () {\n\t\t\t\t\t_.each(self.searchingFor, function (promise) {\n\t\t\t\t\t\tpromise.reject(Error('error'));\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\t/**\n\t\t\t\t * Internal function for 'recursive' polling.\n\t\t\t\t *\n\t\t\t\t * Only within the scope of _checkForResults, this function\n\t\t\t\t * wraps a single wait/poll cycle. If there are results still pending\n\t\t\t\t * this method calls itself although it's not really recursive\n\t\t\t\t * because of the setTimeout().\n\t\t\t\t */\n\n\t\t\t\tfunction _fetchResults () {\n\t\t\t\t\t// within each timeout do an ajax call\n\t\t\t\t\tsetTimeout(function () {\n\t\t\t\t\t\tself.setupGetParams(self.urlRoot + encodeURIComponent(self.searchId))\n\t\t\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t\t\t.then(function (data) {\n\t\t\t\t\t\t\t--pollCounter;\n\n\t\t\t\t\t\t\t// assuming success, loop through all the suffix results\n\t\t\t\t\t\t\t// and if we still have a promise for a suffix then\n\t\t\t\t\t\t\t// resolve that promise and remove it from the list\n\t\t\t\t\t\t\tif (data.hasOwnProperty('results') && data.results.length > 0) {\n\t\t\t\t\t\t\t\t_.each(data.results[0].status, function (status, suffix) {\n\t\t\t\t\t\t\t\t\tsuffix = '.' + suffix;\n\t\t\t\t\t\t\t\t\tif (suffix in self.searchingFor) {\n\t\t\t\t\t\t\t\t\t\tself.searchingFor[suffix].resolve(status);\n\t\t\t\t\t\t\t\t\t\tdelete self.searchingFor[suffix];\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// If the search is reporting completed or we timeout then we want to reject\n\t\t\t\t\t\t\t// any remaining suffix promises and then resolve the search promise.\n\t\t\t\t\t\t\t// If the search isn't completed then keep going even if\n\t\t\t\t\t\t\t// we have no further suffixes to resolve because we don't want\n\t\t\t\t\t\t\t// to trigger a pending search while the previous one is incomplete.\n\t\t\t\t\t\t\tif (data.status === 'complete' || pollCounter === 0) {\n\t\t\t\t\t\t\t\t_rejectRemainingPromises();\n\t\t\t\t\t\t\t\tresolve(data.status);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t_fetchResults();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t},\n\t\t\t\t\t\tfunction (error) {\n\t\t\t\t\t\t\t_rejectRemainingPromises();\n\t\t\t\t\t\t\treject(error);\n\t\t\t\t\t\t});\n\t\t\t\t\t}, self.pollPeriod);\n\t\t\t\t}\n\n\t\t\t\t// Now we've defined the function we want to run it.\n\t\t\t\t_fetchResults();\n\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.domainSearch = ApiDomainSearch;\n\n\t/**\n\t * API Client class for fetching product information.\n\t */\n\tvar ApiProduct = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/products';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerHash = '';\n\n\t\t\t// An array of objects of type {customerId, products, hash}\n\t\t\t// where customer is the customerId, hash is the customer hash\n\t\t\t// and suffixes is an object with keys being the suffix and\n\t\t\t// the value being a deferred promise.\n\t\t\t// Done this way because of a bug in iOS8 safari that\n\t\t\t// means integer keys on an object can screw up the\n\t\t\t// length calculation on that object.\n\t\t\tthis.promises = [];\n\n\t\t\tthis.deferTriggered = false;\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with products.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed for custom prices.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for a product Uid.\n\t\t *\n\t\t * @param {string} productUid The product Uid.\n\t\t * @param {object} options    Options object.\n\t\t *\n\t\t * @returns {Promise} Returning the product data in an object.\n\t\t */\n\t\tfetch: function (productUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(productUid),\n\t\t\t\toptions\n\t\t\t), this.authenticate)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch product data for a list of product Uids.\n\t\t *\n\t\t * @param {object} options Options object\n\t\t *\n\t\t * @returns {Promise} Returning the product data in an object.\n\t\t */\n\t\tfetchSome: function (options) {\n\t\t\tvar qs = buildQueryString(\n\t\t\t\tthis.urlRoot + '/?',\n\t\t\t\toptions\n\t\t\t);\n\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/?',\n\t\t\t\toptions\n\t\t\t), this.authenticate)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all product data for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all product data for a set of services.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForServices: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all domain products for given suffix list.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} returning the product collection.\n\t\t */\n\t\tfetchDomainProductsForSuffixes: function (options) {\n\t\t\tvar url = this.urlRoot + '/domains/?';\n\t\t\tvar baseQueryString = _.reduce(options.suffixes,\n\t\t\t\tfunction (partialQueryString, suffix) {\n\t\t\t\t\treturn partialQueryString + '&suffix[]=' + encodeURIComponent(suffix);\n\t\t\t\t}, '', this\n\t\t\t);\n\n\t\t\tif (!_.isUndefined(options.privacyType) && (typeof options.privacyType === 'string')) {\n\t\t\t\tbaseQueryString += '&privacyType=' + options.privacyType;\n\t\t\t}\n\n\t\t\tif (!_.isUndefined(options.period) && (typeof options.period === 'number')) {\n\t\t\t\tbaseQueryString += '&period=' + options.period;\n\t\t\t}\n\n\t\t\tif (!_.isUndefined(appState.currency) && (typeof appState.currency === 'string')) {\n\t\t\t\tbaseQueryString += '&currency[]=' + appState.currency;\n\t\t\t}\n\n\t\t\tif (!_.isUndefined(options.voucherCode) && (typeof options.voucherCode === 'string')) {\n\t\t\t\tbaseQueryString += '&voucherCode=' + options.voucherCode;\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\t\turl + baseQueryString,\n\t\t\t\t\toptions\n\t\t\t\t), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all product and product relations for the currently authorised customer.\n\t\t *\n\t\t * If a Deferred is supplied in the options.relationships key then it will be resolved\n\t\t * with the mappings linking products to their families.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} returning the product collection.\n\t\t */\n\t\tproductFamiliesForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/families/';\n\t\t\tif (!_.isUndefined(appState.currency) && appState.currency !== '') {\n\t\t\t\turl += '?currency[]=' + appState.currency;\n\t\t\t}\n\t\t\treturn this.setupGetParams(url, this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\tvar products = _.values(data['_embedded'].products);\n\t\t\t\t\tif (_.has(options, 'relationships') && _.isFunction(options.relationships.resolve)) {\n\t\t\t\t\t\tdelete data['_links'];\n\t\t\t\t\t\tdelete data['_embedded'];\n\t\t\t\t\t\toptions.relationships.resolve(data);\n\t\t\t\t\t}\n\t\t\t\t\treturn {results: products};\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch details of other products related to a product Uid.\n\t\t *\n\t\t * @param {object} options Options object with a productUid key.\n\t\t *\n\t\t * @returns {Promise} Returning the product data in an object.\n\t\t */\n\t\tfamilyForProduct: function (options) {\n\t\t\tvar customerId = this.customerId;\n\t\t\tvar customerHash = this.customerHash;\n\n\t\t\tif (_.isUndefined(customerId)) {\n\t\t\t\tcustomerId = 0;\n\t\t\t}\n\t\t\tvar customer = _.findWhere(this.promises, {customerId: customerId});\n\t\t\tif (_.isUndefined(customer)) {\n\t\t\t\tcustomer = {customerId: customerId, customerHash: customerHash, families: {}};\n\t\t\t\tthis.promises.push(customer);\n\t\t\t}\n\t\t\tif (_.isUndefined(customer.families[options.productUid])) {\n\t\t\t\tcustomer.families[options.productUid] = new Deferred();\n\t\t\t}\n\t\t\tif (!this.deferTriggered) {\n\t\t\t\t_.delay(_.bind(this._makeRequests, this), 10);\n\t\t\t\tthis.deferTriggered = true;\n\t\t\t}\n\n\t\t\treturn customer.families[options.productUid].promise;\n\t\t},\n\n\t\t/**\n\t\t * Fetch all upgrade products for a service.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForPackageUpgrade: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\turlRoot + '/packages/' + encodeURIComponent(options.packageId) + '/upgrades',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Actually make the async requests for product data.\n\t\t *\n\t\t * Called via a delay and processes the content of this.promises.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_makeRequests: function () {\n\t\t\tthis.deferTriggered = false;\n\t\t\tif (this.promises.length < 1) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hold a local version of the promises we will be working with\n\t\t\t// and clear the list so new requests can be gathered.\n\t\t\tvar actionedPromises = this.promises;\n\t\t\tthis.promises = [];\n\n\t\t\t// Make a request per customerId\n\t\t\t_.each(actionedPromises, function (customer) {\n\t\t\t\tif (_.isUndefined(customer.families) || _.keys(customer.families).length < 1) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar customerId = customer.customerId;\n\t\t\t\tvar customerHash = customer.customerHash;\n\n\t\t\t\t// Reduce the products into a queryString\n\t\t\t\tvar productsQueryString = _.reduce(customer.families,\n\t\t\t\t\tfunction (queryString, promise, productUid) {\n\t\t\t\t\t\treturn queryString + '&products[]=' + encodeURIComponent(productUid);\n\t\t\t\t\t}, '', this);\n\n\t\t\t\t// Build the full url\n\t\t\t\tvar url = this.urlRoot + '/families/?' + productsQueryString;\n\t\t\t\tif (customerId !== 0) {\n\t\t\t\t\turl += '&customerId=' + encodeURIComponent(customerId) +\n\t\t\t\t\t\t'&customerHash=' + encodeURIComponent(customerHash);\n\t\t\t\t}\n\t\t\t\tif (!_.isUndefined(appState.currency) && appState.currency !== '') {\n\t\t\t\t\turl += '&currency[]=' + encodeURIComponent(appState.currency);\n\t\t\t\t}\n\n\t\t\t\tvar self = this;\n\t\t\t\tthis.setupGetParams(url, this.authenticate)\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\t// Loop through each suffix, build the data needed for each and resolve the\n\t\t\t\t\t// promise. If no data for the suffix exists, reject with an error.\n\t\t\t\t\t_.each(customer.families, function (promise, productUid) {\n\t\t\t\t\t\tif (_.isUndefined(data[productUid])) {\n\t\t\t\t\t\t\tpromise.reject(new Error('no data'));\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Transform data into structure expected by model/UI\n\t\t\t\t\t\tvar familyData = {results: {}};\n\t\t\t\t\t\t_.each(data[productUid].family, function (familyProductUid) {\n\t\t\t\t\t\t\tfamilyData.results[familyProductUid] = data._embedded.products[familyProductUid];\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tpromise.resolve(familyData);\n\t\t\t\t\t}, self);\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\t// On error, reject all suffix promises with the error\n\t\t\t\t\t_.each(customer.families, function (promise) { promise.reject(error); }, self);\n\t\t\t\t});\n\t\t\t}, this);\n\t\t}\n\t});\n\n\tapiStore.product = ApiProduct;\n\n\t/**\n\t * API Client class for fetching package information.\n\t */\n\tvar ApiPackage = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/packages';\n\t\t\tthis.pendingUpdates = [];\n\t\t\tthis.updateTriggered = false;\n\t\t},\n\n\t\t/**\n\t\t * Create a new package on a service.\n\t\t *\n\t\t * Options array should include:\n\t\t *   customerId: integer The customerId\n\t\t *\n\t\t * Options array may include:\n\t\t *  attrs:           array   An array of attributes to return in the data for the created package. Default empty.\n\t\t *  includeEmbedded: boolean Whether to return the product and card object in the returned package data. Default false.\n\t\t *  provision:       boolean Whether to also privision the created package. Default true.\n\t\t *\n\t\t * Options array should include for litemail packages:\n\t\t *  emailAlias: string The email alias to setup.\n\t\t *\n\t\t * @param {string} serviceUid The service to add the package to.\n\t\t * @param {string} productUid The product to add.\n\t\t * @param {Object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tcreate: function (serviceUid, productUid, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\tvar data = {serviceUid: serviceUid, productUid: productUid};\n\t\t\tif (_.has(options, 'emailAlias')) {\n\t\t\t\tdata.emailAlias = options.emailAlias;\n\t\t\t\tdelete options.emailAlias;\n\t\t\t}\n\t\t\treturn self.setupPostParams(buildQueryString(self.urlRoot, options), data, true)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Delete a package on a service.\n\t\t *\n\t\t * @param {number} packageUid The uid of the package to delete.\n\t\t * @param {Object} data       Body data to send in the request.\n\t\t * @param {Object} options    Options to customise the request.\n\t\t */\n\t\tdestroy: function (packageUid, data, options) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(packageUid), options),\n\t\t\t\tdata,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\t\t/**\n\t\t * Fetch package details for a packageId.\n\t\t *\n\t\t * @param {string} packageId The package Id.\n\t\t * @param {object} options   Options object.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tfetch: function (packageId, options) {\n\t\t\tvar self = this;\n\t\t\treturn self.setupGetParams(\n\t\t\t\tbuildQueryString(self.urlRoot + '/' + encodeURIComponent(packageId), options),\n\t\t\t\ttrue\n\t\t\t).then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all package data for a set of services.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForServices: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Set changes for a single package.\n\t\t *\n\t\t * @param {string} packageId The package Id.\n\t\t * @param {object} changes   The values to update.\n\t\t * @param {object} options   Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (packageId, changes, options) {\n\t\t\tvar promise = new Deferred();\n\n\t\t\t// add the update data and a deferred promise to pending updates array\n\t\t\tthis.pendingUpdates.push({\n\t\t\t\tdeferredPromise: promise,\n\t\t\t\tchanges: changes,\n\t\t\t\tpackageId: packageId\n\t\t\t});\n\n\t\t\t// bundle futher updates by waiting before calling updateAll\n\t\t\tif (!this.updateTriggered) {\n\t\t\t\tthis.updateTriggered = true;\n\t\t\t\t_.delay(_.bind(this._updateAll, this), 10);\n\t\t\t}\n\n\t\t\t// return the deferred promise.\n\t\t\treturn promise.promise;\n\t\t},\n\n\t\t/**\n\t\t * Update details for a collection of packages.\n\t\t *\n\t\t * @returns {promise}\n\t\t */\n\t\t_updateAll: function () {\n\t\t\tvar patch = {'operations': []};\n\t\t\tvar toUpdate = this.pendingUpdates;\n\t\t\tvar promises = {};\n\n\t\t\t// reset to allow further updates.\n\t\t\tthis.pendingUpdates = [];\n\t\t\tthis.updateTriggered = false;\n\n\t\t\t// loop over the bundled updates and set the patch data.\n\t\t\t// to keep track of requests later map the deferred promise.\n\t\t\t_.each(toUpdate, function (data) {\n\t\t\t\tpatch.operations.push({\n\t\t\t\t\t'op': 'replace',\n\t\t\t\t\t'path': '/packages/' + data.packageId,\n\t\t\t\t\t'value': data.changes\n\t\t\t\t});\n\n\t\t\t\tpromises['/packages/' + data.packageId] = data.deferredPromise;\n\t\t\t});\n\n\t\t\treturn this.setupPatchParams(this.urlRoot, patch, true).then(this.dispatch.bind(this)).then(\n\t\t\t\tfunction (data) {\n\t\t\t\t\tif (!_.isUndefined(data)) {\n\t\t\t\t\t\t// if any of the patch request operations failed loop through the\n\t\t\t\t\t\t// unprocessed updates, find the matching promises and reject them.\n\t\t\t\t\t\t_.each(data.unprocessed, function (result) {\n\t\t\t\t\t\t\tif (_.has(promises, result.path)) {\n\t\t\t\t\t\t\t\tpromises[result.path].reject(result.error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\n\t\t\t\t\t// resolve each of the (remaining) promises.\n\t\t\t\t\t_.each(promises, function (deferredPromise) {\n\t\t\t\t\t\tdeferredPromise.resolve();\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\t// if things went horribly wrong reject all promises.\n\t\t\t\t\t_.each(promises, function (deferredPromise) {\n\t\t\t\t\t\tdeferredPromise.reject(error);\n\t\t\t\t\t});\n\t\t\t\t\t// note without rethrowing the error any errors in the ajax are swollowed.\n\t\t\t\t\tthrow error;\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch package details for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar self = this;\n\t\t\tvar limit = 2000;\n\t\t\tvar queryString = buildQueryString('?limit=' + encodeURIComponent(limit) + '&start=0', options);\n\n\t\t\treturn this.setupGetParams(this.urlRoot + queryString, true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function (firstPage) {\n\t\t\t\t\tif (_.has(firstPage, '_page') && firstPage['_page'].all > limit) {\n\t\t\t\t\t\tvar pages = [];\n\t\t\t\t\t\tvar packageCount = firstPage['_page'].all;\n\t\t\t\t\t\tvar start = 0;\n\t\t\t\t\t\tdelete firstPage['_page'];\n\n\t\t\t\t\t\tpages.push(Promise.resolve(firstPage));\n\t\t\t\t\t\tstart += limit;\n\n\t\t\t\t\t\twhile (packageCount > start) {\n\t\t\t\t\t\t\tvar queryString = buildQueryString(\n\t\t\t\t\t\t\t\t'?limit=' + encodeURIComponent(limit) + '&start=' + start,\n\t\t\t\t\t\t\t\toptions\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tstart += limit;\n\t\t\t\t\t\t\tvar promise = self.setupGetParams(self.urlRoot + queryString, true)\n\t\t\t\t\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t\t\t\t\t.then(function (data) {\n\t\t\t\t\t\t\t\t\tdelete data['_page'];\n\t\t\t\t\t\t\t\t\treturn data;\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\tpages.push(promise);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treturn Promise.all(pages).then(function (data) {\n\t\t\t\t\t\t\tvar results = Array.prototype.concat.apply([], _.map(data, function (item) {\n\t\t\t\t\t\t\t\tif (_.has(item, 'results')) {\n\t\t\t\t\t\t\t\t\treturn item.results;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\treturn [];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}));\n\t\t\t\t\t\t\tfirstPage.results = results;\n\t\t\t\t\t\t\treturn firstPage;\n\t\t\t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn firstPage;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch the count of renewals for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the renewal count.\n\t\t */\n\t\tfetchRenewalCountForCustomer: function (options) {\n\t\t\tvar self = this;\n\t\t\treturn this.setupHeadParams(this.urlRoot + '/?customerId=' + encodeURIComponent(options.customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function () {\n\t\t\t\t\tif (self.lastResponse) {\n\t\t\t\t\t\treturn self.lastResponse.getResponseHeader('X-Renewals-Due') || 0;\n\t\t\t\t\t}\n\t\t\t\t\treturn 0;\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch upgrade products for a given packageId.\n\t\t *\n\t\t * @returns {Promise} Returning suitable upgrade products.\n\t\t */\n\t\tfetchUpgrades: function (packageId, options) {\n\t\t\tvar self = this;\n\t\t\treturn self.setupGetParams(\n\t\t\t\tbuildQueryString(self.urlRoot + '/' + encodeURIComponent(packageId) + '/upgrades', options), true\n\t\t\t).then(this.dispatch.bind(self));\n\t\t}\n\t});\n\n\tapiStore.package = ApiPackage;\n\n\t/**\n\t * API Client class for performing package activation.\n\t */\n\tvar ApiPackageActivation = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/packages';\n\t\t},\n\n\t\t/**\n\t\t * Activate a package\n\t\t *\n\t\t * @param {string} packageUid A package UID.\n\t\t * @param {object} data       A key/value list of new values to set.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tactivate: function (packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(packageUid) + '/activation',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.packageActivation = ApiPackageActivation;\n\n\t/**\n\t * API Client class for performing package allocation.\n\t */\n\tvar ApiPackageAllocation = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/packages';\n\t\t},\n\n\t\t/**\n\t\t * Allocate a package\n\t\t *\n\t\t * @param {string} packageUid A package UID.\n\t\t * @param {object} data       A key/value list of new values to set.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tallocate: function (packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(packageUid) + '/allocation',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.packageAllocation = ApiPackageAllocation;\n\n\t/**\n\t * API: Consumer withdrawals.\n\t *\n\t * Provides endpoints for the consumer right of withdrawal feature:\n\t * - GET  /consumer-withdrawals/eligible-services  — eligible services within 14-day window\n\t * - GET  /consumer-withdrawals                    — all withdrawal records for a customer\n\t * - POST /consumer-withdrawals                    — create a withdrawal request\n\t */\n\tvar ApiConsumerWithdrawal = Api.extend({\n\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/consumer-withdrawals';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve eligible services for a customer.\n\t\t *\n\t\t * The endpoint performs all server-side filtering: invoices within the\n\t\t * last 14 calendar days, invoice items with non-zero packageId, exclusion\n\t\t * of packages with pending (under_review) withdrawals, product name\n\t\t * resolution, and daysRemaining calculation.\n\t\t *\n\t\t * @param {number} customerId The customer ID.\n\t\t * @param {object} options    Optional query options.\n\t\t *\n\t\t * @returns {Promise} Returning the eligible services in a HAL object.\n\t\t */\n\t\tfetchEligibleServices: function (customerId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/eligible-services',\n\t\t\t\t_.extend({customerId: customerId}, options || {})\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all withdrawal records for a customer.\n\t\t *\n\t\t * The endpoint returns server-resolved display data: product names,\n\t\t * formatted request dates, and human-readable status labels.\n\t\t *\n\t\t * @param {number} customerId The customer ID.\n\t\t * @param {object} options    Optional query options.\n\t\t *\n\t\t * @returns {Promise} Returning the withdrawal records in a HAL object.\n\t\t */\n\t\tfetchForCustomer: function (customerId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot,\n\t\t\t\t_.extend({customerId: customerId}, options || {})\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Create a withdrawal request.\n\t\t *\n\t\t * The endpoint creates a ConsumerWithdrawals record (status: under_review),\n\t\t * raises a TYPE_CUSTOMER_CARE support ticket, and sends a confirmation\n\t\t * email to the customer.\n\t\t *\n\t\t * @param {object} data    The withdrawal data ({packageId, invoiceId, customerId, ...}).\n\t\t * @param {object} options Optional query options.\n\t\t *\n\t\t * @returns {Promise} Returning the created withdrawal record.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(this.urlRoot, options), data, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.consumerWithdrawal = ApiConsumerWithdrawal;\n\n\t/**\n\t * API: Support tickets.\n\t */\n\tvar ApiTicket = Api.extend({\n\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/tickets';\n\t\t},\n\n\t\tfetchTicketCountForCustomer: function (customerId) {\n\t\t\tvar self = this;\n\t\t\treturn this.setupHeadParams(buildQueryString(this.urlRoot, {'customerId': customerId}), true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function () {\n\t\t\t\t\tif (self.lastResponse) {\n\t\t\t\t\t\treturn self.lastResponse.getResponseHeader('X-Tickets-Total') || 0;\n\t\t\t\t\t}\n\t\t\t\t\treturn 0;\n\t\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.ticket = ApiTicket;\n\n\t/**\n\t * API: Customer.\n\t */\n\tvar ApiCustomer = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Update the customer.\n\t\t *\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, changes, options) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(uid), options),\n\t\t\t\tchanges,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve customer.\n\t\t *\n\t\t * @param {string} id      The customerId or accountRef.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the card data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options),\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.customer = ApiCustomer;\n\n\t/**\n\t * API: AccessControlRule.\n\t */\n\tvar ApiAccessControlRule = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Delete an access control rule.\n\t\t *\n\t\t * @param {number} uid     Item UID to delete.\n\t\t * @param {Object} data    A key/value list of data.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (uid, data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupDeleteParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId)\n\t\t\t\t\t+ '/access-control-rules/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Create a new access control rule.\n\t\t *\n\t\t * @param {Object} data    A key/value list of new values.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the address data in an object.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupPostParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId) + '/access-control-rules/',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve access control rule.\n\t\t *\n\t\t * @param {string} uid     The access control rule ID.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the access control rule data in an object.\n\t\t */\n\t\tfetch: function (uid, options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) +\n\t\t\t\t'/access-control-rules/' + encodeURIComponent(uid);\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all access control rules for a customer.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the access control rule data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/access-control-rules/';\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.accessControlRule = ApiAccessControlRule;\n\n\t/**\n\t * API: AddressBookEntry.\n\t */\n\tvar ApiAddressBookEntry = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Delete an address book entry.\n\t\t *\n\t\t * @param {number} uid     Item UID to delete.\n\t\t * @param {Object} data    A key/value list of data.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (uid, data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupDeleteParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId) + '/addresses/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Create a new address book entry.\n\t\t *\n\t\t * @param {Object} data    A key/value list of new values.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the address data in an object.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupPostParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId) + '/addresses/',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Update an address book entry.\n\t\t *\n\t\t * @param {number} uid     Item UID to update.\n\t\t * @param {object} data    A key/value list of new values to set.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, data, options) {\n\t\t\t// TODO ensure customerId obtained correctly\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.customerId) + '/addresses/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve address book entry.\n\t\t *\n\t\t * @param {string} uid     The address book entry ID.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the card data in an object.\n\t\t */\n\t\tfetch: function (uid, options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId)\n\t\t\t\t+ '/addresses/' + encodeURIComponent(uid);\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all address book entries for a customer.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the address book data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/addresses/';\n\n\t\t\tdelete options.customerId;\n\t\t\tif (options.withAccount) {\n\t\t\t\turl += '?withAccount=true';\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.addressBookEntry = ApiAddressBookEntry;\n\n\t/**\n\t * API: Invoice.\n\t */\n\tvar ApiInvoice = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/invoices';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve single invoice.\n\t\t *\n\t\t * @param {string} id      Invoice id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the invoice data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all invoices for a customer.\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t * @returns {Promise} Returning the invoice data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.invoice = ApiInvoice;\n\n\t/**\n\t * API: LcnInvoice.\n\t */\n\tvar ApiLcnInvoice = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/lcn-invoices';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all invoices for a customer.\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t * @returns {Promise} Returning the invoice data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.lcnInvoice = ApiLcnInvoice;\n\n\t/**\n\t * API: Credit receipt.\n\t */\n\tvar ApiCreditReceipt = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/credit-receipts';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve single credit receipt.\n\t\t *\n\t\t * @param {string} id      Credit receipt id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the credit data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all credit receipts for a customer.\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t * @returns {Promise} Returning the credit data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.creditReceipt = ApiCreditReceipt;\n\n\t/**\n\t * API Client class for fetching card information.\n\t */\n\tvar ApiCard = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Delete a specific card via cardId.\n\t\t *\n\t\t * @param {string} cardId  The cardId.\n\t\t * @param {object} options Options array with rest key containing customerId key.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (cardId, options) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.customerId) + '/cards/' + encodeURIComponent(cardId),\n\t\t\t\tnull,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch card details for a specific cardId.\n\t\t *\n\t\t * @param {string} cardId  The cardId.\n\t\t * @param {object} options Options array with rest key containing customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the card data in an object.\n\t\t */\n\t\tfetch: function (cardId, options) {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/cards/' + encodeURIComponent(cardId), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch cards for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.customerId) + '/cards', true\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.card = ApiCard;\n\n\n\t/**\n\t * API Client class for fetching Direct Debit information.\n\t */\n\tvar ApiDirectDebit = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Fetch agreement details for a specific Direct Debit ID.\n\t\t *\n\t\t * @param {string} directDebitId The Direct Debit ID.\n\t\t * @param {object} options       Options array with rest key containing customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the Direct Debit data in an object.\n\t\t */\n\t\tfetch: function (directDebitId, options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId)\n\t\t\t\t+ '/direct-debits/' + encodeURIComponent(directDebitId);\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch agreements for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the Diret Debit data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/direct-debits/';\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.directDebit = ApiDirectDebit;\n\n\t/**\n\t * API Client class for fetching bandwidth charge information.\n\t */\n\tvar ApiBandwidthCharge = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/bandwidth-charges';\n\t\t},\n\n\t\t/**\n\t\t * Fetch bandwidth charge details for a specific bandwidth charge ID.\n\t\t *\n\t\t * @param {string} bandwidthChargeId The bandwidth charge ID.\n\t\t * @param {object} options           Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the bandwidth charge data in an object.\n\t\t */\n\t\tfetch: function (bandwidthChargeId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(bandwidthChargeId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch bandwidth charges for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the bandwidth charge data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.bandwidthCharge = ApiBandwidthCharge;\n\n\t/**\n\t* API client class for accessing rebills.\n\t*\n\t* This exists primarily for getting a count of such via the HEAD REST call.\n\t*/\n\tvar ApiRebill = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/rebills';\n\t\t},\n\n\t\t/**\n\t\t * Fetch rebill details for a rebillId.\n\t\t *\n\t\t * @param {string} rebillId The rebill Id.\n\t\t *\n\t\t * @returns {Promise} Returning the rebill data in an object.\n\t\t */\n\t\trebill: function (rebillId) {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/' + encodeURIComponent(rebillId), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch rebill details for a customer.\n\t\t *\n\t\t * @param {string} customerId The customer Id.\n\t\t *\n\t\t * @returns {Promise} Returning the rebill data in an object.\n\t\t */\n\t\trebillsForCustomer: function (customerId) {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/?customerId=' + encodeURIComponent(customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get number of renewals due for a customer.\n\t\t *\n\t\t * @param {string} customerId The customer id.\n\t\t *\n\t\t * @returns {Promise} Returning the headers in an object.\n\t\t */\n\t\tcount: function (customerId) {\n\t\t\treturn this.setupHeadParams(this.urlRoot + '/?customerId=' + encodeURIComponent(customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.rebill = ApiRebill;\n\n\t/**\n\t * API Client class for fetching forwarding information.\n\t */\n\tvar ApiForwarding = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/forwarding';\n\t\t},\n\n\t\t/**\n\t\t * Fetch forwarding details for a specific domain name.\n\t\t *\n\t\t * @param {string} domainName A domain name.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the forwarding data in an object.\n\t\t */\n\t\tfetch: function (domainName, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(domainName), options\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all forwarding data for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the forwarding data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all forwarding data for a set of services.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForServices: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.forwarding = ApiForwarding;\n\n\t/**\n\t *\n\t * API client class for web forwarding.\n\t *\n\t */\n\tvar ApiForwardingDomain = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/forwarding';\n\t\t},\n\n\t\t/**\n\t\t * Fetch web forwarding details for a specific domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data in an object.\n\t\t */\n\t\tfetch: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update web forwarding details for a domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} data       A key/value list of new values to set.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tupdate: function (serviceUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Remove FirstPage forwarding service for a domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} data       A key/value list of data.\n\t\t * @param {object} options   Options array\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tremoveFirstPage: function (serviceUid, data, options) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain',\n\t\t\t\t{action: 'removeFirstPage'},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Delete web forwarding for a domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} data       A key/value list of data.\n\t\t * @param {object} options    Options array\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tdestroy: function (serviceUid, data, options) {\n\t\t\treturn this.setupDeleteParams(this.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain', null, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.forwardingDomain = ApiForwardingDomain;\n\n\t/**\n\t *\n\t * API client class for email forwarding.\n\t *\n\t */\n\tvar ApiForwardingEmail = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/forwarding';\n\t\t},\n\n\t\t/**\n\t\t * Fetch email forwarding details for a specific domain.\n\t\t *\n\t\t * @param {string} aliasUid An email alias UID.\n\t\t * @param {object} options  Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the email forwarding data in an object.\n\t\t */\n\t\tfetch: function (aliasUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.serviceUid) + '/email/' + encodeURIComponent(aliasUid),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all email forwarding data for a service.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUid key.\n\t\t *\n\t\t * @returns {Promise} Returning the email forwarding data in an object.\n\t\t */\n\t\tfetchForService: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.serviceUid) + '/email',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Delete email forwarding for a domain.\n\t\t *\n\t\t * @param {string} aliasUid An email alias UID.\n\t\t * @param {object} data     A key/value list of data.\n\t\t * @param {object} options  Options array\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tdestroy: function (aliasUid, data, options) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.serviceUid) + '/email/' + encodeURIComponent(aliasUid),\n\t\t\t\tnull,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Create email forwarding for a domain.\n\t\t *\n\t\t * @param {Object} data    A key/value list of new values.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\toptions = options || {};\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.serviceUid) + '/email/',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update email forwarding details for a domain.\n\t\t *\n\t\t * @param {string} aliasUid An email alias UID.\n\t\t * @param {object} data     A key/value list of new values to set.\n\t\t * @param {object} options  Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tupdate: function (aliasUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.serviceUid) + '/email/' + encodeURIComponent(aliasUid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.forwardingEmail = ApiForwardingEmail;\n\n\t/**\n\t * API Client class for posting customer logos.\n\t */\n\tvar ApiLogos = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/logos';\n\t\t},\n\n\t\tpost: function (customerId, data) {\n\t\t\treturn this.setupDataPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(customerId),\n\t\t\t\t{}\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\tdestroy: function (customerId) {\n\t\t\treturn this.setupDeleteParams(this.urlRoot + '/' + encodeURIComponent(customerId), null, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Set up post params without conversion to JSON, here to transmit\n\t\t * an image in $_FILES.\n\t\t *\n\t\t * @param {string} url                Destination URL / query string.\n\t\t * @param {object} data               Formdata object.\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t * @param {string} apiKey             Optional override of the default X-APIKEY value.\n\t\t */\n\t\tsetupDataPostParams: function (url, data, withAuthentication, apiKey) {\n\t\t\treturn getClientParams(withAuthentication, apiKey, 'image/*')\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\t'url': url,\n\t\t\t\t\t'data': data,\n\t\t\t\t\t'contentType': false,\n\t\t\t\t\t'processData': false\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.logos = ApiLogos;\n\n\t/**\n\t * API Client class for fetching Service information.\n\t */\n\tvar ApiService = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/services';\n\t\t},\n\n\t\t/**\n\t\t * Update the service.\n\t\t *\n\t\t * @param {number} uid     Item UID to update.\n\t\t * @param {object} data    A key/value list of new values to set.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch service details for a specific uid.\n\t\t *\n\t\t * @param {string} uid     Item UID to fetch details for.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetch: function (uid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(uid), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all servce data for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch cpanel domain info details for a specific uid.\n\t\t *\n\t\t * @param {string} uid     A service UID.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the cpanel data in an object.\n\t\t */\n\t\tfetchCpanelDomainInfo: function (uid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(uid) + '/cpanel',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch upsell products for a specific uid.\n\t\t *\n\t\t * @returns {Promise} Returning suitable upsell products.\n\t\t */\n\t\tfetchUpsellProducts: function (uid, options) {\n\t\t\tvar self = this;\n\t\t\treturn self.setupGetParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(uid) + '/upsell',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(self));\n\t\t}\n\t});\n\n\tapiStore.service = ApiService;\n\n\t/**\n\t * API: Basekit.\n\t */\n\tvar ApiBasekit = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/basekit';\n\t\t},\n\n\t\t/**\n\t\t * Fetch the login url for the editor.\n\t\t *\n\t\t * @param {string} serviceUid The Service Uid.\n\t\t * @param {object} options    Options.\n\t\t *\n\t\t * @returns {Promise} Returning the url.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve basekit facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.basekit = ApiBasekit;\n\n\t/**\n\t * API: Duda.\n\t */\n\tvar ApiDuda = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/duda';\n\t\t},\n\n\t\t/**\n\t\t * Fetch a login url for the editor.\n\t\t *\n\t\t * @param {string} serviceUid The Service Uid.\n\t\t * @param {string} type       The login URL type to fetch.\n\t\t *\n\t\t * @returns {Promise} Returning the url.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, type) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login?ssoType=' + encodeURIComponent(type || ''),\n\t\t\t\ttrue\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch a list of available templates.\n\t\t *\n\t\t * @returns {Promise} Returning the array of templates.\n\t\t */\n\t\tfetchTemplates: function () {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/templates', false)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve duda facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Reset a duda site.\n\t\t *\n\t\t * @param {string} id         Service id.\n\t\t * @param {string} templateId The id of the template to apply.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\treset: function (id, templateId) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id) + '?templateId=' + encodeURIComponent(templateId),\n\t\t\t\tnull,\n\t\t\t\ttrue\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update the duda facility.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} changes The new values to apply.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (id, changes, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id),\n\t\t\t\toptions\n\t\t\t), changes, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\t});\n\n\tapiStore.duda = ApiDuda;\n\n\t/**\n\t * API: Ecommerce.\n\t */\n\tvar ApiEcommerce = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/ecommerce';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve ecommerce facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.ecommerce = ApiEcommerce;\n\n\t/**\n\t * API: SimplyBook.\n\t */\n\tvar ApiSimplyBook = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/simplybook';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve SimplyBook facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.simplybook = ApiSimplyBook;\n\n\t/**\n\t * API: Macaly.\n\t */\n\tvar ApiMacaly = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/macaly';\n\t\t},\n\n\t\t/**\n\t\t * Fetch the SSO login URL for a Macaly service.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the login URL data.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, itemId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login/' + encodeURIComponent(itemId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Activate a Macaly package.\n\t\t *\n\t\t * @param {string} packageUid The package UID.\n\t\t * @param {object} data       A key/value list of values to send in the POST body.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tactivate: function (packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(packageUid) + '/activation',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of provisioned Macaly items for a service.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the provisioned items.\n\t\t */\n\t\tfetchProvisionedList: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of orphaned Macaly accounts for a service.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the orphaned account items.\n\t\t */\n\t\tfetchOrphanedAccountList: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/orphaned',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of websites for a provisioned Macaly item.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the website list.\n\t\t */\n\t\tfetchWebsiteList: function (serviceUid, itemId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of hostnames for a Macaly website.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {string} websiteId  The website ID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the hostname list.\n\t\t */\n\t\tfetchHostnameList: function (serviceUid, itemId, websiteId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId) + '/hostnames/' + encodeURIComponent(websiteId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Add a hostname to a Macaly website.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {string} websiteId  The website ID.\n\t\t * @param {object} data       A key/value list of values to send in the POST body.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response (202 Accepted).\n\t\t */\n\t\taddHostname: function (serviceUid, itemId, websiteId, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId) + '/hostnames/' + encodeURIComponent(websiteId),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Remove a hostname from a Macaly website.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {string} websiteId  The website ID.\n\t\t * @param {object} data       A key/value list of values to send in the DELETE body.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response (202 Accepted).\n\t\t */\n\t\tremoveHostname: function (serviceUid, itemId, websiteId, data, options) {\n\t\t\treturn this.setupDeleteParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId) + '/hostnames/' + encodeURIComponent(websiteId),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Change the plan for a Macaly package.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} packageUid The package UID.\n\t\t * @param {object} data       A key/value list of values to send in the POST body (e.g. { planCode: 'macaly-hosting-only', productId: 'H123' }).\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tchangePlan: function (serviceUid, packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/' + encodeURIComponent(packageUid) + '/plan',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update the friendly name of a Macaly app.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} packageId  The package ID of the Macaly app.\n\t\t * @param {string} appName    The new friendly name for the app.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tupdateAppName: function (serviceUid, packageId, appName, options) {\n\t\t\treturn this.setupPatchParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/app/' + encodeURIComponent(packageId),\n\t\t\t\toptions\n\t\t\t), {appName: appName}, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.macaly = ApiMacaly;\n\n\t/**\n\t * API: Sitemaker.\n\t */\n\tvar ApiSitemaker = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/sitemaker';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve sitemaker facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.sitemaker = ApiSitemaker;\n\n\t/**\n\t * API: Domain Registration.\n\t */\n\tvar ApiDomainRegistration = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-registration';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve domain registration details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all domain registration details for a customer.\n\t\t *\n\t\t * @param {object} options Options array with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update domain registration details for a service.\n\t\t *\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, changes, options) {\n\t\t\tdelete changes.serviceModel;\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), changes, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainRegistration = ApiDomainRegistration;\n\n\t/**\n\t * API: Email.\n\t */\n\tvar ApiEmail = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/email';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve email facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Activate a namesco email-only product.\n\t\t *\n\t\t * Used when a customer activates their email via the control panel\n\t\t * wizard, supplying an email alias and password instead of the order\n\t\t * process creating the setup automatically.\n\t\t *\n\t\t * @param {string} serviceUid Service uid for the domain being activated.\n\t\t * @param {object} data       Request body containing {emailAlias, password}.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tactivate: function (serviceUid, data) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/activation',\n\t\t\t\tdata || {},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.email = ApiEmail;\n\n\tvar ApiEmailUser = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/email';\n\t\t},\n\n\t\t/**\n\t\t * Fetch all email users for a service.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUid key.\n\t\t *\n\t\t * @returns {Promise} Returning the email user data in an object.\n\t\t */\n\t\tfetchForService: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.serviceUid) + '/users',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the webmail login url for a user.\n\t\t *\n\t\t * @param {string} serviceUid The Service Uid.\n\t\t * @param {string} userUid    The User Uid.\n\t\t * @param {object} options    Options.\n\t\t *\n\t\t * @returns {Promise} Returning the url.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, userUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login/' + encodeURIComponent(userUid),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.emailUser = ApiEmailUser;\n\n\t/**\n\t * API: Office365.\n\t */\n\tvar ApiOffice365 = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/office365';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve office365 facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.office365 = ApiOffice365;\n\n\t/**\n\t * API: OnlineCompliance.\n\t */\n\tvar ApiOnlineCompliance = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/online-compliance';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve Online Compliance facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.onlineCompliance = ApiOnlineCompliance;\n\n\t/**\n\t * API: WebAccessibility.\n\t */\n\tvar ApiWebAccessibility = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/web-accessibility';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve Web Accessibility facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.webAccessibility = ApiWebAccessibility;\n\n\t/**\n\t * API OnlineCompliance Scanner.\n\t */\n\tvar ApiOnlineComplianceScanner = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/online-compliance/scanner';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerHash = '';\n\t\t},\n\t\tstart: function(url) {\n\t\t\treturn this.setupPostParams(this.urlRoot + '/' + encodeURIComponent(url), false)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\t\tcheck: function(url, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(url), options), false)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.onlineComplianceScanner = ApiOnlineComplianceScanner;\n\n\t/**\n\t * API: Quota.\n\t */\n\tvar ApiQuota = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/quota';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve Quota data details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the quota data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.quota = ApiQuota;\n\n\t/**\n\t * API: Mailbox.\n\t */\n\tvar ApiMailbox = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/mailbox';\n\t\t},\n\n\t\t/**\n\t\t * Delete a a mailbox.\n\t\t *\n\t\t * @param {number} uid     Item UID to delete.\n\t\t * @param {Object} data    A key/value list of data.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (uid, data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupDeleteParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(uid) + '/user/' + encodeURIComponent(data.userName),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t}\n\t});\n\n\tapiStore.mailbox = ApiMailbox;\n\n\t/**\n\t * API: Hosting.\n\t */\n\tvar ApiHosting = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/hosting';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve hosting facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.hosting = ApiHosting;\n\n\t/**\n\t * API: Hubspot.\n\t */\n\tvar ApiHubspot = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/hubspot';\n\t\t},\n\n\t\t/**\n\t\t * Push an order to HubSpot for the authenticated customer.\n\t\t *\n\t\t * @param {string} orderRef The order reference.\n\t\t * @param {object} data     Optional request body data (e.g. {extraFlags: {...}}).\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\torderPush: function (orderRef, data) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/order-push/' + encodeURIComponent(orderRef),\n\t\t\t\tdata || {},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Push a customer's contact to HubSpot.\n\t\t *\n\t\t * @param {string} customerId Customer ID.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tcustomerPush: function (customerId) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/customer-push',\n\t\t\t\t{customerId: customerId},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.hubspot = ApiHubspot;\n\n\t/**\n\t * API: Setup.\n\t */\n\tvar ApiSetup = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/setup';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve setup details for a service.\n\t\t *\n\t\t * @param {string} id      Setup id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the setup data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.setup = ApiSetup;\n\n\t/**\n\t * API: Reseller Hosting Data.\n\t */\n\tvar ApiResellerHostingData = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve reseller hosting data for a customer ID.\n\t\t *\n\t\t * @param {string} id      A customer id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the reseller hosting data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\tvar qs = '';\n\t\t\tif (options.includeLiteMail !== undefined) {\n\t\t\t\tqs = '/?includeLiteMail=' + encodeURIComponent(options.includeLiteMail);\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(\n\t\t\t\tbuildQueryString(\n\t\t\t\t\tthis.urlRoot +\n\t\t\t\t\t\t'/' + encodeURIComponent(id) +\n\t\t\t\t\t\t'/reseller-hosting-data' +\n\t\t\t\t\t\tqs,\n\t\t\t\t\toptions\n\t\t\t\t),\n\t\t\t\ttrue\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.resellerHostingData = ApiResellerHostingData;\n\n\t/**\n\t * Address Finder.\n\t */\n\tvar AddressFinder = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/address-search';\n\t\t},\n\n\t\t/**\n\t\t * Find addresses.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tfind: function (query, country, singlesummary, maximumresults, enablefacets, options) {\n\t\t\tconst params = new URLSearchParams({\n\t\t\t\tquery: query,\n\t\t\t\tcountry: country,\n\t\t\t\tsinglesummary: singlesummary,\n\t\t\t\tmaximumresults: maximumresults,\n\t\t\t\tenablefacets: enablefacets\n\t\t\t});\n\n\t\t\t// Replace + with %20 for better server compatibility\n\t\t\tvar encodedQueryString = params.toString().replace(/\\+/g, '%20');\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '?' + encodedQueryString,\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve an address.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tfetch: function (query, country, id, addtags, identifier, lines, options) {\n\t\t\tvar queryParams = {\n\t\t\t\tcountry: country,\n\t\t\t\tquery: query,\n\t\t\t\tid: id,\n\t\t\t\taddtags: addtags,\n\t\t\t\tidentifier: identifier,\n\t\t\t\tlines: lines\n\t\t\t};\n\t\t\tvar queryString = new URLSearchParams(queryParams);\n\n\t\t\t// Replace + with %20 for better server compatibility\n\t\t\tvar encodedQueryString = queryString.toString().replace(/\\+/g, '%20');\n\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/retrieve?' + encodedQueryString,\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.addressFinder = AddressFinder;\n\n\t/**\n\t * API Client class for managing authentication.\n\t *\n\t * Use-able directly and also used by some of the other classes to provide a JWT token header\n\t * during calls to endpoints that require authentication.\n\t *\n\t * General use involves specifying the authentication details using setAuthenticationDetails()\n\t * before then using other Rest API endpoint classes that require authentication.\n\t */\n\tvar ApiAuth = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/tokens';\n\t\t\tthis.defaultKey = urlKey;\n\t\t\tthis.fetchAuthDetails = function () { return false; };\n\t\t\tthis.jwtHeader = {};\n\t\t},\n\n\t\t/**\n\t\t * Set the callback that provides the credentials used for fetching JWT tokens.\n\t\t *\n\t\t * When called, the callback should return an object with a 'mode' key and then\n\t\t * mode-specific values. Authentication mode (set using the 'mode' key) can be\n\t\t * 'basic' or 'sso'.\n\t\t * In basic mode, a username key and a password key should be supplied.\n\t\t * In sso mode, a token key should be supplied with the current SSO auth token.\n\t\t *\n\t\t * @param {function} callback The authentication callback.\n\t\t */\n\t\tsetAuthenticationCallback: function (callback) {\n\t\t\tthis.fetchAuthDetails = callback;\n\t\t},\n\n\t\t/**\n\t\t * Authenticate with the credentials provided in the callback and return a JWT token header.\n\t\t *\n\t\t * @param {string} key Optional override of the default X-APIKEY value.\n\t\t *\n\t\t * @returns {Promise} Returning a jwt header string.\n\t\t */\n\t\tauthenticate: function (key) {\n\t\t\tvar self = this;\n\t\t\tif (_.isUndefined(key)) {\n\t\t\t\tkey = this.defaultKey;\n\t\t\t}\n\n\t\t\treturn this.setupPostParams(this.urlRoot, '', false, key)\n\t\t\t.then(function (params) {\n\t\t\t\tvar authHeader = '';\n\t\t\t\tvar details = self.fetchAuthDetails(key);\n\t\t\t\tif (details === false) {\n\t\t\t\t\tthrow new ApiError('Unable to generate authentication header for key \"' + key + '\"');\n\t\t\t\t}\n\t\t\t\tswitch (details.mode) {\n\t\t\t\t\tcase 'basic':\n\t\t\t\t\t\tauthHeader = 'Basic ' + window.btoa(details.username + ':' + details.password);\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'order':\n\t\t\t\t\t\tvar toBase64 = details.orderId + ':' + details.orderRef;\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t!_.isUndefined(appState.customerId)\n\t\t\t\t\t\t\t&& appState.customerId !== 0\n\t\t\t\t\t\t\t&& !_.isUndefined(appState.customerHash)\n\t\t\t\t\t\t\t&& appState.customerHash.length > 0\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\ttoBase64 += ':' + String(appState.customerId);\n\t\t\t\t\t\t\ttoBase64 += ':' + appState.customerHash;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tauthHeader = 'Order ' + window.btoa(toBase64);\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'sso':\n\t\t\t\t\t\tauthHeader = 'XSC ' + details.token;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tdefault:\n\t\t\t\t\t\t// do nothing for now\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (authHeader === '') {\n\t\t\t\t\tthrow new ApiError('Unable to generate authentication header');\n\t\t\t\t}\n\t\t\t\tparams.headers['Authorization'] = authHeader;\n\t\t\t\treturn params;\n\t\t\t})\n\t\t\t.then(self.dispatch.bind(this))\n\t\t\t.then(function (data) {\n\t\t\t\t// expire the token after 30 seconds.\n\t\t\t\t_.delay(function () { self.jwtHeader[key] = false; }, 30000);\n\t\t\t\treturn 'Bearer ' + data.token;\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return an existing JWT header string or fetch one if none exists.\n\t\t *\n\t\t * @param {string} key Optional override of the default X-APIKEY value.\n\t\t *\n\t\t * @returns {Promise} returning a JWT header string.\n\t\t */\n\t\tgetJwtHeader: function (key) {\n\t\t\tif (_.isUndefined(key)) {\n\t\t\t\tkey = this.defaultKey;\n\t\t\t}\n\t\t\tif (!this.jwtHeader[key]) {\n\t\t\t\tthis.jwtHeader[key] = this.authenticate(key);\n\t\t\t}\n\t\t\treturn this.jwtHeader[key];\n\t\t}\n\t});\n\n\tapiStore.auth = ApiAuth;\n\n\t// End of API endpoint definitions -----\n\n\t// Endpoint names whose constructors and singleton cache support legacy/v2 profiles.\n\tvar profileAwareEndpoints = {\n\t\tdomainSearchStream: true,\n\t\tdomainWhoisStream: true,\n\t\tdomainSearchReport: true\n\t};\n\n\t/**\n\t * Normalize and validate a supported domain endpoint profile.\n\t *\n\t * @param {DomainEndpointProfile} profile Optional endpoint profile.\n\t *\n\t * @returns {DomainEndpointProfile}\n\t */\n\tfunction normalizeEndpointProfile (profile) {\n\t\tif (_.isUndefined(profile)) {\n\t\t\treturn 'legacy';\n\t\t}\n\n\t\tif (profile !== 'legacy' && profile !== 'v2') {\n\t\t\tthrow new Error('Unsupported endpoint profile: ' + profile + '. Expected legacy or v2.');\n\t\t}\n\n\t\treturn profile;\n\t}\n\n\t/**\n\t * Build the URL root for an endpoint and its selected profile.\n\t *\n\t * @param {string}                endpointRoot The endpoint path without a leading slash.\n\t * @param {DomainEndpointProfile} profile      The normalized endpoint profile.\n\t *\n\t * @returns {string} The profile-specific URL root.\n\t */\n\tfunction profileUrlRoot (endpointRoot, profile) {\n\t\treturn urlRoot + '/' + endpointRoot + (profile === 'v2' ? '/v2' : '');\n\t}\n\n\t/**\n\t * Get a default set of params for async requests.\n\t *\n\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t * @param {string} apiKey             Optional override of the default X-APIKEY value.\n\t * @param {string} dataType           Optional override of the default Accept value.\n\t *\n\t * @returns {Promise}\n\t */\n\tfunction getClientParams (withAuthentication, apiKey, dataType) {\n\t\tif (_.isUndefined(apiKey)) {\n\t\t\tapiKey = urlKey;\n\t\t}\n\n\t\tif (_.isUndefined(dataType)) {\n\t\t\tdataType = 'application/json';\n\t\t}\n\n\t\tvar params = {\n\t\t\t'headers': {\n\t\t\t\t'X-APIKEY': apiKey,\n\t\t\t\t'X-APITIME': (new Date()).getTime(),\n\t\t\t\t'Accept': dataType\n\t\t\t},\n\t\t\t'type': 'POST',\n\t\t\t'uri': null,\n\t\t\t'data': ''\n\t\t};\n\t\tif (withAuthentication === true) {\n\t\t\treturn fetchSingleton('auth').getJwtHeader(apiKey)\n\t\t\t.then(function (authHeader) {\n\t\t\t\tparams.headers['Authorization'] = authHeader;\n\t\t\t\treturn params;\n\t\t\t});\n\t\t} else {\n\t\t\treturn Promise.resolve(params);\n\t\t}\n\t}\n\n\t/**\n\t * Build query string.\n\t *\n\t * @param {string} qs   \t Base query string to build on.\n\t * @param {string} options Data object containing API method options.\n\t *\n\t * @returns {string}\n\t */\n\tfunction buildQueryString (qs, options) {\n\t\toptions = options || {};\n\n\t\t// Ensure base query string exists\n\t\tif (_.isString(qs)) {\n\t\t\tif (qs.indexOf('?') === -1) {\n\t\t\t\tqs += '?'; // Base string does not contain a '?', append one so it can be built upon\n\t\t\t}\n\t\t} else {\n\t\t\tqs = '?';\n\t\t}\n\n\t\tif (options.includeEmbedded !== undefined) {\n\t\t\tdelete options.noChildren; // Either 'includeEmbedded' or 'noChildren', not both\n\t\t}\n\n\t\tvar allowedOpts = {\n\t\t\tattrs: 'attrs',\n\t\t\tcustomerId: 'customerId',\n\t\t\tcustomerHash: 'customerHash',\n\t\t\tfilters: 'filters',\n\t\t\tincludeEmbedded: 'includeEmbedded',\n\t\t\tincludeMultiDomain: 'includeMultiDomain',\n\t\t\tnoChildren: 'noChildren',\n\t\t\tproductUids: 'productUids',\n\t\t\tscanId: 'scanId',\n\t\t\tserviceUids: 'serviceUid',\n\t\t\tsetupId: 'setupId',\n\t\t\tsetupSite: 'setupSite',\n\t\t\ttraits: 'traits'\n\t\t};\n\n\t\tfor (var optName in allowedOpts) {\n\t\t\tif (options[optName] !== undefined && options[optName] !== null) {\n\t\t\t\tif (_.isArray(options[optName])) {\n\t\t\t\t\t_.each(options[optName], function (optVal) {\n\t\t\t\t\t\tqs += '&' + allowedOpts[optName] + '[]=' + encodeURIComponent(optVal);\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tqs += '&' + allowedOpts[optName] + '=' + encodeURIComponent(options[optName]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn qs.replace('?&', '?');\n\t}\n\n\tvar urlRoot;\n\tvar urlKey;\n\n\t/**\n\t * Set the shared connection details used by API endpoint instances.\n\t *\n\t * @param {object} details Connection details containing the API root and key.\n\t *\n\t * @returns {void}\n\t */\n\tfunction setConnectionDetails (details) {\n\t\turlRoot = details.root;\n\t\turlKey = details.key;\n\t}\n\n\tvar singletons = {};\n\n\t/**\n\t * Return the cached endpoint instance for an endpoint and optional profile.\n\t *\n\t * Profile-aware endpoints use a separate cache entry for each normalized\n\t * profile; all other endpoints retain their existing endpoint-name cache key.\n\t *\n\t * @param {string}                endpointName Registered endpoint name.\n\t * @param {DomainEndpointProfile} profile      Optional endpoint profile.\n\t *\n\t * @returns {object} Cached API endpoint instance.\n\t */\n\tfunction fetchSingleton (endpointName, profile) {\n\t\tvar cacheKey = endpointName;\n\t\tif (profileAwareEndpoints[endpointName]) {\n\t\t\tprofile = normalizeEndpointProfile(profile);\n\t\t\tcacheKey += ':' + profile;\n\t\t}\n\n\t\tif (!singletons.hasOwnProperty(cacheKey)) {\n\t\t\tsingletons[cacheKey] = new apiStore[endpointName](profile);\n\t\t}\n\t\treturn singletons[cacheKey];\n\t}\n\n\treturn {\n\t\t// Methods\n\t\tgetClientParameters: getClientParams,\n\t\tsetConnectionDetails: setConnectionDetails,\n\t\t// Endpoints\n\t\taccessControlRuleEndpoint: fetchSingleton.bind(null, 'accessControlRule'),\n\t\taddressBookEntryEndpoint: fetchSingleton.bind(null, 'addressBookEntry'),\n\t\tauth: fetchSingleton.bind(null, 'auth'),\n\t\tauthEndpoint: fetchSingleton.bind(null, 'auth'),\n\t\tbandwidthCharge: fetchSingleton.bind(null, 'bandwidthCharge'),\n\t\tbandwidthChargeEndpoint: fetchSingleton.bind(null, 'bandwidthCharge'),\n\t\tbasekitEndpoint: fetchSingleton.bind(null, 'basekit'),\n\t\tcard: fetchSingleton.bind(null, 'card'),\n\t\tcardEndpoint: fetchSingleton.bind(null, 'card'),\n\t\tconsumerWithdrawalEndpoint: fetchSingleton.bind(null, 'consumerWithdrawal'),\n\t\tcreditreceiptEndpoint: fetchSingleton.bind(null, 'creditReceipt'),\n\t\tcustomerEndpoint: fetchSingleton.bind(null, 'customer'),\n\t\tdirectDebit: fetchSingleton.bind(null, 'directDebit'),\n\t\tdirectDebitEndpoint: fetchSingleton.bind(null, 'directDebit'),\n\t\t/**\n\t\t * @param {DomainEndpointProfile} [profile] Endpoint profile.\n\t\t */\n\t\tdomainSearchReport: fetchSingleton.bind(null, 'domainSearchReport'),\n\t\t/**\n\t\t * @param {DomainEndpointProfile} [profile] Endpoint profile.\n\t\t */\n\t\tdomainSearchStreamEndpoint: fetchSingleton.bind(null, 'domainSearchStream'),\n\t\t/**\n\t\t * @param {DomainEndpointProfile} [profile] Endpoint profile.\n\t\t */\n\t\tdomainWhoisStreamEndpoint: fetchSingleton.bind(null, 'domainWhoisStream'),\n\t\tdomainSuggestions: fetchSingleton.bind(null, 'domainSuggestions'),\n\t\tdomainSearch: fetchSingleton.bind(null, 'domainSearch'),\n\t\tdomainSuffix: fetchSingleton.bind(null, 'domainSuffix'),\n\t\tdomainSuffixEndpoint: fetchSingleton.bind(null, 'domainSuffix'),\n\t\tdomainSuffixOffersEndpoint: fetchSingleton.bind(null, 'domainSuffixOffers'),\n\t\tdomainValidationEndpoint: fetchSingleton.bind(null, 'domainValidation'),\n\t\tdomainRegistrationEndpoint: fetchSingleton.bind(null, 'domainRegistration'),\n\t\tdudaEndpoint: fetchSingleton.bind(null, 'duda'),\n\t\temailEndpoint: fetchSingleton.bind(null, 'email'),\n\t\temailUserEndpoint: fetchSingleton.bind(null, 'emailUser'),\n\t\tecommerceEndpoint: fetchSingleton.bind(null, 'ecommerce'),\n\t\tforwarding: fetchSingleton.bind(null, 'forwarding'),\n\t\tforwardingDomain: fetchSingleton.bind(null, 'forwardingDomain'),\n\t\tforwardingEmail: fetchSingleton.bind(null, 'forwardingEmail'),\n\t\tforwardingEndpoint: fetchSingleton.bind(null, 'forwarding'),\n\t\thostingEndpoint: fetchSingleton.bind(null, 'hosting'),\n\t\thubspotEndpoint: fetchSingleton.bind(null, 'hubspot'),\n\t\tinvoiceEndpoint: fetchSingleton.bind(null, 'invoice'),\n\t\tlcnInvoiceEndpoint: fetchSingleton.bind(null, 'lcnInvoice'),\n\t\tlogosEndpoint: fetchSingleton.bind(null, 'logos'),\n\t\tmacalyEndpoint: fetchSingleton.bind(null, 'macaly'),\n\t\toffice365Endpoint: fetchSingleton.bind(null, 'office365'),\n\t\tonlineComplianceEndpoint: fetchSingleton.bind(null, 'onlineCompliance'),\n\t\tonlineComplianceScannerEndpoint: fetchSingleton.bind(null, 'onlineComplianceScanner'),\n\t\torder: fetchSingleton.bind(null, 'order'),\n\t\torderEndpoint: fetchSingleton.bind(null, 'order'),\n\t\tpackageEndpoint: fetchSingleton.bind(null, 'package'),\n\t\tpackageActivationEndpoint: fetchSingleton.bind(null, 'packageActivation'),\n\t\tpackageAllocationEndpoint: fetchSingleton.bind(null, 'packageAllocation'),\n\t\tproduct: fetchSingleton.bind(null, 'product'),\n\t\tproductEndpoint: fetchSingleton.bind(null, 'product'),\n\t\tquotaEndpoint: fetchSingleton.bind(null, 'quota'),\n\t\tmailboxEndpoint: fetchSingleton.bind(null, 'mailbox'),\n\t\trebill: fetchSingleton.bind(null, 'rebill'),\n\t\taddressFinder: fetchSingleton.bind(null, 'addressFinder'),\n\t\tresellerHostingDataEndpoint: fetchSingleton.bind(null, 'resellerHostingData'),\n\t\tserviceEndpoint: fetchSingleton.bind(null, 'service'),\n\t\tsetupEndpoint: fetchSingleton.bind(null, 'setup'),\n\t\tsimplybookEndpoint: fetchSingleton.bind(null, 'simplybook'),\n\t\tsitemakerEndpoint: fetchSingleton.bind(null, 'sitemaker'),\n\t\tsuffix: fetchSingleton.bind(null, 'suffix'),\n\t\tsuffixEndpoint: fetchSingleton.bind(null, 'suffix'),\n\t\tticketEndpoint: fetchSingleton.bind(null, 'ticket'),\n\t\twebAccessibilityEndpoint: fetchSingleton.bind(null, 'webAccessibility')\n\t};\n}));\n\n\n/***/ }),\n/* 8 */,\n/* 9 */,\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar old;\nif (typeof Promise !== \"undefined\") old = Promise;\nfunction noConflict() {\n    try { if (Promise === bluebird) Promise = old; }\n    catch (e) {}\n    return bluebird;\n}\nvar bluebird = __webpack_require__(141)();\nbluebird.noConflict = noConflict;\nmodule.exports = bluebird;\n\n\n/***/ }),\n/* 11 */,\n/* 12 */,\n/* 13 */,\n/* 14 */,\n/* 15 */,\n/* 16 */,\n/* 17 */,\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * jQuery JavaScript Library v3.7.1\n * https://jquery.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2023-08-28T13:37Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket trac-14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\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\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n\t\t// Support: Chrome <=57, Firefox <=52\n\t\t// In some browsers, typeof returns \"function\" for HTML <object> elements\n\t\t// (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n\t\t// We don't want to classify *any* DOM node as a function.\n\t\t// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5\n\t\t// Plus for old WebKit, typeof returns \"function\" for HTML collections\n\t\t// (e.g., `typeof document.getElementsByTagName(\"div\") === \"function\"`). (gh-4756)\n\t\treturn typeof obj === \"function\" && typeof obj.nodeType !== \"number\" &&\n\t\t\ttypeof obj.item !== \"function\";\n\t};\n\n\nvar isWindow = function isWindow( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t};\n\n\nvar document = window.document;\n\n\n\n\tvar preservedScriptAttributes = {\n\t\ttype: true,\n\t\tsrc: true,\n\t\tnonce: true,\n\t\tnoModule: true\n\t};\n\n\tfunction DOMEval( code, node, doc ) {\n\t\tdoc = doc || document;\n\n\t\tvar i, val,\n\t\t\tscript = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tif ( node ) {\n\t\t\tfor ( i in preservedScriptAttributes ) {\n\n\t\t\t\t// Support: Firefox 64+, Edge 18+\n\t\t\t\t// Some browsers don't support the \"nonce\" property on scripts.\n\t\t\t\t// On the other hand, just using `getAttribute` is not enough as\n\t\t\t\t// the `nonce` attribute is reset to an empty string whenever it\n\t\t\t\t// becomes browsing-context connected.\n\t\t\t\t// See https://github.com/whatwg/html/issues/2369\n\t\t\t\t// See https://html.spec.whatwg.org/#nonce-attributes\n\t\t\t\t// The `node.getAttribute` check was added for the sake of\n\t\t\t\t// `jQuery.globalEval` so that it can fake a nonce-containing node\n\t\t\t\t// via an object.\n\t\t\t\tval = node[ i ] || node.getAttribute && node.getAttribute( i );\n\t\t\t\tif ( val ) {\n\t\t\t\t\tscript.setAttribute( i, val );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\t// Support: Android <=2.3 only (functionish RegExp)\n\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof 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\nvar version = \"3.7.1\",\n\n\trhtmlSuffix = /HTML$/i,\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\n\t// Retrieve the text value of an array of DOM nodes\n\ttext: function( elem ) {\n\t\tvar node,\n\t\t\tret = \"\",\n\t\t\ti = 0,\n\t\t\tnodeType = elem.nodeType;\n\n\t\tif ( !nodeType ) {\n\n\t\t\t// If no nodeType, this is expected to be an array\n\t\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t\t// Do not traverse comment nodes\n\t\t\t\tret += jQuery.text( node );\n\t\t\t}\n\t\t}\n\t\tif ( nodeType === 1 || nodeType === 11 ) {\n\t\t\treturn elem.textContent;\n\t\t}\n\t\tif ( nodeType === 9 ) {\n\t\t\treturn elem.documentElement.textContent;\n\t\t}\n\t\tif ( nodeType === 3 || nodeType === 4 ) {\n\t\t\treturn elem.nodeValue;\n\t\t}\n\n\t\t// Do not include comment or processing instruction nodes\n\n\t\treturn ret;\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tisXMLDoc: function( elem ) {\n\t\tvar namespace = elem && elem.namespaceURI,\n\t\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t\t// Assume HTML when documentElement doesn't yet exist, such as inside\n\t\t// document fragments.\n\t\treturn !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n\t},\n\n\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t// push.apply(_, arraylike) throws on ancient WebKit\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\n\tfunction( _i, name ) {\n\t\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\t} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: real iOS 8.2 only (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( isFunction( obj ) || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\n\n\nfunction nodeName( elem, name ) {\n\n\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n}\nvar pop = arr.pop;\n\n\nvar sort = arr.sort;\n\n\nvar splice = arr.splice;\n\n\nvar whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\";\n\n\nvar rtrimCSS = new RegExp(\n\t\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\",\n\t\"g\"\n);\n\n\n\n\n// Note: an element does not contain itself\njQuery.contains = function( a, b ) {\n\tvar bup = b && b.parentNode;\n\n\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE doesn't have `contains` on SVG.\n\t\ta.contains ?\n\t\t\ta.contains( bup ) :\n\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t) );\n};\n\n\n\n\n// CSS string/identifier serialization\n// https://drafts.csswg.org/cssom/#common-serializing-idioms\nvar rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g;\n\nfunction fcssescape( ch, asCodePoint ) {\n\tif ( asCodePoint ) {\n\n\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\tif ( ch === \"\\0\" ) {\n\t\t\treturn \"\\uFFFD\";\n\t\t}\n\n\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t}\n\n\t// Other potentially-special ASCII characters get backslash-escaped\n\treturn \"\\\\\" + ch;\n}\n\njQuery.escapeSelector = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\n\n\n\nvar preferredDoc = document,\n\tpushNative = push;\n\n( function() {\n\nvar i,\n\tExpr,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\tpush = pushNative,\n\n\t// Local document vars\n\tdocument,\n\tdocumentElement,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\tmatches,\n\n\t// Instance-specific data\n\texpando = jQuery.expando,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|\" +\n\t\t\"loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n\tidentifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n\t// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\t\twhitespace + \"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trleadingCombinator = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" +\n\t\twhitespace + \"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\tID: new RegExp( \"^#(\" + identifier + \")\" ),\n\t\tCLASS: new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\tTAG: new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\tATTR: new RegExp( \"^\" + attributes ),\n\t\tPSEUDO: new RegExp( \"^\" + pseudos ),\n\t\tCHILD: new RegExp(\n\t\t\t\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\tbool: new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\tneedsContext: new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\tif ( nonHex ) {\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\treturn nonHex;\n\t\t}\n\n\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t// Support: IE <=11+\n\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t// surrogate pair\n\t\treturn high < 0 ?\n\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// Used for iframes; see `setDocument`.\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE/Edge.\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && nodeName( elem, \"fieldset\" );\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Support: IE <=9 only\n// Accessing document.activeElement can throw unexpectedly\n// https://bugs.jquery.com/ticket/13393\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t( arr = slice.call( preferredDoc.childNodes ) ),\n\t\tpreferredDoc.childNodes\n\t);\n\n\t// Support: Android <=4.0\n\t// Detect silently failing push.apply\n\t// eslint-disable-next-line no-unused-expressions\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = {\n\t\tapply: function( target, els ) {\n\t\t\tpushNative.apply( target, slice.call( els ) );\n\t\t},\n\t\tcall: function( target ) {\n\t\t\tpushNative.apply( target, slice.call( arguments, 1 ) );\n\t\t}\n\t};\n}\n\nfunction find( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\n\t\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tfind.contains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( !nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// We can use :scope instead of the ID hack if the browser\n\t\t\t\t\t// supports it & if we're not changing the context.\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when\n\t\t\t\t\t// strict-comparing two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( newContext != context || !support.scope ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = jQuery.escapeSelector( nid );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrimCSS, \"$1\" ), context, results, seed );\n}\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 */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties\n\t\t// (see https://github.com/jquery/sizzle/issues/157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by jQuery selector module\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement( \"fieldset\" );\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch ( e ) {\n\t\treturn false;\n\t} finally {\n\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn nodeName( elem, \"input\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn ( nodeName( elem, \"input\" ) || nodeName( elem, \"button\" ) ) &&\n\t\t\telem.type === type;\n\t};\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 */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11+\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Checks a node for validity as a jQuery selector context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [node] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nfunction setDocument( node ) {\n\tvar subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocumentElement = document.documentElement;\n\tdocumentIsHTML = !jQuery.isXMLDoc( document );\n\n\t// Support: iOS 7 only, IE 9 - 11+\n\t// Older browsers didn't support unprefixed `matches`.\n\tmatches = documentElement.matches ||\n\t\tdocumentElement.webkitMatchesSelector ||\n\t\tdocumentElement.msMatchesSelector;\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors\n\t// (see trac-13936).\n\t// Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`,\n\t// all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well.\n\tif ( documentElement.msMatchesSelector &&\n\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tpreferredDoc != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t\tsubWindow.addEventListener( \"unload\", unloadHandler );\n\t}\n\n\t// Support: IE <10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert( function( el ) {\n\t\tdocumentElement.appendChild( el ).id = jQuery.expando;\n\t\treturn !document.getElementsByName ||\n\t\t\t!document.getElementsByName( jQuery.expando ).length;\n\t} );\n\n\t// Support: IE 9 only\n\t// Check to see if it's possible to do matchesSelector\n\t// on a disconnected node.\n\tsupport.disconnectedMatch = assert( function( el ) {\n\t\treturn matches.call( el, \"*\" );\n\t} );\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// IE/Edge don't support the :scope pseudo-class.\n\tsupport.scope = assert( function() {\n\t\treturn document.querySelectorAll( \":scope\" );\n\t} );\n\n\t// Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only\n\t// Make sure the `:has()` argument is parsed unforgivingly.\n\t// We include `*` in the test to detect buggy implementations that are\n\t// _selectively_ forgiving (specifically when the list includes at least\n\t// one valid selector).\n\t// Note that we treat complete lack of support for `:has()` as if it were\n\t// spec-compliant support, which is fine because use of `:has()` in such\n\t// environments will fail in the qSA path and fall back to jQuery traversal\n\t// anyway.\n\tsupport.cssHas = assert( function() {\n\t\ttry {\n\t\t\tdocument.querySelector( \":has(*,:jqfake)\" );\n\t\t\treturn false;\n\t\t} catch ( e ) {\n\t\t\treturn true;\n\t\t}\n\t} );\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter.ID = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter.ID =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode( \"id\" );\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( ( elem = elems[ i++ ] ) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find.TAG = function( tag, context ) {\n\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t// DocumentFragment nodes don't have gEBTN\n\t\t} else {\n\t\t\treturn context.querySelectorAll( tag );\n\t\t}\n\t};\n\n\t// Class\n\tExpr.find.CLASS = function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\trbuggyQSA = [];\n\n\t// Build QSA regex\n\t// Regex strategy adopted from Diego Perini\n\tassert( function( el ) {\n\n\t\tvar input;\n\n\t\tdocumentElement.appendChild( el ).innerHTML =\n\t\t\t\"<a id='\" + expando + \"' href='' disabled='disabled'></a>\" +\n\t\t\t\"<select id='\" + expando + \"-\\r\\\\' disabled='disabled'>\" +\n\t\t\t\"<option selected=''></option></select>\";\n\n\t\t// Support: iOS <=7 - 8 only\n\t\t// Boolean attributes and \"value\" are not treated correctly in some XML documents\n\t\tif ( !el.querySelectorAll( \"[selected]\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t}\n\n\t\t// Support: iOS <=7 - 8 only\n\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\trbuggyQSA.push( \"~=\" );\n\t\t}\n\n\t\t// Support: iOS 8 only\n\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\trbuggyQSA.push( \".#.+[+~]\" );\n\t\t}\n\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tif ( !el.querySelectorAll( \":checked\" ).length ) {\n\t\t\trbuggyQSA.push( \":checked\" );\n\t\t}\n\n\t\t// Support: Windows 8 Native Apps\n\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tdocumentElement.appendChild( el ).disabled = true;\n\t\tif ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\n\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t}\n\n\t\t// Support: IE 11+, Edge 15 - 18+\n\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t// Adding a temporary attribute to the document before the selection works\n\t\t// around the issue.\n\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"name\", \"\" );\n\t\tel.appendChild( input );\n\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\n\t\t}\n\t} );\n\n\tif ( !support.cssHas ) {\n\n\t\t// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+\n\t\t// Our regular `try-catch` mechanism fails to detect natively-unsupported\n\t\t// pseudo-classes inside `:has()` (such as `:has(:contains(\"Foo\"))`)\n\t\t// in browsers that parse the `:has()` argument as a forgiving selector list.\n\t\t// https://drafts.csswg.org/selectors/#relational now requires the argument\n\t\t// to be parsed unforgivingly, but browsers have not yet fully adjusted.\n\t\trbuggyQSA.push( \":has\" );\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = function( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( a === document || a.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, a ) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( b === document || b.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, b ) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t};\n\n\treturn document;\n}\n\nfind.matches = function( expr, elements ) {\n\treturn find( expr, null, null, elements );\n};\n\nfind.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn find( expr, document, null, [ elem ] ).length > 0;\n};\n\nfind.contains = function( context, elem ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( context.ownerDocument || context ) != document ) {\n\t\tsetDocument( context );\n\t}\n\treturn jQuery.contains( context, elem );\n};\n\n\nfind.attr = function( elem, name ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( elem.ownerDocument || elem ) != document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\n\t\t// Don't get fooled by Object.prototype properties (see trac-13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\tif ( val !== undefined ) {\n\t\treturn val;\n\t}\n\n\treturn elem.getAttribute( name );\n};\n\nfind.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\njQuery.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\t//\n\t// Support: Android <=4.0+\n\t// Testing for detecting duplicates is unpredictable so instead assume we can't\n\t// depend on duplicate detection in all browsers without a stable sort.\n\thasDuplicate = !support.sortStable;\n\tsortInput = !support.sortStable && slice.call( results, 0 );\n\tsort.call( results, sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tsplice.call( results, duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\njQuery.fn.uniqueSort = function() {\n\treturn this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );\n};\n\nExpr = jQuery.expr = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\tATTR: function( match ) {\n\t\t\tmatch[ 1 ] = match[ 1 ].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || \"\" )\n\t\t\t\t.replace( runescape, funescape );\n\n\t\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\tCHILD: function( match ) {\n\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" )\n\t\t\t\t);\n\t\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[ 3 ] ) {\n\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\tPSEUDO: function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\t\tif ( matchExpr.CHILD.test( match[ 0 ] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[ 3 ] ) {\n\t\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length ) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\tTAG: function( nodeNameSelector ) {\n\t\t\tvar expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn nodeName( elem, expectedNodeName );\n\t\t\t\t};\n\t\t},\n\n\t\tCLASS: function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace + \")\" + className +\n\t\t\t\t\t\"(\" + whitespace + \"|$)\" ) ) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\tATTR: function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = find.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\tif ( operator === \"=\" ) {\n\t\t\t\t\treturn result === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"!=\" ) {\n\t\t\t\t\treturn result !== check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"^=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) === 0;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"*=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"$=\" ) {\n\t\t\t\t\treturn check && result.slice( -check.length ) === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"~=\" ) {\n\t\t\t\t\treturn ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" )\n\t\t\t\t\t\t.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"|=\" ) {\n\t\t\t\t\treturn result === check || result.slice( 0, check.length + 1 ) === check + \"-\";\n\t\t\t\t}\n\n\t\t\t\treturn false;\n\t\t\t};\n\t\t},\n\n\t\tCHILD: function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\t\t\t\t\t\t\touterCache = parent[ expando ] || ( parent[ expando ] = {} );\n\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\t\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ expando ] = {} );\n\t\t\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\tPSEUDO: function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// https://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tfind.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as jQuery does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction( function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf.call( seed, matched[ i ] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[ i ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} ) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\tnot: markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrimCSS, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element\n\t\t\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\thas: markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn find( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\tcontains: markFunction( function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// https://www.w3.org/TR/selectors/#lang-pseudo\n\t\tlang: markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tfind.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\ttarget: function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\troot: function( elem ) {\n\t\t\treturn elem === documentElement;\n\t\t},\n\n\t\tfocus: function( elem ) {\n\t\t\treturn elem === safeActiveElement() &&\n\t\t\t\tdocument.hasFocus() &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\tenabled: createDisabledPseudo( false ),\n\t\tdisabled: createDisabledPseudo( true ),\n\n\t\tchecked: function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\treturn ( nodeName( elem, \"input\" ) && !!elem.checked ) ||\n\t\t\t\t( nodeName( elem, \"option\" ) && !!elem.selected );\n\t\t},\n\n\t\tselected: function( elem ) {\n\n\t\t\t// Support: IE <=11+\n\t\t\t// Accessing the selectedIndex property\n\t\t\t// forces the browser to treat the default option as\n\t\t\t// selected when in an optgroup.\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\tempty: function( elem ) {\n\n\t\t\t// https://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\tparent: function( elem ) {\n\t\t\treturn !Expr.pseudos.empty( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\theader: function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\tinput: function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\tbutton: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"button\" ||\n\t\t\t\tnodeName( elem, \"button\" );\n\t\t},\n\n\t\ttext: function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"text\" &&\n\n\t\t\t\t// Support: IE <10 only\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear\n\t\t\t\t// with elem.type === \"text\"\n\t\t\t\t( ( attr = elem.getAttribute( \"type\" ) ) == null ||\n\t\t\t\t\tattr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\tfirst: createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\tlast: createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\teq: createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\teven: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\todd: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tlt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i;\n\n\t\t\tif ( argument < 0 ) {\n\t\t\t\ti = argument + length;\n\t\t\t} else if ( argument > length ) {\n\t\t\t\ti = length;\n\t\t\t} else {\n\t\t\t\ti = argument;\n\t\t\t}\n\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tgt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\nExpr.pseudos.nth = Expr.pseudos.eq;\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\nfunction tokenize( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rleadingCombinator.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrimCSS, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\tif ( parseOnly ) {\n\t\treturn soFar.length;\n\t}\n\n\treturn soFar ?\n\t\tfind.error( selector ) :\n\n\t\t// Cache the tokens\n\t\ttokenCache( selector, groups ).slice( 0 );\n}\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\n\t\t\t\t\t\tif ( skip && nodeName( elem, skip ) ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = outerCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\touterCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tfind( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem, matcherOut,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed ||\n\t\t\t\tmultipleContexts( selector || \"*\",\n\t\t\t\t\tcontext.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems;\n\n\t\tif ( matcher ) {\n\n\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter\n\t\t\t// or preexisting results,\n\t\t\tmatcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t[] :\n\n\t\t\t\t// ...otherwise use results directly\n\t\t\t\tresults;\n\n\t\t\t// Find primary matches\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t} else {\n\t\t\tmatcherOut = matcherIn;\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf.call( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tvar ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element\n\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 )\n\t\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrimCSS, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find.TAG( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: iOS <=7 - 9 only\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching\n\t\t\t// elements by id. (see trac-14142)\n\t\t\tfor ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tjQuery.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\nfunction compile( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n}\n\n/**\n * A low-level selection function that works with jQuery's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with jQuery selector compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nfunction select( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find.ID(\n\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\tcontext\n\t\t\t) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = Expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) || context\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n}\n\n// One-time assignments\n\n// Support: Android <=4.0 - 4.1+\n// Sort stability\nsupport.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Android <=4.0 - 4.1+\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert( function( el ) {\n\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement( \"fieldset\" ) ) & 1;\n} );\n\njQuery.find = find;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.unique = jQuery.uniqueSort;\n\n// These have always been private, but they used to be documented as part of\n// Sizzle so let's maintain them for now for backwards compatibility purposes.\nfind.compile = compile;\nfind.select = select;\nfind.setDocument = setDocument;\nfind.tokenize = tokenize;\n\nfind.escape = jQuery.escapeSelector;\nfind.getText = jQuery.text;\nfind.isXML = jQuery.isXMLDoc;\nfind.selectors = jQuery.expr;\nfind.support = jQuery.support;\nfind.uniqueSort = jQuery.uniqueSort;\n\n\t/* eslint-enable */\n\n} )();\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\nvar rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\n\n\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)\n\t// Strict HTML recognition (trac-11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to jQuery#find\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// <object> elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\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 */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && isFunction( ( method = value.promise ) ) ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && isFunction( ( method = value.then ) ) ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\n\t\t// Support: Android 4.0 only\n\t\t// Strict mode functions invoked without .call/.apply get global-object context\n\t\treject.apply( undefined, [ value ] );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\t\"catch\": function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( _i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( isFunction( then ) ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.error );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the error, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getErrorHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getErrorHook();\n\n\t\t\t\t\t\t\t\t// The deprecated alias of the above. While the name suggests\n\t\t\t\t\t\t\t\t// returning the stack, not an error instance, jQuery just passes\n\t\t\t\t\t\t\t\t// it directly to `console.warn` so both will work; an instance\n\t\t\t\t\t\t\t\t// just better cooperates with source maps.\n\t\t\t\t\t\t\t\t} else if ( jQuery.Deferred.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getStackHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onProgress ) ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onFulfilled ) ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onRejected ) ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the primary Deferred\n\t\t\tprimary = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tprimary.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( primary.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn primary.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );\n\t\t}\n\n\t\treturn primary.promise();\n\t}\n} );\n\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error\n// captured before the async barrier to get the original error cause\n// which may otherwise be hidden.\njQuery.Deferred.exceptionHook = function( error, asyncError ) {\n\n\t// Support: IE 8 - 9 only\n\t// Console exists when dev tools are open, which can happen at any time\n\tif ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn( \"jQuery.Deferred exception: \" + error.message,\n\t\t\terror.stack, asyncError );\n\t}\n};\n\n\n\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n\n\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See trac-6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\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\nif ( document.readyState === \"complete\" ||\n\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, _key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\t\tvalue :\n\t\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n};\n\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\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 (trac-9572)\nfunction camelCase( string ) {\n\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n}\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see trac-8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\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\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11 only\n\t\t\t\t\t\t// The attrs elements can be null (trac-14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar documentElement = document.documentElement;\n\n\n\n\tvar isAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t\t},\n\t\tcomposed = { composed: true };\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n\t// Check attachment across shadow DOM boundaries when possible (gh-3504)\n\t// Support: iOS 10.0-10.2 only\n\t// Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n\t// leading to errors. We need to check for `getRootNode`.\n\tif ( documentElement.getRootNode ) {\n\t\tisAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t\t};\n\t}\nvar isHiddenWithinTree = function( elem, el ) {\n\n\t\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\n\t\t// Inline style trumps all\n\t\treturn elem.style.display === \"none\" ||\n\t\t\telem.style.display === \"\" &&\n\n\t\t\t// Otherwise, check computed style\n\t\t\t// Support: Firefox <=43 - 45\n\t\t\t// Disconnected elements can have computed display: none, so first confirm that elem is\n\t\t\t// in the document.\n\t\t\tisAttached( elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = elem.nodeType &&\n\t\t\t( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i );\n\nvar rscriptType = ( /^$|^module$|\\/(?:java|ecma)script/i );\n\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0 - 4.3 only\n\t// Check state lost if the name is set (trac-11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (trac-14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Android <=4.1 only\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE <=11 only\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\n\t// Support: IE <=9 only\n\t// IE <=9 replaces <option> tags with their contents when inserted outside of\n\t// the select element.\n\tdiv.innerHTML = \"<option></option>\";\n\tsupport.option = !!div.lastChild;\n} )();\n\n\n// We have to close these tags to support XHTML (trac-13200)\nvar wrapMap = {\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n// Support: IE <=9 only\nif ( !support.option ) {\n\twrapMap.optgroup = wrapMap.option = [ 1, \"<select multiple='multiple'>\", \"</select>\" ];\n}\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11 only\n\t// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\tret = context.getElementsByTagName( tag || \"*\" );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, attached, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (trac-12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tattached = isAttached( elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( attached ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\nvar rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\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 */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = Object.create( null );\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t)[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: IE <=9\n\t\t\t// Black-hole SVG <use> instance trees (trac-13180)\n\t\t\tcur.nodeType &&\n\n\t\t\t// Support: Firefox <=42\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11 only\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (trac-13208)\n\t\t\t\t// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (trac-13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", true );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\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.\nfunction leverageNative( el, type, isSetup ) {\n\n\t// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !isSetup ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\tif ( !saved ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object), so this array\n\t\t\t\t\t// will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tdataPriv.set( this, type, false );\n\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\n\t\t\t\t\t\treturn result;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling surrogate\n\t\t\t\t// (focus or blur), assume that the surrogate already propagated from triggering\n\t\t\t\t// the native event and prevent that from happening again here.\n\t\t\t\t// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n\t\t\t\t// bubbling surrogate propagates *after* the non-bubbling base), but that seems\n\t\t\t\t// less bad than duplication.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order\n\t\t\t// Fire an inner synthetic event with the original arguments\n\t\t\t} else if ( saved ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, jQuery.event.trigger(\n\t\t\t\t\tsaved[ 0 ],\n\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\tthis\n\t\t\t\t) );\n\n\t\t\t\t// Abort handling of the native event by all jQuery handlers while allowing\n\t\t\t\t// native handlers on the same element to run. On target, this is achieved\n\t\t\t\t// by stopping immediate propagation just on the jQuery event. However,\n\t\t\t\t// the native event is re-wrapped by a jQuery one on each level of the\n\t\t\t\t// propagation so the only way to stop it for jQuery is to stop it for\n\t\t\t\t// everyone via native `stopPropagation()`. This is not a problem for\n\t\t\t\t// focus/blur which don't bubble, but it does also stop click on checkboxes\n\t\t\t\t// and radios. We accept this limitation.\n\t\t\t\tevent.stopPropagation();\n\t\t\t\tevent.isImmediatePropagationStopped = returnTrue;\n\t\t\t}\n\t\t}\n\t} );\n}\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android <=2.3 only\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\t// Support: Safari <=6 - 7 only\n\t\t// Target should not be a text node (trac-504, trac-13143)\n\t\tthis.target = ( src.target && src.target.nodeType === 3 ) ?\n\t\t\tsrc.target.parentNode :\n\t\t\tsrc.target;\n\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\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\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcode: true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\twhich: true\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\n\tfunction focusMappedHandler( nativeEvent ) {\n\t\tif ( document.documentMode ) {\n\n\t\t\t// Support: IE 11+\n\t\t\t// Attach a single focusin/focusout handler on the document while someone wants\n\t\t\t// focus/blur. This is because the former are synchronous in IE while the latter\n\t\t\t// are async. In other browsers, all those handlers are invoked synchronously.\n\n\t\t\t// `handle` from private data would already wrap the event, but we need\n\t\t\t// to change the `type` here.\n\t\t\tvar handle = dataPriv.get( this, \"handle\" ),\n\t\t\t\tevent = jQuery.event.fix( nativeEvent );\n\t\t\tevent.type = nativeEvent.type === \"focusin\" ? \"focus\" : \"blur\";\n\t\t\tevent.isSimulated = true;\n\n\t\t\t// First, handle focusin/focusout\n\t\t\thandle( nativeEvent );\n\n\t\t\t// ...then, handle focus/blur\n\t\t\t//\n\t\t\t// focus/blur don't bubble while focusin/focusout do; simulate the former by only\n\t\t\t// invoking the handler at the lower level.\n\t\t\tif ( event.target === event.currentTarget ) {\n\n\t\t\t\t// The setup part calls `leverageNative`, which, in turn, calls\n\t\t\t\t// `jQuery.event.add`, so event handle will already have been set\n\t\t\t\t// by this point.\n\t\t\t\thandle( event );\n\t\t\t}\n\t\t} else {\n\n\t\t\t// For non-IE browsers, attach a single capturing handler on the document\n\t\t\t// while someone wants focusin/focusout.\n\t\t\tjQuery.event.simulate( delegateType, nativeEvent.target,\n\t\t\t\tjQuery.event.fix( nativeEvent ) );\n\t\t}\n\t}\n\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\tvar attaches;\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, true );\n\n\t\t\tif ( document.documentMode ) {\n\n\t\t\t\t// Support: IE 9 - 11+\n\t\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\t\tattaches = dataPriv.get( this, delegateType );\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t}\n\t\t\t\tdataPriv.set( this, delegateType, ( attaches || 0 ) + 1 );\n\t\t\t} else {\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tvar attaches;\n\n\t\t\tif ( document.documentMode ) {\n\t\t\t\tattaches = dataPriv.get( this, delegateType ) - 1;\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t\tdataPriv.remove( this, delegateType );\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.set( this, delegateType, attaches );\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Return false to indicate standard teardown should be applied\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\n\t\t// Suppress native focus or blur if we're currently inside\n\t\t// a leveraged native-event stack\n\t\t_default: function( event ) {\n\t\t\treturn dataPriv.get( event.target, type );\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n\n\t// Support: Firefox <=44\n\t// Firefox doesn't have focus(in | out) events\n\t// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n\t//\n\t// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n\t// focus(in | out) events fire after focus & blur events,\n\t// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n\t// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\n\t//\n\t// Support: IE 9 - 11+\n\t// To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch,\n\t// attach a single handler for both events in IE.\n\tjQuery.event.special[ delegateType ] = {\n\t\tsetup: function() {\n\n\t\t\t// Handle: regular nodes (via `this.ownerDocument`), window\n\t\t\t// (via `this.document`) & document (via `this`).\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType );\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.addEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t}\n\t\t\tdataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 );\n\t\t},\n\t\tteardown: function() {\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType ) - 1;\n\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.removeEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( dataHolder, delegateType );\n\t\t\t} else {\n\t\t\t\tdataPriv.set( dataHolder, delegateType, attaches );\n\t\t\t}\n\t\t}\n\t};\n} );\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).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\n\t// Support: IE <=10 - 11, Edge 12 - 13 only\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\n\trcleanScript = /^\\s*<!\\[CDATA\\[|\\]\\]>\\s*$/g;\n\n// Prefer a tbody over its parent table for containing new rows\nfunction manipulationTarget( elem, content ) {\n\tif ( nodeName( elem, \"table\" ) &&\n\t\tnodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\n\n\t\treturn jQuery( elem ).children( \"tbody\" )[ 0 ] || elem;\n\t}\n\n\treturn elem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.get( src );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdataPriv.remove( dest, \"handle events\" );\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = flat( args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( valueIsFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (trac-8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Re-enable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce || node.getAttribute( \"nonce\" )\n\t\t\t\t\t\t\t\t}, doc );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Unwrap a CDATA section containing script contents. This shouldn't be\n\t\t\t\t\t\t\t// needed as in XML documents they're already not visible when\n\t\t\t\t\t\t\t// inspecting element contents and in HTML documents they have no\n\t\t\t\t\t\t\t// meaning but we're preserving that logic for backwards compatibility.\n\t\t\t\t\t\t\t// This will be removed completely in 4.0. See gh-4904.\n\t\t\t\t\t\t\tDOMEval( node.textContent.replace( rcleanScript, \"\" ), node, doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && isAttached( node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html;\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = isAttached( elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew jQuery#find here for performance reasons:\n\t\t\t// https://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t// .get() because push.apply(_, arraylike) throws on ancient WebKit\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar rcustomProp = /^--/;\n\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar swap = function( elem, options, callback ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.call( elem );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\nvar rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\n\n\n\n( function() {\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\n\t\t// This is a singleton, we need to execute it only once\n\t\tif ( !div ) {\n\t\t\treturn;\n\t\t}\n\n\t\tcontainer.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n\t\t\t\"margin-top:1px;padding:0;border:0\";\n\t\tdiv.style.cssText =\n\t\t\t\"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"width:60%;top:1%\";\n\t\tdocumentElement.appendChild( container ).appendChild( div );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\n\t\t// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\t\treliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;\n\n\t\t// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.right = \"60%\";\n\t\tpixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\n\n\t\t// Support: IE 9 - 11 only\n\t\t// Detect misreporting of content dimensions for box-sizing:border-box elements\n\t\tboxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\n\n\t\t// Support: IE 9 only\n\t\t// Detect overflow:scroll screwiness (gh-3699)\n\t\t// Support: Chrome <=64\n\t\t// Don't get tricked when zoom affects offsetWidth (gh-4029)\n\t\tdiv.style.position = \"absolute\";\n\t\tscrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;\n\n\t\tdocumentElement.removeChild( container );\n\n\t\t// Nullify the div so it wouldn't be stored in the memory and\n\t\t// it will also be a sign that checks already performed\n\t\tdiv = null;\n\t}\n\n\tfunction roundPixelMeasures( measure ) {\n\t\treturn Math.round( parseFloat( measure ) );\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\n\t\treliableTrDimensionsVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE <=9 - 11 only\n\t// Style of cloned element affects source element cloned (trac-8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tjQuery.extend( support, {\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelBoxStyles: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelBoxStylesVal;\n\t\t},\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\tscrollboxSize: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn scrollboxSizeVal;\n\t\t},\n\n\t\t// Support: IE 9 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Behavior in IE 9 is more subtle than in newer versions & it passes\n\t\t// some versions of this test; make sure not to make it pass there!\n\t\t//\n\t\t// Support: Firefox 70+\n\t\t// Only Firefox includes border widths\n\t\t// in computed dimensions. (gh-4529)\n\t\treliableTrDimensions: function() {\n\t\t\tvar table, tr, trChild, trStyle;\n\t\t\tif ( reliableTrDimensionsVal == null ) {\n\t\t\t\ttable = document.createElement( \"table\" );\n\t\t\t\ttr = document.createElement( \"tr\" );\n\t\t\t\ttrChild = document.createElement( \"div\" );\n\n\t\t\t\ttable.style.cssText = \"position:absolute;left:-11111px;border-collapse:separate\";\n\t\t\t\ttr.style.cssText = \"box-sizing:content-box;border:1px solid\";\n\n\t\t\t\t// Support: Chrome 86+\n\t\t\t\t// Height set through cssText does not get applied.\n\t\t\t\t// Computed height then comes back as 0.\n\t\t\t\ttr.style.height = \"1px\";\n\t\t\t\ttrChild.style.height = \"9px\";\n\n\t\t\t\t// Support: Android 8 Chrome 86+\n\t\t\t\t// In our bodyBackground.html iframe,\n\t\t\t\t// display for all div elements is set to \"inline\",\n\t\t\t\t// which causes a problem only in Android 8 Chrome 86.\n\t\t\t\t// Ensuring the div is `display: block`\n\t\t\t\t// gets around this issue.\n\t\t\t\ttrChild.style.display = \"block\";\n\n\t\t\t\tdocumentElement\n\t\t\t\t\t.appendChild( table )\n\t\t\t\t\t.appendChild( tr )\n\t\t\t\t\t.appendChild( trChild );\n\n\t\t\t\ttrStyle = window.getComputedStyle( tr );\n\t\t\t\treliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderTopWidth, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;\n\n\t\t\t\tdocumentElement.removeChild( table );\n\t\t\t}\n\t\t\treturn reliableTrDimensionsVal;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\t\tisCustomProp = rcustomProp.test( name ),\n\n\t\t// Support: Firefox 51+\n\t\t// Retrieving style before computed somehow\n\t\t// fixes an issue with getting wrong values\n\t\t// on detached elements\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for:\n\t//   .css('filter') (IE 9 only, trac-12537)\n\t//   .css('--customProperty) (gh-3144)\n\tif ( computed ) {\n\n\t\t// Support: IE <=9 - 11+\n\t\t// IE only supports `\"float\"` in `getPropertyValue`; in computed styles\n\t\t// it's only available as `\"cssFloat\"`. We no longer modify properties\n\t\t// sent to `.css()` apart from camelCasing, so we need to check both.\n\t\t// Normally, this would create difference in behavior: if\n\t\t// `getPropertyValue` returns an empty string, the value returned\n\t\t// by `.css()` would be `undefined`. This is usually the case for\n\t\t// disconnected elements. However, in IE even disconnected elements\n\t\t// with no styles return `\"none\"` for `getPropertyValue( \"float\" )`\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( isCustomProp && ret ) {\n\n\t\t\t// Support: Firefox 105+, Chrome <=105+\n\t\t\t// Spec requires trimming whitespace for custom properties (gh-4926).\n\t\t\t// Firefox only trims leading whitespace. Chrome just collapses\n\t\t\t// both leading & trailing whitespace to a single space.\n\t\t\t//\n\t\t\t// Fall back to `undefined` if empty string returned.\n\t\t\t// This collapses a missing definition with property defined\n\t\t\t// and set to an empty string but there's no standard API\n\t\t\t// allowing us to differentiate them without a performance penalty\n\t\t\t// and returning `undefined` aligns with older jQuery.\n\t\t\t//\n\t\t\t// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED\n\t\t\t// as whitespace while CSS does not, but this is not a problem\n\t\t\t// because CSS preprocessing replaces them with U+000A LINE FEED\n\t\t\t// (which *is* CSS whitespace)\n\t\t\t// https://www.w3.org/TR/css-syntax-3/#input-preprocessing\n\t\t\tret = ret.replace( rtrimCSS, \"$1\" ) || undefined;\n\t\t}\n\n\t\tif ( ret === \"\" && !isAttached( elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// https://drafts.csswg.org/cssom/#resolved-values\n\t\tif ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11 only\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style,\n\tvendorProps = {};\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a potentially-mapped jQuery.cssProps or vendor prefixed property\nfunction finalPropName( name ) {\n\tvar final = jQuery.cssProps[ name ] || vendorProps[ name ];\n\n\tif ( final ) {\n\t\treturn final;\n\t}\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorProps[ name ] = vendorPropName( name ) || name;\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t};\n\nfunction setPositiveNumber( _elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0,\n\t\tmarginDelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\t// Count margin delta separately to only add it after scroll gutter adjustment.\n\t\t// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).\n\t\tif ( box === \"margin\" ) {\n\t\t\tmarginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta + marginDelta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = !support.boxSizingReliable() || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Support: Firefox <=54\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\t// Support: IE 9 - 11 only\n\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t// In those cases, the computed value can be trusted to be border-box.\n\tif ( ( !support.boxSizingReliable() && isBorderBox ||\n\n\t\t// Support: IE 10 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Interestingly, in some cases IE 9 doesn't suffer from this issue.\n\t\t!support.reliableTrDimensions() && nodeName( elem, \"tr\" ) ||\n\n\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\tval === \"auto\" ||\n\n\t\t// Support: Android <=4.1 - 4.3 only\n\t\t// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n\t\t!parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\tanimationIterationCount: true,\n\t\taspectRatio: true,\n\t\tborderImageSlice: true,\n\t\tcolumnCount: true,\n\t\tflexGrow: true,\n\t\tflexShrink: true,\n\t\tfontWeight: true,\n\t\tgridArea: true,\n\t\tgridColumn: true,\n\t\tgridColumnEnd: true,\n\t\tgridColumnStart: true,\n\t\tgridRow: true,\n\t\tgridRowEnd: true,\n\t\tgridRowStart: true,\n\t\tlineHeight: true,\n\t\topacity: true,\n\t\torder: true,\n\t\torphans: true,\n\t\tscale: true,\n\t\twidows: true,\n\t\tzIndex: true,\n\t\tzoom: true,\n\n\t\t// SVG-related\n\t\tfillOpacity: true,\n\t\tfloodOpacity: true,\n\t\tstopOpacity: true,\n\t\tstrokeMiterlimit: true,\n\t\tstrokeOpacity: true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (trac-7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug trac-9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (trac-7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\t// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n\t\t\t// \"px\" to a few hardcoded values.\n\t\t\tif ( type === \"number\" && !isCustomProp ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\n\t\t\t\t\t// Support: Safari 8+\n\t\t\t\t\t// Table columns in Safari have non-zero offsetWidth & zero\n\t\t\t\t\t// getBoundingClientRect().width unless display is changed.\n\t\t\t\t\t// Support: IE <=11 only\n\t\t\t\t\t// Running getBoundingClientRect on a disconnected node\n\t\t\t\t\t// in IE throws an error.\n\t\t\t\t\t( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\n\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t} ) :\n\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\n\t\t\t\t// Only read styles.position if the test has a chance to fail\n\t\t\t\t// to avoid forcing a reflow.\n\t\t\t\tscrollboxSizeBuggy = !support.scrollboxSize() &&\n\t\t\t\t\tstyles.position === \"absolute\",\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tboxSizingNeeded = scrollboxSizeBuggy || extra,\n\t\t\t\tisBorderBox = boxSizingNeeded &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Account for unreliable border-box dimensions by comparing offset* to computed and\n\t\t\t// faking a content-box to get border and padding (gh-3699)\n\t\t\tif ( isBorderBox && scrollboxSizeBuggy ) {\n\t\t\t\tsubtract -= Math.ceil(\n\t\t\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\t\t\tparseFloat( styles[ dimension ] ) -\n\t\t\t\t\tboxModelAdjustment( elem, dimension, \"border\", false, styles ) -\n\t\t\t\t\t0.5\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 && (\n\t\t\t\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE <=9 only\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, jQuery.fx.interval );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11, Edge 12 - 15\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY and Edge just mirrors\n\t\t// the overflowX value there.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t/* eslint-disable no-loop-func */\n\n\t\t\tanim.done( function() {\n\n\t\t\t\t/* eslint-enable no-loop-func */\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3 only\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tisFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !isFunction( easing ) && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\n\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: Android <=4.3 only\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE <=11 only\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: IE <=11 only\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tnodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( _i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle,\n\t\t\tlowercaseName = name.toLowerCase();\n\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ lowercaseName ];\n\t\t\tattrHandle[ lowercaseName ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tlowercaseName :\n\t\t\t\tnull;\n\t\t\tattrHandle[ lowercaseName ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11 only\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// Use proper attribute retrieval (trac-12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\trclickable.test( elem.nodeName ) &&\n\t\t\t\t\telem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\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\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\n\t// Strip and collapse whitespace according to HTML spec\n\t// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\tfunction stripAndCollapse( value ) {\n\t\tvar tokens = value.match( rnothtmlwhite ) || [];\n\t\treturn tokens.join( \" \" );\n\t}\n\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + className + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += className + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + className + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + className + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar classNames, className, i, self,\n\t\t\ttype = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\treturn this.each( function() {\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\tself = jQuery( this );\n\n\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle most common string cases\n\t\t\t\tif ( typeof ret === \"string\" ) {\n\t\t\t\t\treturn ret.replace( rreturn, \"\" );\n\t\t\t\t}\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE <=10 - 11 only\n\t\t\t\t\t// option.text throws exceptions (trac-14686, trac-14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (trac-2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t/* eslint-disable no-cond-assign */\n\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t/* eslint-enable no-cond-assign */\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\nvar location = window.location;\n\nvar nonce = { guid: Date.now() };\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, parserErrorElem;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11 only\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {}\n\n\tparserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\n\tif ( !xml || parserErrorElem ) {\n\t\tjQuery.error( \"Invalid XML: \" + (\n\t\t\tparserErrorElem ?\n\t\t\t\tjQuery.map( parserErrorElem.childNodes, function( el ) {\n\t\t\t\t\treturn el.textContent;\n\t\t\t\t} ).join( \"\\n\" ) :\n\t\t\t\tdata\n\t\t) );\n\t}\n\treturn xml;\n};\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (trac-9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || Object.create( null ) )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (trac-6170)\n\t\t\t\tif ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = isFunction( valueOrFunction ) ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\tif ( a == null ) {\n\t\treturn \"\";\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} ).filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} ).map( function( _i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// trac-7653, trac-8125, trac-8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\noriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes trac-9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\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 */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( match[ 2 ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() + \" \" ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match.join( \", \" );\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (trac-10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket trac-12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11, Edge 12 - 15\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11 only\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// trac-9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce.guid++ ) +\n\t\t\t\t\tuncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Use a noop converter for missing script but not if jsonp\n\t\t\tif ( !isSuccess &&\n\t\t\t\tjQuery.inArray( \"script\", s.dataTypes ) > -1 &&\n\t\t\t\tjQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\n\njQuery._evalUrl = function( url, options, doc ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (trac-11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( isFunction( html ) ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\n\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE <=9 only\n\t\t// trac-1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.ontimeout =\n\t\t\t\t\t\t\t\t\txhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see trac-8605, trac-14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t\t// Support: IE 9 only\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// trac-14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain or forced-by-attrs requests\n\tif ( s.crossDomain || s.scriptAttrs ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" )\n\t\t\t\t\t.attr( s.scriptAttrs || {} )\n\t\t\t\t\t.prop( { charset: s.scriptCharset, src: s.url } )\n\t\t\t\t\t.on( \"load error\", callback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce.guid++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\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\nsupport.createHTMLDocument = ( function() {\n\tvar body = document.implementation.createHTMLDocument( \"\" ).body;\n\tbody.innerHTML = \"<form></form><form></form>\";\n\treturn body.childNodes.length === 2;\n} )();\n\n\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\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( typeof data !== \"string\" ) {\n\t\treturn [];\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\n\tvar base, parsed, scripts;\n\n\tif ( !context ) {\n\n\t\t// Stop scripts or inline event handlers from being executed immediately\n\t\t// by using document.implementation\n\t\tif ( support.createHTMLDocument ) {\n\t\t\tcontext = document.implementation.createHTMLDocument( \"\" );\n\n\t\t\t// Set the base href for the created document\n\t\t\t// so any parsed elements with URLs\n\t\t\t// are based on the document's URL (gh-2965)\n\t\t\tbase = context.createElement( \"base\" );\n\t\t\tbase.href = document.location.href;\n\t\t\tcontext.head.appendChild( base );\n\t\t} else {\n\t\t\tcontext = document;\n\t\t}\n\t}\n\n\tparsed = rsingleTag.exec( data );\n\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = stripAndCollapse( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\njQuery.expr.pseudos.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\n\t// offset() relates an element's border box to the document origin\n\toffset: function( options ) {\n\n\t\t// Preserve chaining for setter\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar rect, win,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !elem ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n\t\t// Support: IE <=11 only\n\t\t// Running getBoundingClientRect on a\n\t\t// disconnected node in IE throws an error\n\t\tif ( !elem.getClientRects().length ) {\n\t\t\treturn { top: 0, left: 0 };\n\t\t}\n\n\t\t// Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\t\trect = elem.getBoundingClientRect();\n\t\twin = elem.ownerDocument.defaultView;\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset,\n\t\t\tleft: rect.left + win.pageXOffset\n\t\t};\n\t},\n\n\t// position() relates an element's margin box to its offset parent's padding box\n\t// This corresponds to the behavior of CSS absolute positioning\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset, doc,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// position:fixed elements are offset from the viewport, which itself always has zero offset\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume position:fixed implies availability of getBoundingClientRect\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\t\t\toffset = this.offset();\n\n\t\t\t// Account for the *real* offset parent, which can be the document or its root element\n\t\t\t// when a statically positioned element is identified\n\t\t\tdoc = elem.ownerDocument;\n\t\t\toffsetParent = elem.offsetParent || doc.documentElement;\n\t\t\twhile ( offsetParent &&\n\t\t\t\t( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\n\t\t\t\toffsetParent = offsetParent.parentNode;\n\t\t\t}\n\t\t\tif ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\n\n\t\t\t\t// Incorporate borders into its offset, since they are outside its content origin\n\t\t\t\tparentOffset = jQuery( offsetParent ).offset();\n\t\t\t\tparentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\n\t\t\t\tparentOffset.left += jQuery.css( offsetParent, \"borderLeftWidth\", true );\n\t\t\t}\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\n\t\t\t// Coalesce documents and windows\n\t\t\tvar win;\n\t\t\tif ( isWindow( elem ) ) {\n\t\t\t\twin = elem;\n\t\t\t} else if ( elem.nodeType === 9 ) {\n\t\t\t\twin = elem.defaultView;\n\t\t\t}\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\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\njQuery.each( [ \"top\", \"left\" ], function( _i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( {\n\t\tpadding: \"inner\" + name,\n\t\tcontent: type,\n\t\t\"\": \"outer\" + name\n\t}, function( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( isWindow( elem ) ) {\n\n\t\t\t\t\t// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n\t\t\t\t\treturn funcName.indexOf( \"outer\" ) === 0 ?\n\t\t\t\t\t\telem[ \"inner\" + name ] :\n\t\t\t\t\t\telem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable );\n\t\t};\n\t} );\n} );\n\n\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( _i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t},\n\n\thover: function( fnOver, fnOut ) {\n\t\treturn this\n\t\t\t.on( \"mouseenter\", fnOver )\n\t\t\t.on( \"mouseleave\", fnOut || fnOver );\n\t}\n} );\n\njQuery.each(\n\t( \"blur focus focusin focusout resize scroll click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\n\tfunction( _i, name ) {\n\n\t\t// Handle event binding\n\t\tjQuery.fn[ name ] = function( data, fn ) {\n\t\t\treturn arguments.length > 0 ?\n\t\t\t\tthis.on( name, null, data, fn ) :\n\t\t\t\tthis.trigger( name );\n\t\t};\n\t}\n);\n\n\n\n\n// Support: Android <=4.0 only\n// Make sure we trim BOM and NBSP\n// Require that the \"whitespace run\" starts from a non-whitespace\n// to avoid O(N^2) behavior when the engine would try matching \"\\s+$\" at each space position.\nvar rtrim = /^[\\s\\uFEFF\\xA0]+|([^\\s\\uFEFF\\xA0])[\\s\\uFEFF\\xA0]+$/g;\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\njQuery.proxy = function( fn, context ) {\n\tvar tmp, args, proxy;\n\n\tif ( typeof context === \"string\" ) {\n\t\ttmp = fn[ context ];\n\t\tcontext = fn;\n\t\tfn = tmp;\n\t}\n\n\t// Quick check to determine if target is callable, in the spec\n\t// this throws a TypeError, but we will just return undefined.\n\tif ( !isFunction( fn ) ) {\n\t\treturn undefined;\n\t}\n\n\t// Simulated bind\n\targs = slice.call( arguments, 2 );\n\tproxy = function() {\n\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t};\n\n\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\treturn proxy;\n};\n\njQuery.holdReady = function( hold ) {\n\tif ( hold ) {\n\t\tjQuery.readyWait++;\n\t} else {\n\t\tjQuery.ready( true );\n\t}\n};\njQuery.isArray = Array.isArray;\njQuery.parseJSON = JSON.parse;\njQuery.nodeName = nodeName;\njQuery.isFunction = isFunction;\njQuery.isWindow = isWindow;\njQuery.camelCase = camelCase;\njQuery.type = toType;\n\njQuery.now = Date.now;\n\njQuery.isNumeric = function( obj ) {\n\n\t// As of jQuery 3.0, isNumeric is limited to\n\t// strings and numbers (primitives or objects)\n\t// that can be coerced to finite numbers (gh-2662)\n\tvar type = jQuery.type( obj );\n\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t!isNaN( obj - parseFloat( obj ) );\n};\n\njQuery.trim = function( text ) {\n\treturn text == null ?\n\t\t\"\" :\n\t\t( text + \"\" ).replace( rtrim, \"$1\" );\n};\n\n\n\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\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\nif ( true ) {\n\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {\n\t\treturn jQuery;\n\t}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n}\n\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (trac-13566)\nif ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n\n\n/***/ }),\n/* 19 */,\n/* 20 */,\n/* 21 */,\n/* 22 */,\n/* 23 */,\n/* 24 */,\n/* 25 */\n/***/ (function(module, exports) {\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar es5 = __webpack_require__(32);\nvar Objectfreeze = es5.freeze;\nvar util = __webpack_require__(6);\nvar inherits = util.inherits;\nvar notEnumerableProp = util.notEnumerableProp;\n\nfunction subError(nameProperty, defaultMessage) {\n    function SubError(message) {\n        if (!(this instanceof SubError)) return new SubError(message);\n        notEnumerableProp(this, \"message\",\n            typeof message === \"string\" ? message : defaultMessage);\n        notEnumerableProp(this, \"name\", nameProperty);\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, this.constructor);\n        } else {\n            Error.call(this);\n        }\n    }\n    inherits(SubError, Error);\n    return SubError;\n}\n\nvar _TypeError, _RangeError;\nvar Warning = subError(\"Warning\", \"warning\");\nvar CancellationError = subError(\"CancellationError\", \"cancellation error\");\nvar TimeoutError = subError(\"TimeoutError\", \"timeout error\");\nvar AggregateError = subError(\"AggregateError\", \"aggregate error\");\ntry {\n    _TypeError = TypeError;\n    _RangeError = RangeError;\n} catch(e) {\n    _TypeError = subError(\"TypeError\", \"type error\");\n    _RangeError = subError(\"RangeError\", \"range error\");\n}\n\nvar methods = (\"join pop push shift unshift slice filter forEach some \" +\n    \"every map indexOf lastIndexOf reduce reduceRight sort reverse\").split(\" \");\n\nfor (var i = 0; i < methods.length; ++i) {\n    if (typeof Array.prototype[methods[i]] === \"function\") {\n        AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];\n    }\n}\n\nes5.defineProperty(AggregateError.prototype, \"length\", {\n    value: 0,\n    configurable: false,\n    writable: true,\n    enumerable: true\n});\nAggregateError.prototype[\"isOperational\"] = true;\nvar level = 0;\nAggregateError.prototype.toString = function() {\n    var indent = Array(level * 4 + 1).join(\" \");\n    var ret = \"\\n\" + indent + \"AggregateError of:\" + \"\\n\";\n    level++;\n    indent = Array(level * 4 + 1).join(\" \");\n    for (var i = 0; i < this.length; ++i) {\n        var str = this[i] === this ? \"[Circular AggregateError]\" : this[i] + \"\";\n        var lines = str.split(\"\\n\");\n        for (var j = 0; j < lines.length; ++j) {\n            lines[j] = indent + lines[j];\n        }\n        str = lines.join(\"\\n\");\n        ret += str + \"\\n\";\n    }\n    level--;\n    return ret;\n};\n\nfunction OperationalError(message) {\n    if (!(this instanceof OperationalError))\n        return new OperationalError(message);\n    notEnumerableProp(this, \"name\", \"OperationalError\");\n    notEnumerableProp(this, \"message\", message);\n    this.cause = message;\n    this[\"isOperational\"] = true;\n\n    if (message instanceof Error) {\n        notEnumerableProp(this, \"message\", message.message);\n        notEnumerableProp(this, \"stack\", message.stack);\n    } else if (Error.captureStackTrace) {\n        Error.captureStackTrace(this, this.constructor);\n    }\n\n}\ninherits(OperationalError, Error);\n\nvar errorTypes = Error[\"__BluebirdErrorTypes__\"];\nif (!errorTypes) {\n    errorTypes = Objectfreeze({\n        CancellationError: CancellationError,\n        TimeoutError: TimeoutError,\n        OperationalError: OperationalError,\n        RejectionError: OperationalError,\n        AggregateError: AggregateError\n    });\n    es5.defineProperty(Error, \"__BluebirdErrorTypes__\", {\n        value: errorTypes,\n        writable: false,\n        enumerable: false,\n        configurable: false\n    });\n}\n\nmodule.exports = {\n    Error: Error,\n    TypeError: _TypeError,\n    RangeError: _RangeError,\n    CancellationError: errorTypes.CancellationError,\n    OperationalError: errorTypes.OperationalError,\n    TimeoutError: errorTypes.TimeoutError,\n    AggregateError: errorTypes.AggregateError,\n    Warning: Warning\n};\n\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/* globals define */\n\n/**\n * Provide deferred promises.\n */\n\n/**\n * UMD Loader from https://github.com/umdjs/umd/blob/master/amdWeb.js\n */\n(function (root, factory) {\n\tif (true) {\n\t\t// AMD. Register as an anonymous module.\n\t\t!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :\n\t\t\t\t__WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else {\n\t\t// Browser globals\n\t\troot.Deferred = factory;\n\t}\n}(this, function () {\n\treturn function () {\n\t\tvar deferred = {};\n\t\tdeferred.promise = new Promise(function (resolve, reject) {\n\t\t\tdeferred.resolve = resolve;\n\t\t\tdeferred.reject = reject;\n\t\t});\n\t\treturn deferred;\n\t};\n}));\n\n\n/***/ }),\n/* 28 */,\n/* 29 */,\n/* 30 */,\n/* 31 */\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports) {\n\nvar isES5 = (function(){\n    \"use strict\";\n    return this === undefined;\n})();\n\nif (isES5) {\n    module.exports = {\n        freeze: Object.freeze,\n        defineProperty: Object.defineProperty,\n        getDescriptor: Object.getOwnPropertyDescriptor,\n        keys: Object.keys,\n        names: Object.getOwnPropertyNames,\n        getPrototypeOf: Object.getPrototypeOf,\n        isArray: Array.isArray,\n        isES5: isES5,\n        propertyIsWritable: function(obj, prop) {\n            var descriptor = Object.getOwnPropertyDescriptor(obj, prop);\n            return !!(!descriptor || descriptor.writable || descriptor.set);\n        }\n    };\n} else {\n    var has = {}.hasOwnProperty;\n    var str = {}.toString;\n    var proto = {}.constructor.prototype;\n\n    var ObjectKeys = function (o) {\n        var ret = [];\n        for (var key in o) {\n            if (has.call(o, key)) {\n                ret.push(key);\n            }\n        }\n        return ret;\n    };\n\n    var ObjectGetDescriptor = function(o, key) {\n        return {value: o[key]};\n    };\n\n    var ObjectDefineProperty = function (o, key, desc) {\n        o[key] = desc.value;\n        return o;\n    };\n\n    var ObjectFreeze = function (obj) {\n        return obj;\n    };\n\n    var ObjectGetPrototypeOf = function (obj) {\n        try {\n            return Object(obj).constructor.prototype;\n        }\n        catch (e) {\n            return proto;\n        }\n    };\n\n    var ArrayIsArray = function (obj) {\n        try {\n            return str.call(obj) === \"[object Array]\";\n        }\n        catch(e) {\n            return false;\n        }\n    };\n\n    module.exports = {\n        isArray: ArrayIsArray,\n        keys: ObjectKeys,\n        names: ObjectKeys,\n        defineProperty: ObjectDefineProperty,\n        getDescriptor: ObjectGetDescriptor,\n        freeze: ObjectFreeze,\n        getPrototypeOf: ObjectGetPrototypeOf,\n        isES5: isES5,\n        propertyIsWritable: function() {\n            return true;\n        }\n    };\n}\n\n\n/***/ }),\n/* 33 */,\n/* 34 */,\n/* 35 */,\n/* 36 */,\n/* 37 */,\n/* 38 */,\n/* 39 */,\n/* 40 */,\n/* 41 */,\n/* 42 */,\n/* 43 */,\n/* 44 */,\n/* 45 */,\n/* 46 */,\n/* 47 */,\n/* 48 */,\n/* 49 */,\n/* 50 */,\n/* 51 */,\n/* 52 */,\n/* 53 */,\n/* 54 */,\n/* 55 */,\n/* 56 */,\n/* 57 */,\n/* 58 */,\n/* 59 */,\n/* 60 */,\n/* 61 */,\n/* 62 */,\n/* 63 */,\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* globals define */\n\n/**\n * UMD Loader from https://github.com/umdjs/umd/blob/master/amdWeb.js\n */\n(function (root, factory) {\n\tif (true) {\n\t\t// AMD. Register as an anonymous module.\n\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(4)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else {\n\t\t// Browser globals\n\t\troot.Class = factory(root._);\n\t}\n}(this, function (_) {\n\t/**\n\t * Root extendable Class object.\n\t *\n\t * Based on Backbone.js. Requires Underscore.js.\n\t */\n\tvar Class = function () {\n\t\tthis.initialize.apply(this, arguments);\n\t};\n\t_.extend(Class.prototype, {initialize: function () {}});\n\n\t/**\n\t * Subclass via extend.\n\t *\n\t * @param object props   An object of all prototype properties to set.\n\t * @param object statics An object of all class static properties to set.\n\t *\n\t * prototype properties are most usually functions and are shared across all\n\t * instances of your class. If you have attributes set as prototype properties\n\t * (instead of initializing them in initialize) then they will be shared across\n\t * all instances of the class in the same way - like static attributes in PHP\n\t * classes. Unless overridden, they are also available to all subclasses.\n\t *\n\t * static properties are properties set on the class Function itself. This\n\t * allows you to use the constructor Function like an object.\n\t *\n\t * props object also supports the following special properties run during 'new':\n\t *   constructor: Run before anything else. Can entirely replace all normal setup\n\t *                 including skipping the running of all init. Use with care.\n\t *   initialize: Run last in the 'new' process. This is the function you would\n\t *                 usually use to do setting up of attributes and defaults.\n\t *\n\t * The resulting object can be used with 'new' like a normal\n\t * prototype/Function constructor.\n\t *\n\t * The object supports this._super() to call the parent a-la:\n\t * http://ejohn.org/blog/simple-javascript-inheritance/\n\t *\n\t * The object supports this.__super__ to access the parent class (but usually\n\t * you would use this._super()). You CANNOT use this.__super__ to get to a\n\t * parent's parent so be very careful - it can easily cause infinite loops.\n\t *\n\t * @return object\n\t */\n\n\tClass.extend = function (props, statics) {\n\t\tvar unImplementedSuper = function (method) { throw new Error('Super does not implement this method: ' + method); };\n\t\tvar parent = this;\n\t\tvar child;\n\t\tvar _super = parent.prototype;\n\t\tvar fnTest = /\\b_super\\b/;\n\t\tif (props && _.has(props, 'constructor')) {\n\t\t\tchild = props.constructor;\n\t\t} else {\n\t\t\tchild = function () { return parent.apply(this, arguments); };\n\t\t}\n\t\t_.extend(child, parent, statics);\n\t\tvar Surrogate = function () { this.constructor = child; };\n\t\tSurrogate.prototype = _super;\n\t\tchild.prototype = new Surrogate();\n\t\t_.extend(child.prototype, props, {__super__: _super});\n\t\t// Copy the properties over onto the new prototype\n\t\tfor (var name in props) {\n\t\t\t// Check if we're overwriting an existing function\n\t\t\tif (typeof props[name] === 'function' && fnTest.test(props[name])) {\n\t\t\t\tchild.prototype[name] = (function (name, fn) {\n\t\t\t\t\tvar wrapper = function () {\n\t\t\t\t\t\tvar tmp = this._super;\n\t\t\t\t\t\t// Add a new ._super() method that is the same method but on the super-class\n\t\t\t\t\t\tthis._super = _super[name] || unImplementedSuper(name);\n\t\t\t\t\t\t// The method only need to be bound temporarily, so we remove it when we're done executing\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tvar ret = fn.apply(this, arguments);\n\t\t\t\t\t\t} finally {\n\t\t\t\t\t\t\tthis._super = tmp;\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn ret;\n\t\t\t\t\t};\n\t\t\t\t\t// we must move properties from old function to new\n\t\t\t\t\tfor (var prop in fn) {\n\t\t\t\t\t\twrapper[prop] = fn[prop];\n\t\t\t\t\t\tdelete fn[prop];\n\t\t\t\t\t}\n\t\t\t\t\treturn wrapper;\n\t\t\t\t})(name, props[name]);\n\t\t\t}\n\t\t}\n\t\treturn child;\n\t};\n\n\treturn Class;\n}));\n\n\n/***/ }),\n/* 65 */,\n/* 66 */,\n/* 67 */,\n/* 68 */,\n/* 69 */,\n/* 70 */,\n/* 71 */,\n/* 72 */,\n/* 73 */,\n/* 74 */,\n/* 75 */,\n/* 76 */,\n/* 77 */,\n/* 78 */,\n/* 79 */,\n/* 80 */,\n/* 81 */,\n/* 82 */,\n/* 83 */,\n/* 84 */,\n/* 85 */,\n/* 86 */,\n/* 87 */,\n/* 88 */,\n/* 89 */,\n/* 90 */,\n/* 91 */,\n/* 92 */,\n/* 93 */,\n/* 94 */,\n/* 95 */,\n/* 96 */,\n/* 97 */,\n/* 98 */,\n/* 99 */,\n/* 100 */,\n/* 101 */,\n/* 102 */,\n/* 103 */,\n/* 104 */,\n/* 105 */,\n/* 106 */,\n/* 107 */,\n/* 108 */,\n/* 109 */,\n/* 110 */,\n/* 111 */,\n/* 112 */,\n/* 113 */,\n/* 114 */,\n/* 115 */,\n/* 116 */,\n/* 117 */,\n/* 118 */,\n/* 119 */,\n/* 120 */,\n/* 121 */,\n/* 122 */,\n/* 123 */,\n/* 124 */,\n/* 125 */,\n/* 126 */,\n/* 127 */,\n/* 128 */,\n/* 129 */,\n/* 130 */,\n/* 131 */,\n/* 132 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(NEXT_FILTER) {\nvar util = __webpack_require__(6);\nvar getKeys = __webpack_require__(32).keys;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\n\nfunction catchFilter(instances, cb, promise) {\n    return function(e) {\n        var boundTo = promise._boundValue();\n        predicateLoop: for (var i = 0; i < instances.length; ++i) {\n            var item = instances[i];\n\n            if (item === Error ||\n                (item != null && item.prototype instanceof Error)) {\n                if (e instanceof item) {\n                    return tryCatch(cb).call(boundTo, e);\n                }\n            } else if (typeof item === \"function\") {\n                var matchesPredicate = tryCatch(item).call(boundTo, e);\n                if (matchesPredicate === errorObj) {\n                    return matchesPredicate;\n                } else if (matchesPredicate) {\n                    return tryCatch(cb).call(boundTo, e);\n                }\n            } else if (util.isObject(e)) {\n                var keys = getKeys(item);\n                for (var j = 0; j < keys.length; ++j) {\n                    var key = keys[j];\n                    if (item[key] != e[key]) {\n                        continue predicateLoop;\n                    }\n                }\n                return tryCatch(cb).call(boundTo, e);\n            }\n        }\n        return NEXT_FILTER;\n    };\n}\n\nreturn catchFilter;\n};\n\n\n/***/ }),\n/* 133 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar util = __webpack_require__(6);\nvar maybeWrapAsError = util.maybeWrapAsError;\nvar errors = __webpack_require__(26);\nvar OperationalError = errors.OperationalError;\nvar es5 = __webpack_require__(32);\n\nfunction isUntypedError(obj) {\n    return obj instanceof Error &&\n        es5.getPrototypeOf(obj) === Error.prototype;\n}\n\nvar rErrorKey = /^(?:name|message|stack|cause)$/;\nfunction wrapAsOperationalError(obj) {\n    var ret;\n    if (isUntypedError(obj)) {\n        ret = new OperationalError(obj);\n        ret.name = obj.name;\n        ret.message = obj.message;\n        ret.stack = obj.stack;\n        var keys = es5.keys(obj);\n        for (var i = 0; i < keys.length; ++i) {\n            var key = keys[i];\n            if (!rErrorKey.test(key)) {\n                ret[key] = obj[key];\n            }\n        }\n        return ret;\n    }\n    util.markAsOriginatingFromRejection(obj);\n    return obj;\n}\n\nfunction nodebackForPromise(promise, multiArgs) {\n    return function(err, value) {\n        if (promise === null) return;\n        if (err) {\n            var wrapped = wrapAsOperationalError(maybeWrapAsError(err));\n            promise._attachExtraTrace(wrapped);\n            promise._reject(wrapped);\n        } else if (!multiArgs) {\n            promise._fulfill(value);\n        } else {\n            var $_len = arguments.length;var args = new Array(Math.max($_len - 1, 0)); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];};\n            promise._fulfill(args);\n        }\n        promise = null;\n    };\n}\n\nmodule.exports = nodebackForPromise;\n\n\n/***/ }),\n/* 134 */,\n/* 135 */,\n/* 136 */,\n/* 137 */,\n/* 138 */,\n/* 139 */,\n/* 140 */,\n/* 141 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\nmodule.exports = function() {\nvar makeSelfResolutionError = function () {\n    return new TypeError(\"circular promise resolution chain\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n};\nvar reflectHandler = function() {\n    return new Promise.PromiseInspection(this._target());\n};\nvar apiRejection = function(msg) {\n    return Promise.reject(new TypeError(msg));\n};\nfunction Proxyable() {}\nvar UNDEFINED_BINDING = {};\nvar util = __webpack_require__(6);\n\nvar getDomain;\nif (util.isNode) {\n    getDomain = function() {\n        var ret = process.domain;\n        if (ret === undefined) ret = null;\n        return ret;\n    };\n} else {\n    getDomain = function() {\n        return null;\n    };\n}\nutil.notEnumerableProp(Promise, \"_getDomain\", getDomain);\n\nvar es5 = __webpack_require__(32);\nvar Async = __webpack_require__(142);\nvar async = new Async();\nes5.defineProperty(Promise, \"_async\", {value: async});\nvar errors = __webpack_require__(26);\nvar TypeError = Promise.TypeError = errors.TypeError;\nPromise.RangeError = errors.RangeError;\nvar CancellationError = Promise.CancellationError = errors.CancellationError;\nPromise.TimeoutError = errors.TimeoutError;\nPromise.OperationalError = errors.OperationalError;\nPromise.RejectionError = errors.OperationalError;\nPromise.AggregateError = errors.AggregateError;\nvar INTERNAL = function(){};\nvar APPLY = {};\nvar NEXT_FILTER = {};\nvar tryConvertToPromise = __webpack_require__(147)(Promise, INTERNAL);\nvar PromiseArray =\n    __webpack_require__(148)(Promise, INTERNAL,\n                               tryConvertToPromise, apiRejection, Proxyable);\nvar Context = __webpack_require__(149)(Promise);\n /*jshint unused:false*/\nvar createContext = Context.create;\nvar debug = __webpack_require__(150)(Promise, Context);\nvar CapturedTrace = debug.CapturedTrace;\nvar PassThroughHandlerContext =\n    __webpack_require__(151)(Promise, tryConvertToPromise, NEXT_FILTER);\nvar catchFilter = __webpack_require__(132)(NEXT_FILTER);\nvar nodebackForPromise = __webpack_require__(133);\nvar errorObj = util.errorObj;\nvar tryCatch = util.tryCatch;\nfunction check(self, executor) {\n    if (self == null || self.constructor !== Promise) {\n        throw new TypeError(\"the promise constructor cannot be invoked directly\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    if (typeof executor !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(executor));\n    }\n\n}\n\nfunction Promise(executor) {\n    if (executor !== INTERNAL) {\n        check(this, executor);\n    }\n    this._bitField = 0;\n    this._fulfillmentHandler0 = undefined;\n    this._rejectionHandler0 = undefined;\n    this._promise0 = undefined;\n    this._receiver0 = undefined;\n    this._resolveFromExecutor(executor);\n    this._promiseCreated();\n    this._fireEvent(\"promiseCreated\", this);\n}\n\nPromise.prototype.toString = function () {\n    return \"[object Promise]\";\n};\n\nPromise.prototype.caught = Promise.prototype[\"catch\"] = function (fn) {\n    var len = arguments.length;\n    if (len > 1) {\n        var catchInstances = new Array(len - 1),\n            j = 0, i;\n        for (i = 0; i < len - 1; ++i) {\n            var item = arguments[i];\n            if (util.isObject(item)) {\n                catchInstances[j++] = item;\n            } else {\n                return apiRejection(\"Catch statement predicate: \" +\n                    \"expecting an object but got \" + util.classString(item));\n            }\n        }\n        catchInstances.length = j;\n        fn = arguments[i];\n\n        if (typeof fn !== \"function\") {\n            throw new TypeError(\"The last argument to .catch() \" +\n                \"must be a function, got \" + util.toString(fn));\n        }\n        return this.then(undefined, catchFilter(catchInstances, fn, this));\n    }\n    return this.then(undefined, fn);\n};\n\nPromise.prototype.reflect = function () {\n    return this._then(reflectHandler,\n        reflectHandler, undefined, this, undefined);\n};\n\nPromise.prototype.then = function (didFulfill, didReject) {\n    if (debug.warnings() && arguments.length > 0 &&\n        typeof didFulfill !== \"function\" &&\n        typeof didReject !== \"function\") {\n        var msg = \".then() only accepts functions but was passed: \" +\n                util.classString(didFulfill);\n        if (arguments.length > 1) {\n            msg += \", \" + util.classString(didReject);\n        }\n        this._warn(msg);\n    }\n    return this._then(didFulfill, didReject, undefined, undefined, undefined);\n};\n\nPromise.prototype.done = function (didFulfill, didReject) {\n    var promise =\n        this._then(didFulfill, didReject, undefined, undefined, undefined);\n    promise._setIsFinal();\n};\n\nPromise.prototype.spread = function (fn) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    return this.all()._then(fn, undefined, undefined, APPLY, undefined);\n};\n\nPromise.prototype.toJSON = function () {\n    var ret = {\n        isFulfilled: false,\n        isRejected: false,\n        fulfillmentValue: undefined,\n        rejectionReason: undefined\n    };\n    if (this.isFulfilled()) {\n        ret.fulfillmentValue = this.value();\n        ret.isFulfilled = true;\n    } else if (this.isRejected()) {\n        ret.rejectionReason = this.reason();\n        ret.isRejected = true;\n    }\n    return ret;\n};\n\nPromise.prototype.all = function () {\n    if (arguments.length > 0) {\n        this._warn(\".all() was passed arguments but it does not take any\");\n    }\n    return new PromiseArray(this).promise();\n};\n\nPromise.prototype.error = function (fn) {\n    return this.caught(util.originatesFromRejection, fn);\n};\n\nPromise.getNewLibraryCopy = module.exports;\n\nPromise.is = function (val) {\n    return val instanceof Promise;\n};\n\nPromise.fromNode = Promise.fromCallback = function(fn) {\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs\n                                         : false;\n    var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));\n    if (result === errorObj) {\n        ret._rejectCallback(result.e, true);\n    }\n    if (!ret._isFateSealed()) ret._setAsyncGuaranteed();\n    return ret;\n};\n\nPromise.all = function (promises) {\n    return new PromiseArray(promises).promise();\n};\n\nPromise.cast = function (obj) {\n    var ret = tryConvertToPromise(obj);\n    if (!(ret instanceof Promise)) {\n        ret = new Promise(INTERNAL);\n        ret._captureStackTrace();\n        ret._setFulfilled();\n        ret._rejectionHandler0 = obj;\n    }\n    return ret;\n};\n\nPromise.resolve = Promise.fulfilled = Promise.cast;\n\nPromise.reject = Promise.rejected = function (reason) {\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    ret._rejectCallback(reason, true);\n    return ret;\n};\n\nPromise.setScheduler = function(fn) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    return async.setScheduler(fn);\n};\n\nPromise.prototype._then = function (\n    didFulfill,\n    didReject,\n    _,    receiver,\n    internalData\n) {\n    var haveInternalData = internalData !== undefined;\n    var promise = haveInternalData ? internalData : new Promise(INTERNAL);\n    var target = this._target();\n    var bitField = target._bitField;\n\n    if (!haveInternalData) {\n        promise._propagateFrom(this, 3);\n        promise._captureStackTrace();\n        if (receiver === undefined &&\n            ((this._bitField & 2097152) !== 0)) {\n            if (!((bitField & 50397184) === 0)) {\n                receiver = this._boundValue();\n            } else {\n                receiver = target === this ? undefined : this._boundTo;\n            }\n        }\n        this._fireEvent(\"promiseChained\", this, promise);\n    }\n\n    var domain = getDomain();\n    if (!((bitField & 50397184) === 0)) {\n        var handler, value, settler = target._settlePromiseCtx;\n        if (((bitField & 33554432) !== 0)) {\n            value = target._rejectionHandler0;\n            handler = didFulfill;\n        } else if (((bitField & 16777216) !== 0)) {\n            value = target._fulfillmentHandler0;\n            handler = didReject;\n            target._unsetRejectionIsUnhandled();\n        } else {\n            settler = target._settlePromiseLateCancellationObserver;\n            value = new CancellationError(\"late cancellation observer\");\n            target._attachExtraTrace(value);\n            handler = didReject;\n        }\n\n        async.invoke(settler, target, {\n            handler: domain === null ? handler\n                : (typeof handler === \"function\" &&\n                    util.domainBind(domain, handler)),\n            promise: promise,\n            receiver: receiver,\n            value: value\n        });\n    } else {\n        target._addCallbacks(didFulfill, didReject, promise, receiver, domain);\n    }\n\n    return promise;\n};\n\nPromise.prototype._length = function () {\n    return this._bitField & 65535;\n};\n\nPromise.prototype._isFateSealed = function () {\n    return (this._bitField & 117506048) !== 0;\n};\n\nPromise.prototype._isFollowing = function () {\n    return (this._bitField & 67108864) === 67108864;\n};\n\nPromise.prototype._setLength = function (len) {\n    this._bitField = (this._bitField & -65536) |\n        (len & 65535);\n};\n\nPromise.prototype._setFulfilled = function () {\n    this._bitField = this._bitField | 33554432;\n    this._fireEvent(\"promiseFulfilled\", this);\n};\n\nPromise.prototype._setRejected = function () {\n    this._bitField = this._bitField | 16777216;\n    this._fireEvent(\"promiseRejected\", this);\n};\n\nPromise.prototype._setFollowing = function () {\n    this._bitField = this._bitField | 67108864;\n    this._fireEvent(\"promiseResolved\", this);\n};\n\nPromise.prototype._setIsFinal = function () {\n    this._bitField = this._bitField | 4194304;\n};\n\nPromise.prototype._isFinal = function () {\n    return (this._bitField & 4194304) > 0;\n};\n\nPromise.prototype._unsetCancelled = function() {\n    this._bitField = this._bitField & (~65536);\n};\n\nPromise.prototype._setCancelled = function() {\n    this._bitField = this._bitField | 65536;\n    this._fireEvent(\"promiseCancelled\", this);\n};\n\nPromise.prototype._setWillBeCancelled = function() {\n    this._bitField = this._bitField | 8388608;\n};\n\nPromise.prototype._setAsyncGuaranteed = function() {\n    if (async.hasCustomScheduler()) return;\n    this._bitField = this._bitField | 134217728;\n};\n\nPromise.prototype._receiverAt = function (index) {\n    var ret = index === 0 ? this._receiver0 : this[\n            index * 4 - 4 + 3];\n    if (ret === UNDEFINED_BINDING) {\n        return undefined;\n    } else if (ret === undefined && this._isBound()) {\n        return this._boundValue();\n    }\n    return ret;\n};\n\nPromise.prototype._promiseAt = function (index) {\n    return this[\n            index * 4 - 4 + 2];\n};\n\nPromise.prototype._fulfillmentHandlerAt = function (index) {\n    return this[\n            index * 4 - 4 + 0];\n};\n\nPromise.prototype._rejectionHandlerAt = function (index) {\n    return this[\n            index * 4 - 4 + 1];\n};\n\nPromise.prototype._boundValue = function() {};\n\nPromise.prototype._migrateCallback0 = function (follower) {\n    var bitField = follower._bitField;\n    var fulfill = follower._fulfillmentHandler0;\n    var reject = follower._rejectionHandler0;\n    var promise = follower._promise0;\n    var receiver = follower._receiverAt(0);\n    if (receiver === undefined) receiver = UNDEFINED_BINDING;\n    this._addCallbacks(fulfill, reject, promise, receiver, null);\n};\n\nPromise.prototype._migrateCallbackAt = function (follower, index) {\n    var fulfill = follower._fulfillmentHandlerAt(index);\n    var reject = follower._rejectionHandlerAt(index);\n    var promise = follower._promiseAt(index);\n    var receiver = follower._receiverAt(index);\n    if (receiver === undefined) receiver = UNDEFINED_BINDING;\n    this._addCallbacks(fulfill, reject, promise, receiver, null);\n};\n\nPromise.prototype._addCallbacks = function (\n    fulfill,\n    reject,\n    promise,\n    receiver,\n    domain\n) {\n    var index = this._length();\n\n    if (index >= 65535 - 4) {\n        index = 0;\n        this._setLength(0);\n    }\n\n    if (index === 0) {\n        this._promise0 = promise;\n        this._receiver0 = receiver;\n        if (typeof fulfill === \"function\") {\n            this._fulfillmentHandler0 =\n                domain === null ? fulfill : util.domainBind(domain, fulfill);\n        }\n        if (typeof reject === \"function\") {\n            this._rejectionHandler0 =\n                domain === null ? reject : util.domainBind(domain, reject);\n        }\n    } else {\n        var base = index * 4 - 4;\n        this[base + 2] = promise;\n        this[base + 3] = receiver;\n        if (typeof fulfill === \"function\") {\n            this[base + 0] =\n                domain === null ? fulfill : util.domainBind(domain, fulfill);\n        }\n        if (typeof reject === \"function\") {\n            this[base + 1] =\n                domain === null ? reject : util.domainBind(domain, reject);\n        }\n    }\n    this._setLength(index + 1);\n    return index;\n};\n\nPromise.prototype._proxy = function (proxyable, arg) {\n    this._addCallbacks(undefined, undefined, arg, proxyable, null);\n};\n\nPromise.prototype._resolveCallback = function(value, shouldBind) {\n    if (((this._bitField & 117506048) !== 0)) return;\n    if (value === this)\n        return this._rejectCallback(makeSelfResolutionError(), false);\n    var maybePromise = tryConvertToPromise(value, this);\n    if (!(maybePromise instanceof Promise)) return this._fulfill(value);\n\n    if (shouldBind) this._propagateFrom(maybePromise, 2);\n\n    var promise = maybePromise._target();\n\n    if (promise === this) {\n        this._reject(makeSelfResolutionError());\n        return;\n    }\n\n    var bitField = promise._bitField;\n    if (((bitField & 50397184) === 0)) {\n        var len = this._length();\n        if (len > 0) promise._migrateCallback0(this);\n        for (var i = 1; i < len; ++i) {\n            promise._migrateCallbackAt(this, i);\n        }\n        this._setFollowing();\n        this._setLength(0);\n        this._setFollowee(promise);\n    } else if (((bitField & 33554432) !== 0)) {\n        this._fulfill(promise._value());\n    } else if (((bitField & 16777216) !== 0)) {\n        this._reject(promise._reason());\n    } else {\n        var reason = new CancellationError(\"late cancellation observer\");\n        promise._attachExtraTrace(reason);\n        this._reject(reason);\n    }\n};\n\nPromise.prototype._rejectCallback =\nfunction(reason, synchronous, ignoreNonErrorWarnings) {\n    var trace = util.ensureErrorObject(reason);\n    var hasStack = trace === reason;\n    if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {\n        var message = \"a promise was rejected with a non-error: \" +\n            util.classString(reason);\n        this._warn(message, true);\n    }\n    this._attachExtraTrace(trace, synchronous ? hasStack : false);\n    this._reject(reason);\n};\n\nPromise.prototype._resolveFromExecutor = function (executor) {\n    if (executor === INTERNAL) return;\n    var promise = this;\n    this._captureStackTrace();\n    this._pushContext();\n    var synchronous = true;\n    var r = this._execute(executor, function(value) {\n        promise._resolveCallback(value);\n    }, function (reason) {\n        promise._rejectCallback(reason, synchronous);\n    });\n    synchronous = false;\n    this._popContext();\n\n    if (r !== undefined) {\n        promise._rejectCallback(r, true);\n    }\n};\n\nPromise.prototype._settlePromiseFromHandler = function (\n    handler, receiver, value, promise\n) {\n    var bitField = promise._bitField;\n    if (((bitField & 65536) !== 0)) return;\n    promise._pushContext();\n    var x;\n    if (receiver === APPLY) {\n        if (!value || typeof value.length !== \"number\") {\n            x = errorObj;\n            x.e = new TypeError(\"cannot .spread() a non-array: \" +\n                                    util.classString(value));\n        } else {\n            x = tryCatch(handler).apply(this._boundValue(), value);\n        }\n    } else {\n        x = tryCatch(handler).call(receiver, value);\n    }\n    var promiseCreated = promise._popContext();\n    bitField = promise._bitField;\n    if (((bitField & 65536) !== 0)) return;\n\n    if (x === NEXT_FILTER) {\n        promise._reject(value);\n    } else if (x === errorObj) {\n        promise._rejectCallback(x.e, false);\n    } else {\n        debug.checkForgottenReturns(x, promiseCreated, \"\",  promise, this);\n        promise._resolveCallback(x);\n    }\n};\n\nPromise.prototype._target = function() {\n    var ret = this;\n    while (ret._isFollowing()) ret = ret._followee();\n    return ret;\n};\n\nPromise.prototype._followee = function() {\n    return this._rejectionHandler0;\n};\n\nPromise.prototype._setFollowee = function(promise) {\n    this._rejectionHandler0 = promise;\n};\n\nPromise.prototype._settlePromise = function(promise, handler, receiver, value) {\n    var isPromise = promise instanceof Promise;\n    var bitField = this._bitField;\n    var asyncGuaranteed = ((bitField & 134217728) !== 0);\n    if (((bitField & 65536) !== 0)) {\n        if (isPromise) promise._invokeInternalOnCancel();\n\n        if (receiver instanceof PassThroughHandlerContext &&\n            receiver.isFinallyHandler()) {\n            receiver.cancelPromise = promise;\n            if (tryCatch(handler).call(receiver, value) === errorObj) {\n                promise._reject(errorObj.e);\n            }\n        } else if (handler === reflectHandler) {\n            promise._fulfill(reflectHandler.call(receiver));\n        } else if (receiver instanceof Proxyable) {\n            receiver._promiseCancelled(promise);\n        } else if (isPromise || promise instanceof PromiseArray) {\n            promise._cancel();\n        } else {\n            receiver.cancel();\n        }\n    } else if (typeof handler === \"function\") {\n        if (!isPromise) {\n            handler.call(receiver, value, promise);\n        } else {\n            if (asyncGuaranteed) promise._setAsyncGuaranteed();\n            this._settlePromiseFromHandler(handler, receiver, value, promise);\n        }\n    } else if (receiver instanceof Proxyable) {\n        if (!receiver._isResolved()) {\n            if (((bitField & 33554432) !== 0)) {\n                receiver._promiseFulfilled(value, promise);\n            } else {\n                receiver._promiseRejected(value, promise);\n            }\n        }\n    } else if (isPromise) {\n        if (asyncGuaranteed) promise._setAsyncGuaranteed();\n        if (((bitField & 33554432) !== 0)) {\n            promise._fulfill(value);\n        } else {\n            promise._reject(value);\n        }\n    }\n};\n\nPromise.prototype._settlePromiseLateCancellationObserver = function(ctx) {\n    var handler = ctx.handler;\n    var promise = ctx.promise;\n    var receiver = ctx.receiver;\n    var value = ctx.value;\n    if (typeof handler === \"function\") {\n        if (!(promise instanceof Promise)) {\n            handler.call(receiver, value, promise);\n        } else {\n            this._settlePromiseFromHandler(handler, receiver, value, promise);\n        }\n    } else if (promise instanceof Promise) {\n        promise._reject(value);\n    }\n};\n\nPromise.prototype._settlePromiseCtx = function(ctx) {\n    this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);\n};\n\nPromise.prototype._settlePromise0 = function(handler, value, bitField) {\n    var promise = this._promise0;\n    var receiver = this._receiverAt(0);\n    this._promise0 = undefined;\n    this._receiver0 = undefined;\n    this._settlePromise(promise, handler, receiver, value);\n};\n\nPromise.prototype._clearCallbackDataAtIndex = function(index) {\n    var base = index * 4 - 4;\n    this[base + 2] =\n    this[base + 3] =\n    this[base + 0] =\n    this[base + 1] = undefined;\n};\n\nPromise.prototype._fulfill = function (value) {\n    var bitField = this._bitField;\n    if (((bitField & 117506048) >>> 16)) return;\n    if (value === this) {\n        var err = makeSelfResolutionError();\n        this._attachExtraTrace(err);\n        return this._reject(err);\n    }\n    this._setFulfilled();\n    this._rejectionHandler0 = value;\n\n    if ((bitField & 65535) > 0) {\n        if (((bitField & 134217728) !== 0)) {\n            this._settlePromises();\n        } else {\n            async.settlePromises(this);\n        }\n        this._dereferenceTrace();\n    }\n};\n\nPromise.prototype._reject = function (reason) {\n    var bitField = this._bitField;\n    if (((bitField & 117506048) >>> 16)) return;\n    this._setRejected();\n    this._fulfillmentHandler0 = reason;\n\n    if (this._isFinal()) {\n        return async.fatalError(reason, util.isNode);\n    }\n\n    if ((bitField & 65535) > 0) {\n        async.settlePromises(this);\n    } else {\n        this._ensurePossibleRejectionHandled();\n    }\n};\n\nPromise.prototype._fulfillPromises = function (len, value) {\n    for (var i = 1; i < len; i++) {\n        var handler = this._fulfillmentHandlerAt(i);\n        var promise = this._promiseAt(i);\n        var receiver = this._receiverAt(i);\n        this._clearCallbackDataAtIndex(i);\n        this._settlePromise(promise, handler, receiver, value);\n    }\n};\n\nPromise.prototype._rejectPromises = function (len, reason) {\n    for (var i = 1; i < len; i++) {\n        var handler = this._rejectionHandlerAt(i);\n        var promise = this._promiseAt(i);\n        var receiver = this._receiverAt(i);\n        this._clearCallbackDataAtIndex(i);\n        this._settlePromise(promise, handler, receiver, reason);\n    }\n};\n\nPromise.prototype._settlePromises = function () {\n    var bitField = this._bitField;\n    var len = (bitField & 65535);\n\n    if (len > 0) {\n        if (((bitField & 16842752) !== 0)) {\n            var reason = this._fulfillmentHandler0;\n            this._settlePromise0(this._rejectionHandler0, reason, bitField);\n            this._rejectPromises(len, reason);\n        } else {\n            var value = this._rejectionHandler0;\n            this._settlePromise0(this._fulfillmentHandler0, value, bitField);\n            this._fulfillPromises(len, value);\n        }\n        this._setLength(0);\n    }\n    this._clearCancellationData();\n};\n\nPromise.prototype._settledValue = function() {\n    var bitField = this._bitField;\n    if (((bitField & 33554432) !== 0)) {\n        return this._rejectionHandler0;\n    } else if (((bitField & 16777216) !== 0)) {\n        return this._fulfillmentHandler0;\n    }\n};\n\nif (typeof Symbol !== \"undefined\" && Symbol.toStringTag) {\n    es5.defineProperty(Promise.prototype, Symbol.toStringTag, {\n        get: function () {\n            return \"Object\";\n        }\n    });\n}\n\nfunction deferResolve(v) {this.promise._resolveCallback(v);}\nfunction deferReject(v) {this.promise._rejectCallback(v, false);}\n\nPromise.defer = Promise.pending = function() {\n    debug.deprecated(\"Promise.defer\", \"new Promise\");\n    var promise = new Promise(INTERNAL);\n    return {\n        promise: promise,\n        resolve: deferResolve,\n        reject: deferReject\n    };\n};\n\nutil.notEnumerableProp(Promise,\n                       \"_makeSelfResolutionError\",\n                       makeSelfResolutionError);\n\n__webpack_require__(152)(Promise, INTERNAL, tryConvertToPromise, apiRejection,\n    debug);\n__webpack_require__(153)(Promise, INTERNAL, tryConvertToPromise, debug);\n__webpack_require__(154)(Promise, PromiseArray, apiRejection, debug);\n__webpack_require__(155)(Promise);\n__webpack_require__(156)(Promise);\n__webpack_require__(157)(\n    Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain);\nPromise.Promise = Promise;\nPromise.version = \"3.5.5\";\n__webpack_require__(158)(Promise);\n__webpack_require__(159)(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);\n__webpack_require__(160)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);\n__webpack_require__(161)(Promise);\n__webpack_require__(162)(Promise, INTERNAL);\n__webpack_require__(163)(Promise, PromiseArray, tryConvertToPromise, apiRejection);\n__webpack_require__(164)(Promise, INTERNAL, tryConvertToPromise, apiRejection);\n__webpack_require__(165)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);\n__webpack_require__(166)(Promise, PromiseArray, debug);\n__webpack_require__(167)(Promise, PromiseArray, apiRejection);\n__webpack_require__(168)(Promise, INTERNAL, debug);\n__webpack_require__(169)(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);\n__webpack_require__(170)(Promise);\n__webpack_require__(171)(Promise, INTERNAL);\n__webpack_require__(172)(Promise, INTERNAL);\n                                                         \n    util.toFastProperties(Promise);                                          \n    util.toFastProperties(Promise.prototype);                                \n    function fillTypes(value) {                                              \n        var p = new Promise(INTERNAL);                                       \n        p._fulfillmentHandler0 = value;                                      \n        p._rejectionHandler0 = value;                                        \n        p._promise0 = value;                                                 \n        p._receiver0 = value;                                                \n    }                                                                        \n    // Complete slack tracking, opt out of field-type tracking and           \n    // stabilize map                                                         \n    fillTypes({a: 1});                                                       \n    fillTypes({b: 2});                                                       \n    fillTypes({c: 3});                                                       \n    fillTypes(1);                                                            \n    fillTypes(function(){});                                                 \n    fillTypes(undefined);                                                    \n    fillTypes(false);                                                        \n    fillTypes(new Promise(INTERNAL));                                        \n    debug.setBounds(Async.firstLineError, util.lastLineError);               \n    return Promise;                                                          \n\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(25)))\n\n/***/ }),\n/* 142 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\nvar firstLineError;\ntry {throw new Error(); } catch (e) {firstLineError = e;}\nvar schedule = __webpack_require__(143);\nvar Queue = __webpack_require__(146);\nvar util = __webpack_require__(6);\n\nfunction Async() {\n    this._customScheduler = false;\n    this._isTickUsed = false;\n    this._lateQueue = new Queue(16);\n    this._normalQueue = new Queue(16);\n    this._haveDrainedQueues = false;\n    this._trampolineEnabled = true;\n    var self = this;\n    this.drainQueues = function () {\n        self._drainQueues();\n    };\n    this._schedule = schedule;\n}\n\nAsync.prototype.setScheduler = function(fn) {\n    var prev = this._schedule;\n    this._schedule = fn;\n    this._customScheduler = true;\n    return prev;\n};\n\nAsync.prototype.hasCustomScheduler = function() {\n    return this._customScheduler;\n};\n\nAsync.prototype.enableTrampoline = function() {\n    this._trampolineEnabled = true;\n};\n\nAsync.prototype.disableTrampolineIfNecessary = function() {\n    if (util.hasDevTools) {\n        this._trampolineEnabled = false;\n    }\n};\n\nAsync.prototype.haveItemsQueued = function () {\n    return this._isTickUsed || this._haveDrainedQueues;\n};\n\n\nAsync.prototype.fatalError = function(e, isNode) {\n    if (isNode) {\n        process.stderr.write(\"Fatal \" + (e instanceof Error ? e.stack : e) +\n            \"\\n\");\n        process.exit(2);\n    } else {\n        this.throwLater(e);\n    }\n};\n\nAsync.prototype.throwLater = function(fn, arg) {\n    if (arguments.length === 1) {\n        arg = fn;\n        fn = function () { throw arg; };\n    }\n    if (typeof setTimeout !== \"undefined\") {\n        setTimeout(function() {\n            fn(arg);\n        }, 0);\n    } else try {\n        this._schedule(function() {\n            fn(arg);\n        });\n    } catch (e) {\n        throw new Error(\"No async scheduler available\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n};\n\nfunction AsyncInvokeLater(fn, receiver, arg) {\n    this._lateQueue.push(fn, receiver, arg);\n    this._queueTick();\n}\n\nfunction AsyncInvoke(fn, receiver, arg) {\n    this._normalQueue.push(fn, receiver, arg);\n    this._queueTick();\n}\n\nfunction AsyncSettlePromises(promise) {\n    this._normalQueue._pushOne(promise);\n    this._queueTick();\n}\n\nif (!util.hasDevTools) {\n    Async.prototype.invokeLater = AsyncInvokeLater;\n    Async.prototype.invoke = AsyncInvoke;\n    Async.prototype.settlePromises = AsyncSettlePromises;\n} else {\n    Async.prototype.invokeLater = function (fn, receiver, arg) {\n        if (this._trampolineEnabled) {\n            AsyncInvokeLater.call(this, fn, receiver, arg);\n        } else {\n            this._schedule(function() {\n                setTimeout(function() {\n                    fn.call(receiver, arg);\n                }, 100);\n            });\n        }\n    };\n\n    Async.prototype.invoke = function (fn, receiver, arg) {\n        if (this._trampolineEnabled) {\n            AsyncInvoke.call(this, fn, receiver, arg);\n        } else {\n            this._schedule(function() {\n                fn.call(receiver, arg);\n            });\n        }\n    };\n\n    Async.prototype.settlePromises = function(promise) {\n        if (this._trampolineEnabled) {\n            AsyncSettlePromises.call(this, promise);\n        } else {\n            this._schedule(function() {\n                promise._settlePromises();\n            });\n        }\n    };\n}\n\nfunction _drainQueue(queue) {\n    while (queue.length() > 0) {\n        _drainQueueStep(queue);\n    }\n}\n\nfunction _drainQueueStep(queue) {\n    var fn = queue.shift();\n    if (typeof fn !== \"function\") {\n        fn._settlePromises();\n    } else {\n        var receiver = queue.shift();\n        var arg = queue.shift();\n        fn.call(receiver, arg);\n    }\n}\n\nAsync.prototype._drainQueues = function () {\n    _drainQueue(this._normalQueue);\n    this._reset();\n    this._haveDrainedQueues = true;\n    _drainQueue(this._lateQueue);\n};\n\nAsync.prototype._queueTick = function () {\n    if (!this._isTickUsed) {\n        this._isTickUsed = true;\n        this._schedule(this.drainQueues);\n    }\n};\n\nAsync.prototype._reset = function () {\n    this._isTickUsed = false;\n};\n\nmodule.exports = Async;\nmodule.exports.firstLineError = firstLineError;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(25)))\n\n/***/ }),\n/* 143 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, process, setImmediate) {\nvar util = __webpack_require__(6);\nvar schedule;\nvar noAsyncScheduler = function() {\n    throw new Error(\"No async scheduler available\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n};\nvar NativePromise = util.getNativePromise();\nif (util.isNode && typeof MutationObserver === \"undefined\") {\n    var GlobalSetImmediate = global.setImmediate;\n    var ProcessNextTick = process.nextTick;\n    schedule = util.isRecentNode\n                ? function(fn) { GlobalSetImmediate.call(global, fn); }\n                : function(fn) { ProcessNextTick.call(process, fn); };\n} else if (typeof NativePromise === \"function\" &&\n           typeof NativePromise.resolve === \"function\") {\n    var nativePromise = NativePromise.resolve();\n    schedule = function(fn) {\n        nativePromise.then(fn);\n    };\n} else if ((typeof MutationObserver !== \"undefined\") &&\n          !(typeof window !== \"undefined\" &&\n            window.navigator &&\n            (window.navigator.standalone || window.cordova)) &&\n          (\"classList\" in document.documentElement)) {\n    schedule = (function() {\n        var div = document.createElement(\"div\");\n        var opts = {attributes: true};\n        var toggleScheduled = false;\n        var div2 = document.createElement(\"div\");\n        var o2 = new MutationObserver(function() {\n            div.classList.toggle(\"foo\");\n            toggleScheduled = false;\n        });\n        o2.observe(div2, opts);\n\n        var scheduleToggle = function() {\n            if (toggleScheduled) return;\n            toggleScheduled = true;\n            div2.classList.toggle(\"foo\");\n        };\n\n        return function schedule(fn) {\n            var o = new MutationObserver(function() {\n                o.disconnect();\n                fn();\n            });\n            o.observe(div, opts);\n            scheduleToggle();\n        };\n    })();\n} else if (typeof setImmediate !== \"undefined\") {\n    schedule = function (fn) {\n        setImmediate(fn);\n    };\n} else if (typeof setTimeout !== \"undefined\") {\n    schedule = function (fn) {\n        setTimeout(fn, 0);\n    };\n} else {\n    schedule = noAsyncScheduler;\n}\nmodule.exports = schedule;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31), __webpack_require__(25), __webpack_require__(144).setImmediate))\n\n/***/ }),\n/* 144 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(145);\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31)))\n\n/***/ }),\n/* 145 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31), __webpack_require__(25)))\n\n/***/ }),\n/* 146 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nfunction arrayMove(src, srcIndex, dst, dstIndex, len) {\n    for (var j = 0; j < len; ++j) {\n        dst[j + dstIndex] = src[j + srcIndex];\n        src[j + srcIndex] = void 0;\n    }\n}\n\nfunction Queue(capacity) {\n    this._capacity = capacity;\n    this._length = 0;\n    this._front = 0;\n}\n\nQueue.prototype._willBeOverCapacity = function (size) {\n    return this._capacity < size;\n};\n\nQueue.prototype._pushOne = function (arg) {\n    var length = this.length();\n    this._checkCapacity(length + 1);\n    var i = (this._front + length) & (this._capacity - 1);\n    this[i] = arg;\n    this._length = length + 1;\n};\n\nQueue.prototype.push = function (fn, receiver, arg) {\n    var length = this.length() + 3;\n    if (this._willBeOverCapacity(length)) {\n        this._pushOne(fn);\n        this._pushOne(receiver);\n        this._pushOne(arg);\n        return;\n    }\n    var j = this._front + length - 3;\n    this._checkCapacity(length);\n    var wrapMask = this._capacity - 1;\n    this[(j + 0) & wrapMask] = fn;\n    this[(j + 1) & wrapMask] = receiver;\n    this[(j + 2) & wrapMask] = arg;\n    this._length = length;\n};\n\nQueue.prototype.shift = function () {\n    var front = this._front,\n        ret = this[front];\n\n    this[front] = undefined;\n    this._front = (front + 1) & (this._capacity - 1);\n    this._length--;\n    return ret;\n};\n\nQueue.prototype.length = function () {\n    return this._length;\n};\n\nQueue.prototype._checkCapacity = function (size) {\n    if (this._capacity < size) {\n        this._resizeTo(this._capacity << 1);\n    }\n};\n\nQueue.prototype._resizeTo = function (capacity) {\n    var oldCapacity = this._capacity;\n    this._capacity = capacity;\n    var front = this._front;\n    var length = this._length;\n    var moveItemsCount = (front + length) & (oldCapacity - 1);\n    arrayMove(this, 0, this, oldCapacity, moveItemsCount);\n};\n\nmodule.exports = Queue;\n\n\n/***/ }),\n/* 147 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, INTERNAL) {\nvar util = __webpack_require__(6);\nvar errorObj = util.errorObj;\nvar isObject = util.isObject;\n\nfunction tryConvertToPromise(obj, context) {\n    if (isObject(obj)) {\n        if (obj instanceof Promise) return obj;\n        var then = getThen(obj);\n        if (then === errorObj) {\n            if (context) context._pushContext();\n            var ret = Promise.reject(then.e);\n            if (context) context._popContext();\n            return ret;\n        } else if (typeof then === \"function\") {\n            if (isAnyBluebirdPromise(obj)) {\n                var ret = new Promise(INTERNAL);\n                obj._then(\n                    ret._fulfill,\n                    ret._reject,\n                    undefined,\n                    ret,\n                    null\n                );\n                return ret;\n            }\n            return doThenable(obj, then, context);\n        }\n    }\n    return obj;\n}\n\nfunction doGetThen(obj) {\n    return obj.then;\n}\n\nfunction getThen(obj) {\n    try {\n        return doGetThen(obj);\n    } catch (e) {\n        errorObj.e = e;\n        return errorObj;\n    }\n}\n\nvar hasProp = {}.hasOwnProperty;\nfunction isAnyBluebirdPromise(obj) {\n    try {\n        return hasProp.call(obj, \"_promise0\");\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction doThenable(x, then, context) {\n    var promise = new Promise(INTERNAL);\n    var ret = promise;\n    if (context) context._pushContext();\n    promise._captureStackTrace();\n    if (context) context._popContext();\n    var synchronous = true;\n    var result = util.tryCatch(then).call(x, resolve, reject);\n    synchronous = false;\n\n    if (promise && result === errorObj) {\n        promise._rejectCallback(result.e, true, true);\n        promise = null;\n    }\n\n    function resolve(value) {\n        if (!promise) return;\n        promise._resolveCallback(value);\n        promise = null;\n    }\n\n    function reject(reason) {\n        if (!promise) return;\n        promise._rejectCallback(reason, synchronous, true);\n        promise = null;\n    }\n    return ret;\n}\n\nreturn tryConvertToPromise;\n};\n\n\n/***/ }),\n/* 148 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, INTERNAL, tryConvertToPromise,\n    apiRejection, Proxyable) {\nvar util = __webpack_require__(6);\nvar isArray = util.isArray;\n\nfunction toResolutionValue(val) {\n    switch(val) {\n    case -2: return [];\n    case -3: return {};\n    case -6: return new Map();\n    }\n}\n\nfunction PromiseArray(values) {\n    var promise = this._promise = new Promise(INTERNAL);\n    if (values instanceof Promise) {\n        promise._propagateFrom(values, 3);\n    }\n    promise._setOnCancel(this);\n    this._values = values;\n    this._length = 0;\n    this._totalResolved = 0;\n    this._init(undefined, -2);\n}\nutil.inherits(PromiseArray, Proxyable);\n\nPromiseArray.prototype.length = function () {\n    return this._length;\n};\n\nPromiseArray.prototype.promise = function () {\n    return this._promise;\n};\n\nPromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {\n    var values = tryConvertToPromise(this._values, this._promise);\n    if (values instanceof Promise) {\n        values = values._target();\n        var bitField = values._bitField;\n        ;\n        this._values = values;\n\n        if (((bitField & 50397184) === 0)) {\n            this._promise._setAsyncGuaranteed();\n            return values._then(\n                init,\n                this._reject,\n                undefined,\n                this,\n                resolveValueIfEmpty\n           );\n        } else if (((bitField & 33554432) !== 0)) {\n            values = values._value();\n        } else if (((bitField & 16777216) !== 0)) {\n            return this._reject(values._reason());\n        } else {\n            return this._cancel();\n        }\n    }\n    values = util.asArray(values);\n    if (values === null) {\n        var err = apiRejection(\n            \"expecting an array or an iterable object but got \" + util.classString(values)).reason();\n        this._promise._rejectCallback(err, false);\n        return;\n    }\n\n    if (values.length === 0) {\n        if (resolveValueIfEmpty === -5) {\n            this._resolveEmptyArray();\n        }\n        else {\n            this._resolve(toResolutionValue(resolveValueIfEmpty));\n        }\n        return;\n    }\n    this._iterate(values);\n};\n\nPromiseArray.prototype._iterate = function(values) {\n    var len = this.getActualLength(values.length);\n    this._length = len;\n    this._values = this.shouldCopyValues() ? new Array(len) : this._values;\n    var result = this._promise;\n    var isResolved = false;\n    var bitField = null;\n    for (var i = 0; i < len; ++i) {\n        var maybePromise = tryConvertToPromise(values[i], result);\n\n        if (maybePromise instanceof Promise) {\n            maybePromise = maybePromise._target();\n            bitField = maybePromise._bitField;\n        } else {\n            bitField = null;\n        }\n\n        if (isResolved) {\n            if (bitField !== null) {\n                maybePromise.suppressUnhandledRejections();\n            }\n        } else if (bitField !== null) {\n            if (((bitField & 50397184) === 0)) {\n                maybePromise._proxy(this, i);\n                this._values[i] = maybePromise;\n            } else if (((bitField & 33554432) !== 0)) {\n                isResolved = this._promiseFulfilled(maybePromise._value(), i);\n            } else if (((bitField & 16777216) !== 0)) {\n                isResolved = this._promiseRejected(maybePromise._reason(), i);\n            } else {\n                isResolved = this._promiseCancelled(i);\n            }\n        } else {\n            isResolved = this._promiseFulfilled(maybePromise, i);\n        }\n    }\n    if (!isResolved) result._setAsyncGuaranteed();\n};\n\nPromiseArray.prototype._isResolved = function () {\n    return this._values === null;\n};\n\nPromiseArray.prototype._resolve = function (value) {\n    this._values = null;\n    this._promise._fulfill(value);\n};\n\nPromiseArray.prototype._cancel = function() {\n    if (this._isResolved() || !this._promise._isCancellable()) return;\n    this._values = null;\n    this._promise._cancel();\n};\n\nPromiseArray.prototype._reject = function (reason) {\n    this._values = null;\n    this._promise._rejectCallback(reason, false);\n};\n\nPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    this._values[index] = value;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        this._resolve(this._values);\n        return true;\n    }\n    return false;\n};\n\nPromiseArray.prototype._promiseCancelled = function() {\n    this._cancel();\n    return true;\n};\n\nPromiseArray.prototype._promiseRejected = function (reason) {\n    this._totalResolved++;\n    this._reject(reason);\n    return true;\n};\n\nPromiseArray.prototype._resultCancelled = function() {\n    if (this._isResolved()) return;\n    var values = this._values;\n    this._cancel();\n    if (values instanceof Promise) {\n        values.cancel();\n    } else {\n        for (var i = 0; i < values.length; ++i) {\n            if (values[i] instanceof Promise) {\n                values[i].cancel();\n            }\n        }\n    }\n};\n\nPromiseArray.prototype.shouldCopyValues = function () {\n    return true;\n};\n\nPromiseArray.prototype.getActualLength = function (len) {\n    return len;\n};\n\nreturn PromiseArray;\n};\n\n\n/***/ }),\n/* 149 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise) {\nvar longStackTraces = false;\nvar contextStack = [];\n\nPromise.prototype._promiseCreated = function() {};\nPromise.prototype._pushContext = function() {};\nPromise.prototype._popContext = function() {return null;};\nPromise._peekContext = Promise.prototype._peekContext = function() {};\n\nfunction Context() {\n    this._trace = new Context.CapturedTrace(peekContext());\n}\nContext.prototype._pushContext = function () {\n    if (this._trace !== undefined) {\n        this._trace._promiseCreated = null;\n        contextStack.push(this._trace);\n    }\n};\n\nContext.prototype._popContext = function () {\n    if (this._trace !== undefined) {\n        var trace = contextStack.pop();\n        var ret = trace._promiseCreated;\n        trace._promiseCreated = null;\n        return ret;\n    }\n    return null;\n};\n\nfunction createContext() {\n    if (longStackTraces) return new Context();\n}\n\nfunction peekContext() {\n    var lastIndex = contextStack.length - 1;\n    if (lastIndex >= 0) {\n        return contextStack[lastIndex];\n    }\n    return undefined;\n}\nContext.CapturedTrace = null;\nContext.create = createContext;\nContext.deactivateLongStackTraces = function() {};\nContext.activateLongStackTraces = function() {\n    var Promise_pushContext = Promise.prototype._pushContext;\n    var Promise_popContext = Promise.prototype._popContext;\n    var Promise_PeekContext = Promise._peekContext;\n    var Promise_peekContext = Promise.prototype._peekContext;\n    var Promise_promiseCreated = Promise.prototype._promiseCreated;\n    Context.deactivateLongStackTraces = function() {\n        Promise.prototype._pushContext = Promise_pushContext;\n        Promise.prototype._popContext = Promise_popContext;\n        Promise._peekContext = Promise_PeekContext;\n        Promise.prototype._peekContext = Promise_peekContext;\n        Promise.prototype._promiseCreated = Promise_promiseCreated;\n        longStackTraces = false;\n    };\n    longStackTraces = true;\n    Promise.prototype._pushContext = Context.prototype._pushContext;\n    Promise.prototype._popContext = Context.prototype._popContext;\n    Promise._peekContext = Promise.prototype._peekContext = peekContext;\n    Promise.prototype._promiseCreated = function() {\n        var ctx = this._peekContext();\n        if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;\n    };\n};\nreturn Context;\n};\n\n\n/***/ }),\n/* 150 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\nmodule.exports = function(Promise, Context) {\nvar getDomain = Promise._getDomain;\nvar async = Promise._async;\nvar Warning = __webpack_require__(26).Warning;\nvar util = __webpack_require__(6);\nvar es5 = __webpack_require__(32);\nvar canAttachTrace = util.canAttachTrace;\nvar unhandledRejectionHandled;\nvar possiblyUnhandledRejection;\nvar bluebirdFramePattern =\n    /[\\\\\\/]bluebird[\\\\\\/]js[\\\\\\/](release|debug|instrumented)/;\nvar nodeFramePattern = /\\((?:timers\\.js):\\d+:\\d+\\)/;\nvar parseLinePattern = /[\\/<\\(](.+?):(\\d+):(\\d+)\\)?\\s*$/;\nvar stackFramePattern = null;\nvar formatStack = null;\nvar indentStackFrames = false;\nvar printWarning;\nvar debugging = !!(util.env(\"BLUEBIRD_DEBUG\") != 0 &&\n                        (false ||\n                         util.env(\"BLUEBIRD_DEBUG\") ||\n                         util.env(\"NODE_ENV\") === \"development\"));\n\nvar warnings = !!(util.env(\"BLUEBIRD_WARNINGS\") != 0 &&\n    (debugging || util.env(\"BLUEBIRD_WARNINGS\")));\n\nvar longStackTraces = !!(util.env(\"BLUEBIRD_LONG_STACK_TRACES\") != 0 &&\n    (debugging || util.env(\"BLUEBIRD_LONG_STACK_TRACES\")));\n\nvar wForgottenReturn = util.env(\"BLUEBIRD_W_FORGOTTEN_RETURN\") != 0 &&\n    (warnings || !!util.env(\"BLUEBIRD_W_FORGOTTEN_RETURN\"));\n\nPromise.prototype.suppressUnhandledRejections = function() {\n    var target = this._target();\n    target._bitField = ((target._bitField & (~1048576)) |\n                      524288);\n};\n\nPromise.prototype._ensurePossibleRejectionHandled = function () {\n    if ((this._bitField & 524288) !== 0) return;\n    this._setRejectionIsUnhandled();\n    var self = this;\n    setTimeout(function() {\n        self._notifyUnhandledRejection();\n    }, 1);\n};\n\nPromise.prototype._notifyUnhandledRejectionIsHandled = function () {\n    fireRejectionEvent(\"rejectionHandled\",\n                                  unhandledRejectionHandled, undefined, this);\n};\n\nPromise.prototype._setReturnedNonUndefined = function() {\n    this._bitField = this._bitField | 268435456;\n};\n\nPromise.prototype._returnedNonUndefined = function() {\n    return (this._bitField & 268435456) !== 0;\n};\n\nPromise.prototype._notifyUnhandledRejection = function () {\n    if (this._isRejectionUnhandled()) {\n        var reason = this._settledValue();\n        this._setUnhandledRejectionIsNotified();\n        fireRejectionEvent(\"unhandledRejection\",\n                                      possiblyUnhandledRejection, reason, this);\n    }\n};\n\nPromise.prototype._setUnhandledRejectionIsNotified = function () {\n    this._bitField = this._bitField | 262144;\n};\n\nPromise.prototype._unsetUnhandledRejectionIsNotified = function () {\n    this._bitField = this._bitField & (~262144);\n};\n\nPromise.prototype._isUnhandledRejectionNotified = function () {\n    return (this._bitField & 262144) > 0;\n};\n\nPromise.prototype._setRejectionIsUnhandled = function () {\n    this._bitField = this._bitField | 1048576;\n};\n\nPromise.prototype._unsetRejectionIsUnhandled = function () {\n    this._bitField = this._bitField & (~1048576);\n    if (this._isUnhandledRejectionNotified()) {\n        this._unsetUnhandledRejectionIsNotified();\n        this._notifyUnhandledRejectionIsHandled();\n    }\n};\n\nPromise.prototype._isRejectionUnhandled = function () {\n    return (this._bitField & 1048576) > 0;\n};\n\nPromise.prototype._warn = function(message, shouldUseOwnTrace, promise) {\n    return warn(message, shouldUseOwnTrace, promise || this);\n};\n\nPromise.onPossiblyUnhandledRejection = function (fn) {\n    var domain = getDomain();\n    possiblyUnhandledRejection =\n        typeof fn === \"function\" ? (domain === null ?\n                                            fn : util.domainBind(domain, fn))\n                                 : undefined;\n};\n\nPromise.onUnhandledRejectionHandled = function (fn) {\n    var domain = getDomain();\n    unhandledRejectionHandled =\n        typeof fn === \"function\" ? (domain === null ?\n                                            fn : util.domainBind(domain, fn))\n                                 : undefined;\n};\n\nvar disableLongStackTraces = function() {};\nPromise.longStackTraces = function () {\n    if (async.haveItemsQueued() && !config.longStackTraces) {\n        throw new Error(\"cannot enable long stack traces after promises have been created\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    if (!config.longStackTraces && longStackTracesIsSupported()) {\n        var Promise_captureStackTrace = Promise.prototype._captureStackTrace;\n        var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;\n        var Promise_dereferenceTrace = Promise.prototype._dereferenceTrace;\n        config.longStackTraces = true;\n        disableLongStackTraces = function() {\n            if (async.haveItemsQueued() && !config.longStackTraces) {\n                throw new Error(\"cannot enable long stack traces after promises have been created\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n            }\n            Promise.prototype._captureStackTrace = Promise_captureStackTrace;\n            Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;\n            Promise.prototype._dereferenceTrace = Promise_dereferenceTrace;\n            Context.deactivateLongStackTraces();\n            async.enableTrampoline();\n            config.longStackTraces = false;\n        };\n        Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;\n        Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;\n        Promise.prototype._dereferenceTrace = longStackTracesDereferenceTrace;\n        Context.activateLongStackTraces();\n        async.disableTrampolineIfNecessary();\n    }\n};\n\nPromise.hasLongStackTraces = function () {\n    return config.longStackTraces && longStackTracesIsSupported();\n};\n\nvar fireDomEvent = (function() {\n    try {\n        if (typeof CustomEvent === \"function\") {\n            var event = new CustomEvent(\"CustomEvent\");\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                var eventData = {\n                    detail: event,\n                    cancelable: true\n                };\n                es5.defineProperty(\n                    eventData, \"promise\", {value: event.promise});\n                es5.defineProperty(eventData, \"reason\", {value: event.reason});\n                var domEvent = new CustomEvent(name.toLowerCase(), eventData);\n                return !util.global.dispatchEvent(domEvent);\n            };\n        } else if (typeof Event === \"function\") {\n            var event = new Event(\"CustomEvent\");\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                var domEvent = new Event(name.toLowerCase(), {\n                    cancelable: true\n                });\n                domEvent.detail = event;\n                es5.defineProperty(domEvent, \"promise\", {value: event.promise});\n                es5.defineProperty(domEvent, \"reason\", {value: event.reason});\n                return !util.global.dispatchEvent(domEvent);\n            };\n        } else {\n            var event = document.createEvent(\"CustomEvent\");\n            event.initCustomEvent(\"testingtheevent\", false, true, {});\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                var domEvent = document.createEvent(\"CustomEvent\");\n                domEvent.initCustomEvent(name.toLowerCase(), false, true,\n                    event);\n                return !util.global.dispatchEvent(domEvent);\n            };\n        }\n    } catch (e) {}\n    return function() {\n        return false;\n    };\n})();\n\nvar fireGlobalEvent = (function() {\n    if (util.isNode) {\n        return function() {\n            return process.emit.apply(process, arguments);\n        };\n    } else {\n        if (!util.global) {\n            return function() {\n                return false;\n            };\n        }\n        return function(name) {\n            var methodName = \"on\" + name.toLowerCase();\n            var method = util.global[methodName];\n            if (!method) return false;\n            method.apply(util.global, [].slice.call(arguments, 1));\n            return true;\n        };\n    }\n})();\n\nfunction generatePromiseLifecycleEventObject(name, promise) {\n    return {promise: promise};\n}\n\nvar eventToObjectGenerator = {\n    promiseCreated: generatePromiseLifecycleEventObject,\n    promiseFulfilled: generatePromiseLifecycleEventObject,\n    promiseRejected: generatePromiseLifecycleEventObject,\n    promiseResolved: generatePromiseLifecycleEventObject,\n    promiseCancelled: generatePromiseLifecycleEventObject,\n    promiseChained: function(name, promise, child) {\n        return {promise: promise, child: child};\n    },\n    warning: function(name, warning) {\n        return {warning: warning};\n    },\n    unhandledRejection: function (name, reason, promise) {\n        return {reason: reason, promise: promise};\n    },\n    rejectionHandled: generatePromiseLifecycleEventObject\n};\n\nvar activeFireEvent = function (name) {\n    var globalEventFired = false;\n    try {\n        globalEventFired = fireGlobalEvent.apply(null, arguments);\n    } catch (e) {\n        async.throwLater(e);\n        globalEventFired = true;\n    }\n\n    var domEventFired = false;\n    try {\n        domEventFired = fireDomEvent(name,\n                    eventToObjectGenerator[name].apply(null, arguments));\n    } catch (e) {\n        async.throwLater(e);\n        domEventFired = true;\n    }\n\n    return domEventFired || globalEventFired;\n};\n\nPromise.config = function(opts) {\n    opts = Object(opts);\n    if (\"longStackTraces\" in opts) {\n        if (opts.longStackTraces) {\n            Promise.longStackTraces();\n        } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {\n            disableLongStackTraces();\n        }\n    }\n    if (\"warnings\" in opts) {\n        var warningsOption = opts.warnings;\n        config.warnings = !!warningsOption;\n        wForgottenReturn = config.warnings;\n\n        if (util.isObject(warningsOption)) {\n            if (\"wForgottenReturn\" in warningsOption) {\n                wForgottenReturn = !!warningsOption.wForgottenReturn;\n            }\n        }\n    }\n    if (\"cancellation\" in opts && opts.cancellation && !config.cancellation) {\n        if (async.haveItemsQueued()) {\n            throw new Error(\n                \"cannot enable cancellation after promises are in use\");\n        }\n        Promise.prototype._clearCancellationData =\n            cancellationClearCancellationData;\n        Promise.prototype._propagateFrom = cancellationPropagateFrom;\n        Promise.prototype._onCancel = cancellationOnCancel;\n        Promise.prototype._setOnCancel = cancellationSetOnCancel;\n        Promise.prototype._attachCancellationCallback =\n            cancellationAttachCancellationCallback;\n        Promise.prototype._execute = cancellationExecute;\n        propagateFromFunction = cancellationPropagateFrom;\n        config.cancellation = true;\n    }\n    if (\"monitoring\" in opts) {\n        if (opts.monitoring && !config.monitoring) {\n            config.monitoring = true;\n            Promise.prototype._fireEvent = activeFireEvent;\n        } else if (!opts.monitoring && config.monitoring) {\n            config.monitoring = false;\n            Promise.prototype._fireEvent = defaultFireEvent;\n        }\n    }\n    return Promise;\n};\n\nfunction defaultFireEvent() { return false; }\n\nPromise.prototype._fireEvent = defaultFireEvent;\nPromise.prototype._execute = function(executor, resolve, reject) {\n    try {\n        executor(resolve, reject);\n    } catch (e) {\n        return e;\n    }\n};\nPromise.prototype._onCancel = function () {};\nPromise.prototype._setOnCancel = function (handler) { ; };\nPromise.prototype._attachCancellationCallback = function(onCancel) {\n    ;\n};\nPromise.prototype._captureStackTrace = function () {};\nPromise.prototype._attachExtraTrace = function () {};\nPromise.prototype._dereferenceTrace = function () {};\nPromise.prototype._clearCancellationData = function() {};\nPromise.prototype._propagateFrom = function (parent, flags) {\n    ;\n    ;\n};\n\nfunction cancellationExecute(executor, resolve, reject) {\n    var promise = this;\n    try {\n        executor(resolve, reject, function(onCancel) {\n            if (typeof onCancel !== \"function\") {\n                throw new TypeError(\"onCancel must be a function, got: \" +\n                                    util.toString(onCancel));\n            }\n            promise._attachCancellationCallback(onCancel);\n        });\n    } catch (e) {\n        return e;\n    }\n}\n\nfunction cancellationAttachCancellationCallback(onCancel) {\n    if (!this._isCancellable()) return this;\n\n    var previousOnCancel = this._onCancel();\n    if (previousOnCancel !== undefined) {\n        if (util.isArray(previousOnCancel)) {\n            previousOnCancel.push(onCancel);\n        } else {\n            this._setOnCancel([previousOnCancel, onCancel]);\n        }\n    } else {\n        this._setOnCancel(onCancel);\n    }\n}\n\nfunction cancellationOnCancel() {\n    return this._onCancelField;\n}\n\nfunction cancellationSetOnCancel(onCancel) {\n    this._onCancelField = onCancel;\n}\n\nfunction cancellationClearCancellationData() {\n    this._cancellationParent = undefined;\n    this._onCancelField = undefined;\n}\n\nfunction cancellationPropagateFrom(parent, flags) {\n    if ((flags & 1) !== 0) {\n        this._cancellationParent = parent;\n        var branchesRemainingToCancel = parent._branchesRemainingToCancel;\n        if (branchesRemainingToCancel === undefined) {\n            branchesRemainingToCancel = 0;\n        }\n        parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;\n    }\n    if ((flags & 2) !== 0 && parent._isBound()) {\n        this._setBoundTo(parent._boundTo);\n    }\n}\n\nfunction bindingPropagateFrom(parent, flags) {\n    if ((flags & 2) !== 0 && parent._isBound()) {\n        this._setBoundTo(parent._boundTo);\n    }\n}\nvar propagateFromFunction = bindingPropagateFrom;\n\nfunction boundValueFunction() {\n    var ret = this._boundTo;\n    if (ret !== undefined) {\n        if (ret instanceof Promise) {\n            if (ret.isFulfilled()) {\n                return ret.value();\n            } else {\n                return undefined;\n            }\n        }\n    }\n    return ret;\n}\n\nfunction longStackTracesCaptureStackTrace() {\n    this._trace = new CapturedTrace(this._peekContext());\n}\n\nfunction longStackTracesAttachExtraTrace(error, ignoreSelf) {\n    if (canAttachTrace(error)) {\n        var trace = this._trace;\n        if (trace !== undefined) {\n            if (ignoreSelf) trace = trace._parent;\n        }\n        if (trace !== undefined) {\n            trace.attachExtraTrace(error);\n        } else if (!error.__stackCleaned__) {\n            var parsed = parseStackAndMessage(error);\n            util.notEnumerableProp(error, \"stack\",\n                parsed.message + \"\\n\" + parsed.stack.join(\"\\n\"));\n            util.notEnumerableProp(error, \"__stackCleaned__\", true);\n        }\n    }\n}\n\nfunction longStackTracesDereferenceTrace() {\n    this._trace = undefined;\n}\n\nfunction checkForgottenReturns(returnValue, promiseCreated, name, promise,\n                               parent) {\n    if (returnValue === undefined && promiseCreated !== null &&\n        wForgottenReturn) {\n        if (parent !== undefined && parent._returnedNonUndefined()) return;\n        if ((promise._bitField & 65535) === 0) return;\n\n        if (name) name = name + \" \";\n        var handlerLine = \"\";\n        var creatorLine = \"\";\n        if (promiseCreated._trace) {\n            var traceLines = promiseCreated._trace.stack.split(\"\\n\");\n            var stack = cleanStack(traceLines);\n            for (var i = stack.length - 1; i >= 0; --i) {\n                var line = stack[i];\n                if (!nodeFramePattern.test(line)) {\n                    var lineMatches = line.match(parseLinePattern);\n                    if (lineMatches) {\n                        handlerLine  = \"at \" + lineMatches[1] +\n                            \":\" + lineMatches[2] + \":\" + lineMatches[3] + \" \";\n                    }\n                    break;\n                }\n            }\n\n            if (stack.length > 0) {\n                var firstUserLine = stack[0];\n                for (var i = 0; i < traceLines.length; ++i) {\n\n                    if (traceLines[i] === firstUserLine) {\n                        if (i > 0) {\n                            creatorLine = \"\\n\" + traceLines[i - 1];\n                        }\n                        break;\n                    }\n                }\n\n            }\n        }\n        var msg = \"a promise was created in a \" + name +\n            \"handler \" + handlerLine + \"but was not returned from it, \" +\n            \"see http://goo.gl/rRqMUw\" +\n            creatorLine;\n        promise._warn(msg, true, promiseCreated);\n    }\n}\n\nfunction deprecated(name, replacement) {\n    var message = name +\n        \" is deprecated and will be removed in a future version.\";\n    if (replacement) message += \" Use \" + replacement + \" instead.\";\n    return warn(message);\n}\n\nfunction warn(message, shouldUseOwnTrace, promise) {\n    if (!config.warnings) return;\n    var warning = new Warning(message);\n    var ctx;\n    if (shouldUseOwnTrace) {\n        promise._attachExtraTrace(warning);\n    } else if (config.longStackTraces && (ctx = Promise._peekContext())) {\n        ctx.attachExtraTrace(warning);\n    } else {\n        var parsed = parseStackAndMessage(warning);\n        warning.stack = parsed.message + \"\\n\" + parsed.stack.join(\"\\n\");\n    }\n\n    if (!activeFireEvent(\"warning\", warning)) {\n        formatAndLogError(warning, \"\", true);\n    }\n}\n\nfunction reconstructStack(message, stacks) {\n    for (var i = 0; i < stacks.length - 1; ++i) {\n        stacks[i].push(\"From previous event:\");\n        stacks[i] = stacks[i].join(\"\\n\");\n    }\n    if (i < stacks.length) {\n        stacks[i] = stacks[i].join(\"\\n\");\n    }\n    return message + \"\\n\" + stacks.join(\"\\n\");\n}\n\nfunction removeDuplicateOrEmptyJumps(stacks) {\n    for (var i = 0; i < stacks.length; ++i) {\n        if (stacks[i].length === 0 ||\n            ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {\n            stacks.splice(i, 1);\n            i--;\n        }\n    }\n}\n\nfunction removeCommonRoots(stacks) {\n    var current = stacks[0];\n    for (var i = 1; i < stacks.length; ++i) {\n        var prev = stacks[i];\n        var currentLastIndex = current.length - 1;\n        var currentLastLine = current[currentLastIndex];\n        var commonRootMeetPoint = -1;\n\n        for (var j = prev.length - 1; j >= 0; --j) {\n            if (prev[j] === currentLastLine) {\n                commonRootMeetPoint = j;\n                break;\n            }\n        }\n\n        for (var j = commonRootMeetPoint; j >= 0; --j) {\n            var line = prev[j];\n            if (current[currentLastIndex] === line) {\n                current.pop();\n                currentLastIndex--;\n            } else {\n                break;\n            }\n        }\n        current = prev;\n    }\n}\n\nfunction cleanStack(stack) {\n    var ret = [];\n    for (var i = 0; i < stack.length; ++i) {\n        var line = stack[i];\n        var isTraceLine = \"    (No stack trace)\" === line ||\n            stackFramePattern.test(line);\n        var isInternalFrame = isTraceLine && shouldIgnore(line);\n        if (isTraceLine && !isInternalFrame) {\n            if (indentStackFrames && line.charAt(0) !== \" \") {\n                line = \"    \" + line;\n            }\n            ret.push(line);\n        }\n    }\n    return ret;\n}\n\nfunction stackFramesAsArray(error) {\n    var stack = error.stack.replace(/\\s+$/g, \"\").split(\"\\n\");\n    for (var i = 0; i < stack.length; ++i) {\n        var line = stack[i];\n        if (\"    (No stack trace)\" === line || stackFramePattern.test(line)) {\n            break;\n        }\n    }\n    if (i > 0 && error.name != \"SyntaxError\") {\n        stack = stack.slice(i);\n    }\n    return stack;\n}\n\nfunction parseStackAndMessage(error) {\n    var stack = error.stack;\n    var message = error.toString();\n    stack = typeof stack === \"string\" && stack.length > 0\n                ? stackFramesAsArray(error) : [\"    (No stack trace)\"];\n    return {\n        message: message,\n        stack: error.name == \"SyntaxError\" ? stack : cleanStack(stack)\n    };\n}\n\nfunction formatAndLogError(error, title, isSoft) {\n    if (typeof console !== \"undefined\") {\n        var message;\n        if (util.isObject(error)) {\n            var stack = error.stack;\n            message = title + formatStack(stack, error);\n        } else {\n            message = title + String(error);\n        }\n        if (typeof printWarning === \"function\") {\n            printWarning(message, isSoft);\n        } else if (typeof console.log === \"function\" ||\n            typeof console.log === \"object\") {\n            console.log(message);\n        }\n    }\n}\n\nfunction fireRejectionEvent(name, localHandler, reason, promise) {\n    var localEventFired = false;\n    try {\n        if (typeof localHandler === \"function\") {\n            localEventFired = true;\n            if (name === \"rejectionHandled\") {\n                localHandler(promise);\n            } else {\n                localHandler(reason, promise);\n            }\n        }\n    } catch (e) {\n        async.throwLater(e);\n    }\n\n    if (name === \"unhandledRejection\") {\n        if (!activeFireEvent(name, reason, promise) && !localEventFired) {\n            formatAndLogError(reason, \"Unhandled rejection \");\n        }\n    } else {\n        activeFireEvent(name, promise);\n    }\n}\n\nfunction formatNonError(obj) {\n    var str;\n    if (typeof obj === \"function\") {\n        str = \"[function \" +\n            (obj.name || \"anonymous\") +\n            \"]\";\n    } else {\n        str = obj && typeof obj.toString === \"function\"\n            ? obj.toString() : util.toString(obj);\n        var ruselessToString = /\\[object [a-zA-Z0-9$_]+\\]/;\n        if (ruselessToString.test(str)) {\n            try {\n                var newStr = JSON.stringify(obj);\n                str = newStr;\n            }\n            catch(e) {\n\n            }\n        }\n        if (str.length === 0) {\n            str = \"(empty array)\";\n        }\n    }\n    return (\"(<\" + snip(str) + \">, no stack trace)\");\n}\n\nfunction snip(str) {\n    var maxChars = 41;\n    if (str.length < maxChars) {\n        return str;\n    }\n    return str.substr(0, maxChars - 3) + \"...\";\n}\n\nfunction longStackTracesIsSupported() {\n    return typeof captureStackTrace === \"function\";\n}\n\nvar shouldIgnore = function() { return false; };\nvar parseLineInfoRegex = /[\\/<\\(]([^:\\/]+):(\\d+):(?:\\d+)\\)?\\s*$/;\nfunction parseLineInfo(line) {\n    var matches = line.match(parseLineInfoRegex);\n    if (matches) {\n        return {\n            fileName: matches[1],\n            line: parseInt(matches[2], 10)\n        };\n    }\n}\n\nfunction setBounds(firstLineError, lastLineError) {\n    if (!longStackTracesIsSupported()) return;\n    var firstStackLines = (firstLineError.stack || \"\").split(\"\\n\");\n    var lastStackLines = (lastLineError.stack || \"\").split(\"\\n\");\n    var firstIndex = -1;\n    var lastIndex = -1;\n    var firstFileName;\n    var lastFileName;\n    for (var i = 0; i < firstStackLines.length; ++i) {\n        var result = parseLineInfo(firstStackLines[i]);\n        if (result) {\n            firstFileName = result.fileName;\n            firstIndex = result.line;\n            break;\n        }\n    }\n    for (var i = 0; i < lastStackLines.length; ++i) {\n        var result = parseLineInfo(lastStackLines[i]);\n        if (result) {\n            lastFileName = result.fileName;\n            lastIndex = result.line;\n            break;\n        }\n    }\n    if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||\n        firstFileName !== lastFileName || firstIndex >= lastIndex) {\n        return;\n    }\n\n    shouldIgnore = function(line) {\n        if (bluebirdFramePattern.test(line)) return true;\n        var info = parseLineInfo(line);\n        if (info) {\n            if (info.fileName === firstFileName &&\n                (firstIndex <= info.line && info.line <= lastIndex)) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\n\nfunction CapturedTrace(parent) {\n    this._parent = parent;\n    this._promisesCreated = 0;\n    var length = this._length = 1 + (parent === undefined ? 0 : parent._length);\n    captureStackTrace(this, CapturedTrace);\n    if (length > 32) this.uncycle();\n}\nutil.inherits(CapturedTrace, Error);\nContext.CapturedTrace = CapturedTrace;\n\nCapturedTrace.prototype.uncycle = function() {\n    var length = this._length;\n    if (length < 2) return;\n    var nodes = [];\n    var stackToIndex = {};\n\n    for (var i = 0, node = this; node !== undefined; ++i) {\n        nodes.push(node);\n        node = node._parent;\n    }\n    length = this._length = i;\n    for (var i = length - 1; i >= 0; --i) {\n        var stack = nodes[i].stack;\n        if (stackToIndex[stack] === undefined) {\n            stackToIndex[stack] = i;\n        }\n    }\n    for (var i = 0; i < length; ++i) {\n        var currentStack = nodes[i].stack;\n        var index = stackToIndex[currentStack];\n        if (index !== undefined && index !== i) {\n            if (index > 0) {\n                nodes[index - 1]._parent = undefined;\n                nodes[index - 1]._length = 1;\n            }\n            nodes[i]._parent = undefined;\n            nodes[i]._length = 1;\n            var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;\n\n            if (index < length - 1) {\n                cycleEdgeNode._parent = nodes[index + 1];\n                cycleEdgeNode._parent.uncycle();\n                cycleEdgeNode._length =\n                    cycleEdgeNode._parent._length + 1;\n            } else {\n                cycleEdgeNode._parent = undefined;\n                cycleEdgeNode._length = 1;\n            }\n            var currentChildLength = cycleEdgeNode._length + 1;\n            for (var j = i - 2; j >= 0; --j) {\n                nodes[j]._length = currentChildLength;\n                currentChildLength++;\n            }\n            return;\n        }\n    }\n};\n\nCapturedTrace.prototype.attachExtraTrace = function(error) {\n    if (error.__stackCleaned__) return;\n    this.uncycle();\n    var parsed = parseStackAndMessage(error);\n    var message = parsed.message;\n    var stacks = [parsed.stack];\n\n    var trace = this;\n    while (trace !== undefined) {\n        stacks.push(cleanStack(trace.stack.split(\"\\n\")));\n        trace = trace._parent;\n    }\n    removeCommonRoots(stacks);\n    removeDuplicateOrEmptyJumps(stacks);\n    util.notEnumerableProp(error, \"stack\", reconstructStack(message, stacks));\n    util.notEnumerableProp(error, \"__stackCleaned__\", true);\n};\n\nvar captureStackTrace = (function stackDetection() {\n    var v8stackFramePattern = /^\\s*at\\s*/;\n    var v8stackFormatter = function(stack, error) {\n        if (typeof stack === \"string\") return stack;\n\n        if (error.name !== undefined &&\n            error.message !== undefined) {\n            return error.toString();\n        }\n        return formatNonError(error);\n    };\n\n    if (typeof Error.stackTraceLimit === \"number\" &&\n        typeof Error.captureStackTrace === \"function\") {\n        Error.stackTraceLimit += 6;\n        stackFramePattern = v8stackFramePattern;\n        formatStack = v8stackFormatter;\n        var captureStackTrace = Error.captureStackTrace;\n\n        shouldIgnore = function(line) {\n            return bluebirdFramePattern.test(line);\n        };\n        return function(receiver, ignoreUntil) {\n            Error.stackTraceLimit += 6;\n            captureStackTrace(receiver, ignoreUntil);\n            Error.stackTraceLimit -= 6;\n        };\n    }\n    var err = new Error();\n\n    if (typeof err.stack === \"string\" &&\n        err.stack.split(\"\\n\")[0].indexOf(\"stackDetection@\") >= 0) {\n        stackFramePattern = /@/;\n        formatStack = v8stackFormatter;\n        indentStackFrames = true;\n        return function captureStackTrace(o) {\n            o.stack = new Error().stack;\n        };\n    }\n\n    var hasStackAfterThrow;\n    try { throw new Error(); }\n    catch(e) {\n        hasStackAfterThrow = (\"stack\" in e);\n    }\n    if (!(\"stack\" in err) && hasStackAfterThrow &&\n        typeof Error.stackTraceLimit === \"number\") {\n        stackFramePattern = v8stackFramePattern;\n        formatStack = v8stackFormatter;\n        return function captureStackTrace(o) {\n            Error.stackTraceLimit += 6;\n            try { throw new Error(); }\n            catch(e) { o.stack = e.stack; }\n            Error.stackTraceLimit -= 6;\n        };\n    }\n\n    formatStack = function(stack, error) {\n        if (typeof stack === \"string\") return stack;\n\n        if ((typeof error === \"object\" ||\n            typeof error === \"function\") &&\n            error.name !== undefined &&\n            error.message !== undefined) {\n            return error.toString();\n        }\n        return formatNonError(error);\n    };\n\n    return null;\n\n})([]);\n\nif (typeof console !== \"undefined\" && typeof console.warn !== \"undefined\") {\n    printWarning = function (message) {\n        console.warn(message);\n    };\n    if (util.isNode && process.stderr.isTTY) {\n        printWarning = function(message, isSoft) {\n            var color = isSoft ? \"\\u001b[33m\" : \"\\u001b[31m\";\n            console.warn(color + message + \"\\u001b[0m\\n\");\n        };\n    } else if (!util.isNode && typeof (new Error().stack) === \"string\") {\n        printWarning = function(message, isSoft) {\n            console.warn(\"%c\" + message,\n                        isSoft ? \"color: darkorange\" : \"color: red\");\n        };\n    }\n}\n\nvar config = {\n    warnings: warnings,\n    longStackTraces: false,\n    cancellation: false,\n    monitoring: false\n};\n\nif (longStackTraces) Promise.longStackTraces();\n\nreturn {\n    longStackTraces: function() {\n        return config.longStackTraces;\n    },\n    warnings: function() {\n        return config.warnings;\n    },\n    cancellation: function() {\n        return config.cancellation;\n    },\n    monitoring: function() {\n        return config.monitoring;\n    },\n    propagateFromFunction: function() {\n        return propagateFromFunction;\n    },\n    boundValueFunction: function() {\n        return boundValueFunction;\n    },\n    checkForgottenReturns: checkForgottenReturns,\n    setBounds: setBounds,\n    warn: warn,\n    deprecated: deprecated,\n    CapturedTrace: CapturedTrace,\n    fireDomEvent: fireDomEvent,\n    fireGlobalEvent: fireGlobalEvent\n};\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(25)))\n\n/***/ }),\n/* 151 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {\nvar util = __webpack_require__(6);\nvar CancellationError = Promise.CancellationError;\nvar errorObj = util.errorObj;\nvar catchFilter = __webpack_require__(132)(NEXT_FILTER);\n\nfunction PassThroughHandlerContext(promise, type, handler) {\n    this.promise = promise;\n    this.type = type;\n    this.handler = handler;\n    this.called = false;\n    this.cancelPromise = null;\n}\n\nPassThroughHandlerContext.prototype.isFinallyHandler = function() {\n    return this.type === 0;\n};\n\nfunction FinallyHandlerCancelReaction(finallyHandler) {\n    this.finallyHandler = finallyHandler;\n}\n\nFinallyHandlerCancelReaction.prototype._resultCancelled = function() {\n    checkCancel(this.finallyHandler);\n};\n\nfunction checkCancel(ctx, reason) {\n    if (ctx.cancelPromise != null) {\n        if (arguments.length > 1) {\n            ctx.cancelPromise._reject(reason);\n        } else {\n            ctx.cancelPromise._cancel();\n        }\n        ctx.cancelPromise = null;\n        return true;\n    }\n    return false;\n}\n\nfunction succeed() {\n    return finallyHandler.call(this, this.promise._target()._settledValue());\n}\nfunction fail(reason) {\n    if (checkCancel(this, reason)) return;\n    errorObj.e = reason;\n    return errorObj;\n}\nfunction finallyHandler(reasonOrValue) {\n    var promise = this.promise;\n    var handler = this.handler;\n\n    if (!this.called) {\n        this.called = true;\n        var ret = this.isFinallyHandler()\n            ? handler.call(promise._boundValue())\n            : handler.call(promise._boundValue(), reasonOrValue);\n        if (ret === NEXT_FILTER) {\n            return ret;\n        } else if (ret !== undefined) {\n            promise._setReturnedNonUndefined();\n            var maybePromise = tryConvertToPromise(ret, promise);\n            if (maybePromise instanceof Promise) {\n                if (this.cancelPromise != null) {\n                    if (maybePromise._isCancelled()) {\n                        var reason =\n                            new CancellationError(\"late cancellation observer\");\n                        promise._attachExtraTrace(reason);\n                        errorObj.e = reason;\n                        return errorObj;\n                    } else if (maybePromise.isPending()) {\n                        maybePromise._attachCancellationCallback(\n                            new FinallyHandlerCancelReaction(this));\n                    }\n                }\n                return maybePromise._then(\n                    succeed, fail, undefined, this, undefined);\n            }\n        }\n    }\n\n    if (promise.isRejected()) {\n        checkCancel(this);\n        errorObj.e = reasonOrValue;\n        return errorObj;\n    } else {\n        checkCancel(this);\n        return reasonOrValue;\n    }\n}\n\nPromise.prototype._passThrough = function(handler, type, success, fail) {\n    if (typeof handler !== \"function\") return this.then();\n    return this._then(success,\n                      fail,\n                      undefined,\n                      new PassThroughHandlerContext(this, type, handler),\n                      undefined);\n};\n\nPromise.prototype.lastly =\nPromise.prototype[\"finally\"] = function (handler) {\n    return this._passThrough(handler,\n                             0,\n                             finallyHandler,\n                             finallyHandler);\n};\n\n\nPromise.prototype.tap = function (handler) {\n    return this._passThrough(handler, 1, finallyHandler);\n};\n\nPromise.prototype.tapCatch = function (handlerOrPredicate) {\n    var len = arguments.length;\n    if(len === 1) {\n        return this._passThrough(handlerOrPredicate,\n                                 1,\n                                 undefined,\n                                 finallyHandler);\n    } else {\n         var catchInstances = new Array(len - 1),\n            j = 0, i;\n        for (i = 0; i < len - 1; ++i) {\n            var item = arguments[i];\n            if (util.isObject(item)) {\n                catchInstances[j++] = item;\n            } else {\n                return Promise.reject(new TypeError(\n                    \"tapCatch statement predicate: \"\n                    + \"expecting an object but got \" + util.classString(item)\n                ));\n            }\n        }\n        catchInstances.length = j;\n        var handler = arguments[i];\n        return this._passThrough(catchFilter(catchInstances, handler, this),\n                                 1,\n                                 undefined,\n                                 finallyHandler);\n    }\n\n};\n\nreturn PassThroughHandlerContext;\n};\n\n\n/***/ }),\n/* 152 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports =\nfunction(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {\nvar util = __webpack_require__(6);\nvar tryCatch = util.tryCatch;\n\nPromise.method = function (fn) {\n    if (typeof fn !== \"function\") {\n        throw new Promise.TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    return function () {\n        var ret = new Promise(INTERNAL);\n        ret._captureStackTrace();\n        ret._pushContext();\n        var value = tryCatch(fn).apply(this, arguments);\n        var promiseCreated = ret._popContext();\n        debug.checkForgottenReturns(\n            value, promiseCreated, \"Promise.method\", ret);\n        ret._resolveFromSyncValue(value);\n        return ret;\n    };\n};\n\nPromise.attempt = Promise[\"try\"] = function (fn) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    ret._pushContext();\n    var value;\n    if (arguments.length > 1) {\n        debug.deprecated(\"calling Promise.try with more than 1 argument\");\n        var arg = arguments[1];\n        var ctx = arguments[2];\n        value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)\n                                  : tryCatch(fn).call(ctx, arg);\n    } else {\n        value = tryCatch(fn)();\n    }\n    var promiseCreated = ret._popContext();\n    debug.checkForgottenReturns(\n        value, promiseCreated, \"Promise.try\", ret);\n    ret._resolveFromSyncValue(value);\n    return ret;\n};\n\nPromise.prototype._resolveFromSyncValue = function (value) {\n    if (value === util.errorObj) {\n        this._rejectCallback(value.e, false);\n    } else {\n        this._resolveCallback(value, true);\n    }\n};\n};\n\n\n/***/ }),\n/* 153 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {\nvar calledBind = false;\nvar rejectThis = function(_, e) {\n    this._reject(e);\n};\n\nvar targetRejected = function(e, context) {\n    context.promiseRejectionQueued = true;\n    context.bindingPromise._then(rejectThis, rejectThis, null, this, e);\n};\n\nvar bindingResolved = function(thisArg, context) {\n    if (((this._bitField & 50397184) === 0)) {\n        this._resolveCallback(context.target);\n    }\n};\n\nvar bindingRejected = function(e, context) {\n    if (!context.promiseRejectionQueued) this._reject(e);\n};\n\nPromise.prototype.bind = function (thisArg) {\n    if (!calledBind) {\n        calledBind = true;\n        Promise.prototype._propagateFrom = debug.propagateFromFunction();\n        Promise.prototype._boundValue = debug.boundValueFunction();\n    }\n    var maybePromise = tryConvertToPromise(thisArg);\n    var ret = new Promise(INTERNAL);\n    ret._propagateFrom(this, 1);\n    var target = this._target();\n    ret._setBoundTo(maybePromise);\n    if (maybePromise instanceof Promise) {\n        var context = {\n            promiseRejectionQueued: false,\n            promise: ret,\n            target: target,\n            bindingPromise: maybePromise\n        };\n        target._then(INTERNAL, targetRejected, undefined, ret, context);\n        maybePromise._then(\n            bindingResolved, bindingRejected, undefined, ret, context);\n        ret._setOnCancel(maybePromise);\n    } else {\n        ret._resolveCallback(target);\n    }\n    return ret;\n};\n\nPromise.prototype._setBoundTo = function (obj) {\n    if (obj !== undefined) {\n        this._bitField = this._bitField | 2097152;\n        this._boundTo = obj;\n    } else {\n        this._bitField = this._bitField & (~2097152);\n    }\n};\n\nPromise.prototype._isBound = function () {\n    return (this._bitField & 2097152) === 2097152;\n};\n\nPromise.bind = function (thisArg, value) {\n    return Promise.resolve(value).bind(thisArg);\n};\n};\n\n\n/***/ }),\n/* 154 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, PromiseArray, apiRejection, debug) {\nvar util = __webpack_require__(6);\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar async = Promise._async;\n\nPromise.prototype[\"break\"] = Promise.prototype.cancel = function() {\n    if (!debug.cancellation()) return this._warn(\"cancellation is disabled\");\n\n    var promise = this;\n    var child = promise;\n    while (promise._isCancellable()) {\n        if (!promise._cancelBy(child)) {\n            if (child._isFollowing()) {\n                child._followee().cancel();\n            } else {\n                child._cancelBranched();\n            }\n            break;\n        }\n\n        var parent = promise._cancellationParent;\n        if (parent == null || !parent._isCancellable()) {\n            if (promise._isFollowing()) {\n                promise._followee().cancel();\n            } else {\n                promise._cancelBranched();\n            }\n            break;\n        } else {\n            if (promise._isFollowing()) promise._followee().cancel();\n            promise._setWillBeCancelled();\n            child = promise;\n            promise = parent;\n        }\n    }\n};\n\nPromise.prototype._branchHasCancelled = function() {\n    this._branchesRemainingToCancel--;\n};\n\nPromise.prototype._enoughBranchesHaveCancelled = function() {\n    return this._branchesRemainingToCancel === undefined ||\n           this._branchesRemainingToCancel <= 0;\n};\n\nPromise.prototype._cancelBy = function(canceller) {\n    if (canceller === this) {\n        this._branchesRemainingToCancel = 0;\n        this._invokeOnCancel();\n        return true;\n    } else {\n        this._branchHasCancelled();\n        if (this._enoughBranchesHaveCancelled()) {\n            this._invokeOnCancel();\n            return true;\n        }\n    }\n    return false;\n};\n\nPromise.prototype._cancelBranched = function() {\n    if (this._enoughBranchesHaveCancelled()) {\n        this._cancel();\n    }\n};\n\nPromise.prototype._cancel = function() {\n    if (!this._isCancellable()) return;\n    this._setCancelled();\n    async.invoke(this._cancelPromises, this, undefined);\n};\n\nPromise.prototype._cancelPromises = function() {\n    if (this._length() > 0) this._settlePromises();\n};\n\nPromise.prototype._unsetOnCancel = function() {\n    this._onCancelField = undefined;\n};\n\nPromise.prototype._isCancellable = function() {\n    return this.isPending() && !this._isCancelled();\n};\n\nPromise.prototype.isCancellable = function() {\n    return this.isPending() && !this.isCancelled();\n};\n\nPromise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {\n    if (util.isArray(onCancelCallback)) {\n        for (var i = 0; i < onCancelCallback.length; ++i) {\n            this._doInvokeOnCancel(onCancelCallback[i], internalOnly);\n        }\n    } else if (onCancelCallback !== undefined) {\n        if (typeof onCancelCallback === \"function\") {\n            if (!internalOnly) {\n                var e = tryCatch(onCancelCallback).call(this._boundValue());\n                if (e === errorObj) {\n                    this._attachExtraTrace(e.e);\n                    async.throwLater(e.e);\n                }\n            }\n        } else {\n            onCancelCallback._resultCancelled(this);\n        }\n    }\n};\n\nPromise.prototype._invokeOnCancel = function() {\n    var onCancelCallback = this._onCancel();\n    this._unsetOnCancel();\n    async.invoke(this._doInvokeOnCancel, this, onCancelCallback);\n};\n\nPromise.prototype._invokeInternalOnCancel = function() {\n    if (this._isCancellable()) {\n        this._doInvokeOnCancel(this._onCancel(), true);\n        this._unsetOnCancel();\n    }\n};\n\nPromise.prototype._resultCancelled = function() {\n    this.cancel();\n};\n\n};\n\n\n/***/ }),\n/* 155 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise) {\nfunction returner() {\n    return this.value;\n}\nfunction thrower() {\n    throw this.reason;\n}\n\nPromise.prototype[\"return\"] =\nPromise.prototype.thenReturn = function (value) {\n    if (value instanceof Promise) value.suppressUnhandledRejections();\n    return this._then(\n        returner, undefined, undefined, {value: value}, undefined);\n};\n\nPromise.prototype[\"throw\"] =\nPromise.prototype.thenThrow = function (reason) {\n    return this._then(\n        thrower, undefined, undefined, {reason: reason}, undefined);\n};\n\nPromise.prototype.catchThrow = function (reason) {\n    if (arguments.length <= 1) {\n        return this._then(\n            undefined, thrower, undefined, {reason: reason}, undefined);\n    } else {\n        var _reason = arguments[1];\n        var handler = function() {throw _reason;};\n        return this.caught(reason, handler);\n    }\n};\n\nPromise.prototype.catchReturn = function (value) {\n    if (arguments.length <= 1) {\n        if (value instanceof Promise) value.suppressUnhandledRejections();\n        return this._then(\n            undefined, returner, undefined, {value: value}, undefined);\n    } else {\n        var _value = arguments[1];\n        if (_value instanceof Promise) _value.suppressUnhandledRejections();\n        var handler = function() {return _value;};\n        return this.caught(value, handler);\n    }\n};\n};\n\n\n/***/ }),\n/* 156 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise) {\nfunction PromiseInspection(promise) {\n    if (promise !== undefined) {\n        promise = promise._target();\n        this._bitField = promise._bitField;\n        this._settledValueField = promise._isFateSealed()\n            ? promise._settledValue() : undefined;\n    }\n    else {\n        this._bitField = 0;\n        this._settledValueField = undefined;\n    }\n}\n\nPromiseInspection.prototype._settledValue = function() {\n    return this._settledValueField;\n};\n\nvar value = PromiseInspection.prototype.value = function () {\n    if (!this.isFulfilled()) {\n        throw new TypeError(\"cannot get fulfillment value of a non-fulfilled promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    return this._settledValue();\n};\n\nvar reason = PromiseInspection.prototype.error =\nPromiseInspection.prototype.reason = function () {\n    if (!this.isRejected()) {\n        throw new TypeError(\"cannot get rejection reason of a non-rejected promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    return this._settledValue();\n};\n\nvar isFulfilled = PromiseInspection.prototype.isFulfilled = function() {\n    return (this._bitField & 33554432) !== 0;\n};\n\nvar isRejected = PromiseInspection.prototype.isRejected = function () {\n    return (this._bitField & 16777216) !== 0;\n};\n\nvar isPending = PromiseInspection.prototype.isPending = function () {\n    return (this._bitField & 50397184) === 0;\n};\n\nvar isResolved = PromiseInspection.prototype.isResolved = function () {\n    return (this._bitField & 50331648) !== 0;\n};\n\nPromiseInspection.prototype.isCancelled = function() {\n    return (this._bitField & 8454144) !== 0;\n};\n\nPromise.prototype.__isCancelled = function() {\n    return (this._bitField & 65536) === 65536;\n};\n\nPromise.prototype._isCancelled = function() {\n    return this._target().__isCancelled();\n};\n\nPromise.prototype.isCancelled = function() {\n    return (this._target()._bitField & 8454144) !== 0;\n};\n\nPromise.prototype.isPending = function() {\n    return isPending.call(this._target());\n};\n\nPromise.prototype.isRejected = function() {\n    return isRejected.call(this._target());\n};\n\nPromise.prototype.isFulfilled = function() {\n    return isFulfilled.call(this._target());\n};\n\nPromise.prototype.isResolved = function() {\n    return isResolved.call(this._target());\n};\n\nPromise.prototype.value = function() {\n    return value.call(this._target());\n};\n\nPromise.prototype.reason = function() {\n    var target = this._target();\n    target._unsetRejectionIsUnhandled();\n    return reason.call(target);\n};\n\nPromise.prototype._value = function() {\n    return this._settledValue();\n};\n\nPromise.prototype._reason = function() {\n    this._unsetRejectionIsUnhandled();\n    return this._settledValue();\n};\n\nPromise.PromiseInspection = PromiseInspection;\n};\n\n\n/***/ }),\n/* 157 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports =\nfunction(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async,\n         getDomain) {\nvar util = __webpack_require__(6);\nvar canEvaluate = util.canEvaluate;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar reject;\n\nif (true) {\nif (canEvaluate) {\n    var thenCallback = function(i) {\n        return new Function(\"value\", \"holder\", \"                             \\n\\\n            'use strict';                                                    \\n\\\n            holder.pIndex = value;                                           \\n\\\n            holder.checkFulfillment(this);                                   \\n\\\n            \".replace(/Index/g, i));\n    };\n\n    var promiseSetter = function(i) {\n        return new Function(\"promise\", \"holder\", \"                           \\n\\\n            'use strict';                                                    \\n\\\n            holder.pIndex = promise;                                         \\n\\\n            \".replace(/Index/g, i));\n    };\n\n    var generateHolderClass = function(total) {\n        var props = new Array(total);\n        for (var i = 0; i < props.length; ++i) {\n            props[i] = \"this.p\" + (i+1);\n        }\n        var assignment = props.join(\" = \") + \" = null;\";\n        var cancellationCode= \"var promise;\\n\" + props.map(function(prop) {\n            return \"                                                         \\n\\\n                promise = \" + prop + \";                                      \\n\\\n                if (promise instanceof Promise) {                            \\n\\\n                    promise.cancel();                                        \\n\\\n                }                                                            \\n\\\n            \";\n        }).join(\"\\n\");\n        var passedArguments = props.join(\", \");\n        var name = \"Holder$\" + total;\n\n\n        var code = \"return function(tryCatch, errorObj, Promise, async) {    \\n\\\n            'use strict';                                                    \\n\\\n            function [TheName](fn) {                                         \\n\\\n                [TheProperties]                                              \\n\\\n                this.fn = fn;                                                \\n\\\n                this.asyncNeeded = true;                                     \\n\\\n                this.now = 0;                                                \\n\\\n            }                                                                \\n\\\n                                                                             \\n\\\n            [TheName].prototype._callFunction = function(promise) {          \\n\\\n                promise._pushContext();                                      \\n\\\n                var ret = tryCatch(this.fn)([ThePassedArguments]);           \\n\\\n                promise._popContext();                                       \\n\\\n                if (ret === errorObj) {                                      \\n\\\n                    promise._rejectCallback(ret.e, false);                   \\n\\\n                } else {                                                     \\n\\\n                    promise._resolveCallback(ret);                           \\n\\\n                }                                                            \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            [TheName].prototype.checkFulfillment = function(promise) {       \\n\\\n                var now = ++this.now;                                        \\n\\\n                if (now === [TheTotal]) {                                    \\n\\\n                    if (this.asyncNeeded) {                                  \\n\\\n                        async.invoke(this._callFunction, this, promise);     \\n\\\n                    } else {                                                 \\n\\\n                        this._callFunction(promise);                         \\n\\\n                    }                                                        \\n\\\n                                                                             \\n\\\n                }                                                            \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            [TheName].prototype._resultCancelled = function() {              \\n\\\n                [CancellationCode]                                           \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            return [TheName];                                                \\n\\\n        }(tryCatch, errorObj, Promise, async);                               \\n\\\n        \";\n\n        code = code.replace(/\\[TheName\\]/g, name)\n            .replace(/\\[TheTotal\\]/g, total)\n            .replace(/\\[ThePassedArguments\\]/g, passedArguments)\n            .replace(/\\[TheProperties\\]/g, assignment)\n            .replace(/\\[CancellationCode\\]/g, cancellationCode);\n\n        return new Function(\"tryCatch\", \"errorObj\", \"Promise\", \"async\", code)\n                           (tryCatch, errorObj, Promise, async);\n    };\n\n    var holderClasses = [];\n    var thenCallbacks = [];\n    var promiseSetters = [];\n\n    for (var i = 0; i < 8; ++i) {\n        holderClasses.push(generateHolderClass(i + 1));\n        thenCallbacks.push(thenCallback(i + 1));\n        promiseSetters.push(promiseSetter(i + 1));\n    }\n\n    reject = function (reason) {\n        this._reject(reason);\n    };\n}}\n\nPromise.join = function () {\n    var last = arguments.length - 1;\n    var fn;\n    if (last > 0 && typeof arguments[last] === \"function\") {\n        fn = arguments[last];\n        if (true) {\n            if (last <= 8 && canEvaluate) {\n                var ret = new Promise(INTERNAL);\n                ret._captureStackTrace();\n                var HolderClass = holderClasses[last - 1];\n                var holder = new HolderClass(fn);\n                var callbacks = thenCallbacks;\n\n                for (var i = 0; i < last; ++i) {\n                    var maybePromise = tryConvertToPromise(arguments[i], ret);\n                    if (maybePromise instanceof Promise) {\n                        maybePromise = maybePromise._target();\n                        var bitField = maybePromise._bitField;\n                        ;\n                        if (((bitField & 50397184) === 0)) {\n                            maybePromise._then(callbacks[i], reject,\n                                               undefined, ret, holder);\n                            promiseSetters[i](maybePromise, holder);\n                            holder.asyncNeeded = false;\n                        } else if (((bitField & 33554432) !== 0)) {\n                            callbacks[i].call(ret,\n                                              maybePromise._value(), holder);\n                        } else if (((bitField & 16777216) !== 0)) {\n                            ret._reject(maybePromise._reason());\n                        } else {\n                            ret._cancel();\n                        }\n                    } else {\n                        callbacks[i].call(ret, maybePromise, holder);\n                    }\n                }\n\n                if (!ret._isFateSealed()) {\n                    if (holder.asyncNeeded) {\n                        var domain = getDomain();\n                        if (domain !== null) {\n                            holder.fn = util.domainBind(domain, holder.fn);\n                        }\n                    }\n                    ret._setAsyncGuaranteed();\n                    ret._setOnCancel(holder);\n                }\n                return ret;\n            }\n        }\n    }\n    var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];};\n    if (fn) args.pop();\n    var ret = new PromiseArray(args).promise();\n    return fn !== undefined ? ret.spread(fn) : ret;\n};\n\n};\n\n\n/***/ }),\n/* 158 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar cr = Object.create;\nif (cr) {\n    var callerCache = cr(null);\n    var getterCache = cr(null);\n    callerCache[\" size\"] = getterCache[\" size\"] = 0;\n}\n\nmodule.exports = function(Promise) {\nvar util = __webpack_require__(6);\nvar canEvaluate = util.canEvaluate;\nvar isIdentifier = util.isIdentifier;\n\nvar getMethodCaller;\nvar getGetter;\nif (true) {\nvar makeMethodCaller = function (methodName) {\n    return new Function(\"ensureMethod\", \"                                    \\n\\\n        return function(obj) {                                               \\n\\\n            'use strict'                                                     \\n\\\n            var len = this.length;                                           \\n\\\n            ensureMethod(obj, 'methodName');                                 \\n\\\n            switch(len) {                                                    \\n\\\n                case 1: return obj.methodName(this[0]);                      \\n\\\n                case 2: return obj.methodName(this[0], this[1]);             \\n\\\n                case 3: return obj.methodName(this[0], this[1], this[2]);    \\n\\\n                case 0: return obj.methodName();                             \\n\\\n                default:                                                     \\n\\\n                    return obj.methodName.apply(obj, this);                  \\n\\\n            }                                                                \\n\\\n        };                                                                   \\n\\\n        \".replace(/methodName/g, methodName))(ensureMethod);\n};\n\nvar makeGetter = function (propertyName) {\n    return new Function(\"obj\", \"                                             \\n\\\n        'use strict';                                                        \\n\\\n        return obj.propertyName;                                             \\n\\\n        \".replace(\"propertyName\", propertyName));\n};\n\nvar getCompiled = function(name, compiler, cache) {\n    var ret = cache[name];\n    if (typeof ret !== \"function\") {\n        if (!isIdentifier(name)) {\n            return null;\n        }\n        ret = compiler(name);\n        cache[name] = ret;\n        cache[\" size\"]++;\n        if (cache[\" size\"] > 512) {\n            var keys = Object.keys(cache);\n            for (var i = 0; i < 256; ++i) delete cache[keys[i]];\n            cache[\" size\"] = keys.length - 256;\n        }\n    }\n    return ret;\n};\n\ngetMethodCaller = function(name) {\n    return getCompiled(name, makeMethodCaller, callerCache);\n};\n\ngetGetter = function(name) {\n    return getCompiled(name, makeGetter, getterCache);\n};\n}\n\nfunction ensureMethod(obj, methodName) {\n    var fn;\n    if (obj != null) fn = obj[methodName];\n    if (typeof fn !== \"function\") {\n        var message = \"Object \" + util.classString(obj) + \" has no method '\" +\n            util.toString(methodName) + \"'\";\n        throw new Promise.TypeError(message);\n    }\n    return fn;\n}\n\nfunction caller(obj) {\n    var methodName = this.pop();\n    var fn = ensureMethod(obj, methodName);\n    return fn.apply(obj, this);\n}\nPromise.prototype.call = function (methodName) {\n    var $_len = arguments.length;var args = new Array(Math.max($_len - 1, 0)); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];};\n    if (true) {\n        if (canEvaluate) {\n            var maybeCaller = getMethodCaller(methodName);\n            if (maybeCaller !== null) {\n                return this._then(\n                    maybeCaller, undefined, undefined, args, undefined);\n            }\n        }\n    }\n    args.push(methodName);\n    return this._then(caller, undefined, undefined, args, undefined);\n};\n\nfunction namedGetter(obj) {\n    return obj[this];\n}\nfunction indexedGetter(obj) {\n    var index = +this;\n    if (index < 0) index = Math.max(0, index + obj.length);\n    return obj[index];\n}\nPromise.prototype.get = function (propertyName) {\n    var isIndex = (typeof propertyName === \"number\");\n    var getter;\n    if (!isIndex) {\n        if (canEvaluate) {\n            var maybeGetter = getGetter(propertyName);\n            getter = maybeGetter !== null ? maybeGetter : namedGetter;\n        } else {\n            getter = namedGetter;\n        }\n    } else {\n        getter = indexedGetter;\n    }\n    return this._then(getter, undefined, undefined, propertyName, undefined);\n};\n};\n\n\n/***/ }),\n/* 159 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise,\n                          apiRejection,\n                          INTERNAL,\n                          tryConvertToPromise,\n                          Proxyable,\n                          debug) {\nvar errors = __webpack_require__(26);\nvar TypeError = errors.TypeError;\nvar util = __webpack_require__(6);\nvar errorObj = util.errorObj;\nvar tryCatch = util.tryCatch;\nvar yieldHandlers = [];\n\nfunction promiseFromYieldHandler(value, yieldHandlers, traceParent) {\n    for (var i = 0; i < yieldHandlers.length; ++i) {\n        traceParent._pushContext();\n        var result = tryCatch(yieldHandlers[i])(value);\n        traceParent._popContext();\n        if (result === errorObj) {\n            traceParent._pushContext();\n            var ret = Promise.reject(errorObj.e);\n            traceParent._popContext();\n            return ret;\n        }\n        var maybePromise = tryConvertToPromise(result, traceParent);\n        if (maybePromise instanceof Promise) return maybePromise;\n    }\n    return null;\n}\n\nfunction PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {\n    if (debug.cancellation()) {\n        var internal = new Promise(INTERNAL);\n        var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);\n        this._promise = internal.lastly(function() {\n            return _finallyPromise;\n        });\n        internal._captureStackTrace();\n        internal._setOnCancel(this);\n    } else {\n        var promise = this._promise = new Promise(INTERNAL);\n        promise._captureStackTrace();\n    }\n    this._stack = stack;\n    this._generatorFunction = generatorFunction;\n    this._receiver = receiver;\n    this._generator = undefined;\n    this._yieldHandlers = typeof yieldHandler === \"function\"\n        ? [yieldHandler].concat(yieldHandlers)\n        : yieldHandlers;\n    this._yieldedPromise = null;\n    this._cancellationPhase = false;\n}\nutil.inherits(PromiseSpawn, Proxyable);\n\nPromiseSpawn.prototype._isResolved = function() {\n    return this._promise === null;\n};\n\nPromiseSpawn.prototype._cleanup = function() {\n    this._promise = this._generator = null;\n    if (debug.cancellation() && this._finallyPromise !== null) {\n        this._finallyPromise._fulfill();\n        this._finallyPromise = null;\n    }\n};\n\nPromiseSpawn.prototype._promiseCancelled = function() {\n    if (this._isResolved()) return;\n    var implementsReturn = typeof this._generator[\"return\"] !== \"undefined\";\n\n    var result;\n    if (!implementsReturn) {\n        var reason = new Promise.CancellationError(\n            \"generator .return() sentinel\");\n        Promise.coroutine.returnSentinel = reason;\n        this._promise._attachExtraTrace(reason);\n        this._promise._pushContext();\n        result = tryCatch(this._generator[\"throw\"]).call(this._generator,\n                                                         reason);\n        this._promise._popContext();\n    } else {\n        this._promise._pushContext();\n        result = tryCatch(this._generator[\"return\"]).call(this._generator,\n                                                          undefined);\n        this._promise._popContext();\n    }\n    this._cancellationPhase = true;\n    this._yieldedPromise = null;\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._promiseFulfilled = function(value) {\n    this._yieldedPromise = null;\n    this._promise._pushContext();\n    var result = tryCatch(this._generator.next).call(this._generator, value);\n    this._promise._popContext();\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._promiseRejected = function(reason) {\n    this._yieldedPromise = null;\n    this._promise._attachExtraTrace(reason);\n    this._promise._pushContext();\n    var result = tryCatch(this._generator[\"throw\"])\n        .call(this._generator, reason);\n    this._promise._popContext();\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._resultCancelled = function() {\n    if (this._yieldedPromise instanceof Promise) {\n        var promise = this._yieldedPromise;\n        this._yieldedPromise = null;\n        promise.cancel();\n    }\n};\n\nPromiseSpawn.prototype.promise = function () {\n    return this._promise;\n};\n\nPromiseSpawn.prototype._run = function () {\n    this._generator = this._generatorFunction.call(this._receiver);\n    this._receiver =\n        this._generatorFunction = undefined;\n    this._promiseFulfilled(undefined);\n};\n\nPromiseSpawn.prototype._continue = function (result) {\n    var promise = this._promise;\n    if (result === errorObj) {\n        this._cleanup();\n        if (this._cancellationPhase) {\n            return promise.cancel();\n        } else {\n            return promise._rejectCallback(result.e, false);\n        }\n    }\n\n    var value = result.value;\n    if (result.done === true) {\n        this._cleanup();\n        if (this._cancellationPhase) {\n            return promise.cancel();\n        } else {\n            return promise._resolveCallback(value);\n        }\n    } else {\n        var maybePromise = tryConvertToPromise(value, this._promise);\n        if (!(maybePromise instanceof Promise)) {\n            maybePromise =\n                promiseFromYieldHandler(maybePromise,\n                                        this._yieldHandlers,\n                                        this._promise);\n            if (maybePromise === null) {\n                this._promiseRejected(\n                    new TypeError(\n                        \"A value %s was yielded that could not be treated as a promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\\u000a\".replace(\"%s\", String(value)) +\n                        \"From coroutine:\\u000a\" +\n                        this._stack.split(\"\\n\").slice(1, -7).join(\"\\n\")\n                    )\n                );\n                return;\n            }\n        }\n        maybePromise = maybePromise._target();\n        var bitField = maybePromise._bitField;\n        ;\n        if (((bitField & 50397184) === 0)) {\n            this._yieldedPromise = maybePromise;\n            maybePromise._proxy(this, null);\n        } else if (((bitField & 33554432) !== 0)) {\n            Promise._async.invoke(\n                this._promiseFulfilled, this, maybePromise._value()\n            );\n        } else if (((bitField & 16777216) !== 0)) {\n            Promise._async.invoke(\n                this._promiseRejected, this, maybePromise._reason()\n            );\n        } else {\n            this._promiseCancelled();\n        }\n    }\n};\n\nPromise.coroutine = function (generatorFunction, options) {\n    if (typeof generatorFunction !== \"function\") {\n        throw new TypeError(\"generatorFunction must be a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var yieldHandler = Object(options).yieldHandler;\n    var PromiseSpawn$ = PromiseSpawn;\n    var stack = new Error().stack;\n    return function () {\n        var generator = generatorFunction.apply(this, arguments);\n        var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,\n                                      stack);\n        var ret = spawn.promise();\n        spawn._generator = generator;\n        spawn._promiseFulfilled(undefined);\n        return ret;\n    };\n};\n\nPromise.coroutine.addYieldHandler = function(fn) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    yieldHandlers.push(fn);\n};\n\nPromise.spawn = function (generatorFunction) {\n    debug.deprecated(\"Promise.spawn()\", \"Promise.coroutine()\");\n    if (typeof generatorFunction !== \"function\") {\n        return apiRejection(\"generatorFunction must be a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var spawn = new PromiseSpawn(generatorFunction, this);\n    var ret = spawn.promise();\n    spawn._run(Promise.spawn);\n    return ret;\n};\n};\n\n\n/***/ }),\n/* 160 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise,\n                          PromiseArray,\n                          apiRejection,\n                          tryConvertToPromise,\n                          INTERNAL,\n                          debug) {\nvar getDomain = Promise._getDomain;\nvar util = __webpack_require__(6);\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar async = Promise._async;\n\nfunction MappingPromiseArray(promises, fn, limit, _filter) {\n    this.constructor$(promises);\n    this._promise._captureStackTrace();\n    var domain = getDomain();\n    this._callback = domain === null ? fn : util.domainBind(domain, fn);\n    this._preservedValues = _filter === INTERNAL\n        ? new Array(this.length())\n        : null;\n    this._limit = limit;\n    this._inFlight = 0;\n    this._queue = [];\n    async.invoke(this._asyncInit, this, undefined);\n}\nutil.inherits(MappingPromiseArray, PromiseArray);\n\nMappingPromiseArray.prototype._asyncInit = function() {\n    this._init$(undefined, -2);\n};\n\nMappingPromiseArray.prototype._init = function () {};\n\nMappingPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    var values = this._values;\n    var length = this.length();\n    var preservedValues = this._preservedValues;\n    var limit = this._limit;\n\n    if (index < 0) {\n        index = (index * -1) - 1;\n        values[index] = value;\n        if (limit >= 1) {\n            this._inFlight--;\n            this._drainQueue();\n            if (this._isResolved()) return true;\n        }\n    } else {\n        if (limit >= 1 && this._inFlight >= limit) {\n            values[index] = value;\n            this._queue.push(index);\n            return false;\n        }\n        if (preservedValues !== null) preservedValues[index] = value;\n\n        var promise = this._promise;\n        var callback = this._callback;\n        var receiver = promise._boundValue();\n        promise._pushContext();\n        var ret = tryCatch(callback).call(receiver, value, index, length);\n        var promiseCreated = promise._popContext();\n        debug.checkForgottenReturns(\n            ret,\n            promiseCreated,\n            preservedValues !== null ? \"Promise.filter\" : \"Promise.map\",\n            promise\n        );\n        if (ret === errorObj) {\n            this._reject(ret.e);\n            return true;\n        }\n\n        var maybePromise = tryConvertToPromise(ret, this._promise);\n        if (maybePromise instanceof Promise) {\n            maybePromise = maybePromise._target();\n            var bitField = maybePromise._bitField;\n            ;\n            if (((bitField & 50397184) === 0)) {\n                if (limit >= 1) this._inFlight++;\n                values[index] = maybePromise;\n                maybePromise._proxy(this, (index + 1) * -1);\n                return false;\n            } else if (((bitField & 33554432) !== 0)) {\n                ret = maybePromise._value();\n            } else if (((bitField & 16777216) !== 0)) {\n                this._reject(maybePromise._reason());\n                return true;\n            } else {\n                this._cancel();\n                return true;\n            }\n        }\n        values[index] = ret;\n    }\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= length) {\n        if (preservedValues !== null) {\n            this._filter(values, preservedValues);\n        } else {\n            this._resolve(values);\n        }\n        return true;\n    }\n    return false;\n};\n\nMappingPromiseArray.prototype._drainQueue = function () {\n    var queue = this._queue;\n    var limit = this._limit;\n    var values = this._values;\n    while (queue.length > 0 && this._inFlight < limit) {\n        if (this._isResolved()) return;\n        var index = queue.pop();\n        this._promiseFulfilled(values[index], index);\n    }\n};\n\nMappingPromiseArray.prototype._filter = function (booleans, values) {\n    var len = values.length;\n    var ret = new Array(len);\n    var j = 0;\n    for (var i = 0; i < len; ++i) {\n        if (booleans[i]) ret[j++] = values[i];\n    }\n    ret.length = j;\n    this._resolve(ret);\n};\n\nMappingPromiseArray.prototype.preservedValues = function () {\n    return this._preservedValues;\n};\n\nfunction map(promises, fn, options, _filter) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n\n    var limit = 0;\n    if (options !== undefined) {\n        if (typeof options === \"object\" && options !== null) {\n            if (typeof options.concurrency !== \"number\") {\n                return Promise.reject(\n                    new TypeError(\"'concurrency' must be a number but it is \" +\n                                    util.classString(options.concurrency)));\n            }\n            limit = options.concurrency;\n        } else {\n            return Promise.reject(new TypeError(\n                            \"options argument must be an object but it is \" +\n                             util.classString(options)));\n        }\n    }\n    limit = typeof limit === \"number\" &&\n        isFinite(limit) && limit >= 1 ? limit : 0;\n    return new MappingPromiseArray(promises, fn, limit, _filter).promise();\n}\n\nPromise.prototype.map = function (fn, options) {\n    return map(this, fn, options, null);\n};\n\nPromise.map = function (promises, fn, options, _filter) {\n    return map(promises, fn, options, _filter);\n};\n\n\n};\n\n\n/***/ }),\n/* 161 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise) {\nvar util = __webpack_require__(6);\nvar async = Promise._async;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\n\nfunction spreadAdapter(val, nodeback) {\n    var promise = this;\n    if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);\n    var ret =\n        tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\n\nfunction successAdapter(val, nodeback) {\n    var promise = this;\n    var receiver = promise._boundValue();\n    var ret = val === undefined\n        ? tryCatch(nodeback).call(receiver, null)\n        : tryCatch(nodeback).call(receiver, null, val);\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\nfunction errorAdapter(reason, nodeback) {\n    var promise = this;\n    if (!reason) {\n        var newReason = new Error(reason + \"\");\n        newReason.cause = reason;\n        reason = newReason;\n    }\n    var ret = tryCatch(nodeback).call(promise._boundValue(), reason);\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\n\nPromise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,\n                                                                     options) {\n    if (typeof nodeback == \"function\") {\n        var adapter = successAdapter;\n        if (options !== undefined && Object(options).spread) {\n            adapter = spreadAdapter;\n        }\n        this._then(\n            adapter,\n            errorAdapter,\n            undefined,\n            this,\n            nodeback\n        );\n    }\n    return this;\n};\n};\n\n\n/***/ }),\n/* 162 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, INTERNAL) {\nvar THIS = {};\nvar util = __webpack_require__(6);\nvar nodebackForPromise = __webpack_require__(133);\nvar withAppended = util.withAppended;\nvar maybeWrapAsError = util.maybeWrapAsError;\nvar canEvaluate = util.canEvaluate;\nvar TypeError = __webpack_require__(26).TypeError;\nvar defaultSuffix = \"Async\";\nvar defaultPromisified = {__isPromisified__: true};\nvar noCopyProps = [\n    \"arity\",    \"length\",\n    \"name\",\n    \"arguments\",\n    \"caller\",\n    \"callee\",\n    \"prototype\",\n    \"__isPromisified__\"\n];\nvar noCopyPropsPattern = new RegExp(\"^(?:\" + noCopyProps.join(\"|\") + \")$\");\n\nvar defaultFilter = function(name) {\n    return util.isIdentifier(name) &&\n        name.charAt(0) !== \"_\" &&\n        name !== \"constructor\";\n};\n\nfunction propsFilter(key) {\n    return !noCopyPropsPattern.test(key);\n}\n\nfunction isPromisified(fn) {\n    try {\n        return fn.__isPromisified__ === true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n\nfunction hasPromisified(obj, key, suffix) {\n    var val = util.getDataPropertyOrDefault(obj, key + suffix,\n                                            defaultPromisified);\n    return val ? isPromisified(val) : false;\n}\nfunction checkValid(ret, suffix, suffixRegexp) {\n    for (var i = 0; i < ret.length; i += 2) {\n        var key = ret[i];\n        if (suffixRegexp.test(key)) {\n            var keyWithoutAsyncSuffix = key.replace(suffixRegexp, \"\");\n            for (var j = 0; j < ret.length; j += 2) {\n                if (ret[j] === keyWithoutAsyncSuffix) {\n                    throw new TypeError(\"Cannot promisify an API that has normal methods with '%s'-suffix\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\"\n                        .replace(\"%s\", suffix));\n                }\n            }\n        }\n    }\n}\n\nfunction promisifiableMethods(obj, suffix, suffixRegexp, filter) {\n    var keys = util.inheritedDataKeys(obj);\n    var ret = [];\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var value = obj[key];\n        var passesDefaultFilter = filter === defaultFilter\n            ? true : defaultFilter(key, value, obj);\n        if (typeof value === \"function\" &&\n            !isPromisified(value) &&\n            !hasPromisified(obj, key, suffix) &&\n            filter(key, value, obj, passesDefaultFilter)) {\n            ret.push(key, value);\n        }\n    }\n    checkValid(ret, suffix, suffixRegexp);\n    return ret;\n}\n\nvar escapeIdentRegex = function(str) {\n    return str.replace(/([$])/, \"\\\\$\");\n};\n\nvar makeNodePromisifiedEval;\nif (true) {\nvar switchCaseArgumentOrder = function(likelyArgumentCount) {\n    var ret = [likelyArgumentCount];\n    var min = Math.max(0, likelyArgumentCount - 1 - 3);\n    for(var i = likelyArgumentCount - 1; i >= min; --i) {\n        ret.push(i);\n    }\n    for(var i = likelyArgumentCount + 1; i <= 3; ++i) {\n        ret.push(i);\n    }\n    return ret;\n};\n\nvar argumentSequence = function(argumentCount) {\n    return util.filledRange(argumentCount, \"_arg\", \"\");\n};\n\nvar parameterDeclaration = function(parameterCount) {\n    return util.filledRange(\n        Math.max(parameterCount, 3), \"_arg\", \"\");\n};\n\nvar parameterCount = function(fn) {\n    if (typeof fn.length === \"number\") {\n        return Math.max(Math.min(fn.length, 1023 + 1), 0);\n    }\n    return 0;\n};\n\nmakeNodePromisifiedEval =\nfunction(callback, receiver, originalName, fn, _, multiArgs) {\n    var newParameterCount = Math.max(0, parameterCount(fn) - 1);\n    var argumentOrder = switchCaseArgumentOrder(newParameterCount);\n    var shouldProxyThis = typeof callback === \"string\" || receiver === THIS;\n\n    function generateCallForArgumentCount(count) {\n        var args = argumentSequence(count).join(\", \");\n        var comma = count > 0 ? \", \" : \"\";\n        var ret;\n        if (shouldProxyThis) {\n            ret = \"ret = callback.call(this, {{args}}, nodeback); break;\\n\";\n        } else {\n            ret = receiver === undefined\n                ? \"ret = callback({{args}}, nodeback); break;\\n\"\n                : \"ret = callback.call(receiver, {{args}}, nodeback); break;\\n\";\n        }\n        return ret.replace(\"{{args}}\", args).replace(\", \", comma);\n    }\n\n    function generateArgumentSwitchCase() {\n        var ret = \"\";\n        for (var i = 0; i < argumentOrder.length; ++i) {\n            ret += \"case \" + argumentOrder[i] +\":\" +\n                generateCallForArgumentCount(argumentOrder[i]);\n        }\n\n        ret += \"                                                             \\n\\\n        default:                                                             \\n\\\n            var args = new Array(len + 1);                                   \\n\\\n            var i = 0;                                                       \\n\\\n            for (var i = 0; i < len; ++i) {                                  \\n\\\n               args[i] = arguments[i];                                       \\n\\\n            }                                                                \\n\\\n            args[i] = nodeback;                                              \\n\\\n            [CodeForCall]                                                    \\n\\\n            break;                                                           \\n\\\n        \".replace(\"[CodeForCall]\", (shouldProxyThis\n                                ? \"ret = callback.apply(this, args);\\n\"\n                                : \"ret = callback.apply(receiver, args);\\n\"));\n        return ret;\n    }\n\n    var getFunctionCode = typeof callback === \"string\"\n                                ? (\"this != null ? this['\"+callback+\"'] : fn\")\n                                : \"fn\";\n    var body = \"'use strict';                                                \\n\\\n        var ret = function (Parameters) {                                    \\n\\\n            'use strict';                                                    \\n\\\n            var len = arguments.length;                                      \\n\\\n            var promise = new Promise(INTERNAL);                             \\n\\\n            promise._captureStackTrace();                                    \\n\\\n            var nodeback = nodebackForPromise(promise, \" + multiArgs + \");   \\n\\\n            var ret;                                                         \\n\\\n            var callback = tryCatch([GetFunctionCode]);                      \\n\\\n            switch(len) {                                                    \\n\\\n                [CodeForSwitchCase]                                          \\n\\\n            }                                                                \\n\\\n            if (ret === errorObj) {                                          \\n\\\n                promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\\n\\\n            }                                                                \\n\\\n            if (!promise._isFateSealed()) promise._setAsyncGuaranteed();     \\n\\\n            return promise;                                                  \\n\\\n        };                                                                   \\n\\\n        notEnumerableProp(ret, '__isPromisified__', true);                   \\n\\\n        return ret;                                                          \\n\\\n    \".replace(\"[CodeForSwitchCase]\", generateArgumentSwitchCase())\n        .replace(\"[GetFunctionCode]\", getFunctionCode);\n    body = body.replace(\"Parameters\", parameterDeclaration(newParameterCount));\n    return new Function(\"Promise\",\n                        \"fn\",\n                        \"receiver\",\n                        \"withAppended\",\n                        \"maybeWrapAsError\",\n                        \"nodebackForPromise\",\n                        \"tryCatch\",\n                        \"errorObj\",\n                        \"notEnumerableProp\",\n                        \"INTERNAL\",\n                        body)(\n                    Promise,\n                    fn,\n                    receiver,\n                    withAppended,\n                    maybeWrapAsError,\n                    nodebackForPromise,\n                    util.tryCatch,\n                    util.errorObj,\n                    util.notEnumerableProp,\n                    INTERNAL);\n};\n}\n\nfunction makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {\n    var defaultThis = (function() {return this;})();\n    var method = callback;\n    if (typeof method === \"string\") {\n        callback = fn;\n    }\n    function promisified() {\n        var _receiver = receiver;\n        if (receiver === THIS) _receiver = this;\n        var promise = new Promise(INTERNAL);\n        promise._captureStackTrace();\n        var cb = typeof method === \"string\" && this !== defaultThis\n            ? this[method] : callback;\n        var fn = nodebackForPromise(promise, multiArgs);\n        try {\n            cb.apply(_receiver, withAppended(arguments, fn));\n        } catch(e) {\n            promise._rejectCallback(maybeWrapAsError(e), true, true);\n        }\n        if (!promise._isFateSealed()) promise._setAsyncGuaranteed();\n        return promise;\n    }\n    util.notEnumerableProp(promisified, \"__isPromisified__\", true);\n    return promisified;\n}\n\nvar makeNodePromisified = canEvaluate\n    ? makeNodePromisifiedEval\n    : makeNodePromisifiedClosure;\n\nfunction promisifyAll(obj, suffix, filter, promisifier, multiArgs) {\n    var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + \"$\");\n    var methods =\n        promisifiableMethods(obj, suffix, suffixRegexp, filter);\n\n    for (var i = 0, len = methods.length; i < len; i+= 2) {\n        var key = methods[i];\n        var fn = methods[i+1];\n        var promisifiedKey = key + suffix;\n        if (promisifier === makeNodePromisified) {\n            obj[promisifiedKey] =\n                makeNodePromisified(key, THIS, key, fn, suffix, multiArgs);\n        } else {\n            var promisified = promisifier(fn, function() {\n                return makeNodePromisified(key, THIS, key,\n                                           fn, suffix, multiArgs);\n            });\n            util.notEnumerableProp(promisified, \"__isPromisified__\", true);\n            obj[promisifiedKey] = promisified;\n        }\n    }\n    util.toFastProperties(obj);\n    return obj;\n}\n\nfunction promisify(callback, receiver, multiArgs) {\n    return makeNodePromisified(callback, receiver, undefined,\n                                callback, null, multiArgs);\n}\n\nPromise.promisify = function (fn, options) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    if (isPromisified(fn)) {\n        return fn;\n    }\n    options = Object(options);\n    var receiver = options.context === undefined ? THIS : options.context;\n    var multiArgs = !!options.multiArgs;\n    var ret = promisify(fn, receiver, multiArgs);\n    util.copyDescriptors(fn, ret, propsFilter);\n    return ret;\n};\n\nPromise.promisifyAll = function (target, options) {\n    if (typeof target !== \"function\" && typeof target !== \"object\") {\n        throw new TypeError(\"the target of promisifyAll must be an object or a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    options = Object(options);\n    var multiArgs = !!options.multiArgs;\n    var suffix = options.suffix;\n    if (typeof suffix !== \"string\") suffix = defaultSuffix;\n    var filter = options.filter;\n    if (typeof filter !== \"function\") filter = defaultFilter;\n    var promisifier = options.promisifier;\n    if (typeof promisifier !== \"function\") promisifier = makeNodePromisified;\n\n    if (!util.isIdentifier(suffix)) {\n        throw new RangeError(\"suffix must be a valid identifier\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n\n    var keys = util.inheritedDataKeys(target);\n    for (var i = 0; i < keys.length; ++i) {\n        var value = target[keys[i]];\n        if (keys[i] !== \"constructor\" &&\n            util.isClass(value)) {\n            promisifyAll(value.prototype, suffix, filter, promisifier,\n                multiArgs);\n            promisifyAll(value, suffix, filter, promisifier, multiArgs);\n        }\n    }\n\n    return promisifyAll(target, suffix, filter, promisifier, multiArgs);\n};\n};\n\n\n\n/***/ }),\n/* 163 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(\n    Promise, PromiseArray, tryConvertToPromise, apiRejection) {\nvar util = __webpack_require__(6);\nvar isObject = util.isObject;\nvar es5 = __webpack_require__(32);\nvar Es6Map;\nif (typeof Map === \"function\") Es6Map = Map;\n\nvar mapToEntries = (function() {\n    var index = 0;\n    var size = 0;\n\n    function extractEntry(value, key) {\n        this[index] = value;\n        this[index + size] = key;\n        index++;\n    }\n\n    return function mapToEntries(map) {\n        size = map.size;\n        index = 0;\n        var ret = new Array(map.size * 2);\n        map.forEach(extractEntry, ret);\n        return ret;\n    };\n})();\n\nvar entriesToMap = function(entries) {\n    var ret = new Es6Map();\n    var length = entries.length / 2 | 0;\n    for (var i = 0; i < length; ++i) {\n        var key = entries[length + i];\n        var value = entries[i];\n        ret.set(key, value);\n    }\n    return ret;\n};\n\nfunction PropertiesPromiseArray(obj) {\n    var isMap = false;\n    var entries;\n    if (Es6Map !== undefined && obj instanceof Es6Map) {\n        entries = mapToEntries(obj);\n        isMap = true;\n    } else {\n        var keys = es5.keys(obj);\n        var len = keys.length;\n        entries = new Array(len * 2);\n        for (var i = 0; i < len; ++i) {\n            var key = keys[i];\n            entries[i] = obj[key];\n            entries[i + len] = key;\n        }\n    }\n    this.constructor$(entries);\n    this._isMap = isMap;\n    this._init$(undefined, isMap ? -6 : -3);\n}\nutil.inherits(PropertiesPromiseArray, PromiseArray);\n\nPropertiesPromiseArray.prototype._init = function () {};\n\nPropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    this._values[index] = value;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        var val;\n        if (this._isMap) {\n            val = entriesToMap(this._values);\n        } else {\n            val = {};\n            var keyOffset = this.length();\n            for (var i = 0, len = this.length(); i < len; ++i) {\n                val[this._values[i + keyOffset]] = this._values[i];\n            }\n        }\n        this._resolve(val);\n        return true;\n    }\n    return false;\n};\n\nPropertiesPromiseArray.prototype.shouldCopyValues = function () {\n    return false;\n};\n\nPropertiesPromiseArray.prototype.getActualLength = function (len) {\n    return len >> 1;\n};\n\nfunction props(promises) {\n    var ret;\n    var castValue = tryConvertToPromise(promises);\n\n    if (!isObject(castValue)) {\n        return apiRejection(\"cannot await properties of a non-object\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    } else if (castValue instanceof Promise) {\n        ret = castValue._then(\n            Promise.props, undefined, undefined, undefined, undefined);\n    } else {\n        ret = new PropertiesPromiseArray(castValue).promise();\n    }\n\n    if (castValue instanceof Promise) {\n        ret._propagateFrom(castValue, 2);\n    }\n    return ret;\n}\n\nPromise.prototype.props = function () {\n    return props(this);\n};\n\nPromise.props = function (promises) {\n    return props(promises);\n};\n};\n\n\n/***/ }),\n/* 164 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(\n    Promise, INTERNAL, tryConvertToPromise, apiRejection) {\nvar util = __webpack_require__(6);\n\nvar raceLater = function (promise) {\n    return promise.then(function(array) {\n        return race(array, promise);\n    });\n};\n\nfunction race(promises, parent) {\n    var maybePromise = tryConvertToPromise(promises);\n\n    if (maybePromise instanceof Promise) {\n        return raceLater(maybePromise);\n    } else {\n        promises = util.asArray(promises);\n        if (promises === null)\n            return apiRejection(\"expecting an array or an iterable object but got \" + util.classString(promises));\n    }\n\n    var ret = new Promise(INTERNAL);\n    if (parent !== undefined) {\n        ret._propagateFrom(parent, 3);\n    }\n    var fulfill = ret._fulfill;\n    var reject = ret._reject;\n    for (var i = 0, len = promises.length; i < len; ++i) {\n        var val = promises[i];\n\n        if (val === undefined && !(i in promises)) {\n            continue;\n        }\n\n        Promise.cast(val)._then(fulfill, reject, undefined, ret, null);\n    }\n    return ret;\n}\n\nPromise.race = function (promises) {\n    return race(promises, undefined);\n};\n\nPromise.prototype.race = function () {\n    return race(this, undefined);\n};\n\n};\n\n\n/***/ }),\n/* 165 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise,\n                          PromiseArray,\n                          apiRejection,\n                          tryConvertToPromise,\n                          INTERNAL,\n                          debug) {\nvar getDomain = Promise._getDomain;\nvar util = __webpack_require__(6);\nvar tryCatch = util.tryCatch;\n\nfunction ReductionPromiseArray(promises, fn, initialValue, _each) {\n    this.constructor$(promises);\n    var domain = getDomain();\n    this._fn = domain === null ? fn : util.domainBind(domain, fn);\n    if (initialValue !== undefined) {\n        initialValue = Promise.resolve(initialValue);\n        initialValue._attachCancellationCallback(this);\n    }\n    this._initialValue = initialValue;\n    this._currentCancellable = null;\n    if(_each === INTERNAL) {\n        this._eachValues = Array(this._length);\n    } else if (_each === 0) {\n        this._eachValues = null;\n    } else {\n        this._eachValues = undefined;\n    }\n    this._promise._captureStackTrace();\n    this._init$(undefined, -5);\n}\nutil.inherits(ReductionPromiseArray, PromiseArray);\n\nReductionPromiseArray.prototype._gotAccum = function(accum) {\n    if (this._eachValues !== undefined && \n        this._eachValues !== null && \n        accum !== INTERNAL) {\n        this._eachValues.push(accum);\n    }\n};\n\nReductionPromiseArray.prototype._eachComplete = function(value) {\n    if (this._eachValues !== null) {\n        this._eachValues.push(value);\n    }\n    return this._eachValues;\n};\n\nReductionPromiseArray.prototype._init = function() {};\n\nReductionPromiseArray.prototype._resolveEmptyArray = function() {\n    this._resolve(this._eachValues !== undefined ? this._eachValues\n                                                 : this._initialValue);\n};\n\nReductionPromiseArray.prototype.shouldCopyValues = function () {\n    return false;\n};\n\nReductionPromiseArray.prototype._resolve = function(value) {\n    this._promise._resolveCallback(value);\n    this._values = null;\n};\n\nReductionPromiseArray.prototype._resultCancelled = function(sender) {\n    if (sender === this._initialValue) return this._cancel();\n    if (this._isResolved()) return;\n    this._resultCancelled$();\n    if (this._currentCancellable instanceof Promise) {\n        this._currentCancellable.cancel();\n    }\n    if (this._initialValue instanceof Promise) {\n        this._initialValue.cancel();\n    }\n};\n\nReductionPromiseArray.prototype._iterate = function (values) {\n    this._values = values;\n    var value;\n    var i;\n    var length = values.length;\n    if (this._initialValue !== undefined) {\n        value = this._initialValue;\n        i = 0;\n    } else {\n        value = Promise.resolve(values[0]);\n        i = 1;\n    }\n\n    this._currentCancellable = value;\n\n    if (!value.isRejected()) {\n        for (; i < length; ++i) {\n            var ctx = {\n                accum: null,\n                value: values[i],\n                index: i,\n                length: length,\n                array: this\n            };\n            value = value._then(gotAccum, undefined, undefined, ctx, undefined);\n        }\n    }\n\n    if (this._eachValues !== undefined) {\n        value = value\n            ._then(this._eachComplete, undefined, undefined, this, undefined);\n    }\n    value._then(completed, completed, undefined, value, this);\n};\n\nPromise.prototype.reduce = function (fn, initialValue) {\n    return reduce(this, fn, initialValue, null);\n};\n\nPromise.reduce = function (promises, fn, initialValue, _each) {\n    return reduce(promises, fn, initialValue, _each);\n};\n\nfunction completed(valueOrReason, array) {\n    if (this.isFulfilled()) {\n        array._resolve(valueOrReason);\n    } else {\n        array._reject(valueOrReason);\n    }\n}\n\nfunction reduce(promises, fn, initialValue, _each) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    var array = new ReductionPromiseArray(promises, fn, initialValue, _each);\n    return array.promise();\n}\n\nfunction gotAccum(accum) {\n    this.accum = accum;\n    this.array._gotAccum(accum);\n    var value = tryConvertToPromise(this.value, this.array._promise);\n    if (value instanceof Promise) {\n        this.array._currentCancellable = value;\n        return value._then(gotValue, undefined, undefined, this, undefined);\n    } else {\n        return gotValue.call(this, value);\n    }\n}\n\nfunction gotValue(value) {\n    var array = this.array;\n    var promise = array._promise;\n    var fn = tryCatch(array._fn);\n    promise._pushContext();\n    var ret;\n    if (array._eachValues !== undefined) {\n        ret = fn.call(promise._boundValue(), value, this.index, this.length);\n    } else {\n        ret = fn.call(promise._boundValue(),\n                              this.accum, value, this.index, this.length);\n    }\n    if (ret instanceof Promise) {\n        array._currentCancellable = ret;\n    }\n    var promiseCreated = promise._popContext();\n    debug.checkForgottenReturns(\n        ret,\n        promiseCreated,\n        array._eachValues !== undefined ? \"Promise.each\" : \"Promise.reduce\",\n        promise\n    );\n    return ret;\n}\n};\n\n\n/***/ }),\n/* 166 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports =\n    function(Promise, PromiseArray, debug) {\nvar PromiseInspection = Promise.PromiseInspection;\nvar util = __webpack_require__(6);\n\nfunction SettledPromiseArray(values) {\n    this.constructor$(values);\n}\nutil.inherits(SettledPromiseArray, PromiseArray);\n\nSettledPromiseArray.prototype._promiseResolved = function (index, inspection) {\n    this._values[index] = inspection;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        this._resolve(this._values);\n        return true;\n    }\n    return false;\n};\n\nSettledPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    var ret = new PromiseInspection();\n    ret._bitField = 33554432;\n    ret._settledValueField = value;\n    return this._promiseResolved(index, ret);\n};\nSettledPromiseArray.prototype._promiseRejected = function (reason, index) {\n    var ret = new PromiseInspection();\n    ret._bitField = 16777216;\n    ret._settledValueField = reason;\n    return this._promiseResolved(index, ret);\n};\n\nPromise.settle = function (promises) {\n    debug.deprecated(\".settle()\", \".reflect()\");\n    return new SettledPromiseArray(promises).promise();\n};\n\nPromise.prototype.settle = function () {\n    return Promise.settle(this);\n};\n};\n\n\n/***/ }),\n/* 167 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports =\nfunction(Promise, PromiseArray, apiRejection) {\nvar util = __webpack_require__(6);\nvar RangeError = __webpack_require__(26).RangeError;\nvar AggregateError = __webpack_require__(26).AggregateError;\nvar isArray = util.isArray;\nvar CANCELLATION = {};\n\n\nfunction SomePromiseArray(values) {\n    this.constructor$(values);\n    this._howMany = 0;\n    this._unwrap = false;\n    this._initialized = false;\n}\nutil.inherits(SomePromiseArray, PromiseArray);\n\nSomePromiseArray.prototype._init = function () {\n    if (!this._initialized) {\n        return;\n    }\n    if (this._howMany === 0) {\n        this._resolve([]);\n        return;\n    }\n    this._init$(undefined, -5);\n    var isArrayResolved = isArray(this._values);\n    if (!this._isResolved() &&\n        isArrayResolved &&\n        this._howMany > this._canPossiblyFulfill()) {\n        this._reject(this._getRangeError(this.length()));\n    }\n};\n\nSomePromiseArray.prototype.init = function () {\n    this._initialized = true;\n    this._init();\n};\n\nSomePromiseArray.prototype.setUnwrap = function () {\n    this._unwrap = true;\n};\n\nSomePromiseArray.prototype.howMany = function () {\n    return this._howMany;\n};\n\nSomePromiseArray.prototype.setHowMany = function (count) {\n    this._howMany = count;\n};\n\nSomePromiseArray.prototype._promiseFulfilled = function (value) {\n    this._addFulfilled(value);\n    if (this._fulfilled() === this.howMany()) {\n        this._values.length = this.howMany();\n        if (this.howMany() === 1 && this._unwrap) {\n            this._resolve(this._values[0]);\n        } else {\n            this._resolve(this._values);\n        }\n        return true;\n    }\n    return false;\n\n};\nSomePromiseArray.prototype._promiseRejected = function (reason) {\n    this._addRejected(reason);\n    return this._checkOutcome();\n};\n\nSomePromiseArray.prototype._promiseCancelled = function () {\n    if (this._values instanceof Promise || this._values == null) {\n        return this._cancel();\n    }\n    this._addRejected(CANCELLATION);\n    return this._checkOutcome();\n};\n\nSomePromiseArray.prototype._checkOutcome = function() {\n    if (this.howMany() > this._canPossiblyFulfill()) {\n        var e = new AggregateError();\n        for (var i = this.length(); i < this._values.length; ++i) {\n            if (this._values[i] !== CANCELLATION) {\n                e.push(this._values[i]);\n            }\n        }\n        if (e.length > 0) {\n            this._reject(e);\n        } else {\n            this._cancel();\n        }\n        return true;\n    }\n    return false;\n};\n\nSomePromiseArray.prototype._fulfilled = function () {\n    return this._totalResolved;\n};\n\nSomePromiseArray.prototype._rejected = function () {\n    return this._values.length - this.length();\n};\n\nSomePromiseArray.prototype._addRejected = function (reason) {\n    this._values.push(reason);\n};\n\nSomePromiseArray.prototype._addFulfilled = function (value) {\n    this._values[this._totalResolved++] = value;\n};\n\nSomePromiseArray.prototype._canPossiblyFulfill = function () {\n    return this.length() - this._rejected();\n};\n\nSomePromiseArray.prototype._getRangeError = function (count) {\n    var message = \"Input array must contain at least \" +\n            this._howMany + \" items but contains only \" + count + \" items\";\n    return new RangeError(message);\n};\n\nSomePromiseArray.prototype._resolveEmptyArray = function () {\n    this._reject(this._getRangeError(0));\n};\n\nfunction some(promises, howMany) {\n    if ((howMany | 0) !== howMany || howMany < 0) {\n        return apiRejection(\"expecting a positive integer\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var ret = new SomePromiseArray(promises);\n    var promise = ret.promise();\n    ret.setHowMany(howMany);\n    ret.init();\n    return promise;\n}\n\nPromise.some = function (promises, howMany) {\n    return some(promises, howMany);\n};\n\nPromise.prototype.some = function (howMany) {\n    return some(this, howMany);\n};\n\nPromise._SomePromiseArray = SomePromiseArray;\n};\n\n\n/***/ }),\n/* 168 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, INTERNAL, debug) {\nvar util = __webpack_require__(6);\nvar TimeoutError = Promise.TimeoutError;\n\nfunction HandleWrapper(handle)  {\n    this.handle = handle;\n}\n\nHandleWrapper.prototype._resultCancelled = function() {\n    clearTimeout(this.handle);\n};\n\nvar afterValue = function(value) { return delay(+this).thenReturn(value); };\nvar delay = Promise.delay = function (ms, value) {\n    var ret;\n    var handle;\n    if (value !== undefined) {\n        ret = Promise.resolve(value)\n                ._then(afterValue, null, null, ms, undefined);\n        if (debug.cancellation() && value instanceof Promise) {\n            ret._setOnCancel(value);\n        }\n    } else {\n        ret = new Promise(INTERNAL);\n        handle = setTimeout(function() { ret._fulfill(); }, +ms);\n        if (debug.cancellation()) {\n            ret._setOnCancel(new HandleWrapper(handle));\n        }\n        ret._captureStackTrace();\n    }\n    ret._setAsyncGuaranteed();\n    return ret;\n};\n\nPromise.prototype.delay = function (ms) {\n    return delay(ms, this);\n};\n\nvar afterTimeout = function (promise, message, parent) {\n    var err;\n    if (typeof message !== \"string\") {\n        if (message instanceof Error) {\n            err = message;\n        } else {\n            err = new TimeoutError(\"operation timed out\");\n        }\n    } else {\n        err = new TimeoutError(message);\n    }\n    util.markAsOriginatingFromRejection(err);\n    promise._attachExtraTrace(err);\n    promise._reject(err);\n\n    if (parent != null) {\n        parent.cancel();\n    }\n};\n\nfunction successClear(value) {\n    clearTimeout(this.handle);\n    return value;\n}\n\nfunction failureClear(reason) {\n    clearTimeout(this.handle);\n    throw reason;\n}\n\nPromise.prototype.timeout = function (ms, message) {\n    ms = +ms;\n    var ret, parent;\n\n    var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() {\n        if (ret.isPending()) {\n            afterTimeout(ret, message, parent);\n        }\n    }, ms));\n\n    if (debug.cancellation()) {\n        parent = this.then();\n        ret = parent._then(successClear, failureClear,\n                            undefined, handleWrapper, undefined);\n        ret._setOnCancel(handleWrapper);\n    } else {\n        ret = this._then(successClear, failureClear,\n                            undefined, handleWrapper, undefined);\n    }\n\n    return ret;\n};\n\n};\n\n\n/***/ }),\n/* 169 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function (Promise, apiRejection, tryConvertToPromise,\n    createContext, INTERNAL, debug) {\n    var util = __webpack_require__(6);\n    var TypeError = __webpack_require__(26).TypeError;\n    var inherits = __webpack_require__(6).inherits;\n    var errorObj = util.errorObj;\n    var tryCatch = util.tryCatch;\n    var NULL = {};\n\n    function thrower(e) {\n        setTimeout(function(){throw e;}, 0);\n    }\n\n    function castPreservingDisposable(thenable) {\n        var maybePromise = tryConvertToPromise(thenable);\n        if (maybePromise !== thenable &&\n            typeof thenable._isDisposable === \"function\" &&\n            typeof thenable._getDisposer === \"function\" &&\n            thenable._isDisposable()) {\n            maybePromise._setDisposable(thenable._getDisposer());\n        }\n        return maybePromise;\n    }\n    function dispose(resources, inspection) {\n        var i = 0;\n        var len = resources.length;\n        var ret = new Promise(INTERNAL);\n        function iterator() {\n            if (i >= len) return ret._fulfill();\n            var maybePromise = castPreservingDisposable(resources[i++]);\n            if (maybePromise instanceof Promise &&\n                maybePromise._isDisposable()) {\n                try {\n                    maybePromise = tryConvertToPromise(\n                        maybePromise._getDisposer().tryDispose(inspection),\n                        resources.promise);\n                } catch (e) {\n                    return thrower(e);\n                }\n                if (maybePromise instanceof Promise) {\n                    return maybePromise._then(iterator, thrower,\n                                              null, null, null);\n                }\n            }\n            iterator();\n        }\n        iterator();\n        return ret;\n    }\n\n    function Disposer(data, promise, context) {\n        this._data = data;\n        this._promise = promise;\n        this._context = context;\n    }\n\n    Disposer.prototype.data = function () {\n        return this._data;\n    };\n\n    Disposer.prototype.promise = function () {\n        return this._promise;\n    };\n\n    Disposer.prototype.resource = function () {\n        if (this.promise().isFulfilled()) {\n            return this.promise().value();\n        }\n        return NULL;\n    };\n\n    Disposer.prototype.tryDispose = function(inspection) {\n        var resource = this.resource();\n        var context = this._context;\n        if (context !== undefined) context._pushContext();\n        var ret = resource !== NULL\n            ? this.doDispose(resource, inspection) : null;\n        if (context !== undefined) context._popContext();\n        this._promise._unsetDisposable();\n        this._data = null;\n        return ret;\n    };\n\n    Disposer.isDisposer = function (d) {\n        return (d != null &&\n                typeof d.resource === \"function\" &&\n                typeof d.tryDispose === \"function\");\n    };\n\n    function FunctionDisposer(fn, promise, context) {\n        this.constructor$(fn, promise, context);\n    }\n    inherits(FunctionDisposer, Disposer);\n\n    FunctionDisposer.prototype.doDispose = function (resource, inspection) {\n        var fn = this.data();\n        return fn.call(resource, resource, inspection);\n    };\n\n    function maybeUnwrapDisposer(value) {\n        if (Disposer.isDisposer(value)) {\n            this.resources[this.index]._setDisposable(value);\n            return value.promise();\n        }\n        return value;\n    }\n\n    function ResourceList(length) {\n        this.length = length;\n        this.promise = null;\n        this[length-1] = null;\n    }\n\n    ResourceList.prototype._resultCancelled = function() {\n        var len = this.length;\n        for (var i = 0; i < len; ++i) {\n            var item = this[i];\n            if (item instanceof Promise) {\n                item.cancel();\n            }\n        }\n    };\n\n    Promise.using = function () {\n        var len = arguments.length;\n        if (len < 2) return apiRejection(\n                        \"you must pass at least 2 arguments to Promise.using\");\n        var fn = arguments[len - 1];\n        if (typeof fn !== \"function\") {\n            return apiRejection(\"expecting a function but got \" + util.classString(fn));\n        }\n        var input;\n        var spreadArgs = true;\n        if (len === 2 && Array.isArray(arguments[0])) {\n            input = arguments[0];\n            len = input.length;\n            spreadArgs = false;\n        } else {\n            input = arguments;\n            len--;\n        }\n        var resources = new ResourceList(len);\n        for (var i = 0; i < len; ++i) {\n            var resource = input[i];\n            if (Disposer.isDisposer(resource)) {\n                var disposer = resource;\n                resource = resource.promise();\n                resource._setDisposable(disposer);\n            } else {\n                var maybePromise = tryConvertToPromise(resource);\n                if (maybePromise instanceof Promise) {\n                    resource =\n                        maybePromise._then(maybeUnwrapDisposer, null, null, {\n                            resources: resources,\n                            index: i\n                    }, undefined);\n                }\n            }\n            resources[i] = resource;\n        }\n\n        var reflectedResources = new Array(resources.length);\n        for (var i = 0; i < reflectedResources.length; ++i) {\n            reflectedResources[i] = Promise.resolve(resources[i]).reflect();\n        }\n\n        var resultPromise = Promise.all(reflectedResources)\n            .then(function(inspections) {\n                for (var i = 0; i < inspections.length; ++i) {\n                    var inspection = inspections[i];\n                    if (inspection.isRejected()) {\n                        errorObj.e = inspection.error();\n                        return errorObj;\n                    } else if (!inspection.isFulfilled()) {\n                        resultPromise.cancel();\n                        return;\n                    }\n                    inspections[i] = inspection.value();\n                }\n                promise._pushContext();\n\n                fn = tryCatch(fn);\n                var ret = spreadArgs\n                    ? fn.apply(undefined, inspections) : fn(inspections);\n                var promiseCreated = promise._popContext();\n                debug.checkForgottenReturns(\n                    ret, promiseCreated, \"Promise.using\", promise);\n                return ret;\n            });\n\n        var promise = resultPromise.lastly(function() {\n            var inspection = new Promise.PromiseInspection(resultPromise);\n            return dispose(resources, inspection);\n        });\n        resources.promise = promise;\n        promise._setOnCancel(resources);\n        return promise;\n    };\n\n    Promise.prototype._setDisposable = function (disposer) {\n        this._bitField = this._bitField | 131072;\n        this._disposer = disposer;\n    };\n\n    Promise.prototype._isDisposable = function () {\n        return (this._bitField & 131072) > 0;\n    };\n\n    Promise.prototype._getDisposer = function () {\n        return this._disposer;\n    };\n\n    Promise.prototype._unsetDisposable = function () {\n        this._bitField = this._bitField & (~131072);\n        this._disposer = undefined;\n    };\n\n    Promise.prototype.disposer = function (fn) {\n        if (typeof fn === \"function\") {\n            return new FunctionDisposer(fn, this, createContext());\n        }\n        throw new TypeError();\n    };\n\n};\n\n\n/***/ }),\n/* 170 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise) {\nvar SomePromiseArray = Promise._SomePromiseArray;\nfunction any(promises) {\n    var ret = new SomePromiseArray(promises);\n    var promise = ret.promise();\n    ret.setHowMany(1);\n    ret.setUnwrap();\n    ret.init();\n    return promise;\n}\n\nPromise.any = function (promises) {\n    return any(promises);\n};\n\nPromise.prototype.any = function () {\n    return any(this);\n};\n\n};\n\n\n/***/ }),\n/* 171 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, INTERNAL) {\nvar PromiseReduce = Promise.reduce;\nvar PromiseAll = Promise.all;\n\nfunction promiseAllThis() {\n    return PromiseAll(this);\n}\n\nfunction PromiseMapSeries(promises, fn) {\n    return PromiseReduce(promises, fn, INTERNAL, INTERNAL);\n}\n\nPromise.prototype.each = function (fn) {\n    return PromiseReduce(this, fn, INTERNAL, 0)\n              ._then(promiseAllThis, undefined, undefined, this, undefined);\n};\n\nPromise.prototype.mapSeries = function (fn) {\n    return PromiseReduce(this, fn, INTERNAL, INTERNAL);\n};\n\nPromise.each = function (promises, fn) {\n    return PromiseReduce(promises, fn, INTERNAL, 0)\n              ._then(promiseAllThis, undefined, undefined, promises, undefined);\n};\n\nPromise.mapSeries = PromiseMapSeries;\n};\n\n\n\n/***/ }),\n/* 172 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nmodule.exports = function(Promise, INTERNAL) {\nvar PromiseMap = Promise.map;\n\nPromise.prototype.filter = function (fn, options) {\n    return PromiseMap(this, fn, options, INTERNAL);\n};\n\nPromise.filter = function (promises, fn, options) {\n    return PromiseMap(promises, fn, options, INTERNAL);\n};\n};\n\n\n/***/ }),\n/* 173 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * jQuery Cookie Plugin v1.4.1\n * https://github.com/carhartl/jquery-cookie\n *\n * Copyright 2013 Klaus Hartl\n * Released under the MIT license\n */\n(function (factory) {\n\tif (true) {\n\t\t// AMD\n\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(18)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else if (typeof exports === 'object') {\n\t\t// CommonJS\n\t\tfactory(require('jquery'));\n\t} else {\n\t\t// Browser globals\n\t\tfactory(jQuery);\n\t}\n}(function ($) {\n\n\tvar pluses = /\\+/g;\n\n\tfunction encode(s) {\n\t\treturn config.raw ? s : encodeURIComponent(s);\n\t}\n\n\tfunction decode(s) {\n\t\treturn config.raw ? s : decodeURIComponent(s);\n\t}\n\n\tfunction stringifyCookieValue(value) {\n\t\treturn encode(config.json ? JSON.stringify(value) : String(value));\n\t}\n\n\tfunction parseCookieValue(s) {\n\t\tif (s.indexOf('\"') === 0) {\n\t\t\t// This is a quoted cookie as according to RFC2068, unescape...\n\t\t\ts = s.slice(1, -1).replace(/\\\\\"/g, '\"').replace(/\\\\\\\\/g, '\\\\');\n\t\t}\n\n\t\ttry {\n\t\t\t// Replace server-side written pluses with spaces.\n\t\t\t// If we can't decode the cookie, ignore it, it's unusable.\n\t\t\t// If we can't parse the cookie, ignore it, it's unusable.\n\t\t\ts = decodeURIComponent(s.replace(pluses, ' '));\n\t\t\treturn config.json ? JSON.parse(s) : s;\n\t\t} catch(e) {}\n\t}\n\n\tfunction read(s, converter) {\n\t\tvar value = config.raw ? s : parseCookieValue(s);\n\t\treturn $.isFunction(converter) ? converter(value) : value;\n\t}\n\n\tvar config = $.cookie = function (key, value, options) {\n\n\t\t// Write\n\n\t\tif (value !== undefined && !$.isFunction(value)) {\n\t\t\toptions = $.extend({}, config.defaults, options);\n\n\t\t\tif (typeof options.expires === 'number') {\n\t\t\t\tvar days = options.expires, t = options.expires = new Date();\n\t\t\t\tt.setTime(+t + days * 864e+5);\n\t\t\t}\n\n\t\t\treturn (document.cookie = [\n\t\t\t\tencode(key), '=', stringifyCookieValue(value),\n\t\t\t\toptions.expires ? '; expires=' + options.expires.toUTCString() : '', // use expires attribute, max-age is not supported by IE\n\t\t\t\toptions.path    ? '; path=' + options.path : '',\n\t\t\t\toptions.domain  ? '; domain=' + options.domain : '',\n\t\t\t\toptions.secure  ? '; secure' : ''\n\t\t\t].join(''));\n\t\t}\n\n\t\t// Read\n\n\t\tvar result = key ? undefined : {};\n\n\t\t// To prevent the for loop in the first place assign an empty array\n\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t// calling $.cookie().\n\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\n\t\tfor (var i = 0, l = cookies.length; i < l; i++) {\n\t\t\tvar parts = cookies[i].split('=');\n\t\t\tvar name = decode(parts.shift());\n\t\t\tvar cookie = parts.join('=');\n\n\t\t\tif (key && key === name) {\n\t\t\t\t// If second argument (value) is a function it's a converter...\n\t\t\t\tresult = read(cookie, value);\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\t// Prevent storing a cookie that we couldn't decode.\n\t\t\tif (!key && (cookie = read(cookie)) !== undefined) {\n\t\t\t\tresult[name] = cookie;\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t};\n\n\tconfig.defaults = {};\n\n\t$.removeCookie = function (key, options) {\n\t\tif ($.cookie(key) === undefined) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Must not alter options, thus extending a fresh object...\n\t\t$.cookie(key, '', $.extend({}, options, { expires: -1 }));\n\t\treturn !$.cookie(key);\n\t};\n\n}));\n\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// manifest.js"," \t// install a JSONP callback for chunk loading\n \tvar parentJsonpFunction = window[\"webpackJsonp\"];\n \twindow[\"webpackJsonp\"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [], result;\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n \t\tif(executeModules) {\n \t\t\tfor(i=0; i < executeModules.length; i++) {\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = executeModules[i]);\n \t\t\t}\n \t\t}\n \t\treturn result;\n \t};\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// objects to store loaded and loading chunks\n \tvar installedChunks = {\n \t\t4: 0\n \t};\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, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\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 = \"\";\n\n \t// on error function for async loading\n \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap d2f75300c2db1f97d54a","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define('underscore', factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {\n    var current = global._;\n    var exports = global._ = factory();\n    exports.noConflict = function () { global._ = current; return exports; };\n  }()));\n}(this, (function () {\n  //     Underscore.js 1.13.8\n  //     https://underscorejs.org\n  //     (c) 2009-2026 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors\n  //     Underscore may be freely distributed under the MIT license.\n\n  // Current version.\n  var VERSION = '1.13.8';\n\n  // Establish the root object, `window` (`self`) in the browser, `global`\n  // on the server, or `this` in some virtual machines. We use `self`\n  // instead of `window` for `WebWorker` support.\n  var root = (typeof self == 'object' && self.self === self && self) ||\n            (typeof global == 'object' && global.global === global && global) ||\n            Function('return this')() ||\n            {};\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype;\n  var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var push = ArrayProto.push,\n      slice = ArrayProto.slice,\n      toString = ObjProto.toString,\n      hasOwnProperty = ObjProto.hasOwnProperty;\n\n  // Modern feature detection.\n  var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',\n      supportsDataView = typeof DataView !== 'undefined';\n\n  // All **ECMAScript 5+** native function implementations that we hope to use\n  // are declared here.\n  var nativeIsArray = Array.isArray,\n      nativeKeys = Object.keys,\n      nativeCreate = Object.create,\n      nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;\n\n  // Create references to these builtin functions because we override them.\n  var _isNaN = isNaN,\n      _isFinite = isFinite;\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n    'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  // The largest integer that can be represented exactly.\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n\n  // Some functions take a variable number of arguments, or a few expected\n  // arguments at the beginning and then a variable number of values to operate\n  // on. This helper accumulates all remaining arguments past the function’s\n  // argument length (or an explicit `startIndex`), into an array that becomes\n  // the last argument. Similar to ES6’s \"rest parameter\".\n  function restArguments(func, startIndex) {\n    startIndex = startIndex == null ? func.length - 1 : +startIndex;\n    return function() {\n      var length = Math.max(arguments.length - startIndex, 0),\n          rest = Array(length),\n          index = 0;\n      for (; index < length; index++) {\n        rest[index] = arguments[index + startIndex];\n      }\n      switch (startIndex) {\n        case 0: return func.call(this, rest);\n        case 1: return func.call(this, arguments[0], rest);\n        case 2: return func.call(this, arguments[0], arguments[1], rest);\n      }\n      var args = Array(startIndex + 1);\n      for (index = 0; index < startIndex; index++) {\n        args[index] = arguments[index];\n      }\n      args[startIndex] = rest;\n      return func.apply(this, args);\n    };\n  }\n\n  // Is a given variable an object?\n  function isObject(obj) {\n    var type = typeof obj;\n    return type === 'function' || (type === 'object' && !!obj);\n  }\n\n  // Is a given value equal to null?\n  function isNull(obj) {\n    return obj === null;\n  }\n\n  // Is a given variable undefined?\n  function isUndefined(obj) {\n    return obj === void 0;\n  }\n\n  // Is a given value a boolean?\n  function isBoolean(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  }\n\n  // Is a given value a DOM element?\n  function isElement(obj) {\n    return !!(obj && obj.nodeType === 1);\n  }\n\n  // Internal function for creating a `toString`-based type tester.\n  function tagTester(name) {\n    var tag = '[object ' + name + ']';\n    return function(obj) {\n      return toString.call(obj) === tag;\n    };\n  }\n\n  var isString = tagTester('String');\n\n  var isNumber = tagTester('Number');\n\n  var isDate = tagTester('Date');\n\n  var isRegExp = tagTester('RegExp');\n\n  var isError = tagTester('Error');\n\n  var isSymbol = tagTester('Symbol');\n\n  var isArrayBuffer = tagTester('ArrayBuffer');\n\n  var isFunction = tagTester('Function');\n\n  // Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old\n  // v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\n  var nodelist = root.document && root.document.childNodes;\n  if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n    isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  var isFunction$1 = isFunction;\n\n  var hasObjectTag = tagTester('Object');\n\n  // In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.\n  // In IE 11, the most common among them, this problem also applies to\n  // `Map`, `WeakMap` and `Set`.\n  // Also, there are cases where an application can override the native\n  // `DataView` object, in cases like that we can't use the constructor\n  // safely and should just rely on alternate `DataView` checks\n  var hasDataViewBug = (\n        supportsDataView && (!/\\[native code\\]/.test(String(DataView)) || hasObjectTag(new DataView(new ArrayBuffer(8))))\n      ),\n      isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));\n\n  var isDataView = tagTester('DataView');\n\n  // In IE 10 - Edge 13, we need a different heuristic\n  // to determine whether an object is a `DataView`.\n  // Also, in cases where the native `DataView` is\n  // overridden we can't rely on the tag itself.\n  function alternateIsDataView(obj) {\n    return obj != null && isFunction$1(obj.getInt8) && isArrayBuffer(obj.buffer);\n  }\n\n  var isDataView$1 = (hasDataViewBug ? alternateIsDataView : isDataView);\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native `Array.isArray`.\n  var isArray = nativeIsArray || tagTester('Array');\n\n  // Internal function to check whether `key` is an own property name of `obj`.\n  function has$1(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  }\n\n  var isArguments = tagTester('Arguments');\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  (function() {\n    if (!isArguments(arguments)) {\n      isArguments = function(obj) {\n        return has$1(obj, 'callee');\n      };\n    }\n  }());\n\n  var isArguments$1 = isArguments;\n\n  // Is a given object a finite number?\n  function isFinite$1(obj) {\n    return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));\n  }\n\n  // Is the given value `NaN`?\n  function isNaN$1(obj) {\n    return isNumber(obj) && _isNaN(obj);\n  }\n\n  // Predicate-generating function. Often useful outside of Underscore.\n  function constant(value) {\n    return function() {\n      return value;\n    };\n  }\n\n  // Common internal logic for `isArrayLike` and `isBufferLike`.\n  function createSizePropertyCheck(getSizeProperty) {\n    return function(collection) {\n      var sizeProperty = getSizeProperty(collection);\n      return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;\n    }\n  }\n\n  // Internal helper to generate a function to obtain property `key` from `obj`.\n  function shallowProperty(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  }\n\n  // Internal helper to obtain the `byteLength` property of an object.\n  var getByteLength = shallowProperty('byteLength');\n\n  // Internal helper to determine whether we should spend extensive checks against\n  // `ArrayBuffer` et al.\n  var isBufferLike = createSizePropertyCheck(getByteLength);\n\n  // Is a given value a typed array?\n  var typedArrayPattern = /\\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\\]/;\n  function isTypedArray(obj) {\n    // `ArrayBuffer.isView` is the most future-proof, so use it when available.\n    // Otherwise, fall back on the above regular expression.\n    return nativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) :\n                  isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));\n  }\n\n  var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false);\n\n  // Internal helper to obtain the `length` property of an object.\n  var getLength = shallowProperty('length');\n\n  // Internal helper to create a simple lookup structure.\n  // `collectNonEnumProps` used to depend on `_.contains`, but this led to\n  // circular imports. `emulatedSet` is a one-off solution that only works for\n  // arrays of strings.\n  function emulatedSet(keys) {\n    var hash = {};\n    for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;\n    return {\n      contains: function(key) { return hash[key] === true; },\n      push: function(key) {\n        hash[key] = true;\n        return keys.push(key);\n      }\n    };\n  }\n\n  // Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't\n  // be iterated by `for key in ...` and thus missed. Extends `keys` in place if\n  // needed.\n  function collectNonEnumProps(obj, keys) {\n    keys = emulatedSet(keys);\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (isFunction$1(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (has$1(obj, prop) && !keys.contains(prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`.\n  function keys(obj) {\n    if (!isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (has$1(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  }\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  function isEmpty(obj) {\n    if (obj == null) return true;\n    // Skip the more expensive `toString`-based type checks if `obj` has no\n    // `.length`.\n    var length = getLength(obj);\n    if (typeof length == 'number' && (\n      isArray(obj) || isString(obj) || isArguments$1(obj)\n    )) return length === 0;\n    return getLength(keys(obj)) === 0;\n  }\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  function isMatch(object, attrs) {\n    var _keys = keys(attrs), length = _keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = _keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  }\n\n  // If Underscore is called as a function, it returns a wrapped object that can\n  // be used OO-style. This wrapper holds altered versions of all functions added\n  // through `_.mixin`. Wrapped objects may be chained.\n  function _$1(obj) {\n    if (obj instanceof _$1) return obj;\n    if (!(this instanceof _$1)) return new _$1(obj);\n    this._wrapped = obj;\n  }\n\n  _$1.VERSION = VERSION;\n\n  // Extracts the result from a wrapped and chained object.\n  _$1.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxies for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _$1.prototype.valueOf = _$1.prototype.toJSON = _$1.prototype.value;\n\n  _$1.prototype.toString = function() {\n    return String(this._wrapped);\n  };\n\n  // Internal function to wrap or shallow-copy an ArrayBuffer,\n  // typed array or DataView to a new view, reusing the buffer.\n  function toBufferView(bufferSource) {\n    return new Uint8Array(\n      bufferSource.buffer || bufferSource,\n      bufferSource.byteOffset || 0,\n      getByteLength(bufferSource)\n    );\n  }\n\n  // We use this string twice, so give it a name for minification.\n  var tagDataView = '[object DataView]';\n\n  // Perform a deep comparison to check if two objects are equal.\n  function isEqual(a, b) {\n    var todo = [{a: a, b: b}];\n    // Initializing stacks of traversed objects for cycle detection.\n    var aStack = [], bStack = [];\n\n    while (todo.length) {\n      var frame = todo.pop();\n      if (frame === true) {\n        // Remove the first object from the stack of traversed objects.\n        aStack.pop();\n        bStack.pop();\n        continue;\n      }\n      a = frame.a;\n      b = frame.b;\n\n      // Identical objects are equal. `0 === -0`, but they aren't identical.\n      // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).\n      if (a === b) {\n        if (a !== 0 || 1 / a === 1 / b) continue;\n        return false;\n      }\n      // `null` or `undefined` only equal to itself (strict comparison).\n      if (a == null || b == null) return false;\n      // `NaN`s are equivalent, but non-reflexive.\n      if (a !== a) {\n        if (b !== b) continue;\n        return false;\n      }\n      // Exhaust primitive checks\n      var type = typeof a;\n      if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n\n  // Internal recursive comparison function for `_.isEqual`.\n      // Unwrap any wrapped objects.\n      if (a instanceof _$1) a = a._wrapped;\n      if (b instanceof _$1) b = b._wrapped;\n      // Compare `[[Class]]` names.\n      var className = toString.call(a);\n      if (className !== toString.call(b)) return false;\n      // Work around a bug in IE 10 - Edge 13.\n      if (hasDataViewBug && className == '[object Object]' && isDataView$1(a)) {\n        if (!isDataView$1(b)) return false;\n        className = tagDataView;\n      }\n      switch (className) {\n        // These types are compared by value.\n      case '[object RegExp]':\n        // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        if ('' + a === '' + b) continue;\n        return false;\n      case '[object Number]':\n        todo.push({a: +a, b: +b});\n        continue;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        if (+a === +b) continue;\n        return false;\n      case '[object Symbol]':\n        if (SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b)) continue;\n        return false;\n      case '[object ArrayBuffer]':\n      case tagDataView:\n        // Coerce to typed array so we can fall through.\n        todo.push({a: toBufferView(a), b: toBufferView(b)});\n        continue;\n      }\n\n      var areArrays = className === '[object Array]';\n      if (!areArrays && isTypedArray$1(a)) {\n        var byteLength = getByteLength(a);\n        if (byteLength !== getByteLength(b)) return false;\n        if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) continue;\n        areArrays = true;\n      }\n      if (!areArrays) {\n        if (typeof a != 'object' || typeof b != 'object') return false;\n\n        // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n        // from different frames are.\n        var aCtor = a.constructor, bCtor = b.constructor;\n        if (aCtor !== bCtor && !(isFunction$1(aCtor) && aCtor instanceof aCtor &&\n                                 isFunction$1(bCtor) && bCtor instanceof bCtor)\n            && ('constructor' in a && 'constructor' in b)) {\n          return false;\n        }\n      }\n\n      // Assume equality for cyclic structures. The algorithm for detecting cyclic\n      // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n      var length = aStack.length;\n      while (length--) {\n        // Linear search. Performance is inversely proportional to the number of\n        // unique nested structures.\n        if (aStack[length] === a) {\n          if (bStack[length] === b) break;\n          return false;\n        }\n      }\n      if (length >= 0) continue;\n\n      // Add the first object to the stack of traversed objects.\n      aStack.push(a);\n      bStack.push(b);\n      todo.push(true);\n\n      // Recursively compare objects and arrays.\n      if (areArrays) {\n        // Compare array lengths to determine if a deep comparison is necessary.\n        length = a.length;\n        if (length !== b.length) return false;\n        // Deep compare the contents, ignoring non-numeric properties.\n        while (length--) {\n          todo.push({a: a[length], b: b[length]});\n        }\n      } else {\n        // Deep compare objects.\n        var _keys = keys(a), key;\n        length = _keys.length;\n        // Ensure that both objects contain the same number of properties before comparing deep equality.\n        if (keys(b).length !== length) return false;\n        while (length--) {\n          // Deep compare each member\n          key = _keys[length];\n          if (!has$1(b, key)) return false;\n          todo.push({a: a[key], b: b[key]});\n        }\n      }\n    }\n    return true;\n  }\n\n  // Retrieve all the enumerable property names of an object.\n  function allKeys(obj) {\n    if (!isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  }\n\n  // Since the regular `Object.prototype.toString` type tests don't work for\n  // some types in IE 11, we use a fingerprinting heuristic instead, based\n  // on the methods. It's not great, but it's the best we got.\n  // The fingerprint method lists are defined below.\n  function ie11fingerprint(methods) {\n    var length = getLength(methods);\n    return function(obj) {\n      if (obj == null) return false;\n      // `Map`, `WeakMap` and `Set` have no enumerable keys.\n      var keys = allKeys(obj);\n      if (getLength(keys)) return false;\n      for (var i = 0; i < length; i++) {\n        if (!isFunction$1(obj[methods[i]])) return false;\n      }\n      // If we are testing against `WeakMap`, we need to ensure that\n      // `obj` doesn't have a `forEach` method in order to distinguish\n      // it from a regular `Map`.\n      return methods !== weakMapMethods || !isFunction$1(obj[forEachName]);\n    };\n  }\n\n  // In the interest of compact minification, we write\n  // each string in the fingerprints only once.\n  var forEachName = 'forEach',\n      hasName = 'has',\n      commonInit = ['clear', 'delete'],\n      mapTail = ['get', hasName, 'set'];\n\n  // `Map`, `WeakMap` and `Set` each have slightly different\n  // combinations of the above sublists.\n  var mapMethods = commonInit.concat(forEachName, mapTail),\n      weakMapMethods = commonInit.concat(mapTail),\n      setMethods = ['add'].concat(commonInit, forEachName, hasName);\n\n  var isMap = isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');\n\n  var isWeakMap = isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');\n\n  var isSet = isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');\n\n  var isWeakSet = tagTester('WeakSet');\n\n  // Retrieve the values of an object's properties.\n  function values(obj) {\n    var _keys = keys(obj);\n    var length = _keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[_keys[i]];\n    }\n    return values;\n  }\n\n  // Convert an object into a list of `[key, value]` pairs.\n  // The opposite of `_.object` with one argument.\n  function pairs(obj) {\n    var _keys = keys(obj);\n    var length = _keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [_keys[i], obj[_keys[i]]];\n    }\n    return pairs;\n  }\n\n  // Invert the keys and values of an object. The values must be serializable.\n  function invert(obj) {\n    var result = {};\n    var _keys = keys(obj);\n    for (var i = 0, length = _keys.length; i < length; i++) {\n      result[obj[_keys[i]]] = _keys[i];\n    }\n    return result;\n  }\n\n  // Return a sorted list of the function names available on the object.\n  function functions(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (isFunction$1(obj[key])) names.push(key);\n    }\n    return names.sort();\n  }\n\n  // An internal function for creating assigner functions.\n  function createAssigner(keysFunc, defaults) {\n    return function(obj) {\n      var length = arguments.length;\n      if (defaults) obj = Object(obj);\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!defaults || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  }\n\n  // Extend a given object with all the properties in passed-in object(s).\n  var extend = createAssigner(allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in\n  // object(s).\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  var extendOwn = createAssigner(keys);\n\n  // Fill in a given object with default properties.\n  var defaults = createAssigner(allKeys, true);\n\n  // Create a naked function reference for surrogate-prototype-swapping.\n  function ctor() {\n    return function(){};\n  }\n\n  // An internal function for creating a new object that inherits from another.\n  function baseCreate(prototype) {\n    if (!isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    var Ctor = ctor();\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  }\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  function create(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) extendOwn(result, props);\n    return result;\n  }\n\n  // Create a (shallow-cloned) duplicate of an object.\n  function clone(obj) {\n    if (!isObject(obj)) return obj;\n    return isArray(obj) ? obj.slice() : extend({}, obj);\n  }\n\n  // Invokes `interceptor` with the `obj` and then returns `obj`.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  function tap(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  }\n\n  // Normalize a (deep) property `path` to array.\n  // Like `_.iteratee`, this function can be customized.\n  function toPath$1(path) {\n    return isArray(path) ? path : [path];\n  }\n  _$1.toPath = toPath$1;\n\n  // Internal wrapper for `_.toPath` to enable minification.\n  // Similar to `cb` for `_.iteratee`.\n  function toPath(path) {\n    return _$1.toPath(path);\n  }\n\n  // Internal function to obtain a nested property in `obj` along `path`.\n  function deepGet(obj, path) {\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      if (obj == null) return void 0;\n      obj = obj[path[i]];\n    }\n    return length ? obj : void 0;\n  }\n\n  // Get the value of the (deep) property on `path` from `object`.\n  // If any property in `path` does not exist or if the value is\n  // `undefined`, return `defaultValue` instead.\n  // The `path` is normalized through `_.toPath`.\n  function get(object, path, defaultValue) {\n    var value = deepGet(object, toPath(path));\n    return isUndefined(value) ? defaultValue : value;\n  }\n\n  // Shortcut function for checking if an object has a given property directly on\n  // itself (in other words, not on a prototype). Unlike the internal `has`\n  // function, this public version can also traverse nested properties.\n  function has(obj, path) {\n    path = toPath(path);\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      var key = path[i];\n      if (!has$1(obj, key)) return false;\n      obj = obj[key];\n    }\n    return !!length;\n  }\n\n  // Keep the identity function around for default iteratees.\n  function identity(value) {\n    return value;\n  }\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  function matcher(attrs) {\n    attrs = extendOwn({}, attrs);\n    return function(obj) {\n      return isMatch(obj, attrs);\n    };\n  }\n\n  // Creates a function that, when passed an object, will traverse that object’s\n  // properties down the given `path`, specified as an array of keys or indices.\n  function property(path) {\n    path = toPath(path);\n    return function(obj) {\n      return deepGet(obj, path);\n    };\n  }\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  function optimizeCb(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      // The 2-argument case is omitted because we’re not using it.\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  }\n\n  // An internal function to generate callbacks that can be applied to each\n  // element in a collection, returning the desired result — either `_.identity`,\n  // an arbitrary callback, a property matcher, or a property accessor.\n  function baseIteratee(value, context, argCount) {\n    if (value == null) return identity;\n    if (isFunction$1(value)) return optimizeCb(value, context, argCount);\n    if (isObject(value) && !isArray(value)) return matcher(value);\n    return property(value);\n  }\n\n  // External wrapper for our callback generator. Users may customize\n  // `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n  // This abstraction hides the internal-only `argCount` argument.\n  function iteratee(value, context) {\n    return baseIteratee(value, context, Infinity);\n  }\n  _$1.iteratee = iteratee;\n\n  // The function we call internally to generate a callback. It invokes\n  // `_.iteratee` if overridden, otherwise `baseIteratee`.\n  function cb(value, context, argCount) {\n    if (_$1.iteratee !== iteratee) return _$1.iteratee(value, context);\n    return baseIteratee(value, context, argCount);\n  }\n\n  // Returns the results of applying the `iteratee` to each element of `obj`.\n  // In contrast to `_.map` it returns an object.\n  function mapObject(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var _keys = keys(obj),\n        length = _keys.length,\n        results = {};\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys[index];\n      results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  }\n\n  // Predicate-generating function. Often useful outside of Underscore.\n  function noop(){}\n\n  // Generates a function for a given object that returns a given property.\n  function propertyOf(obj) {\n    if (obj == null) return noop;\n    return function(path) {\n      return get(obj, path);\n    };\n  }\n\n  // Run a function **n** times.\n  function times(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  }\n\n  // Return a random integer between `min` and `max` (inclusive).\n  function random(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  }\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  var now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n  // Internal helper to generate functions for escaping and unescaping strings\n  // to/from HTML interpolation.\n  function createEscaper(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped.\n    var source = '(?:' + keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  }\n\n  // Internal list of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n\n  // Function for escaping strings to HTML interpolation.\n  var _escape = createEscaper(escapeMap);\n\n  // Internal list of HTML entities for unescaping.\n  var unescapeMap = invert(escapeMap);\n\n  // Function for unescaping strings from HTML interpolation.\n  var _unescape = createEscaper(unescapeMap);\n\n  // By default, Underscore uses ERB-style template delimiters. Change the\n  // following template settings to use alternative delimiters.\n  var templateSettings = _$1.templateSettings = {\n    evaluate: /<%([\\s\\S]+?)%>/g,\n    interpolate: /<%=([\\s\\S]+?)%>/g,\n    escape: /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `_.templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\": \"'\",\n    '\\\\': '\\\\',\n    '\\r': 'r',\n    '\\n': 'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  function escapeChar(match) {\n    return '\\\\' + escapes[match];\n  }\n\n  // In order to prevent third-party code injection through\n  // `_.templateSettings.variable`, we test it against the following regular\n  // expression. It is intentionally a bit more liberal than just matching valid\n  // identifiers, but still prevents possible loopholes through defaults or\n  // destructuring assignment.\n  var bareIdentifier = /^\\s*(\\w|\\$)+\\s*$/;\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  function template(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = defaults({}, settings, _$1.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offset.\n      return match;\n    });\n    source += \"';\\n\";\n\n    var argument = settings.variable;\n    if (argument) {\n      // Insure against third-party code injection. (CVE-2021-23358)\n      if (!bareIdentifier.test(argument)) throw new Error(\n        'variable is not a bare identifier: ' + argument\n      );\n    } else {\n      // If a variable is not specified, place data values in local scope.\n      source = 'with(obj||{}){\\n' + source + '}\\n';\n      argument = 'obj';\n    }\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    var render;\n    try {\n      render = new Function(argument, '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _$1);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  }\n\n  // Traverses the children of `obj` along `path`. If a child is a function, it\n  // is invoked with its parent as context. Returns the value of the final\n  // child, or `fallback` if any child is undefined.\n  function result(obj, path, fallback) {\n    path = toPath(path);\n    var length = path.length;\n    if (!length) {\n      return isFunction$1(fallback) ? fallback.call(obj) : fallback;\n    }\n    for (var i = 0; i < length; i++) {\n      var prop = obj == null ? void 0 : obj[path[i]];\n      if (prop === void 0) {\n        prop = fallback;\n        i = length; // Ensure we don't continue iterating.\n      }\n      obj = isFunction$1(prop) ? prop.call(obj) : prop;\n    }\n    return obj;\n  }\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  function uniqueId(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  }\n\n  // Start chaining a wrapped Underscore object.\n  function chain(obj) {\n    var instance = _$1(obj);\n    instance._chain = true;\n    return instance;\n  }\n\n  // Internal function to execute `sourceFunc` bound to `context` with optional\n  // `args`. Determines whether to execute a function as a constructor or as a\n  // normal function.\n  function executeBound(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (isObject(result)) return result;\n    return self;\n  }\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. `_` acts\n  // as a placeholder by default, allowing any combination of arguments to be\n  // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\n  var partial = restArguments(function(func, boundArgs) {\n    var placeholder = partial.placeholder;\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  });\n\n  partial.placeholder = _$1;\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally).\n  var bind = restArguments(function(func, context, args) {\n    if (!isFunction$1(func)) throw new TypeError('Bind must be called on a function');\n    var bound = restArguments(function(callArgs) {\n      return executeBound(func, bound, context, this, args.concat(callArgs));\n    });\n    return bound;\n  });\n\n  // Internal helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object.\n  // Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var isArrayLike = createSizePropertyCheck(getLength);\n\n  // Internal implementation of a recursive `flatten` function.\n  function flatten$1(input, depth, strict) {\n    if (!depth && depth !== 0) depth = Infinity;\n    var output = [], idx = 0, i = 0, length = getLength(input) || 0, stack = [];\n    while (true) {\n      if (i >= length) {\n        if (!stack.length) break;\n        var frame = stack.pop();\n        i = frame.i;\n        input = frame.v;\n        length = getLength(input);\n        continue;\n      }\n      var value = input[i++];\n      if (stack.length >= depth) {\n        output[idx++] = value;\n      } else if (isArrayLike(value) && (isArray(value) || isArguments$1(value))) {\n        // Flatten current level of array or arguments object.\n        stack.push({i: i, v: input});\n        i = 0;\n        input = value;\n        length = getLength(input);\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  }\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  var bindAll = restArguments(function(obj, keys) {\n    keys = flatten$1(keys, false, false);\n    var index = keys.length;\n    if (index < 1) throw new Error('bindAll must be passed function names');\n    while (index--) {\n      var key = keys[index];\n      obj[key] = bind(obj[key], obj);\n    }\n    return obj;\n  });\n\n  // Memoize an expensive function by storing its results.\n  function memoize(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!has$1(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  }\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  var delay = restArguments(function(func, wait, args) {\n    return setTimeout(function() {\n      return func.apply(null, args);\n    }, wait);\n  });\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  var defer = partial(delay, _$1, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  function throttle(func, wait, options) {\n    var timeout, context, args, result;\n    var previous = 0;\n    if (!options) options = {};\n\n    var later = function() {\n      previous = options.leading === false ? 0 : now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n\n    var throttled = function() {\n      var _now = now();\n      if (!previous && options.leading === false) previous = _now;\n      var remaining = wait - (_now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = _now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n\n    throttled.cancel = function() {\n      clearTimeout(timeout);\n      previous = 0;\n      timeout = context = args = null;\n    };\n\n    return throttled;\n  }\n\n  // When a sequence of calls of the returned function ends, the argument\n  // function is triggered. The end of a sequence is defined by the `wait`\n  // parameter. If `immediate` is passed, the argument function will be\n  // triggered at the beginning of the sequence instead of at the end.\n  function debounce(func, wait, immediate) {\n    var timeout, previous, args, result, context;\n\n    var later = function() {\n      var passed = now() - previous;\n      if (wait > passed) {\n        timeout = setTimeout(later, wait - passed);\n      } else {\n        timeout = null;\n        if (!immediate) result = func.apply(context, args);\n        // This check is needed because `func` can recursively invoke `debounced`.\n        if (!timeout) args = context = null;\n      }\n    };\n\n    var debounced = restArguments(function(_args) {\n      context = this;\n      args = _args;\n      previous = now();\n      if (!timeout) {\n        timeout = setTimeout(later, wait);\n        if (immediate) result = func.apply(context, args);\n      }\n      return result;\n    });\n\n    debounced.cancel = function() {\n      clearTimeout(timeout);\n      timeout = args = context = null;\n    };\n\n    return debounced;\n  }\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  function wrap(func, wrapper) {\n    return partial(wrapper, func);\n  }\n\n  // Returns a negated version of the passed-in predicate.\n  function negate(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  }\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  function compose() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  }\n\n  // Returns a function that will only be executed on and after the Nth call.\n  function after(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  }\n\n  // Returns a function that will only be executed up to (but not including) the\n  // Nth call.\n  function before(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  }\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  var once = partial(before, 2);\n\n  // Returns the first key on an object that passes a truth test.\n  function findKey(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = keys(obj), key;\n    for (var i = 0, length = _keys.length; i < length; i++) {\n      key = _keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  }\n\n  // Internal function to generate `_.findIndex` and `_.findLastIndex`.\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a truth test.\n  var findIndex = createPredicateIndexFinder(1);\n\n  // Returns the last index on an array-like that passes a truth test.\n  var findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  function sortedIndex(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  }\n\n  // Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n          i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n          length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), isNaN$1);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  var indexOf = createIndexFinder(1, findIndex, sortedIndex);\n\n  // Return the position of the last occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  var lastIndexOf = createIndexFinder(-1, findLastIndex);\n\n  // Return the first value which passes a truth test.\n  function find(obj, predicate, context) {\n    var keyFinder = isArrayLike(obj) ? findIndex : findKey;\n    var key = keyFinder(obj, predicate, context);\n    if (key !== void 0 && key !== -1) return obj[key];\n  }\n\n  // Convenience version of a common use case of `_.find`: getting the first\n  // object containing specific `key:value` pairs.\n  function findWhere(obj, attrs) {\n    return find(obj, matcher(attrs));\n  }\n\n  // The cornerstone for collection functions, an `each`\n  // implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  function each(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var _keys = keys(obj);\n      for (i = 0, length = _keys.length; i < length; i++) {\n        iteratee(obj[_keys[i]], _keys[i], obj);\n      }\n    }\n    return obj;\n  }\n\n  // Return the results of applying the iteratee to each element.\n  function map(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  }\n\n  // Internal helper to create a reducing function, iterating left or right.\n  function createReduce(dir) {\n    // Wrap code that reassigns argument variables in a separate function than\n    // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n    var reducer = function(obj, iteratee, memo, initial) {\n      var _keys = !isArrayLike(obj) && keys(obj),\n          length = (_keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      if (!initial) {\n        memo = obj[_keys ? _keys[index] : index];\n        index += dir;\n      }\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = _keys ? _keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    };\n\n    return function(obj, iteratee, memo, context) {\n      var initial = arguments.length >= 3;\n      return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  var reduce = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  var reduceRight = createReduce(-1);\n\n  // Return all the elements that pass a truth test.\n  function filter(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  }\n\n  // Return all the elements for which a truth test fails.\n  function reject(obj, predicate, context) {\n    return filter(obj, negate(cb(predicate)), context);\n  }\n\n  // Determine whether all of the elements pass a truth test.\n  function every(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  }\n\n  // Determine if at least one element in the object passes a truth test.\n  function some(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  }\n\n  // Determine if the array or object contains a given item (using `===`).\n  function contains(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return indexOf(obj, item, fromIndex) >= 0;\n  }\n\n  // Invoke a method (with arguments) on every item in a collection.\n  var invoke = restArguments(function(obj, path, args) {\n    var contextPath, func;\n    if (isFunction$1(path)) {\n      func = path;\n    } else {\n      path = toPath(path);\n      contextPath = path.slice(0, -1);\n      path = path[path.length - 1];\n    }\n    return map(obj, function(context) {\n      var method = func;\n      if (!method) {\n        if (contextPath && contextPath.length) {\n          context = deepGet(context, contextPath);\n        }\n        if (context == null) return void 0;\n        method = context[path];\n      }\n      return method == null ? method : method.apply(context, args);\n    });\n  });\n\n  // Convenience version of a common use case of `_.map`: fetching a property.\n  function pluck(obj, key) {\n    return map(obj, property(key));\n  }\n\n  // Convenience version of a common use case of `_.filter`: selecting only\n  // objects containing specific `key:value` pairs.\n  function where(obj, attrs) {\n    return filter(obj, matcher(attrs));\n  }\n\n  // Return the maximum element (or element-based computation).\n  function max(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n      obj = isArrayLike(obj) ? obj : values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  }\n\n  // Return the minimum element (or element-based computation).\n  function min(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n      obj = isArrayLike(obj) ? obj : values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed < lastComputed || (computed === Infinity && result === Infinity)) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  }\n\n  // Safely create a real, live array from anything iterable.\n  var reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\n  function toArray(obj) {\n    if (!obj) return [];\n    if (isArray(obj)) return slice.call(obj);\n    if (isString(obj)) {\n      // Keep surrogate pair characters together.\n      return obj.match(reStrSymbol);\n    }\n    if (isArrayLike(obj)) return map(obj, identity);\n    return values(obj);\n  }\n\n  // Sample **n** random values from a collection using the modern version of the\n  // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `_.map`.\n  function sample(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = values(obj);\n      return obj[random(obj.length - 1)];\n    }\n    var sample = toArray(obj);\n    var length = getLength(sample);\n    n = Math.max(Math.min(n, length), 0);\n    var last = length - 1;\n    for (var index = 0; index < n; index++) {\n      var rand = random(index, last);\n      var temp = sample[index];\n      sample[index] = sample[rand];\n      sample[rand] = temp;\n    }\n    return sample.slice(0, n);\n  }\n\n  // Shuffle a collection.\n  function shuffle(obj) {\n    return sample(obj, Infinity);\n  }\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  function sortBy(obj, iteratee, context) {\n    var index = 0;\n    iteratee = cb(iteratee, context);\n    return pluck(map(obj, function(value, key, list) {\n      return {\n        value: value,\n        index: index++,\n        criteria: iteratee(value, key, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  }\n\n  // An internal function used for aggregate \"group by\" operations.\n  function group(behavior, partition) {\n    return function(obj, iteratee, context) {\n      var result = partition ? [[], []] : {};\n      iteratee = cb(iteratee, context);\n      each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  }\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  var groupBy = group(function(result, value, key) {\n    if (has$1(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `_.groupBy`, but for\n  // when you know that your index values will be unique.\n  var indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  var countBy = group(function(result, value, key) {\n    if (has$1(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Split a collection into two arrays: one whose elements all pass the given\n  // truth test, and one whose elements all do not pass the truth test.\n  var partition = group(function(result, value, pass) {\n    result[pass ? 0 : 1].push(value);\n  }, true);\n\n  // Return the number of elements in a collection.\n  function size(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : keys(obj).length;\n  }\n\n  // Internal `_.pick` helper function to determine whether `key` is an enumerable\n  // property name of `obj`.\n  function keyInObj(value, key, obj) {\n    return key in obj;\n  }\n\n  // Return a copy of the object only containing the allowed properties.\n  var pick = restArguments(function(obj, keys) {\n    var result = {}, iteratee = keys[0];\n    if (obj == null) return result;\n    if (isFunction$1(iteratee)) {\n      if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n      keys = allKeys(obj);\n    } else {\n      iteratee = keyInObj;\n      keys = flatten$1(keys, false, false);\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  });\n\n  // Return a copy of the object without the disallowed properties.\n  var omit = restArguments(function(obj, keys) {\n    var iteratee = keys[0], context;\n    if (isFunction$1(iteratee)) {\n      iteratee = negate(iteratee);\n      if (keys.length > 1) context = keys[1];\n    } else {\n      keys = map(flatten$1(keys, false, false), String);\n      iteratee = function(value, key) {\n        return !contains(keys, key);\n      };\n    }\n    return pick(obj, iteratee, context);\n  });\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  function initial(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  }\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. The **guard** check allows it to work with `_.map`.\n  function first(array, n, guard) {\n    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n    if (n == null || guard) return array[0];\n    return initial(array, array.length - n);\n  }\n\n  // Returns everything but the first entry of the `array`. Especially useful on\n  // the `arguments` object. Passing an **n** will return the rest N values in the\n  // `array`.\n  function rest(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  }\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  function last(array, n, guard) {\n    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n    if (n == null || guard) return array[array.length - 1];\n    return rest(array, Math.max(0, array.length - n));\n  }\n\n  // Trim out all falsy values from an array.\n  function compact(array) {\n    return filter(array, Boolean);\n  }\n\n  // Flatten out an array, either recursively (by default), or up to `depth`.\n  // Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.\n  function flatten(array, depth) {\n    return flatten$1(array, depth, false);\n  }\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  var difference = restArguments(function(array, rest) {\n    rest = flatten$1(rest, true, true);\n    return filter(array, function(value){\n      return !contains(rest, value);\n    });\n  });\n\n  // Return a version of the array that does not contain the specified value(s).\n  var without = restArguments(function(array, otherArrays) {\n    return difference(array, otherArrays);\n  });\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // The faster algorithm will not work with an iteratee if the iteratee\n  // is not a one-to-one function, so providing an iteratee will disable\n  // the faster algorithm.\n  function uniq(array, isSorted, iteratee, context) {\n    if (!isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted && !iteratee) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  }\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  var union = restArguments(function(arrays) {\n    return uniq(flatten$1(arrays, true, true));\n  });\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  function intersection(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (contains(result, item)) continue;\n      var j;\n      for (j = 1; j < argsLength; j++) {\n        if (!contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  }\n\n  // Complement of zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices.\n  function unzip(array) {\n    var length = (array && max(array, getLength).length) || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = pluck(array, index);\n    }\n    return result;\n  }\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  var zip = restArguments(unzip);\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values. Passing by pairs is the reverse of `_.pairs`.\n  function object(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  }\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](https://docs.python.org/library/functions.html#range).\n  function range(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    if (!step) {\n      step = stop < start ? -1 : 1;\n    }\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  }\n\n  // Chunk a single array into multiple arrays, each containing `count` or fewer\n  // items.\n  function chunk(array, count) {\n    if (count == null || count < 1) return [];\n    var result = [];\n    var i = 0, length = array.length;\n    while (i < length) {\n      result.push(slice.call(array, i, i += count));\n    }\n    return result;\n  }\n\n  // Helper function to continue chaining intermediate results.\n  function chainResult(instance, obj) {\n    return instance._chain ? _$1(obj).chain() : obj;\n  }\n\n  // Add your own custom functions to the Underscore object.\n  function mixin(obj) {\n    each(functions(obj), function(name) {\n      var func = _$1[name] = obj[name];\n      _$1.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return chainResult(this, func.apply(_$1, args));\n      };\n    });\n    return _$1;\n  }\n\n  // Add all mutator `Array` functions to the wrapper.\n  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _$1.prototype[name] = function() {\n      var obj = this._wrapped;\n      if (obj != null) {\n        method.apply(obj, arguments);\n        if ((name === 'shift' || name === 'splice') && obj.length === 0) {\n          delete obj[0];\n        }\n      }\n      return chainResult(this, obj);\n    };\n  });\n\n  // Add all accessor `Array` functions to the wrapper.\n  each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _$1.prototype[name] = function() {\n      var obj = this._wrapped;\n      if (obj != null) obj = method.apply(obj, arguments);\n      return chainResult(this, obj);\n    };\n  });\n\n  // Named Exports\n\n  var allExports = {\n    __proto__: null,\n    VERSION: VERSION,\n    restArguments: restArguments,\n    isObject: isObject,\n    isNull: isNull,\n    isUndefined: isUndefined,\n    isBoolean: isBoolean,\n    isElement: isElement,\n    isString: isString,\n    isNumber: isNumber,\n    isDate: isDate,\n    isRegExp: isRegExp,\n    isError: isError,\n    isSymbol: isSymbol,\n    isArrayBuffer: isArrayBuffer,\n    isDataView: isDataView$1,\n    isArray: isArray,\n    isFunction: isFunction$1,\n    isArguments: isArguments$1,\n    isFinite: isFinite$1,\n    isNaN: isNaN$1,\n    isTypedArray: isTypedArray$1,\n    isEmpty: isEmpty,\n    isMatch: isMatch,\n    isEqual: isEqual,\n    isMap: isMap,\n    isWeakMap: isWeakMap,\n    isSet: isSet,\n    isWeakSet: isWeakSet,\n    keys: keys,\n    allKeys: allKeys,\n    values: values,\n    pairs: pairs,\n    invert: invert,\n    functions: functions,\n    methods: functions,\n    extend: extend,\n    extendOwn: extendOwn,\n    assign: extendOwn,\n    defaults: defaults,\n    create: create,\n    clone: clone,\n    tap: tap,\n    get: get,\n    has: has,\n    mapObject: mapObject,\n    identity: identity,\n    constant: constant,\n    noop: noop,\n    toPath: toPath$1,\n    property: property,\n    propertyOf: propertyOf,\n    matcher: matcher,\n    matches: matcher,\n    times: times,\n    random: random,\n    now: now,\n    escape: _escape,\n    unescape: _unescape,\n    templateSettings: templateSettings,\n    template: template,\n    result: result,\n    uniqueId: uniqueId,\n    chain: chain,\n    iteratee: iteratee,\n    partial: partial,\n    bind: bind,\n    bindAll: bindAll,\n    memoize: memoize,\n    delay: delay,\n    defer: defer,\n    throttle: throttle,\n    debounce: debounce,\n    wrap: wrap,\n    negate: negate,\n    compose: compose,\n    after: after,\n    before: before,\n    once: once,\n    findKey: findKey,\n    findIndex: findIndex,\n    findLastIndex: findLastIndex,\n    sortedIndex: sortedIndex,\n    indexOf: indexOf,\n    lastIndexOf: lastIndexOf,\n    find: find,\n    detect: find,\n    findWhere: findWhere,\n    each: each,\n    forEach: each,\n    map: map,\n    collect: map,\n    reduce: reduce,\n    foldl: reduce,\n    inject: reduce,\n    reduceRight: reduceRight,\n    foldr: reduceRight,\n    filter: filter,\n    select: filter,\n    reject: reject,\n    every: every,\n    all: every,\n    some: some,\n    any: some,\n    contains: contains,\n    includes: contains,\n    include: contains,\n    invoke: invoke,\n    pluck: pluck,\n    where: where,\n    max: max,\n    min: min,\n    shuffle: shuffle,\n    sample: sample,\n    sortBy: sortBy,\n    groupBy: groupBy,\n    indexBy: indexBy,\n    countBy: countBy,\n    partition: partition,\n    toArray: toArray,\n    size: size,\n    pick: pick,\n    omit: omit,\n    first: first,\n    head: first,\n    take: first,\n    initial: initial,\n    last: last,\n    rest: rest,\n    tail: rest,\n    drop: rest,\n    compact: compact,\n    flatten: flatten,\n    without: without,\n    uniq: uniq,\n    unique: uniq,\n    union: union,\n    intersection: intersection,\n    difference: difference,\n    unzip: unzip,\n    transpose: unzip,\n    zip: zip,\n    object: object,\n    range: range,\n    chunk: chunk,\n    mixin: mixin,\n    'default': _$1\n  };\n\n  // Default Export\n\n  // Add all of the Underscore functions to the wrapper object.\n  var _ = mixin(allExports);\n  // Legacy Node.js API.\n  _._ = _;\n\n  return _;\n\n})));\n//# sourceMappingURL=underscore-umd.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/underscore/underscore-umd.js\n// module id = 4\n// module chunks = 4","\"use strict\";\nvar es5 = require(\"./es5\");\nvar canEvaluate = typeof navigator == \"undefined\";\n\nvar errorObj = {e: {}};\nvar tryCatchTarget;\nvar globalObject = typeof self !== \"undefined\" ? self :\n    typeof window !== \"undefined\" ? window :\n    typeof global !== \"undefined\" ? global :\n    this !== undefined ? this : null;\n\nfunction tryCatcher() {\n    try {\n        var target = tryCatchTarget;\n        tryCatchTarget = null;\n        return target.apply(this, arguments);\n    } catch (e) {\n        errorObj.e = e;\n        return errorObj;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\n\nvar inherits = function(Child, Parent) {\n    var hasProp = {}.hasOwnProperty;\n\n    function T() {\n        this.constructor = Child;\n        this.constructor$ = Parent;\n        for (var propertyName in Parent.prototype) {\n            if (hasProp.call(Parent.prototype, propertyName) &&\n                propertyName.charAt(propertyName.length-1) !== \"$\"\n           ) {\n                this[propertyName + \"$\"] = Parent.prototype[propertyName];\n            }\n        }\n    }\n    T.prototype = Parent.prototype;\n    Child.prototype = new T();\n    return Child.prototype;\n};\n\n\nfunction isPrimitive(val) {\n    return val == null || val === true || val === false ||\n        typeof val === \"string\" || typeof val === \"number\";\n\n}\n\nfunction isObject(value) {\n    return typeof value === \"function\" ||\n           typeof value === \"object\" && value !== null;\n}\n\nfunction maybeWrapAsError(maybeError) {\n    if (!isPrimitive(maybeError)) return maybeError;\n\n    return new Error(safeToString(maybeError));\n}\n\nfunction withAppended(target, appendee) {\n    var len = target.length;\n    var ret = new Array(len + 1);\n    var i;\n    for (i = 0; i < len; ++i) {\n        ret[i] = target[i];\n    }\n    ret[i] = appendee;\n    return ret;\n}\n\nfunction getDataPropertyOrDefault(obj, key, defaultValue) {\n    if (es5.isES5) {\n        var desc = Object.getOwnPropertyDescriptor(obj, key);\n\n        if (desc != null) {\n            return desc.get == null && desc.set == null\n                    ? desc.value\n                    : defaultValue;\n        }\n    } else {\n        return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;\n    }\n}\n\nfunction notEnumerableProp(obj, name, value) {\n    if (isPrimitive(obj)) return obj;\n    var descriptor = {\n        value: value,\n        configurable: true,\n        enumerable: false,\n        writable: true\n    };\n    es5.defineProperty(obj, name, descriptor);\n    return obj;\n}\n\nfunction thrower(r) {\n    throw r;\n}\n\nvar inheritedDataKeys = (function() {\n    var excludedPrototypes = [\n        Array.prototype,\n        Object.prototype,\n        Function.prototype\n    ];\n\n    var isExcludedProto = function(val) {\n        for (var i = 0; i < excludedPrototypes.length; ++i) {\n            if (excludedPrototypes[i] === val) {\n                return true;\n            }\n        }\n        return false;\n    };\n\n    if (es5.isES5) {\n        var getKeys = Object.getOwnPropertyNames;\n        return function(obj) {\n            var ret = [];\n            var visitedKeys = Object.create(null);\n            while (obj != null && !isExcludedProto(obj)) {\n                var keys;\n                try {\n                    keys = getKeys(obj);\n                } catch (e) {\n                    return ret;\n                }\n                for (var i = 0; i < keys.length; ++i) {\n                    var key = keys[i];\n                    if (visitedKeys[key]) continue;\n                    visitedKeys[key] = true;\n                    var desc = Object.getOwnPropertyDescriptor(obj, key);\n                    if (desc != null && desc.get == null && desc.set == null) {\n                        ret.push(key);\n                    }\n                }\n                obj = es5.getPrototypeOf(obj);\n            }\n            return ret;\n        };\n    } else {\n        var hasProp = {}.hasOwnProperty;\n        return function(obj) {\n            if (isExcludedProto(obj)) return [];\n            var ret = [];\n\n            /*jshint forin:false */\n            enumeration: for (var key in obj) {\n                if (hasProp.call(obj, key)) {\n                    ret.push(key);\n                } else {\n                    for (var i = 0; i < excludedPrototypes.length; ++i) {\n                        if (hasProp.call(excludedPrototypes[i], key)) {\n                            continue enumeration;\n                        }\n                    }\n                    ret.push(key);\n                }\n            }\n            return ret;\n        };\n    }\n\n})();\n\nvar thisAssignmentPattern = /this\\s*\\.\\s*\\S+\\s*=/;\nfunction isClass(fn) {\n    try {\n        if (typeof fn === \"function\") {\n            var keys = es5.names(fn.prototype);\n\n            var hasMethods = es5.isES5 && keys.length > 1;\n            var hasMethodsOtherThanConstructor = keys.length > 0 &&\n                !(keys.length === 1 && keys[0] === \"constructor\");\n            var hasThisAssignmentAndStaticMethods =\n                thisAssignmentPattern.test(fn + \"\") && es5.names(fn).length > 0;\n\n            if (hasMethods || hasMethodsOtherThanConstructor ||\n                hasThisAssignmentAndStaticMethods) {\n                return true;\n            }\n        }\n        return false;\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction toFastProperties(obj) {\n    /*jshint -W027,-W055,-W031*/\n    function FakeConstructor() {}\n    FakeConstructor.prototype = obj;\n    var receiver = new FakeConstructor();\n    function ic() {\n        return typeof receiver.foo;\n    }\n    ic();\n    ic();\n    return obj;\n    eval(obj);\n}\n\nvar rident = /^[a-z$_][a-z$_0-9]*$/i;\nfunction isIdentifier(str) {\n    return rident.test(str);\n}\n\nfunction filledRange(count, prefix, suffix) {\n    var ret = new Array(count);\n    for(var i = 0; i < count; ++i) {\n        ret[i] = prefix + i + suffix;\n    }\n    return ret;\n}\n\nfunction safeToString(obj) {\n    try {\n        return obj + \"\";\n    } catch (e) {\n        return \"[no string representation]\";\n    }\n}\n\nfunction isError(obj) {\n    return obj instanceof Error ||\n        (obj !== null &&\n           typeof obj === \"object\" &&\n           typeof obj.message === \"string\" &&\n           typeof obj.name === \"string\");\n}\n\nfunction markAsOriginatingFromRejection(e) {\n    try {\n        notEnumerableProp(e, \"isOperational\", true);\n    }\n    catch(ignore) {}\n}\n\nfunction originatesFromRejection(e) {\n    if (e == null) return false;\n    return ((e instanceof Error[\"__BluebirdErrorTypes__\"].OperationalError) ||\n        e[\"isOperational\"] === true);\n}\n\nfunction canAttachTrace(obj) {\n    return isError(obj) && es5.propertyIsWritable(obj, \"stack\");\n}\n\nvar ensureErrorObject = (function() {\n    if (!(\"stack\" in new Error())) {\n        return function(value) {\n            if (canAttachTrace(value)) return value;\n            try {throw new Error(safeToString(value));}\n            catch(err) {return err;}\n        };\n    } else {\n        return function(value) {\n            if (canAttachTrace(value)) return value;\n            return new Error(safeToString(value));\n        };\n    }\n})();\n\nfunction classString(obj) {\n    return {}.toString.call(obj);\n}\n\nfunction copyDescriptors(from, to, filter) {\n    var keys = es5.names(from);\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        if (filter(key)) {\n            try {\n                es5.defineProperty(to, key, es5.getDescriptor(from, key));\n            } catch (ignore) {}\n        }\n    }\n}\n\nvar asArray = function(v) {\n    if (es5.isArray(v)) {\n        return v;\n    }\n    return null;\n};\n\nif (typeof Symbol !== \"undefined\" && Symbol.iterator) {\n    var ArrayFrom = typeof Array.from === \"function\" ? function(v) {\n        return Array.from(v);\n    } : function(v) {\n        var ret = [];\n        var it = v[Symbol.iterator]();\n        var itResult;\n        while (!((itResult = it.next()).done)) {\n            ret.push(itResult.value);\n        }\n        return ret;\n    };\n\n    asArray = function(v) {\n        if (es5.isArray(v)) {\n            return v;\n        } else if (v != null && typeof v[Symbol.iterator] === \"function\") {\n            return ArrayFrom(v);\n        }\n        return null;\n    };\n}\n\nvar isNode = typeof process !== \"undefined\" &&\n        classString(process).toLowerCase() === \"[object process]\";\n\nvar hasEnvVariables = typeof process !== \"undefined\" &&\n    typeof process.env !== \"undefined\";\n\nfunction env(key) {\n    return hasEnvVariables ? process.env[key] : undefined;\n}\n\nfunction getNativePromise() {\n    if (typeof Promise === \"function\") {\n        try {\n            var promise = new Promise(function(){});\n            if ({}.toString.call(promise) === \"[object Promise]\") {\n                return Promise;\n            }\n        } catch (e) {}\n    }\n}\n\nfunction domainBind(self, cb) {\n    return self.bind(cb);\n}\n\nvar ret = {\n    isClass: isClass,\n    isIdentifier: isIdentifier,\n    inheritedDataKeys: inheritedDataKeys,\n    getDataPropertyOrDefault: getDataPropertyOrDefault,\n    thrower: thrower,\n    isArray: es5.isArray,\n    asArray: asArray,\n    notEnumerableProp: notEnumerableProp,\n    isPrimitive: isPrimitive,\n    isObject: isObject,\n    isError: isError,\n    canEvaluate: canEvaluate,\n    errorObj: errorObj,\n    tryCatch: tryCatch,\n    inherits: inherits,\n    withAppended: withAppended,\n    maybeWrapAsError: maybeWrapAsError,\n    toFastProperties: toFastProperties,\n    filledRange: filledRange,\n    toString: safeToString,\n    canAttachTrace: canAttachTrace,\n    ensureErrorObject: ensureErrorObject,\n    originatesFromRejection: originatesFromRejection,\n    markAsOriginatingFromRejection: markAsOriginatingFromRejection,\n    classString: classString,\n    copyDescriptors: copyDescriptors,\n    hasDevTools: typeof chrome !== \"undefined\" && chrome &&\n                 typeof chrome.loadTimes === \"function\",\n    isNode: isNode,\n    hasEnvVariables: hasEnvVariables,\n    env: env,\n    global: globalObject,\n    getNativePromise: getNativePromise,\n    domainBind: domainBind\n};\nret.isRecentNode = ret.isNode && (function() {\n    var version;\n    if (process.versions && process.versions.node) {    \n        version = process.versions.node.split(\".\").map(Number);\n    } else if (process.version) {\n        version = process.version.split(\".\").map(Number);\n    }\n    return (version[0] === 0 && version[1] > 10) || (version[0] > 0);\n})();\n\nif (ret.isNode) ret.toFastProperties(process);\n\ntry {throw new Error(); } catch (e) {ret.lastLineError = e;}\nmodule.exports = ret;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/util.js\n// module id = 6\n// module chunks = 4","/* globals define, XDomainRequest, EventSource */\n// noinspection JSVoidFunctionReturnValueUsed\n\n'use strict';\n/**\n * API objects and subclasses\n */\n\nvar appState = window.appState;\n\n/**\n * UMD Loader from https://github.com/umdjs/umd/blob/master/amdWeb.js\n */\n(function (root, factory) {\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD. Register as an anonymous module.\n\t\tdefine(['underscore', 'jquery', 'dada-class', 'dada-deferred', 'jquery.cookie'], factory);\n\t} else {\n\t\t// Browser globals\n\t\troot.NamescoRest = factory(root._, root.jQuery, root.Class, root.Deferred);\n\t}\n}(this, function (_, jQuery, Class, Deferred) {\n\t/**\n\t * @typedef {('legacy'|'v2')} DomainEndpointProfile\n\t */\n\n\tvar apiStore = {};\n\tvar useSecureCookies = document.location.protocol === 'https:' ? true : false;\n\n\t// Extend the standard error to expose the http status returned.\n\tvar ApiError = function (message, httpStatus, other) {\n\t\tthis.name = 'ApiError';\n\t\tthis.message = message || 'Unknown Error';\n\t\tthis.httpStatus = httpStatus || 400;\n\t\tthis.stack = (new Error()).stack;\n\n\t\tif (typeof other !== undefined) {\n\t\t\t_.extend(this, other);\n\t\t}\n\t};\n\n\tApiError.prototype = Object.create(Error.prototype);\n\tApiError.prototype.constructor = ApiError;\n\n\t/**\n\t * Base API class extended by each of the API classes.\n\t *\n\t * Provides basic shared functionality.\n\t */\n\tvar Api = Class.extend({\n\n\t\tinitialize: function () {\n\t\t\tthis.lastResponse = null;\n\t\t},\n\n\t\tfetch: function () { throw new ApiError('Not implemented'); },\n\t\tfetchSome: function () { throw new ApiError('Not implemented'); },\n\t\tfetchAll: function () { throw new ApiError('Not implemented'); },\n\t\tcreate: function () { throw new ApiError('Not implemented'); },\n\t\tdestroy: function () { throw new ApiError('Not implemented'); },\n\t\tupdate: function () { throw new ApiError('Not implemented'); },\n\t\tfetchForCustomer: function () { throw new ApiError('Not implemented'); },\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a POST with json content.\n\t\t *\n\t\t * @param {string} url                The URL.\n\t\t * @param {object} data               The data to json encode as the POST content.\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t * @param {string} apiKey             Optional override of the default X-APIKEY value.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupPostParams: function (url, data, withAuthentication, apiKey) {\n\t\t\treturn getClientParams(withAuthentication, apiKey)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\t'url': url,\n\t\t\t\t\t'data': JSON.stringify(data),\n\t\t\t\t\t'processData': false\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a GET.\n\t\t *\n\t\t * @param {string} url                The URL\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupGetParams: function (url, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\ttype: 'GET'\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a GET.\n\t\t *\n\t\t * @param {string} url                The URL\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupPatchParams: function (url, data, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\tdata: JSON.stringify(data),\n\t\t\t\t\ttype: 'PATCH',\n\t\t\t\t\tprocessData: false\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a DELETE.\n\t\t *\n\t\t * @param {string} url                The URL.\n\t\t * @param {array}  data               The data.\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} Returning the param object for jQuery\n\t\t */\n\t\tsetupDeleteParams: function (url, data, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\ttype: 'DELETE',\n\t\t\t\t\tdata: JSON.stringify(data),\n\t\t\t\t\tprocessData: false\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Setup the param block needed by jQuery for a HEAD.\n\t\t *\n\t\t * @param {string} url                The URL\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t *\n\t\t * @returns {Promise} returning the param object for jQuery\n\t\t */\n\t\tsetupHeadParams: function (url, withAuthentication) {\n\t\t\treturn getClientParams(withAuthentication)\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\turl: url,\n\t\t\t\t\ttype: 'HEAD'\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return an ajax handler that supports basic promises.\n\t\t */\n\t\tdispatch: function (params) {\n\t\t\tvar self = this;\n\n\t\t\tif (_.isUndefined(self)) {\n\t\t\t\tthrow new ApiError('self not bound in api.dispatch');\n\t\t\t}\n\n\t\t\tif (window.XDomainRequest) {\n\t\t\t\t// IE 9 support\n\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\tvar xdr = new XDomainRequest();\n\t\t\t\t\txdr.ontimeout = function () { reject({statusText: 'Timeout'}); };\n\t\t\t\t\txdr.onerror = function () { reject(self.processAjaxErrorResponse(xdr)); };\n\t\t\t\t\txdr.onprogress = function () {};\n\t\t\t\t\txdr.onload = function () {\n\t\t\t\t\t\tvar data = '';\n\t\t\t\t\t\tif (xdr.responseText.length > 0) {\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tdata = JSON.parse(xdr.responseText);\n\t\t\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\t\t\tdata = false;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (data === false) {\n\t\t\t\t\t\t\treject({statusText: 'Unable to parse response'});\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (!_.isUndefined(data.describedBy)) {\n\t\t\t\t\t\t\treject(self.processAjaxErrorResponse(xdr, data));\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tresolve(data);\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\n\t\t\t\t\tvar actualRequestType = params.type;\n\t\t\t\t\tvar url = window.location.protocol + params.url.replace(/^http(s)?:/, '');\n\t\t\t\t\txdr.open('post', url);\n\t\t\t\t\tif (!_.isUndefined(params.data) && params.data !== '') {\n\t\t\t\t\t\tparams.data = JSON.parse(params.data);\n\t\t\t\t\t}\n\t\t\t\t\tvar data = JSON.stringify(\n\t\t\t\t\t\t{'IE9Headers': params.headers, 'IE9Type': actualRequestType, 'wrappedData': params.data}\n\t\t\t\t\t);\n\t\t\t\t\txdr.send(data);\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\tvar jqXHR = jQuery.ajax(params)\n\t\t\t\t\t.done(function (data) {\n\t\t\t\t\t\tif (_.isUndefined(data)) {\n\t\t\t\t\t\t\tdata = {};\n\t\t\t\t\t\t}\n\t\t\t\t\t\tself.lastResponse = jqXHR;\n\n\t\t\t\t\t\t// In situations where there are issue with CORS and\n\t\t\t\t\t\t// http error codes, a backup is to send back a http 200 code\n\t\t\t\t\t\t// with the application/api-problem+json body content so we\n\t\t\t\t\t\t// do a check for the httpStatus attribute to catch this.\n\t\t\t\t\t\tif (_.has(data, 'httpStatus')) {\n\t\t\t\t\t\t\treject(self.processAjaxErrorResponse(jqXHR, data));\n\t\t\t\t\t\t}\n\t\t\t\t\t\t_.defer(resolve, data);\n\t\t\t\t\t})\n\t\t\t\t\t.fail(function () {\n\t\t\t\t\t\treject(self.processAjaxErrorResponse(jqXHR, null));\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Process an jqXHR from a jQuery ajax fail callback into an Error object.\n\t\t *\n\t\t * The optional data parameter is for if issues with CORS mean a 200 response\n\t\t * needs to be returned but with a application/api-problem+json body content.\n\t\t *\n\t\t * @param {jqXHR}  jqXHR The XHR object passed to the jQuery.ajax.fail callback.\n\t\t * @param {Object} data  Optional. The data passed back from jQuery.\n\t\t *\n\t\t * @returns {Error}\n\t\t */\n\t\tprocessAjaxErrorResponse: function (jqXHR, data) {\n\t\t\ttry {\n\t\t\t\tvar response = data || JSON.parse(jqXHR.responseText);\n\t\t\t\tvar message = response.title;\n\t\t\t\tvar status = response.httpStatus;\n\n\t\t\t\tdelete response.title;\n\t\t\t\tdelete response.httpStatus;\n\n\t\t\t\treturn new ApiError(message, status, response);\n\t\t\t} catch (err) {\n\t\t\t\treturn new ApiError(jqXHR.statusText, jqXHR.status);\n\t\t\t}\n\t\t}\n\t});\n\n\t// Begin API endpoint definitions -----\n\n\t/**\n\t * API client for suffix detail requests.\n\t *\n\t * This class allows you to fetch info for a suffix and the\n\t * period / price / product details for the suffix.\n\t * The class is Promise based and the response datastructure is\n\t * supplied on fullfillment. On error an Error object is provided.\n\t */\n\tvar ApiSuffix = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/suffixes/';\n\n\t\t\t// An array of objects of type {customerId, suffixes, hash}\n\t\t\t// where customer is the customerId, hash is the customer hash\n\t\t\t// and suffixes is an object with keys being the suffix and\n\t\t\t// the value being a deferred promise.\n\t\t\t// Done this way because of a bug in iOS8 safari that\n\t\t\t// means integer keys on an object can screw up the\n\t\t\t// length calculation on that object.\n\t\t\tthis.promises = [];\n\n\t\t\tthis.deferTriggered = false;\n\t\t},\n\n\t\t/**\n\t\t * Return details for the requested suffix.\n\t\t *\n\t\t * If a customer Id is supplied, the pricing details returned will\n\t\t * take customer-specific custom prices into consideration.\n\t\t *\n\t\t * @param {string} suffix       The suffix of interest (e.g. '.com')\n\t\t * @param {int}    customerId   Optional. A customerId.\n\t\t * @param {string} customerHash Required if a customerId is supplied.\n\t\t *\n\t\t * @returns {Promise} - data on fulfillment, Error on reject.\n\t\t */\n\t\tfetchDetails: function (suffix, customerId, customerHash) {\n\t\t\tif (_.isUndefined(customerId)) {\n\t\t\t\tcustomerId = 0;\n\t\t\t}\n\t\t\tvar customer = _.findWhere(this.promises, {customerId: customerId});\n\t\t\tif (_.isUndefined(customer)) {\n\t\t\t\tcustomer = {customerId: customerId, customerHash: customerHash, suffixes: {}};\n\t\t\t\tthis.promises.push(customer);\n\t\t\t}\n\t\t\tif (_.isUndefined(customer.suffixes[suffix])) {\n\t\t\t\tcustomer.suffixes[suffix] = new Deferred();\n\t\t\t}\n\t\t\tif (!this.deferTriggered) {\n\t\t\t\t_.delay(_.bind(this._makeRequests, this), 10);\n\t\t\t\tthis.deferTriggered = true;\n\t\t\t}\n\t\t\treturn customer.suffixes[suffix].promise;\n\t\t},\n\n\t\t/**\n\t\t * Actually make the async requests for suffix data.\n\t\t *\n\t\t * Called via a delay and processes the content of this.promises.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_makeRequests: function () {\n\t\t\tthis.deferTriggered = false;\n\t\t\tif (this.promises.length < 1) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hold a local version of the promises we will be working with\n\t\t\t// and clear the list so new requests can be gathered.\n\t\t\tvar actionedPromises = this.promises;\n\t\t\tthis.promises = [];\n\n\t\t\t// Make a request per customerId\n\t\t\t_.each(actionedPromises, function (customer) {\n\t\t\t\tif (_.isUndefined(customer.suffixes) || customer.suffixes.length < 1) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar customerId = customer.customerId;\n\t\t\t\tvar customerHash = customer.customerHash;\n\n\t\t\t\t// Reduce the suffixes into a queryString\n\t\t\t\tvar suffixesQueryString = _.reduce(customer.suffixes, function (queryString, promise, suffix) {\n\t\t\t\t\treturn queryString + '&suffixes[]=' + suffix;\n\t\t\t\t}, '', this);\n\n\t\t\t\t// Build the full url\n\t\t\t\tvar url = this.urlRoot + '?euroLocale=' + appState.locale + suffixesQueryString;\n\t\t\t\tif (customerId !== 0) {\n\t\t\t\t\turl += '&customerId=' + customerId + '&customerHash=' + customerHash;\n\t\t\t\t}\n\t\t\t\tvar self = this;\n\t\t\t\tthis.setupGetParams(url, true)\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\t// Loop through each suffix, build the data needed for each and resolve the\n\t\t\t\t\t// promise. If no data for the suffix exists, reject with an error.\n\t\t\t\t\t_.each(customer.suffixes, function (promise, suffix) {\n\t\t\t\t\t\tif (_.isUndefined(data[suffix])) {\n\t\t\t\t\t\t\tpromise.reject(new Error('no data'));\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Build the data structure for the individual suffix to match what\n\t\t\t\t\t\t// would have been returned if only a single suffix was requested.\n\t\t\t\t\t\tvar suffixData = {_embedded: {'suffix:periods': {}}};\n\t\t\t\t\t\tsuffixData._links = {self: {href: '/suffixes/' + suffix}, curies: data._links.curies};\n\t\t\t\t\t\tsuffixData[suffix] = data[suffix];\n\t\t\t\t\t\tsuffixData._embedded['suffix:periods']._links = data._embedded['suffix:periods']._links;\n\t\t\t\t\t\tsuffixData._embedded['suffix:periods'][suffix] = data._embedded['suffix:periods'][suffix];\n\t\t\t\t\t\tpromise.resolve(suffixData);\n\t\t\t\t\t}, self);\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\t// On error, reject all suffix promises with the error\n\t\t\t\t\t_.each(customer.suffixes, function (promise) { promise.reject(error); }, self);\n\t\t\t\t});\n\t\t\t}, this);\n\t\t}\n\t});\n\n\tapiStore.suffix = ApiSuffix;\n\n\t/**\n\t * API Client class for fetching Domain Suffix information.\n\t */\n\tvar ApiDomainSuffix = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-suffixes';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with domain suffixes.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed to return customer pricing.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for a single domain suffix.\n\t\t *\n\t\t * @param {string} id      Suffix identifier.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options),\n\t\t\t\tthis.authenticate\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for all domain suffixes (or subset thereof).\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchAll: function (options) {\n\t\t\tvar url = this.urlRoot + '/';\n\n\t\t\tif (options.suffixes) {\n\t\t\t\turl += '?suffixes=' + encodeURIComponent(options.suffixes.toString());\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainSuffix = ApiDomainSuffix;\n\n\t/**\n\t * API Client class for fetching Domain Suffix Offers information.\n\t */\n\tvar ApiDomainSuffixOffers = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-suffixes/offers';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with domain suffixes.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed to return customer pricing.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for a single domain suffix.\n\t\t *\n\t\t * @param {string} id      Suffix identifier.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id),\n\t\t\t\toptions\n\t\t\t), this.authenticate)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for all domain suffixes (or subset thereof).\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchAll: function (options) {\n\t\t\tvar url = this.urlRoot + '/';\n\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainSuffixOffers = ApiDomainSuffixOffers;\n\n\t/**\n\t * API: Basekit.\n\t */\n\tvar ApiDomainValidation = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/services';\n\t\t},\n\n\t\t/**\n\t\t * Trigger resending of domain-validation email validation email.\n\t\t *\n\t\t * To clarify, this is the email that the customer recieves from ICANN\n\t\t * asking them to verify their email address.\n\t\t *\n\t\t * @param {string} serviceUid A service Uid.\n\t\t * @param {object} options    Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tresendEmail: function (serviceUid, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain-validation',\n\t\t\t\toptions\n\t\t\t), {action: 'resendEmail'}, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainValidation = ApiDomainValidation;\n\n\t/**\n\t * API client for working with orders (carts).\n\t *\n\t * This class provides functions to work with an Order (cart).\n\t * The class design is Promise-based and multiple requests are non-blocking.\n\t * Order ID fetching is cached and only done once.\n\t *\n\t * Note that as one of the older classes, this class has some legacy methods\n\t * and is in a state of refactoring so is a little messy in places. In general,\n\t * fetch methods are designed to work with the Nested Types models while\n\t * the get and other methods are more for direct calling. Direct call methods\n\t * tend to auto-create orders where needed while the fetch methods won't.\n\t * Fetch methods also use authentication.\n\t */\n\tvar ApiOrder = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.orderId = jQuery.cookie('orderId') || false;\n\t\t\tthis.orderRef = jQuery.cookie('orderRef') || false;\n\t\t\tthis.promiseOrderId = null;\n\t\t\tthis.urlRoot = urlRoot + '/orders/';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t\tthis.authenticate = false;\n\t\t\tthis.validAddActions = ['new', 'renew', 'upgrade'];\n\t\t},\n\n\t\t/**\n\t\t * Return cached orderId and orderRef.\n\t\t */\n\t\tgetCachedOrderIdentifiers: function () {\n\t\t\treturn {\n\t\t\t\torderId: this.orderId,\n\t\t\t\torderRef: this.orderRef,\n\t\t\t};\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with orders.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed for an order to be owned by a customer.\n\t\t *\n\t\t * Used when we don't have an auth token such as before a customer logs into the cart.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Get the details of a single order.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tget: function (options) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\tvar url = self.urlRoot + encodeURIComponent(orderId);\n\t\t\t\tif (self.authenticate === false) {\n\t\t\t\t\turl += '?orderRef=' + encodeURIComponent(self.orderRef);\n\t\t\t\t}\n\t\t\t\treturn self.setupGetParams(buildQueryString (url, options), self.authenticate)\n\t\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Get details of a single order.\n\t\t *\n\t\t * @param {Number} orderId The order Id.\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tfetch: function (orderId, options) {\n\t\t\tvar url = this.urlRoot + encodeURIComponent(orderId);\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get details of the items in an order.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tfetchItems: function (options) {\n\t\t\tvar url = this.urlRoot + encodeURIComponent(options.orderId) + '/items';\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get details of the products in an order.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tfetchProducts: function (options) {\n\t\t\tvar url = this.urlRoot + encodeURIComponent(options.orderId) + '/products';\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get the details of all unprocessed (saved) orders for customer.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tgetUnprocessed: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Add an item to the order.\n\t\t *\n\t\t * Creates the order if needed. Internally calls getOrderId so there is\n\t\t * no need to call this first. Multiple calls can be made in parallel\n\t\t * and are non-conflicting and no-blocking. However, multiple requests\n\t\t * to add the same product but with different parameters are not\n\t\t * guaranteed to complete in request-sequence.\n\t\t *\n\t\t * @param {Object} data The keyed data structure.\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} - no value on fulfillment, Error on reject.\n\t\t */\n\t\taddToOrder: function (data, options) {\n\t\t\tvar self = this;\n\n\t\t\toptions = _.defaults(\n\t\t\t\t{},\n\t\t\t\toptions,\n\t\t\t\t{\n\t\t\t\t\tcreateNewOrder: false,\n\t\t\t\t\twithAuthentication: this.authenticate\n\t\t\t\t}\n\t\t\t);\n\n\t\t\treturn self._validate(data)\n\t\t\t.then(function () { return self.getOrderId(options); })\n\t\t\t.then(function (orderId) {\n\t\t\t\tdata.orderRef = self.orderRef;\n\t\t\t\treturn self.setupPostParams(\n\t\t\t\t\tself.urlRoot + encodeURIComponent(orderId) + '/items',\n\t\t\t\t\tdata,\n\t\t\t\t\toptions.withAuthentication\n\t\t\t\t).then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Get the orderId.\n\t\t *\n\t\t * Will create a new order id if one doesn't exist in the cookie.\n\t\t *\n\t\t * If 'withAuthentication' is passed as an option then checking the order (if one already exists)\n\t\t * will also include checking the order is owned by the correct customer. If not, a 401 not authorized\n\t\t * is returned and a new orderId is generated for the current customer.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} - orderId on fulfill, Error on reject\n\t\t */\n\t\tgetOrderId: function (options) {\n\t\t\tvar self = this;\n\t\t\toptions = _.defaults(\n\t\t\t\t{},\n\t\t\t\toptions,\n\t\t\t\t{\n\t\t\t\t\tcreateNewOrder: false,\n\t\t\t\t\twithAuthentication: this.authenticate\n\t\t\t\t}\n\t\t\t);\n\n\t\t\tvar canReuseExistingOrder = options.createNewOrder === false;\n\n\t\t\t// Firstly, try to use any previously created promise to get the order ID\n\t\t\tif (canReuseExistingOrder\n\t\t\t\t&& self.promiseOrderId !== null\n\t\t\t) {\n\t\t\t\treturn self.promiseOrderId;\n\t\t\t}\n\n\t\t\t// Failing that, try the existing cached order ID, or simply create a new order\n\t\t\tif (canReuseExistingOrder\n\t\t\t\t&& !_.isUndefined(self.orderId)\n\t\t\t\t&& self.orderId !== false\n\t\t\t) {\n\t\t\t\t// We have an existing orderId\n\t\t\t\tvar url = self.urlRoot + encodeURIComponent(self.orderId) +\n\t\t\t\t\t'?noChildren=true&orderRef=' + encodeURIComponent(self.orderRef);\n\t\t\t\tself.promiseOrderId = self.setupGetParams(url, options.withAuthentication)\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(\n\t\t\t\t\tfunction (order) {\n\t\t\t\t\t\tif (order.onHold || order.processed) {\n\t\t\t\t\t\t\treturn self.getNewOrderId(false, options.origin);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn Promise.resolve(self.orderId);\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\tfunction () { return self.getNewOrderId(false, options.origin); }\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\t// Fall back to creating a new order\n\t\t\t\tself.promiseOrderId = self.getNewOrderId(false, options.origin);\n\t\t\t}\n\n\t\t\treturn self.promiseOrderId;\n\t\t},\n\n\t\t/**\n\t\t * Create and return a new order id.\n\t\t *\n\t\t * By default, if a customerId and customerHash are available, will create an order for the customer.\n\t\t * If there is an error with this data (e.g. hash doesn't match) then we just create an order\n\t\t * without linking it to the customer.\n\t\t *\n\t\t * @param {bool}   ignoreCustomerDetails Optional. Skip specifying the customer when creating the order.\n\t\t * @param {string} orderOrigin          Optional origin for the new order.\n\t\t *\n\t\t * @returns {Promise} - orderId on fulfill, Error on reject\n\t\t */\n\t\tgetNewOrderId: function (ignoreCustomerDetails, orderOrigin) {\n\t\t\tif (_.isUndefined(ignoreCustomerDetails)) {\n\t\t\t\tignoreCustomerDetails = false;\n\t\t\t}\n\n\t\t\tvar withAuthentication;\n\t\t\tif (ignoreCustomerDetails) {\n\t\t\t\twithAuthentication = false;\n\t\t\t} else {\n\t\t\t\twithAuthentication = this.authenticate;\n\t\t\t}\n\t\t\tvar self = this;\n\n\t\t\tself.promiseOrderId = new Promise(function (resolve, reject) {\n\t\t\t\tvar customerDetails = {};\n\t\t\t\tif (!ignoreCustomerDetails && !self.authenticate) {\n\t\t\t\t\tcustomerDetails = {\n\t\t\t\t\t\t'customerId': self.customerId || 0,\n\t\t\t\t\t\t'customerHash': self.customerHash || ''\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\tcustomerDetails.origin = typeof orderOrigin === 'string'\n\t\t\t\t\t&& /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,19}$/.test(orderOrigin)\n\t\t\t\t\t? orderOrigin\n\t\t\t\t\t: '';\n\t\t\t\tself.setupPostParams(self.urlRoot, customerDetails, withAuthentication)\n\t\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t\t.then(function (data) {\n\t\t\t\t\t\tself.orderId = data.uid;\n\t\t\t\t\t\tself.orderRef = data.orderRef;\n\t\t\t\t\t\tdelete data.orderRef;\n\t\t\t\t\t\tjQuery.cookie('orderId', self.orderId, {path: '/', secure: useSecureCookies});\n\t\t\t\t\t\tjQuery.cookie('orderRef', self.orderRef, {path: '/', secure: useSecureCookies});\n\t\t\t\t\t\tresolve(self.orderId);\n\t\t\t\t\t},\n\t\t\t\t\tfunction (error) {\n\t\t\t\t\t\tif (!ignoreCustomerDetails &&\n\t\t\t\t\t\t\t(self.authenticate || (error.httpStatus === 403 && error.message === 'Mismatched customerHash'))\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\tself.getNewOrderId(true, orderOrigin).then(\n\t\t\t\t\t\t\t\tfunction (data) { resolve(data); },\n\t\t\t\t\t\t\t\tfunction (error) { reject(error); }\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treject(error);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t});\n\n\t\t\treturn self.promiseOrderId;\n\t\t},\n\n\t\t/**\n\t\t * Remove a single order item from the cart.\n\t\t *\n\t\t * @param {string|int} orderItemId Either an order item UID or backoffice id.\n\t\t * @param {string}     productType Product type. Required if a backoffice id is supplied.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tremoveItem: function (orderItemId, productType) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\treturn self.setupDeleteParams(self.urlRoot + encodeURIComponent(orderId) + '/items/' +\n\t\t\t\tencodeURIComponent(orderItemId) + '?orderRef=' + encodeURIComponent(self.orderRef) +\n\t\t\t\t(productType ? '&productType=' + encodeURIComponent(productType) : ''), null, self.authenticate)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Clear an order (remove all items under it).\n\t\t *\n\t\t * @returns {Promise} - resolve/reject.\n\t\t */\n\t\tremoveAllItems: function () {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\treturn self.setupDeleteParams(\n\t\t\t\t\tself.urlRoot + encodeURIComponent(orderId) + '/items?orderRef=' + encodeURIComponent(self.orderRef),\n\t\t\t\t\tnull,\n\t\t\t\t\tself.authenticate\n\t\t\t\t)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Update the order.\n\t\t *\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (changes) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\tchanges.orderRef = self.orderRef;\n\t\t\t\treturn self.setupPostParams(self.urlRoot + encodeURIComponent(orderId), changes, self.authenticate)\n\t\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Apply a voucher, optionally only if there is not already one applied.\n\t\t *\n\t\t * @param {string}  voucher The voucher code to apply.\n\t\t * @param {boolean} replace Whether to replace an existing voucher.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tapplyVoucher: function (voucherCode, replace) {\n\t\t\treplace = (typeof (replace) === 'undefined' ? true : replace);\n\t\t\tvoucherCode = {voucherCode: voucherCode.replace(/\\s/g, \"\").toUpperCase(), replace: replace};\n\t\t\tvar params = { voucherCode: voucherCode };\n\t\t\tif (\n\t\t\t\t!_.isUndefined(appState.customerId)\n\t\t\t\t&& appState.customerId !== 0\n\t\t\t\t&& !_.isUndefined(appState.customerHash)\n\t\t\t\t&& appState.customerHash.length > 0\n\t\t\t) {\n\t\t\t\tparams.customerId = String(appState.customerId);\n\t\t\t\tparams.customerHash = appState.customerHash;\n\t\t\t}\n\n\t\t\treturn this.update(params);\n\t\t},\n\n\t\t/**\n\t\t * Mark the order as being partially paid by credit.\n\t\t *\n\t\t * @param {float} amount The amount of credit to use or -1 for all available credit.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tuseCredit: function (amount) {\n\t\t\tif (amount < 0 && amount !== -1) {\n\t\t\t\treturn Promise.reject(new Error('Invalid credit amount'));\n\t\t\t}\n\t\t\treturn this.update({creditAmount: amount});\n\t\t},\n\n\t\t/**\n\t\t * Update an item.\n\t\t *\n\t\t * @param {int}    uid     Id of the order item.\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdateItem: function (uid, changes) {\n\t\t\tvar self = this;\n\t\t\treturn this.getOrderId().then(function (orderId) {\n\t\t\t\tif (!self.authenticate) {\n\t\t\t\t\tchanges.orderRef = self.orderRef;\n\t\t\t\t}\n\t\t\t\treturn self.setupPostParams(\n\t\t\t\t\tself.urlRoot + encodeURIComponent(orderId) + '/items/' + encodeURIComponent(uid),\n\t\t\t\t\tchanges,\n\t\t\t\t\tself.authenticate\n\t\t\t\t).then(self.dispatch.bind(self));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Force an order to process. Uses the customer id and hash.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tprocess: function () {\n\t\t\treturn this.update({\n\t\t\t\tprocess: true,\n\t\t\t\tcustomerId: this.customerId,\n\t\t\t\tcustomerHash: this.customerHash\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch the count of renewals for a customer.\n\t\t *\n\t\t * @param {number} customerId A customerId\n\t\t *\n\t\t * @returns {Promise} Returning the renewal count.\n\t\t */\n\t\tfetchSavedOrderCountForCustomer: function (customerId) {\n\t\t\tvar self = this;\n\t\t\treturn this.setupHeadParams(this.urlRoot + encodeURIComponent(customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function () {\n\t\t\t\t\tif (self.lastResponse) {\n\t\t\t\t\t\treturn self.lastResponse.getResponseHeader('X-Saved-Orders-Total') || 0;\n\t\t\t\t\t}\n\t\t\t\t\treturn 0;\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Clear out a processed order.\n\t\t *\n\t\t * For use after an order's processed to force this api to\n\t\t * create a new one for subsequent operations.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\tclear: function () {\n\t\t\tjQuery.removeCookie('orderId', {path: '/', secure: useSecureCookies});\n\t\t\tjQuery.removeCookie('orderRef', {path: '/', secure: useSecureCookies});\n\t\t\tthis.promiseOrderId = null;\n\t\t},\n\n\t\t/**\n\t\t * Basic validation of the data structure for adding an item to an order.\n\t\t *\n\t\t * Written to use Promises in case we want to do some async stuff in future.\n\t\t *\n\t\t * @param {object} data The data structure to check.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\t_validate: function (data) {\n\t\t\tif (!_.has(data, 'productId')) {\n\t\t\t\treturn Promise.reject(Error('Missing product Id'));\n\t\t\t}\n\n\t\t\tif (!data.productId.match(/^[a-z]/i)) {\n\t\t\t\tif (!_.has(data, 'productType')) {\n\t\t\t\t\treturn Promise.reject(Error('No product type supplied'));\n\t\t\t\t}\n\t\t\t\tif (!(_.contains(['hosting', 'mx', 'other', 'domain', 'server'], data.productType))) {\n\t\t\t\t\treturn Promise.reject(Error('Invalid product type \"' + data.productType + '\"'));\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (!_.has(data, 'serviceName') && !_.has(data, 'serviceId')) {\n\t\t\t\treturn Promise.reject(Error('No service name or ID supplied'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'renewalMethod') &&\n\t\t\t\tdata.renewalMethod !== '' &&\n\t\t\t\t!(_.contains(['rebills', 'auto'], data.renewalMethod))\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid renewal method \"' + data.renewalMethod + '\"'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'actions') &&\n\t\t\t\tdata.actions.length > this.validAddActions.length\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid action data provided (too many actions)'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'actions') &&\n\t\t\t\tdata.actions.includes('renew') &&\n\t\t\t\t(!(_.has(data, 'packageId')) || data.packageId === null)\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid renewal data, packageId missing'));\n\t\t\t}\n\n\t\t\tif (_.has(data, 'actions') &&\n\t\t\t\tdata.actions.includes('upgrade') &&\n\t\t\t\t(!(_.has(data, 'serviceId')) || data.serviceId === null)\n\t\t\t) {\n\t\t\t\treturn Promise.reject(Error('Invalid upgrade data, serviceId missing'));\n\t\t\t}\n\n\t\t\treturn Promise.resolve();\n\t\t}\n\t});\n\n\tapiStore.order = ApiOrder;\n\n\t/**\n\t * API Client for the new, stream-based domain search system.\n\t *\n\t * Check for availability for a domain prefix and a set of suffixes\n\t * using the check() method. Receive results by requesting an\n\t * EventListener for the domain you are interested in using newEventStream().\n\t *\n\t * You can create as many event streams as you wish and you can check\n\t * for availability at any time without collision. Note, however, that the\n\t * domain you request a check for may not be the domain the searches are\n\t * performed on because the Rest API will strip illegal chars, lower-case the\n\t * string and try to identify and strip any suffixes on the passed domain string\n\t * so it is recommended to wait for the check promise to return before requesting\n\t * a stream unless you know the domain string won't change (e.g. if you've\n\t * used the string returned from a previous call).\n\t */\n\tvar ApiDomainSearchStream = Api.extend({\n\t\tinitialize: function (profile) {\n\t\t\tthis._super();\n\t\t\tthis.profile = normalizeEndpointProfile(profile);\n\t\t\tthis.urlRoot = profileUrlRoot('domain-search', this.profile);\n\t\t},\n\n\t\t/**\n\t\t * Request a check for availability of a domain prefix and a set of suffixes.\n\t\t *\n\t\t * The suffixes parameter can be one of the following:\n\t\t *   An array of strings where each string is a suffix with or without the leading period.\n\t\t *   An object of properties with each property key being a suffix without the leading period\n\t\t *    and with the value for each key being a comma-separated list of qualities.\n\t\t *\n\t\t * Qualities control what type of search is performed. Options are:\n\t\t *  local - only check the local ban list and whether a domain registration already exists in backoffice.\n\t\t *  dns - perform a DNS request for NameServer details and consider the domain available if there are no results.\n\t\t *  registrar - query the actual domain registrar.\n\t\t *\n\t\t * When passing an array of strings, the default is to check all qualities (i.e. 'registrar,dns,local').\n\t\t *\n\t\t * @param {string} domain   The domain prefix to use for the checks (i.e. the foo part of foo.com).\n\t\t * @param {Array}  suffixes A structure of suffixes to check for availability.\n\t\t * @param {object} options  Options object.\n\t\t *\n\t\t * @returns {Promise<{domain: string, suffix: string}>} The actual domain prefixed used for searching\n\t\t *                                                    after sanitisation and the identified primary suffix.\n\t\t */\n\t\tcheck: function (domain, suffixes, options) {\n\t\t\toptions = options || {};\n\t\t\tvar requestedSuffixes = [];\n\t\t\tif (_.size(suffixes) === 0) {\n\t\t\t\treturn Promise.reject(new Error('No suffixes provided'));\n\t\t\t}\n\n\t\t\t_.each(suffixes, function (value, index) {\n\t\t\t\tif (isNaN(index)) {\n\t\t\t\t\trequestedSuffixes.push({suffix: index, quality: value});\n\t\t\t\t} else {\n\t\t\t\t\trequestedSuffixes.push({suffix: value, quality: 'registrar,dns,local'});\n\t\t\t\t}\n\t\t\t});\n\t\t\tvar queryString = buildQueryString(this.urlRoot + '/start/' +\n\t\t\t\tencodeURIComponent(domain.replace(/\\/|\\?|&/g, '')), options);\n\n\t\t\tif (options.autoSearchPrimarySuffix !== undefined) {\n\t\t\t\tqueryString += '&autoSearchPrimarySuffix=1';\n\t\t\t}\n\t\t\treturn this.setupPostParams(\n\t\t\t\tqueryString,\n\t\t\t\t{suffixes: requestedSuffixes},\n\t\t\t\tfalse\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this))\n\t\t\t.then(function (results) {\n\t\t\t\tif (_.has(results, 'domain')) {\n\t\t\t\t\treturn {domain: results.domain, suffix: results.suffix};\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error('No domain returned');\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return a new Event Source for the specified domain.\n\t\t *\n\t\t * @param {string} domain The domain prefix. Usually the one returned from check().\n\t\t *\n\t\t * @returns {EventSource}\n\t\t */\n\t\teventSource: function (domain) {\n\t\t\tvar url = this.urlRoot + '/result-stream/' + domain;\n\t\t\treturn new EventSource(url);\n\t\t}\n\t});\n\n\tapiStore.domainSearchStream = ApiDomainSearchStream;\n\n\t/**\n\t * API Client for the new, stream-based domain whois system.\n\t *\n\t * Perform a whois lookup for a domain using the check() method. Receive results\n\t * by requesting an EventListener for the domain you are interested in using\n\t * newEventStream().\n\t *\n\t * Note, the same caveats that apply to ApiDomainSearchStream also apply here.\n\t */\n\tvar ApiDomainWhoisStream = Api.extend({\n\t\tinitialize: function (profile) {\n\t\t\tthis._super();\n\t\t\tthis.profile = normalizeEndpointProfile(profile);\n\t\t\tthis.urlRoot = profileUrlRoot('domain-whois', this.profile);\n\t\t},\n\n\t\t/**\n\t\t * Request a whois lookup for a keyword + suffix.\n\t\t *\n\t\t * @param {string} keyword The keyword part to use for the lookup (e.g. foo from foo.com).\n\t\t * @param {string} suffix  The suffix to use for the lookup (e.g. com from foo.com).\n\t\t *\n\t\t * @returns {Promise<{keyword: string, suffix: string}>} The keyword & suffix used for the lookup.\n\t\t */\n\t\tlookup: function (keyword, suffix) {\n\t\t\tif (!keyword || !suffix) {\n\t\t\t\treturn Promise.reject(new Error('No keyword or suffix provided'));\n\t\t\t}\n\n\t\t\tvar queryString = buildQueryString(this.urlRoot + '/start/' +\n\t\t\t\tencodeURIComponent((keyword + '.' + suffix).replace(/\\/|\\?|&/g, '')));\n\n\t\t\treturn this.setupPostParams(\n\t\t\t\tqueryString,\n\t\t\t\t{keyword: keyword, suffix: suffix},\n\t\t\t\tfalse\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this))\n\t\t\t.then(function (results) {\n\t\t\t\tif (_.has(results, 'keyword')) {\n\t\t\t\t\treturn {keyword: results.keyword, suffix: results.suffix};\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error('No result returned');\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return a new Event Source for the specified keyword.\n\t\t *\n\t\t * @param {string} keyword The keyword.\n\t\t *\n\t\t *\n\t\t * @returns {EventSource}\n\t\t */\n\t\teventSource: function (keyword) {\n\t\t\tvar url = this.urlRoot + '/result-stream/' + keyword;\n\t\t\treturn new EventSource(url);\n\t\t}\n\t});\n\n\tapiStore.domainWhoisStream = ApiDomainWhoisStream;\n\n\tvar ApiDomainSearchReport = Api.extend({\n\t\tinitialize: function (profile) {\n\t\t\tthis._super();\n\t\t\tthis.profile = normalizeEndpointProfile(profile);\n\t\t\tthis.urlRoot = profileUrlRoot('domain-search', this.profile) + '/report';\n\t\t},\n\t\treport: function (data, options) {\n\t\t\tvar self = this;\n\n\t\t\treturn Promise.resolve()\n\t\t\t.then(function () {\n\t\t\t\treturn self.setupPostParams(\n\t\t\t\t\tself.urlRoot,\n\t\t\t\t\tdata,\n\t\t\t\t\tfalse\n\t\t\t\t)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.domainSearchReport = ApiDomainSearchReport\n\n\tvar ApiDomainSuggestions = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-suggestions';\n\t\t},\n\t\tfetch: function(id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id),\n\t\t\t\toptions\n\t\t\t), this.authenticate).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainSuggestions = ApiDomainSuggestions;\n\n\t/**\n\t * Legacy API client for domain searches (deprecated).\n\t *\n\t * This class allows you to initiate or extend a domain search. It uses\n\t * Promises and can handle starting a new search when another is already\n\t * in progress. Suffix availability is communicated via fulfilling promises.\n\t * Overall status of the search is communicated via promises.\n\t *\n\t * General usage pattern:\n\t *  Add suffixes to a search using adToSearch, passing the suffix e.g. '.com'\n\t *  Link the returned promise to the behaviour you want to perform.\n\t *  Call doSearch\n\t */\n\tvar ApiDomainSearch = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.searchId = '';\n\t\t\tthis.domain = '';\n\t\t\tthis.pollPeriod = 500;\n\t\t\tthis.maximumPollRequests = 20;\n\t\t\tthis.urlRoot = urlRoot + '/domain-search/';\n\t\t\tthis.searchingFor = {};\n\t\t\tthis.willSearchFor = {};\n\t\t\tthis.nextSearchPromise = false;\n\t\t\tthis.runningSearchPromise = false;\n\t\t},\n\n\t\t/**\n\t\t * Set the domain for which we want suffix availability.\n\t\t *\n\t\t * @param {string} domain The domain.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\tsetDomain: function (domain) {\n\t\t\tthis.domain = domain;\n\t\t},\n\n\t\t/**\n\t\t * Add a suffix into a pending search set.\n\t\t *\n\t\t * @param {string} suffix The suffix to add (including preceeding '.')\n\t\t *\n\t\t * @returns {Promise} - suffix status on resolve, Error object on reject\n\t\t*/\n\t\taddToSearch: function (suffix, autoTrigger) {\n\t\t\tvar deferred = new Deferred();\n\t\t\tthis.willSearchFor[suffix] = deferred;\n\t\t\tif (autoTrigger !== false) {\n\t\t\t\t_.delay(this.doSearch.bind(this), 20);\n\t\t\t}\n\t\t\treturn deferred.promise;\n\t\t},\n\n\t\t/**\n\t\t * Pick up the results from an existing preheat search.\n\t\t *\n\t\t * Similar to doSearch except we skip the _startSearch() call.\n\t\t *\n\t\t * You can only call this method if there is no running search\n\t\t * and no next search configured. Basically, best to run this asap\n\t\t * on app load. If a search is already running, this method returns\n\t\t * the running search promise.\n\t\t *\n\t\t * Assumes the preheated suffixes have already been added to the search\n\t\t * using addToSearch like normal.\n\t\t *\n\t\t * @returns {Promise} - search id on resolve, Error object on reject\n\t\t */\n\t\tpickUpPreheatSearch: function () {\n\t\t\tvar self = this;\n\t\t\tif (this.runningSearchPromise !== false) {\n\t\t\t\t// If there's a search running already\n\t\t\t\treturn this.runningSearchPromise;\n\t\t\t}\n\t\t\tthis.searchId = jQuery.cookie('searchId');\n\t\t\tvar promise = Promise.resolve(this.searchId);\n\t\t\tthis.runningSearchPromise = promise;\n\n\t\t\tpromise.then(function (searchId) {\n\t\t\t\tself.searchingFor = self.willSearchFor;\n\t\t\t\tself.willSearchFor = {};\n\t\t\t\treturn self._checkForResults();\n\t\t\t}).then(function () {\n\t\t\t\tif (self.nextSearchPromise !== false) {\n\t\t\t\t\tself.runningSearchPromise = self.nextSearchPromise.promise;\n\t\t\t\t\tself.nextSearchPromise.resolve();\n\t\t\t\t} else {\n\t\t\t\t\tself.runningSearchPromise = false;\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn promise;\n\t\t},\n\n\t\t/**\n\t\t * Trigger a search\n\t\t *\n\t\t * @returns {Promise} - search id, reject on error\n\t\t */\n\t\tdoSearch: function () {\n\t\t\tvar self = this;\n\t\t\tvar promise;\n\t\t\tif (this.runningSearchPromise !== false) {\n\t\t\t\t// If there's a search running already\n\t\t\t\tif (this.nextSearchPromise !== false) {\n\t\t\t\t\t// If there's already a pending Promise for the next search, return it\n\t\t\t\t\treturn this.nextSearchPromise.promise;\n\t\t\t\t} else {\n\t\t\t\t\t// Create a new deferred promise and resolve it when the\n\t\t\t\t\t// current search finishes.\n\t\t\t\t\tthis.nextSearchPromise = new Deferred();\n\t\t\t\t\tpromise = this.nextSearchPromise.promise;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// create a pre-resolved starting promise\n\t\t\t\tpromise = this.runningSearchPromise = Promise.resolve();\n\t\t\t}\n\n\t\t\tpromise = promise.then(function () {\n\t\t\t\tself.nextSearchPromise = false;\n\t\t\t\treturn self._startSearch();\n\t\t\t});\n\n\t\t\tpromise.then(function (searchId) {\n\t\t\t\treturn self._checkForResults();\n\t\t\t}).then(function () {\n\t\t\t\tif (self.nextSearchPromise !== false) {\n\t\t\t\t\tself.runningSearchPromise = self.nextSearchPromise.promise;\n\t\t\t\t\tself.nextSearchPromise.resolve();\n\t\t\t\t} else {\n\t\t\t\t\tself.runningSearchPromise = false;\n\t\t\t\t}\n\t\t\t});\n\n\t\t\treturn promise;\n\t\t},\n\n\t\t/**\n\t\t * Internal method to setup a new search or extend an existing one.\n\t\t *\n\t\t * @returns {Promise} - search id (new search), empty (extend) on resolve,\n\t\t*/\n\t\t_startSearch: function () {\n\t\t\tvar self = this;\n\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t// When the promise runs we want to grab all the pending suffixes\n\t\t\t\t// and move them over to the active list, resetting the pending\n\t\t\t\t// list to allow for more suffixes to be added\n\t\t\t\tself.searchingFor = self.willSearchFor;\n\t\t\t\tself.willSearchFor = {};\n\n\t\t\t\tgetClientParams()\n\t\t\t\t.then(function (params) {\n\t\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\t\turl: self.urlRoot + encodeURIComponent(self.searchId),\n\t\t\t\t\t\tdata: JSON.stringify({suffixes: _.keys(self.searchingFor), search: self.domain}),\n\t\t\t\t\t\tprocessData: false\n\t\t\t\t\t});\n\t\t\t\t})\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\tif (data && !_.isUndefined(data.id)) {\n\t\t\t\t\t\tself.searchId = data.id;\n\t\t\t\t\t\tjQuery.cookie('searchId', self.searchId, {path: '/', secure: useSecureCookies});\n\t\t\t\t\t}\n\t\t\t\t\tresolve(self.searchId);\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\treject(error);\n\t\t\t\t});\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Internal method to poll for search results.\n\t\t *\n\t\t * @returns {Promise} - 'searching' or 'completed' on resolve, Error object on reject\n\t\t */\n\t\t_checkForResults: function () {\n\t\t\tvar self = this;\n\t\t\tvar pollCounter = this.maximumPollRequests;\n\n\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t/**\n\t\t\t\t * Helper function to reject all pending suffix Promises.\n\t\t\t\t */\n\t\t\t\tfunction _rejectRemainingPromises () {\n\t\t\t\t\t_.each(self.searchingFor, function (promise) {\n\t\t\t\t\t\tpromise.reject(Error('error'));\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\t/**\n\t\t\t\t * Internal function for 'recursive' polling.\n\t\t\t\t *\n\t\t\t\t * Only within the scope of _checkForResults, this function\n\t\t\t\t * wraps a single wait/poll cycle. If there are results still pending\n\t\t\t\t * this method calls itself although it's not really recursive\n\t\t\t\t * because of the setTimeout().\n\t\t\t\t */\n\n\t\t\t\tfunction _fetchResults () {\n\t\t\t\t\t// within each timeout do an ajax call\n\t\t\t\t\tsetTimeout(function () {\n\t\t\t\t\t\tself.setupGetParams(self.urlRoot + encodeURIComponent(self.searchId))\n\t\t\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t\t\t.then(function (data) {\n\t\t\t\t\t\t\t--pollCounter;\n\n\t\t\t\t\t\t\t// assuming success, loop through all the suffix results\n\t\t\t\t\t\t\t// and if we still have a promise for a suffix then\n\t\t\t\t\t\t\t// resolve that promise and remove it from the list\n\t\t\t\t\t\t\tif (data.hasOwnProperty('results') && data.results.length > 0) {\n\t\t\t\t\t\t\t\t_.each(data.results[0].status, function (status, suffix) {\n\t\t\t\t\t\t\t\t\tsuffix = '.' + suffix;\n\t\t\t\t\t\t\t\t\tif (suffix in self.searchingFor) {\n\t\t\t\t\t\t\t\t\t\tself.searchingFor[suffix].resolve(status);\n\t\t\t\t\t\t\t\t\t\tdelete self.searchingFor[suffix];\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// If the search is reporting completed or we timeout then we want to reject\n\t\t\t\t\t\t\t// any remaining suffix promises and then resolve the search promise.\n\t\t\t\t\t\t\t// If the search isn't completed then keep going even if\n\t\t\t\t\t\t\t// we have no further suffixes to resolve because we don't want\n\t\t\t\t\t\t\t// to trigger a pending search while the previous one is incomplete.\n\t\t\t\t\t\t\tif (data.status === 'complete' || pollCounter === 0) {\n\t\t\t\t\t\t\t\t_rejectRemainingPromises();\n\t\t\t\t\t\t\t\tresolve(data.status);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t_fetchResults();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t},\n\t\t\t\t\t\tfunction (error) {\n\t\t\t\t\t\t\t_rejectRemainingPromises();\n\t\t\t\t\t\t\treject(error);\n\t\t\t\t\t\t});\n\t\t\t\t\t}, self.pollPeriod);\n\t\t\t\t}\n\n\t\t\t\t// Now we've defined the function we want to run it.\n\t\t\t\t_fetchResults();\n\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.domainSearch = ApiDomainSearch;\n\n\t/**\n\t * API Client class for fetching product information.\n\t */\n\tvar ApiProduct = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/products';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerHash = '';\n\n\t\t\t// An array of objects of type {customerId, products, hash}\n\t\t\t// where customer is the customerId, hash is the customer hash\n\t\t\t// and suffixes is an object with keys being the suffix and\n\t\t\t// the value being a deferred promise.\n\t\t\t// Done this way because of a bug in iOS8 safari that\n\t\t\t// means integer keys on an object can screw up the\n\t\t\t// length calculation on that object.\n\t\t\tthis.promises = [];\n\n\t\t\tthis.deferTriggered = false;\n\t\t},\n\n\t\t/**\n\t\t * Setup to use authentication when working with products.\n\t\t *\n\t\t * Used when we already have a suitable auth token.\n\t\t */\n\t\tuseAuthentication: function () {\n\t\t\tthis.authenticate = true;\n\t\t\tthis.customerId = 0;\n\t\t\tthis.customerHash = '';\n\t\t},\n\n\t\t/**\n\t\t * Setup the customer Id and Hash needed for custom prices.\n\t\t *\n\t\t * @param {int}    id   The customer Id.\n\t\t * @param {string} hash The security hash.\n\t\t */\n\t\tsetCustomerDetails: function (id, hash) {\n\t\t\tthis.customerId = id;\n\t\t\tthis.customerHash = hash;\n\t\t\tthis.authenticate = false;\n\t\t},\n\n\t\t/**\n\t\t * Fetch details for a product Uid.\n\t\t *\n\t\t * @param {string} productUid The product Uid.\n\t\t * @param {object} options    Options object.\n\t\t *\n\t\t * @returns {Promise} Returning the product data in an object.\n\t\t */\n\t\tfetch: function (productUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(productUid),\n\t\t\t\toptions\n\t\t\t), this.authenticate)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch product data for a list of product Uids.\n\t\t *\n\t\t * @param {object} options Options object\n\t\t *\n\t\t * @returns {Promise} Returning the product data in an object.\n\t\t */\n\t\tfetchSome: function (options) {\n\t\t\tvar qs = buildQueryString(\n\t\t\t\tthis.urlRoot + '/?',\n\t\t\t\toptions\n\t\t\t);\n\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/?',\n\t\t\t\toptions\n\t\t\t), this.authenticate)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all product data for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all product data for a set of services.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForServices: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all domain products for given suffix list.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} returning the product collection.\n\t\t */\n\t\tfetchDomainProductsForSuffixes: function (options) {\n\t\t\tvar url = this.urlRoot + '/domains/?';\n\t\t\tvar baseQueryString = _.reduce(options.suffixes,\n\t\t\t\tfunction (partialQueryString, suffix) {\n\t\t\t\t\treturn partialQueryString + '&suffix[]=' + encodeURIComponent(suffix);\n\t\t\t\t}, '', this\n\t\t\t);\n\n\t\t\tif (!_.isUndefined(options.privacyType) && (typeof options.privacyType === 'string')) {\n\t\t\t\tbaseQueryString += '&privacyType=' + options.privacyType;\n\t\t\t}\n\n\t\t\tif (!_.isUndefined(options.period) && (typeof options.period === 'number')) {\n\t\t\t\tbaseQueryString += '&period=' + options.period;\n\t\t\t}\n\n\t\t\tif (!_.isUndefined(appState.currency) && (typeof appState.currency === 'string')) {\n\t\t\t\tbaseQueryString += '&currency[]=' + appState.currency;\n\t\t\t}\n\n\t\t\tif (!_.isUndefined(options.voucherCode) && (typeof options.voucherCode === 'string')) {\n\t\t\t\tbaseQueryString += '&voucherCode=' + options.voucherCode;\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\t\turl + baseQueryString,\n\t\t\t\t\toptions\n\t\t\t\t), this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all product and product relations for the currently authorised customer.\n\t\t *\n\t\t * If a Deferred is supplied in the options.relationships key then it will be resolved\n\t\t * with the mappings linking products to their families.\n\t\t *\n\t\t * @param {object} options Options object.\n\t\t *\n\t\t * @returns {Promise} returning the product collection.\n\t\t */\n\t\tproductFamiliesForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/families/';\n\t\t\tif (!_.isUndefined(appState.currency) && appState.currency !== '') {\n\t\t\t\turl += '?currency[]=' + appState.currency;\n\t\t\t}\n\t\t\treturn this.setupGetParams(url, this.authenticate)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\tvar products = _.values(data['_embedded'].products);\n\t\t\t\t\tif (_.has(options, 'relationships') && _.isFunction(options.relationships.resolve)) {\n\t\t\t\t\t\tdelete data['_links'];\n\t\t\t\t\t\tdelete data['_embedded'];\n\t\t\t\t\t\toptions.relationships.resolve(data);\n\t\t\t\t\t}\n\t\t\t\t\treturn {results: products};\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch details of other products related to a product Uid.\n\t\t *\n\t\t * @param {object} options Options object with a productUid key.\n\t\t *\n\t\t * @returns {Promise} Returning the product data in an object.\n\t\t */\n\t\tfamilyForProduct: function (options) {\n\t\t\tvar customerId = this.customerId;\n\t\t\tvar customerHash = this.customerHash;\n\n\t\t\tif (_.isUndefined(customerId)) {\n\t\t\t\tcustomerId = 0;\n\t\t\t}\n\t\t\tvar customer = _.findWhere(this.promises, {customerId: customerId});\n\t\t\tif (_.isUndefined(customer)) {\n\t\t\t\tcustomer = {customerId: customerId, customerHash: customerHash, families: {}};\n\t\t\t\tthis.promises.push(customer);\n\t\t\t}\n\t\t\tif (_.isUndefined(customer.families[options.productUid])) {\n\t\t\t\tcustomer.families[options.productUid] = new Deferred();\n\t\t\t}\n\t\t\tif (!this.deferTriggered) {\n\t\t\t\t_.delay(_.bind(this._makeRequests, this), 10);\n\t\t\t\tthis.deferTriggered = true;\n\t\t\t}\n\n\t\t\treturn customer.families[options.productUid].promise;\n\t\t},\n\n\t\t/**\n\t\t * Fetch all upgrade products for a service.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForPackageUpgrade: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\turlRoot + '/packages/' + encodeURIComponent(options.packageId) + '/upgrades',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Actually make the async requests for product data.\n\t\t *\n\t\t * Called via a delay and processes the content of this.promises.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_makeRequests: function () {\n\t\t\tthis.deferTriggered = false;\n\t\t\tif (this.promises.length < 1) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hold a local version of the promises we will be working with\n\t\t\t// and clear the list so new requests can be gathered.\n\t\t\tvar actionedPromises = this.promises;\n\t\t\tthis.promises = [];\n\n\t\t\t// Make a request per customerId\n\t\t\t_.each(actionedPromises, function (customer) {\n\t\t\t\tif (_.isUndefined(customer.families) || _.keys(customer.families).length < 1) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar customerId = customer.customerId;\n\t\t\t\tvar customerHash = customer.customerHash;\n\n\t\t\t\t// Reduce the products into a queryString\n\t\t\t\tvar productsQueryString = _.reduce(customer.families,\n\t\t\t\t\tfunction (queryString, promise, productUid) {\n\t\t\t\t\t\treturn queryString + '&products[]=' + encodeURIComponent(productUid);\n\t\t\t\t\t}, '', this);\n\n\t\t\t\t// Build the full url\n\t\t\t\tvar url = this.urlRoot + '/families/?' + productsQueryString;\n\t\t\t\tif (customerId !== 0) {\n\t\t\t\t\turl += '&customerId=' + encodeURIComponent(customerId) +\n\t\t\t\t\t\t'&customerHash=' + encodeURIComponent(customerHash);\n\t\t\t\t}\n\t\t\t\tif (!_.isUndefined(appState.currency) && appState.currency !== '') {\n\t\t\t\t\turl += '&currency[]=' + encodeURIComponent(appState.currency);\n\t\t\t\t}\n\n\t\t\t\tvar self = this;\n\t\t\t\tthis.setupGetParams(url, this.authenticate)\n\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t.then(function (data) {\n\t\t\t\t\t// Loop through each suffix, build the data needed for each and resolve the\n\t\t\t\t\t// promise. If no data for the suffix exists, reject with an error.\n\t\t\t\t\t_.each(customer.families, function (promise, productUid) {\n\t\t\t\t\t\tif (_.isUndefined(data[productUid])) {\n\t\t\t\t\t\t\tpromise.reject(new Error('no data'));\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Transform data into structure expected by model/UI\n\t\t\t\t\t\tvar familyData = {results: {}};\n\t\t\t\t\t\t_.each(data[productUid].family, function (familyProductUid) {\n\t\t\t\t\t\t\tfamilyData.results[familyProductUid] = data._embedded.products[familyProductUid];\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tpromise.resolve(familyData);\n\t\t\t\t\t}, self);\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\t// On error, reject all suffix promises with the error\n\t\t\t\t\t_.each(customer.families, function (promise) { promise.reject(error); }, self);\n\t\t\t\t});\n\t\t\t}, this);\n\t\t}\n\t});\n\n\tapiStore.product = ApiProduct;\n\n\t/**\n\t * API Client class for fetching package information.\n\t */\n\tvar ApiPackage = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/packages';\n\t\t\tthis.pendingUpdates = [];\n\t\t\tthis.updateTriggered = false;\n\t\t},\n\n\t\t/**\n\t\t * Create a new package on a service.\n\t\t *\n\t\t * Options array should include:\n\t\t *   customerId: integer The customerId\n\t\t *\n\t\t * Options array may include:\n\t\t *  attrs:           array   An array of attributes to return in the data for the created package. Default empty.\n\t\t *  includeEmbedded: boolean Whether to return the product and card object in the returned package data. Default false.\n\t\t *  provision:       boolean Whether to also privision the created package. Default true.\n\t\t *\n\t\t * Options array should include for litemail packages:\n\t\t *  emailAlias: string The email alias to setup.\n\t\t *\n\t\t * @param {string} serviceUid The service to add the package to.\n\t\t * @param {string} productUid The product to add.\n\t\t * @param {Object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tcreate: function (serviceUid, productUid, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\tvar data = {serviceUid: serviceUid, productUid: productUid};\n\t\t\tif (_.has(options, 'emailAlias')) {\n\t\t\t\tdata.emailAlias = options.emailAlias;\n\t\t\t\tdelete options.emailAlias;\n\t\t\t}\n\t\t\treturn self.setupPostParams(buildQueryString(self.urlRoot, options), data, true)\n\t\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Delete a package on a service.\n\t\t *\n\t\t * @param {number} packageUid The uid of the package to delete.\n\t\t * @param {Object} data       Body data to send in the request.\n\t\t * @param {Object} options    Options to customise the request.\n\t\t */\n\t\tdestroy: function (packageUid, data, options) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(packageUid), options),\n\t\t\t\tdata,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\t\t/**\n\t\t * Fetch package details for a packageId.\n\t\t *\n\t\t * @param {string} packageId The package Id.\n\t\t * @param {object} options   Options object.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tfetch: function (packageId, options) {\n\t\t\tvar self = this;\n\t\t\treturn self.setupGetParams(\n\t\t\t\tbuildQueryString(self.urlRoot + '/' + encodeURIComponent(packageId), options),\n\t\t\t\ttrue\n\t\t\t).then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all package data for a set of services.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForServices: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Set changes for a single package.\n\t\t *\n\t\t * @param {string} packageId The package Id.\n\t\t * @param {object} changes   The values to update.\n\t\t * @param {object} options   Options object.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (packageId, changes, options) {\n\t\t\tvar promise = new Deferred();\n\n\t\t\t// add the update data and a deferred promise to pending updates array\n\t\t\tthis.pendingUpdates.push({\n\t\t\t\tdeferredPromise: promise,\n\t\t\t\tchanges: changes,\n\t\t\t\tpackageId: packageId\n\t\t\t});\n\n\t\t\t// bundle futher updates by waiting before calling updateAll\n\t\t\tif (!this.updateTriggered) {\n\t\t\t\tthis.updateTriggered = true;\n\t\t\t\t_.delay(_.bind(this._updateAll, this), 10);\n\t\t\t}\n\n\t\t\t// return the deferred promise.\n\t\t\treturn promise.promise;\n\t\t},\n\n\t\t/**\n\t\t * Update details for a collection of packages.\n\t\t *\n\t\t * @returns {promise}\n\t\t */\n\t\t_updateAll: function () {\n\t\t\tvar patch = {'operations': []};\n\t\t\tvar toUpdate = this.pendingUpdates;\n\t\t\tvar promises = {};\n\n\t\t\t// reset to allow further updates.\n\t\t\tthis.pendingUpdates = [];\n\t\t\tthis.updateTriggered = false;\n\n\t\t\t// loop over the bundled updates and set the patch data.\n\t\t\t// to keep track of requests later map the deferred promise.\n\t\t\t_.each(toUpdate, function (data) {\n\t\t\t\tpatch.operations.push({\n\t\t\t\t\t'op': 'replace',\n\t\t\t\t\t'path': '/packages/' + data.packageId,\n\t\t\t\t\t'value': data.changes\n\t\t\t\t});\n\n\t\t\t\tpromises['/packages/' + data.packageId] = data.deferredPromise;\n\t\t\t});\n\n\t\t\treturn this.setupPatchParams(this.urlRoot, patch, true).then(this.dispatch.bind(this)).then(\n\t\t\t\tfunction (data) {\n\t\t\t\t\tif (!_.isUndefined(data)) {\n\t\t\t\t\t\t// if any of the patch request operations failed loop through the\n\t\t\t\t\t\t// unprocessed updates, find the matching promises and reject them.\n\t\t\t\t\t\t_.each(data.unprocessed, function (result) {\n\t\t\t\t\t\t\tif (_.has(promises, result.path)) {\n\t\t\t\t\t\t\t\tpromises[result.path].reject(result.error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\n\t\t\t\t\t// resolve each of the (remaining) promises.\n\t\t\t\t\t_.each(promises, function (deferredPromise) {\n\t\t\t\t\t\tdeferredPromise.resolve();\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t\tfunction (error) {\n\t\t\t\t\t// if things went horribly wrong reject all promises.\n\t\t\t\t\t_.each(promises, function (deferredPromise) {\n\t\t\t\t\t\tdeferredPromise.reject(error);\n\t\t\t\t\t});\n\t\t\t\t\t// note without rethrowing the error any errors in the ajax are swollowed.\n\t\t\t\t\tthrow error;\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch package details for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar self = this;\n\t\t\tvar limit = 2000;\n\t\t\tvar queryString = buildQueryString('?limit=' + encodeURIComponent(limit) + '&start=0', options);\n\n\t\t\treturn this.setupGetParams(this.urlRoot + queryString, true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function (firstPage) {\n\t\t\t\t\tif (_.has(firstPage, '_page') && firstPage['_page'].all > limit) {\n\t\t\t\t\t\tvar pages = [];\n\t\t\t\t\t\tvar packageCount = firstPage['_page'].all;\n\t\t\t\t\t\tvar start = 0;\n\t\t\t\t\t\tdelete firstPage['_page'];\n\n\t\t\t\t\t\tpages.push(Promise.resolve(firstPage));\n\t\t\t\t\t\tstart += limit;\n\n\t\t\t\t\t\twhile (packageCount > start) {\n\t\t\t\t\t\t\tvar queryString = buildQueryString(\n\t\t\t\t\t\t\t\t'?limit=' + encodeURIComponent(limit) + '&start=' + start,\n\t\t\t\t\t\t\t\toptions\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tstart += limit;\n\t\t\t\t\t\t\tvar promise = self.setupGetParams(self.urlRoot + queryString, true)\n\t\t\t\t\t\t\t\t.then(self.dispatch.bind(self))\n\t\t\t\t\t\t\t\t.then(function (data) {\n\t\t\t\t\t\t\t\t\tdelete data['_page'];\n\t\t\t\t\t\t\t\t\treturn data;\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\tpages.push(promise);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treturn Promise.all(pages).then(function (data) {\n\t\t\t\t\t\t\tvar results = Array.prototype.concat.apply([], _.map(data, function (item) {\n\t\t\t\t\t\t\t\tif (_.has(item, 'results')) {\n\t\t\t\t\t\t\t\t\treturn item.results;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\treturn [];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}));\n\t\t\t\t\t\t\tfirstPage.results = results;\n\t\t\t\t\t\t\treturn firstPage;\n\t\t\t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn firstPage;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch the count of renewals for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the renewal count.\n\t\t */\n\t\tfetchRenewalCountForCustomer: function (options) {\n\t\t\tvar self = this;\n\t\t\treturn this.setupHeadParams(this.urlRoot + '/?customerId=' + encodeURIComponent(options.customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function () {\n\t\t\t\t\tif (self.lastResponse) {\n\t\t\t\t\t\treturn self.lastResponse.getResponseHeader('X-Renewals-Due') || 0;\n\t\t\t\t\t}\n\t\t\t\t\treturn 0;\n\t\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Fetch upgrade products for a given packageId.\n\t\t *\n\t\t * @returns {Promise} Returning suitable upgrade products.\n\t\t */\n\t\tfetchUpgrades: function (packageId, options) {\n\t\t\tvar self = this;\n\t\t\treturn self.setupGetParams(\n\t\t\t\tbuildQueryString(self.urlRoot + '/' + encodeURIComponent(packageId) + '/upgrades', options), true\n\t\t\t).then(this.dispatch.bind(self));\n\t\t}\n\t});\n\n\tapiStore.package = ApiPackage;\n\n\t/**\n\t * API Client class for performing package activation.\n\t */\n\tvar ApiPackageActivation = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/packages';\n\t\t},\n\n\t\t/**\n\t\t * Activate a package\n\t\t *\n\t\t * @param {string} packageUid A package UID.\n\t\t * @param {object} data       A key/value list of new values to set.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tactivate: function (packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(packageUid) + '/activation',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.packageActivation = ApiPackageActivation;\n\n\t/**\n\t * API Client class for performing package allocation.\n\t */\n\tvar ApiPackageAllocation = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/packages';\n\t\t},\n\n\t\t/**\n\t\t * Allocate a package\n\t\t *\n\t\t * @param {string} packageUid A package UID.\n\t\t * @param {object} data       A key/value list of new values to set.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tallocate: function (packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(packageUid) + '/allocation',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.packageAllocation = ApiPackageAllocation;\n\n\t/**\n\t * API: Consumer withdrawals.\n\t *\n\t * Provides endpoints for the consumer right of withdrawal feature:\n\t * - GET  /consumer-withdrawals/eligible-services  — eligible services within 14-day window\n\t * - GET  /consumer-withdrawals                    — all withdrawal records for a customer\n\t * - POST /consumer-withdrawals                    — create a withdrawal request\n\t */\n\tvar ApiConsumerWithdrawal = Api.extend({\n\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/consumer-withdrawals';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve eligible services for a customer.\n\t\t *\n\t\t * The endpoint performs all server-side filtering: invoices within the\n\t\t * last 14 calendar days, invoice items with non-zero packageId, exclusion\n\t\t * of packages with pending (under_review) withdrawals, product name\n\t\t * resolution, and daysRemaining calculation.\n\t\t *\n\t\t * @param {number} customerId The customer ID.\n\t\t * @param {object} options    Optional query options.\n\t\t *\n\t\t * @returns {Promise} Returning the eligible services in a HAL object.\n\t\t */\n\t\tfetchEligibleServices: function (customerId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/eligible-services',\n\t\t\t\t_.extend({customerId: customerId}, options || {})\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all withdrawal records for a customer.\n\t\t *\n\t\t * The endpoint returns server-resolved display data: product names,\n\t\t * formatted request dates, and human-readable status labels.\n\t\t *\n\t\t * @param {number} customerId The customer ID.\n\t\t * @param {object} options    Optional query options.\n\t\t *\n\t\t * @returns {Promise} Returning the withdrawal records in a HAL object.\n\t\t */\n\t\tfetchForCustomer: function (customerId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot,\n\t\t\t\t_.extend({customerId: customerId}, options || {})\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Create a withdrawal request.\n\t\t *\n\t\t * The endpoint creates a ConsumerWithdrawals record (status: under_review),\n\t\t * raises a TYPE_CUSTOMER_CARE support ticket, and sends a confirmation\n\t\t * email to the customer.\n\t\t *\n\t\t * @param {object} data    The withdrawal data ({packageId, invoiceId, customerId, ...}).\n\t\t * @param {object} options Optional query options.\n\t\t *\n\t\t * @returns {Promise} Returning the created withdrawal record.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(this.urlRoot, options), data, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.consumerWithdrawal = ApiConsumerWithdrawal;\n\n\t/**\n\t * API: Support tickets.\n\t */\n\tvar ApiTicket = Api.extend({\n\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/tickets';\n\t\t},\n\n\t\tfetchTicketCountForCustomer: function (customerId) {\n\t\t\tvar self = this;\n\t\t\treturn this.setupHeadParams(buildQueryString(this.urlRoot, {'customerId': customerId}), true)\n\t\t\t\t.then(this.dispatch.bind(this))\n\t\t\t\t.then(function () {\n\t\t\t\t\tif (self.lastResponse) {\n\t\t\t\t\t\treturn self.lastResponse.getResponseHeader('X-Tickets-Total') || 0;\n\t\t\t\t\t}\n\t\t\t\t\treturn 0;\n\t\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.ticket = ApiTicket;\n\n\t/**\n\t * API: Customer.\n\t */\n\tvar ApiCustomer = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Update the customer.\n\t\t *\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, changes, options) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(uid), options),\n\t\t\t\tchanges,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve customer.\n\t\t *\n\t\t * @param {string} id      The customerId or accountRef.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the card data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tbuildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options),\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.customer = ApiCustomer;\n\n\t/**\n\t * API: AccessControlRule.\n\t */\n\tvar ApiAccessControlRule = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Delete an access control rule.\n\t\t *\n\t\t * @param {number} uid     Item UID to delete.\n\t\t * @param {Object} data    A key/value list of data.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (uid, data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupDeleteParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId)\n\t\t\t\t\t+ '/access-control-rules/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Create a new access control rule.\n\t\t *\n\t\t * @param {Object} data    A key/value list of new values.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the address data in an object.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupPostParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId) + '/access-control-rules/',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve access control rule.\n\t\t *\n\t\t * @param {string} uid     The access control rule ID.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the access control rule data in an object.\n\t\t */\n\t\tfetch: function (uid, options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) +\n\t\t\t\t'/access-control-rules/' + encodeURIComponent(uid);\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all access control rules for a customer.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the access control rule data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/access-control-rules/';\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.accessControlRule = ApiAccessControlRule;\n\n\t/**\n\t * API: AddressBookEntry.\n\t */\n\tvar ApiAddressBookEntry = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Delete an address book entry.\n\t\t *\n\t\t * @param {number} uid     Item UID to delete.\n\t\t * @param {Object} data    A key/value list of data.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (uid, data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupDeleteParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId) + '/addresses/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Create a new address book entry.\n\t\t *\n\t\t * @param {Object} data    A key/value list of new values.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the address data in an object.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupPostParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(data.customerId) + '/addresses/',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t},\n\n\t\t/**\n\t\t * Update an address book entry.\n\t\t *\n\t\t * @param {number} uid     Item UID to update.\n\t\t * @param {object} data    A key/value list of new values to set.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, data, options) {\n\t\t\t// TODO ensure customerId obtained correctly\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.customerId) + '/addresses/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve address book entry.\n\t\t *\n\t\t * @param {string} uid     The address book entry ID.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the card data in an object.\n\t\t */\n\t\tfetch: function (uid, options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId)\n\t\t\t\t+ '/addresses/' + encodeURIComponent(uid);\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all address book entries for a customer.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Returning the address book data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/addresses/';\n\n\t\t\tdelete options.customerId;\n\t\t\tif (options.withAccount) {\n\t\t\t\turl += '?withAccount=true';\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.addressBookEntry = ApiAddressBookEntry;\n\n\t/**\n\t * API: Invoice.\n\t */\n\tvar ApiInvoice = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/invoices';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve single invoice.\n\t\t *\n\t\t * @param {string} id      Invoice id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the invoice data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all invoices for a customer.\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t * @returns {Promise} Returning the invoice data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.invoice = ApiInvoice;\n\n\t/**\n\t * API: LcnInvoice.\n\t */\n\tvar ApiLcnInvoice = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/lcn-invoices';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all invoices for a customer.\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t * @returns {Promise} Returning the invoice data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.lcnInvoice = ApiLcnInvoice;\n\n\t/**\n\t * API: Credit receipt.\n\t */\n\tvar ApiCreditReceipt = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/credit-receipts';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve single credit receipt.\n\t\t *\n\t\t * @param {string} id      Credit receipt id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the credit data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all credit receipts for a customer.\n\t\t *\n\t\t * @param {object} options Options array.\n\t\t * @returns {Promise} Returning the credit data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.creditReceipt = ApiCreditReceipt;\n\n\t/**\n\t * API Client class for fetching card information.\n\t */\n\tvar ApiCard = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Delete a specific card via cardId.\n\t\t *\n\t\t * @param {string} cardId  The cardId.\n\t\t * @param {object} options Options array with rest key containing customerId key.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (cardId, options) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.customerId) + '/cards/' + encodeURIComponent(cardId),\n\t\t\t\tnull,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch card details for a specific cardId.\n\t\t *\n\t\t * @param {string} cardId  The cardId.\n\t\t * @param {object} options Options array with rest key containing customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the card data in an object.\n\t\t */\n\t\tfetch: function (cardId, options) {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/cards/' + encodeURIComponent(cardId), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch cards for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the package data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.customerId) + '/cards', true\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.card = ApiCard;\n\n\n\t/**\n\t * API Client class for fetching Direct Debit information.\n\t */\n\tvar ApiDirectDebit = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Fetch agreement details for a specific Direct Debit ID.\n\t\t *\n\t\t * @param {string} directDebitId The Direct Debit ID.\n\t\t * @param {object} options       Options array with rest key containing customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the Direct Debit data in an object.\n\t\t */\n\t\tfetch: function (directDebitId, options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId)\n\t\t\t\t+ '/direct-debits/' + encodeURIComponent(directDebitId);\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch agreements for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the Diret Debit data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\tvar url = this.urlRoot + '/' + encodeURIComponent(options.customerId) + '/direct-debits/';\n\t\t\tdelete options.customerId;\n\t\t\treturn this.setupGetParams(buildQueryString(url, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.directDebit = ApiDirectDebit;\n\n\t/**\n\t * API Client class for fetching bandwidth charge information.\n\t */\n\tvar ApiBandwidthCharge = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/bandwidth-charges';\n\t\t},\n\n\t\t/**\n\t\t * Fetch bandwidth charge details for a specific bandwidth charge ID.\n\t\t *\n\t\t * @param {string} bandwidthChargeId The bandwidth charge ID.\n\t\t * @param {object} options           Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the bandwidth charge data in an object.\n\t\t */\n\t\tfetch: function (bandwidthChargeId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(bandwidthChargeId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch bandwidth charges for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the bandwidth charge data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.bandwidthCharge = ApiBandwidthCharge;\n\n\t/**\n\t* API client class for accessing rebills.\n\t*\n\t* This exists primarily for getting a count of such via the HEAD REST call.\n\t*/\n\tvar ApiRebill = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/rebills';\n\t\t},\n\n\t\t/**\n\t\t * Fetch rebill details for a rebillId.\n\t\t *\n\t\t * @param {string} rebillId The rebill Id.\n\t\t *\n\t\t * @returns {Promise} Returning the rebill data in an object.\n\t\t */\n\t\trebill: function (rebillId) {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/' + encodeURIComponent(rebillId), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch rebill details for a customer.\n\t\t *\n\t\t * @param {string} customerId The customer Id.\n\t\t *\n\t\t * @returns {Promise} Returning the rebill data in an object.\n\t\t */\n\t\trebillsForCustomer: function (customerId) {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/?customerId=' + encodeURIComponent(customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Get number of renewals due for a customer.\n\t\t *\n\t\t * @param {string} customerId The customer id.\n\t\t *\n\t\t * @returns {Promise} Returning the headers in an object.\n\t\t */\n\t\tcount: function (customerId) {\n\t\t\treturn this.setupHeadParams(this.urlRoot + '/?customerId=' + encodeURIComponent(customerId), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.rebill = ApiRebill;\n\n\t/**\n\t * API Client class for fetching forwarding information.\n\t */\n\tvar ApiForwarding = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/forwarding';\n\t\t},\n\n\t\t/**\n\t\t * Fetch forwarding details for a specific domain name.\n\t\t *\n\t\t * @param {string} domainName A domain name.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the forwarding data in an object.\n\t\t */\n\t\tfetch: function (domainName, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(domainName), options\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all forwarding data for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the forwarding data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all forwarding data for a set of services.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUids key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForServices: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/', options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.forwarding = ApiForwarding;\n\n\t/**\n\t *\n\t * API client class for web forwarding.\n\t *\n\t */\n\tvar ApiForwardingDomain = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/forwarding';\n\t\t},\n\n\t\t/**\n\t\t * Fetch web forwarding details for a specific domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data in an object.\n\t\t */\n\t\tfetch: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update web forwarding details for a domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} data       A key/value list of new values to set.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tupdate: function (serviceUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Remove FirstPage forwarding service for a domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} data       A key/value list of data.\n\t\t * @param {object} options   Options array\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tremoveFirstPage: function (serviceUid, data, options) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain',\n\t\t\t\t{action: 'removeFirstPage'},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Delete web forwarding for a domain.\n\t\t *\n\t\t * @param {string} serviceUid A service UID.\n\t\t * @param {object} data       A key/value list of data.\n\t\t * @param {object} options    Options array\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tdestroy: function (serviceUid, data, options) {\n\t\t\treturn this.setupDeleteParams(this.urlRoot + '/' + encodeURIComponent(serviceUid) + '/domain', null, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.forwardingDomain = ApiForwardingDomain;\n\n\t/**\n\t *\n\t * API client class for email forwarding.\n\t *\n\t */\n\tvar ApiForwardingEmail = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/forwarding';\n\t\t},\n\n\t\t/**\n\t\t * Fetch email forwarding details for a specific domain.\n\t\t *\n\t\t * @param {string} aliasUid An email alias UID.\n\t\t * @param {object} options  Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the email forwarding data in an object.\n\t\t */\n\t\tfetch: function (aliasUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.serviceUid) + '/email/' + encodeURIComponent(aliasUid),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all email forwarding data for a service.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUid key.\n\t\t *\n\t\t * @returns {Promise} Returning the email forwarding data in an object.\n\t\t */\n\t\tfetchForService: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.serviceUid) + '/email',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Delete email forwarding for a domain.\n\t\t *\n\t\t * @param {string} aliasUid An email alias UID.\n\t\t * @param {object} data     A key/value list of data.\n\t\t * @param {object} options  Options array\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tdestroy: function (aliasUid, data, options) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.serviceUid) + '/email/' + encodeURIComponent(aliasUid),\n\t\t\t\tnull,\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Create email forwarding for a domain.\n\t\t *\n\t\t * @param {Object} data    A key/value list of new values.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tcreate: function (data, options) {\n\t\t\toptions = options || {};\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.serviceUid) + '/email/',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update email forwarding details for a domain.\n\t\t *\n\t\t * @param {string} aliasUid An email alias UID.\n\t\t * @param {object} data     A key/value list of new values to set.\n\t\t * @param {object} options  Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning success or failure.\n\t\t */\n\t\tupdate: function (aliasUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(data.serviceUid) + '/email/' + encodeURIComponent(aliasUid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.forwardingEmail = ApiForwardingEmail;\n\n\t/**\n\t * API Client class for posting customer logos.\n\t */\n\tvar ApiLogos = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/logos';\n\t\t},\n\n\t\tpost: function (customerId, data) {\n\t\t\treturn this.setupDataPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(customerId),\n\t\t\t\t{}\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\tdestroy: function (customerId) {\n\t\t\treturn this.setupDeleteParams(this.urlRoot + '/' + encodeURIComponent(customerId), null, true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Set up post params without conversion to JSON, here to transmit\n\t\t * an image in $_FILES.\n\t\t *\n\t\t * @param {string} url                Destination URL / query string.\n\t\t * @param {object} data               Formdata object.\n\t\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t\t * @param {string} apiKey             Optional override of the default X-APIKEY value.\n\t\t */\n\t\tsetupDataPostParams: function (url, data, withAuthentication, apiKey) {\n\t\t\treturn getClientParams(withAuthentication, apiKey, 'image/*')\n\t\t\t.then(function (params) {\n\t\t\t\treturn _.extend({}, params, {\n\t\t\t\t\t'url': url,\n\t\t\t\t\t'data': data,\n\t\t\t\t\t'contentType': false,\n\t\t\t\t\t'processData': false\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t});\n\n\tapiStore.logos = ApiLogos;\n\n\t/**\n\t * API Client class for fetching Service information.\n\t */\n\tvar ApiService = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/services';\n\t\t},\n\n\t\t/**\n\t\t * Update the service.\n\t\t *\n\t\t * @param {number} uid     Item UID to update.\n\t\t * @param {object} data    A key/value list of new values to set.\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch service details for a specific uid.\n\t\t *\n\t\t * @param {string} uid     Item UID to fetch details for.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetch: function (uid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(uid), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch all servce data for a customer.\n\t\t *\n\t\t * @param {object} options Options object with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the service data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch cpanel domain info details for a specific uid.\n\t\t *\n\t\t * @param {string} uid     A service UID.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the cpanel data in an object.\n\t\t */\n\t\tfetchCpanelDomainInfo: function (uid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(uid) + '/cpanel',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch upsell products for a specific uid.\n\t\t *\n\t\t * @returns {Promise} Returning suitable upsell products.\n\t\t */\n\t\tfetchUpsellProducts: function (uid, options) {\n\t\t\tvar self = this;\n\t\t\treturn self.setupGetParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(uid) + '/upsell',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(self));\n\t\t}\n\t});\n\n\tapiStore.service = ApiService;\n\n\t/**\n\t * API: Basekit.\n\t */\n\tvar ApiBasekit = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/basekit';\n\t\t},\n\n\t\t/**\n\t\t * Fetch the login url for the editor.\n\t\t *\n\t\t * @param {string} serviceUid The Service Uid.\n\t\t * @param {object} options    Options.\n\t\t *\n\t\t * @returns {Promise} Returning the url.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve basekit facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.basekit = ApiBasekit;\n\n\t/**\n\t * API: Duda.\n\t */\n\tvar ApiDuda = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/duda';\n\t\t},\n\n\t\t/**\n\t\t * Fetch a login url for the editor.\n\t\t *\n\t\t * @param {string} serviceUid The Service Uid.\n\t\t * @param {string} type       The login URL type to fetch.\n\t\t *\n\t\t * @returns {Promise} Returning the url.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, type) {\n\t\t\treturn this.setupGetParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login?ssoType=' + encodeURIComponent(type || ''),\n\t\t\t\ttrue\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch a list of available templates.\n\t\t *\n\t\t * @returns {Promise} Returning the array of templates.\n\t\t */\n\t\tfetchTemplates: function () {\n\t\t\treturn this.setupGetParams(this.urlRoot + '/templates', false)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve duda facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Reset a duda site.\n\t\t *\n\t\t * @param {string} id         Service id.\n\t\t * @param {string} templateId The id of the template to apply.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\treset: function (id, templateId) {\n\t\t\treturn this.setupDeleteParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id) + '?templateId=' + encodeURIComponent(templateId),\n\t\t\t\tnull,\n\t\t\t\ttrue\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update the duda facility.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} changes The new values to apply.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (id, changes, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(id),\n\t\t\t\toptions\n\t\t\t), changes, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\t});\n\n\tapiStore.duda = ApiDuda;\n\n\t/**\n\t * API: Ecommerce.\n\t */\n\tvar ApiEcommerce = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/ecommerce';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve ecommerce facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.ecommerce = ApiEcommerce;\n\n\t/**\n\t * API: SimplyBook.\n\t */\n\tvar ApiSimplyBook = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/simplybook';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve SimplyBook facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.simplybook = ApiSimplyBook;\n\n\t/**\n\t * API: Macaly.\n\t */\n\tvar ApiMacaly = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/macaly';\n\t\t},\n\n\t\t/**\n\t\t * Fetch the SSO login URL for a Macaly service.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the login URL data.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, itemId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login/' + encodeURIComponent(itemId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Activate a Macaly package.\n\t\t *\n\t\t * @param {string} packageUid The package UID.\n\t\t * @param {object} data       A key/value list of values to send in the POST body.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tactivate: function (packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(packageUid) + '/activation',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of provisioned Macaly items for a service.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the provisioned items.\n\t\t */\n\t\tfetchProvisionedList: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of orphaned Macaly accounts for a service.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the orphaned account items.\n\t\t */\n\t\tfetchOrphanedAccountList: function (serviceUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/orphaned',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of websites for a provisioned Macaly item.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the website list.\n\t\t */\n\t\tfetchWebsiteList: function (serviceUid, itemId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the list of hostnames for a Macaly website.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {string} websiteId  The website ID.\n\t\t * @param {object} options    Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the hostname list.\n\t\t */\n\t\tfetchHostnameList: function (serviceUid, itemId, websiteId, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId) + '/hostnames/' + encodeURIComponent(websiteId),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Add a hostname to a Macaly website.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {string} websiteId  The website ID.\n\t\t * @param {object} data       A key/value list of values to send in the POST body.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response (202 Accepted).\n\t\t */\n\t\taddHostname: function (serviceUid, itemId, websiteId, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId) + '/hostnames/' + encodeURIComponent(websiteId),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Remove a hostname from a Macaly website.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} itemId     The Macaly item ID within the service.\n\t\t * @param {string} websiteId  The website ID.\n\t\t * @param {object} data       A key/value list of values to send in the DELETE body.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response (202 Accepted).\n\t\t */\n\t\tremoveHostname: function (serviceUid, itemId, websiteId, data, options) {\n\t\t\treturn this.setupDeleteParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/websites/' + encodeURIComponent(itemId) + '/hostnames/' + encodeURIComponent(websiteId),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Change the plan for a Macaly package.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} packageUid The package UID.\n\t\t * @param {object} data       A key/value list of values to send in the POST body (e.g. { planCode: 'macaly-hosting-only', productId: 'H123' }).\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tchangePlan: function (serviceUid, packageUid, data, options) {\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/' + encodeURIComponent(packageUid) + '/plan',\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update the friendly name of a Macaly app.\n\t\t *\n\t\t * @param {string} serviceUid The service UID.\n\t\t * @param {string} packageId  The package ID of the Macaly app.\n\t\t * @param {string} appName    The new friendly name for the app.\n\t\t * @param {object} options    Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tupdateAppName: function (serviceUid, packageId, appName, options) {\n\t\t\treturn this.setupPatchParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/app/' + encodeURIComponent(packageId),\n\t\t\t\toptions\n\t\t\t), {appName: appName}, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.macaly = ApiMacaly;\n\n\t/**\n\t * API: Sitemaker.\n\t */\n\tvar ApiSitemaker = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/sitemaker';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve sitemaker facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\n\t});\n\n\tapiStore.sitemaker = ApiSitemaker;\n\n\t/**\n\t * API: Domain Registration.\n\t */\n\tvar ApiDomainRegistration = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/domain-registration';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve domain registration details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve all domain registration details for a customer.\n\t\t *\n\t\t * @param {object} options Options array with a customerId key.\n\t\t *\n\t\t * @returns {Promise} Returning the data in an object.\n\t\t */\n\t\tfetchForCustomer: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot, options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Update domain registration details for a service.\n\t\t *\n\t\t * @param {object} changes a key/value list of new values to set.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tupdate: function (uid, changes, options) {\n\t\t\tdelete changes.serviceModel;\n\t\t\treturn this.setupPostParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(uid),\n\t\t\t\toptions\n\t\t\t), changes, true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.domainRegistration = ApiDomainRegistration;\n\n\t/**\n\t * API: Email.\n\t */\n\tvar ApiEmail = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/email';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve email facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Activate a namesco email-only product.\n\t\t *\n\t\t * Used when a customer activates their email via the control panel\n\t\t * wizard, supplying an email alias and password instead of the order\n\t\t * process creating the setup automatically.\n\t\t *\n\t\t * @param {string} serviceUid Service uid for the domain being activated.\n\t\t * @param {object} data       Request body containing {emailAlias, password}.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tactivate: function (serviceUid, data) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/activation',\n\t\t\t\tdata || {},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.email = ApiEmail;\n\n\tvar ApiEmailUser = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/email';\n\t\t},\n\n\t\t/**\n\t\t * Fetch all email users for a service.\n\t\t *\n\t\t * @param {object} options Options object with a serviceUid key.\n\t\t *\n\t\t * @returns {Promise} Returning the email user data in an object.\n\t\t */\n\t\tfetchForService: function (options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(options.serviceUid) + '/users',\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Fetch the webmail login url for a user.\n\t\t *\n\t\t * @param {string} serviceUid The Service Uid.\n\t\t * @param {string} userUid    The User Uid.\n\t\t * @param {object} options    Options.\n\t\t *\n\t\t * @returns {Promise} Returning the url.\n\t\t */\n\t\tfetchLoginUrl: function (serviceUid, userUid, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/' + encodeURIComponent(serviceUid) + '/login/' + encodeURIComponent(userUid),\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.emailUser = ApiEmailUser;\n\n\t/**\n\t * API: Office365.\n\t */\n\tvar ApiOffice365 = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/office365';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve office365 facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.office365 = ApiOffice365;\n\n\t/**\n\t * API: OnlineCompliance.\n\t */\n\tvar ApiOnlineCompliance = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/online-compliance';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve Online Compliance facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.onlineCompliance = ApiOnlineCompliance;\n\n\t/**\n\t * API: WebAccessibility.\n\t */\n\tvar ApiWebAccessibility = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/web-accessibility';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve Web Accessibility facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.webAccessibility = ApiWebAccessibility;\n\n\t/**\n\t * API OnlineCompliance Scanner.\n\t */\n\tvar ApiOnlineComplianceScanner = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/online-compliance/scanner';\n\t\t\tthis.customerId = 0;\n\t\t\tthis.authenticate = false;\n\t\t\tthis.customerHash = '';\n\t\t},\n\t\tstart: function(url) {\n\t\t\treturn this.setupPostParams(this.urlRoot + '/' + encodeURIComponent(url), false)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\t\tcheck: function(url, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(url), options), false)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.onlineComplianceScanner = ApiOnlineComplianceScanner;\n\n\t/**\n\t * API: Quota.\n\t */\n\tvar ApiQuota = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/quota';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve Quota data details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the quota data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.quota = ApiQuota;\n\n\t/**\n\t * API: Mailbox.\n\t */\n\tvar ApiMailbox = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/mailbox';\n\t\t},\n\n\t\t/**\n\t\t * Delete a a mailbox.\n\t\t *\n\t\t * @param {number} uid     Item UID to delete.\n\t\t * @param {Object} data    A key/value list of data.\n\t\t * @param {Object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise}\n\t\t */\n\t\tdestroy: function (uid, data, options) {\n\t\t\tvar self = this;\n\t\t\toptions = options || {};\n\t\t\treturn self.setupDeleteParams(buildQueryString(\n\t\t\t\tself.urlRoot + '/' + encodeURIComponent(uid) + '/user/' + encodeURIComponent(data.userName),\n\t\t\t\toptions\n\t\t\t), data, true)\n\t\t\t.then(self.dispatch.bind(self));\n\t\t}\n\t});\n\n\tapiStore.mailbox = ApiMailbox;\n\n\t/**\n\t * API: Hosting.\n\t */\n\tvar ApiHosting = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/hosting';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve hosting facility details for a service.\n\t\t *\n\t\t * @param {string} id      Service id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the facility data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.hosting = ApiHosting;\n\n\t/**\n\t * API: Hubspot.\n\t */\n\tvar ApiHubspot = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/hubspot';\n\t\t},\n\n\t\t/**\n\t\t * Push an order to HubSpot for the authenticated customer.\n\t\t *\n\t\t * @param {string} orderRef The order reference.\n\t\t * @param {object} data     Optional request body data (e.g. {extraFlags: {...}}).\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\torderPush: function (orderRef, data) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/order-push/' + encodeURIComponent(orderRef),\n\t\t\t\tdata || {},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Push a customer's contact to HubSpot.\n\t\t *\n\t\t * @param {string} customerId Customer ID.\n\t\t *\n\t\t * @returns {Promise} Resolves with the server response.\n\t\t */\n\t\tcustomerPush: function (customerId) {\n\t\t\treturn this.setupPostParams(\n\t\t\t\tthis.urlRoot + '/customer-push',\n\t\t\t\t{customerId: customerId},\n\t\t\t\ttrue\n\t\t\t).then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.hubspot = ApiHubspot;\n\n\t/**\n\t * API: Setup.\n\t */\n\tvar ApiSetup = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/setup';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve setup details for a service.\n\t\t *\n\t\t * @param {string} id      Setup id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the setup data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\treturn this.setupGetParams(buildQueryString(this.urlRoot + '/' + encodeURIComponent(id), options), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.setup = ApiSetup;\n\n\t/**\n\t * API: Reseller Hosting Data.\n\t */\n\tvar ApiResellerHostingData = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/customers';\n\t\t},\n\n\t\t/**\n\t\t * Retrieve reseller hosting data for a customer ID.\n\t\t *\n\t\t * @param {string} id      A customer id.\n\t\t * @param {object} options Options array.\n\t\t *\n\t\t * @returns {Promise} Returning the reseller hosting data in an object.\n\t\t */\n\t\tfetch: function (id, options) {\n\t\t\tvar qs = '';\n\t\t\tif (options.includeLiteMail !== undefined) {\n\t\t\t\tqs = '/?includeLiteMail=' + encodeURIComponent(options.includeLiteMail);\n\t\t\t}\n\n\t\t\treturn this.setupGetParams(\n\t\t\t\tbuildQueryString(\n\t\t\t\t\tthis.urlRoot +\n\t\t\t\t\t\t'/' + encodeURIComponent(id) +\n\t\t\t\t\t\t'/reseller-hosting-data' +\n\t\t\t\t\t\tqs,\n\t\t\t\t\toptions\n\t\t\t\t),\n\t\t\t\ttrue\n\t\t\t)\n\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.resellerHostingData = ApiResellerHostingData;\n\n\t/**\n\t * Address Finder.\n\t */\n\tvar AddressFinder = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/address-search';\n\t\t},\n\n\t\t/**\n\t\t * Find addresses.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tfind: function (query, country, singlesummary, maximumresults, enablefacets, options) {\n\t\t\tconst params = new URLSearchParams({\n\t\t\t\tquery: query,\n\t\t\t\tcountry: country,\n\t\t\t\tsinglesummary: singlesummary,\n\t\t\t\tmaximumresults: maximumresults,\n\t\t\t\tenablefacets: enablefacets\n\t\t\t});\n\n\t\t\t// Replace + with %20 for better server compatibility\n\t\t\tvar encodedQueryString = params.toString().replace(/\\+/g, '%20');\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '?' + encodedQueryString,\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t},\n\n\t\t/**\n\t\t * Retrieve an address.\n\t\t *\n\t\t * @param {object} options Options to customise the request.\n\t\t *\n\t\t * @returns {Promise} returning the web forwarding data.\n\t\t */\n\t\tfetch: function (query, country, id, addtags, identifier, lines, options) {\n\t\t\tvar queryParams = {\n\t\t\t\tcountry: country,\n\t\t\t\tquery: query,\n\t\t\t\tid: id,\n\t\t\t\taddtags: addtags,\n\t\t\t\tidentifier: identifier,\n\t\t\t\tlines: lines\n\t\t\t};\n\t\t\tvar queryString = new URLSearchParams(queryParams);\n\n\t\t\t// Replace + with %20 for better server compatibility\n\t\t\tvar encodedQueryString = queryString.toString().replace(/\\+/g, '%20');\n\n\t\t\treturn this.setupGetParams(buildQueryString(\n\t\t\t\tthis.urlRoot + '/retrieve?' + encodedQueryString,\n\t\t\t\toptions\n\t\t\t), true)\n\t\t\t\t.then(this.dispatch.bind(this));\n\t\t}\n\t});\n\n\tapiStore.addressFinder = AddressFinder;\n\n\t/**\n\t * API Client class for managing authentication.\n\t *\n\t * Use-able directly and also used by some of the other classes to provide a JWT token header\n\t * during calls to endpoints that require authentication.\n\t *\n\t * General use involves specifying the authentication details using setAuthenticationDetails()\n\t * before then using other Rest API endpoint classes that require authentication.\n\t */\n\tvar ApiAuth = Api.extend({\n\t\tinitialize: function () {\n\t\t\tthis._super();\n\t\t\tthis.urlRoot = urlRoot + '/tokens';\n\t\t\tthis.defaultKey = urlKey;\n\t\t\tthis.fetchAuthDetails = function () { return false; };\n\t\t\tthis.jwtHeader = {};\n\t\t},\n\n\t\t/**\n\t\t * Set the callback that provides the credentials used for fetching JWT tokens.\n\t\t *\n\t\t * When called, the callback should return an object with a 'mode' key and then\n\t\t * mode-specific values. Authentication mode (set using the 'mode' key) can be\n\t\t * 'basic' or 'sso'.\n\t\t * In basic mode, a username key and a password key should be supplied.\n\t\t * In sso mode, a token key should be supplied with the current SSO auth token.\n\t\t *\n\t\t * @param {function} callback The authentication callback.\n\t\t */\n\t\tsetAuthenticationCallback: function (callback) {\n\t\t\tthis.fetchAuthDetails = callback;\n\t\t},\n\n\t\t/**\n\t\t * Authenticate with the credentials provided in the callback and return a JWT token header.\n\t\t *\n\t\t * @param {string} key Optional override of the default X-APIKEY value.\n\t\t *\n\t\t * @returns {Promise} Returning a jwt header string.\n\t\t */\n\t\tauthenticate: function (key) {\n\t\t\tvar self = this;\n\t\t\tif (_.isUndefined(key)) {\n\t\t\t\tkey = this.defaultKey;\n\t\t\t}\n\n\t\t\treturn this.setupPostParams(this.urlRoot, '', false, key)\n\t\t\t.then(function (params) {\n\t\t\t\tvar authHeader = '';\n\t\t\t\tvar details = self.fetchAuthDetails(key);\n\t\t\t\tif (details === false) {\n\t\t\t\t\tthrow new ApiError('Unable to generate authentication header for key \"' + key + '\"');\n\t\t\t\t}\n\t\t\t\tswitch (details.mode) {\n\t\t\t\t\tcase 'basic':\n\t\t\t\t\t\tauthHeader = 'Basic ' + window.btoa(details.username + ':' + details.password);\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'order':\n\t\t\t\t\t\tvar toBase64 = details.orderId + ':' + details.orderRef;\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t!_.isUndefined(appState.customerId)\n\t\t\t\t\t\t\t&& appState.customerId !== 0\n\t\t\t\t\t\t\t&& !_.isUndefined(appState.customerHash)\n\t\t\t\t\t\t\t&& appState.customerHash.length > 0\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\ttoBase64 += ':' + String(appState.customerId);\n\t\t\t\t\t\t\ttoBase64 += ':' + appState.customerHash;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tauthHeader = 'Order ' + window.btoa(toBase64);\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'sso':\n\t\t\t\t\t\tauthHeader = 'XSC ' + details.token;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tdefault:\n\t\t\t\t\t\t// do nothing for now\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (authHeader === '') {\n\t\t\t\t\tthrow new ApiError('Unable to generate authentication header');\n\t\t\t\t}\n\t\t\t\tparams.headers['Authorization'] = authHeader;\n\t\t\t\treturn params;\n\t\t\t})\n\t\t\t.then(self.dispatch.bind(this))\n\t\t\t.then(function (data) {\n\t\t\t\t// expire the token after 30 seconds.\n\t\t\t\t_.delay(function () { self.jwtHeader[key] = false; }, 30000);\n\t\t\t\treturn 'Bearer ' + data.token;\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return an existing JWT header string or fetch one if none exists.\n\t\t *\n\t\t * @param {string} key Optional override of the default X-APIKEY value.\n\t\t *\n\t\t * @returns {Promise} returning a JWT header string.\n\t\t */\n\t\tgetJwtHeader: function (key) {\n\t\t\tif (_.isUndefined(key)) {\n\t\t\t\tkey = this.defaultKey;\n\t\t\t}\n\t\t\tif (!this.jwtHeader[key]) {\n\t\t\t\tthis.jwtHeader[key] = this.authenticate(key);\n\t\t\t}\n\t\t\treturn this.jwtHeader[key];\n\t\t}\n\t});\n\n\tapiStore.auth = ApiAuth;\n\n\t// End of API endpoint definitions -----\n\n\t// Endpoint names whose constructors and singleton cache support legacy/v2 profiles.\n\tvar profileAwareEndpoints = {\n\t\tdomainSearchStream: true,\n\t\tdomainWhoisStream: true,\n\t\tdomainSearchReport: true\n\t};\n\n\t/**\n\t * Normalize and validate a supported domain endpoint profile.\n\t *\n\t * @param {DomainEndpointProfile} profile Optional endpoint profile.\n\t *\n\t * @returns {DomainEndpointProfile}\n\t */\n\tfunction normalizeEndpointProfile (profile) {\n\t\tif (_.isUndefined(profile)) {\n\t\t\treturn 'legacy';\n\t\t}\n\n\t\tif (profile !== 'legacy' && profile !== 'v2') {\n\t\t\tthrow new Error('Unsupported endpoint profile: ' + profile + '. Expected legacy or v2.');\n\t\t}\n\n\t\treturn profile;\n\t}\n\n\t/**\n\t * Build the URL root for an endpoint and its selected profile.\n\t *\n\t * @param {string}                endpointRoot The endpoint path without a leading slash.\n\t * @param {DomainEndpointProfile} profile      The normalized endpoint profile.\n\t *\n\t * @returns {string} The profile-specific URL root.\n\t */\n\tfunction profileUrlRoot (endpointRoot, profile) {\n\t\treturn urlRoot + '/' + endpointRoot + (profile === 'v2' ? '/v2' : '');\n\t}\n\n\t/**\n\t * Get a default set of params for async requests.\n\t *\n\t * @param {bool}   withAuthentication Whether to include the authentication header.\n\t * @param {string} apiKey             Optional override of the default X-APIKEY value.\n\t * @param {string} dataType           Optional override of the default Accept value.\n\t *\n\t * @returns {Promise}\n\t */\n\tfunction getClientParams (withAuthentication, apiKey, dataType) {\n\t\tif (_.isUndefined(apiKey)) {\n\t\t\tapiKey = urlKey;\n\t\t}\n\n\t\tif (_.isUndefined(dataType)) {\n\t\t\tdataType = 'application/json';\n\t\t}\n\n\t\tvar params = {\n\t\t\t'headers': {\n\t\t\t\t'X-APIKEY': apiKey,\n\t\t\t\t'X-APITIME': (new Date()).getTime(),\n\t\t\t\t'Accept': dataType\n\t\t\t},\n\t\t\t'type': 'POST',\n\t\t\t'uri': null,\n\t\t\t'data': ''\n\t\t};\n\t\tif (withAuthentication === true) {\n\t\t\treturn fetchSingleton('auth').getJwtHeader(apiKey)\n\t\t\t.then(function (authHeader) {\n\t\t\t\tparams.headers['Authorization'] = authHeader;\n\t\t\t\treturn params;\n\t\t\t});\n\t\t} else {\n\t\t\treturn Promise.resolve(params);\n\t\t}\n\t}\n\n\t/**\n\t * Build query string.\n\t *\n\t * @param {string} qs   \t Base query string to build on.\n\t * @param {string} options Data object containing API method options.\n\t *\n\t * @returns {string}\n\t */\n\tfunction buildQueryString (qs, options) {\n\t\toptions = options || {};\n\n\t\t// Ensure base query string exists\n\t\tif (_.isString(qs)) {\n\t\t\tif (qs.indexOf('?') === -1) {\n\t\t\t\tqs += '?'; // Base string does not contain a '?', append one so it can be built upon\n\t\t\t}\n\t\t} else {\n\t\t\tqs = '?';\n\t\t}\n\n\t\tif (options.includeEmbedded !== undefined) {\n\t\t\tdelete options.noChildren; // Either 'includeEmbedded' or 'noChildren', not both\n\t\t}\n\n\t\tvar allowedOpts = {\n\t\t\tattrs: 'attrs',\n\t\t\tcustomerId: 'customerId',\n\t\t\tcustomerHash: 'customerHash',\n\t\t\tfilters: 'filters',\n\t\t\tincludeEmbedded: 'includeEmbedded',\n\t\t\tincludeMultiDomain: 'includeMultiDomain',\n\t\t\tnoChildren: 'noChildren',\n\t\t\tproductUids: 'productUids',\n\t\t\tscanId: 'scanId',\n\t\t\tserviceUids: 'serviceUid',\n\t\t\tsetupId: 'setupId',\n\t\t\tsetupSite: 'setupSite',\n\t\t\ttraits: 'traits'\n\t\t};\n\n\t\tfor (var optName in allowedOpts) {\n\t\t\tif (options[optName] !== undefined && options[optName] !== null) {\n\t\t\t\tif (_.isArray(options[optName])) {\n\t\t\t\t\t_.each(options[optName], function (optVal) {\n\t\t\t\t\t\tqs += '&' + allowedOpts[optName] + '[]=' + encodeURIComponent(optVal);\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tqs += '&' + allowedOpts[optName] + '=' + encodeURIComponent(options[optName]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn qs.replace('?&', '?');\n\t}\n\n\tvar urlRoot;\n\tvar urlKey;\n\n\t/**\n\t * Set the shared connection details used by API endpoint instances.\n\t *\n\t * @param {object} details Connection details containing the API root and key.\n\t *\n\t * @returns {void}\n\t */\n\tfunction setConnectionDetails (details) {\n\t\turlRoot = details.root;\n\t\turlKey = details.key;\n\t}\n\n\tvar singletons = {};\n\n\t/**\n\t * Return the cached endpoint instance for an endpoint and optional profile.\n\t *\n\t * Profile-aware endpoints use a separate cache entry for each normalized\n\t * profile; all other endpoints retain their existing endpoint-name cache key.\n\t *\n\t * @param {string}                endpointName Registered endpoint name.\n\t * @param {DomainEndpointProfile} profile      Optional endpoint profile.\n\t *\n\t * @returns {object} Cached API endpoint instance.\n\t */\n\tfunction fetchSingleton (endpointName, profile) {\n\t\tvar cacheKey = endpointName;\n\t\tif (profileAwareEndpoints[endpointName]) {\n\t\t\tprofile = normalizeEndpointProfile(profile);\n\t\t\tcacheKey += ':' + profile;\n\t\t}\n\n\t\tif (!singletons.hasOwnProperty(cacheKey)) {\n\t\t\tsingletons[cacheKey] = new apiStore[endpointName](profile);\n\t\t}\n\t\treturn singletons[cacheKey];\n\t}\n\n\treturn {\n\t\t// Methods\n\t\tgetClientParameters: getClientParams,\n\t\tsetConnectionDetails: setConnectionDetails,\n\t\t// Endpoints\n\t\taccessControlRuleEndpoint: fetchSingleton.bind(null, 'accessControlRule'),\n\t\taddressBookEntryEndpoint: fetchSingleton.bind(null, 'addressBookEntry'),\n\t\tauth: fetchSingleton.bind(null, 'auth'),\n\t\tauthEndpoint: fetchSingleton.bind(null, 'auth'),\n\t\tbandwidthCharge: fetchSingleton.bind(null, 'bandwidthCharge'),\n\t\tbandwidthChargeEndpoint: fetchSingleton.bind(null, 'bandwidthCharge'),\n\t\tbasekitEndpoint: fetchSingleton.bind(null, 'basekit'),\n\t\tcard: fetchSingleton.bind(null, 'card'),\n\t\tcardEndpoint: fetchSingleton.bind(null, 'card'),\n\t\tconsumerWithdrawalEndpoint: fetchSingleton.bind(null, 'consumerWithdrawal'),\n\t\tcreditreceiptEndpoint: fetchSingleton.bind(null, 'creditReceipt'),\n\t\tcustomerEndpoint: fetchSingleton.bind(null, 'customer'),\n\t\tdirectDebit: fetchSingleton.bind(null, 'directDebit'),\n\t\tdirectDebitEndpoint: fetchSingleton.bind(null, 'directDebit'),\n\t\t/**\n\t\t * @param {DomainEndpointProfile} [profile] Endpoint profile.\n\t\t */\n\t\tdomainSearchReport: fetchSingleton.bind(null, 'domainSearchReport'),\n\t\t/**\n\t\t * @param {DomainEndpointProfile} [profile] Endpoint profile.\n\t\t */\n\t\tdomainSearchStreamEndpoint: fetchSingleton.bind(null, 'domainSearchStream'),\n\t\t/**\n\t\t * @param {DomainEndpointProfile} [profile] Endpoint profile.\n\t\t */\n\t\tdomainWhoisStreamEndpoint: fetchSingleton.bind(null, 'domainWhoisStream'),\n\t\tdomainSuggestions: fetchSingleton.bind(null, 'domainSuggestions'),\n\t\tdomainSearch: fetchSingleton.bind(null, 'domainSearch'),\n\t\tdomainSuffix: fetchSingleton.bind(null, 'domainSuffix'),\n\t\tdomainSuffixEndpoint: fetchSingleton.bind(null, 'domainSuffix'),\n\t\tdomainSuffixOffersEndpoint: fetchSingleton.bind(null, 'domainSuffixOffers'),\n\t\tdomainValidationEndpoint: fetchSingleton.bind(null, 'domainValidation'),\n\t\tdomainRegistrationEndpoint: fetchSingleton.bind(null, 'domainRegistration'),\n\t\tdudaEndpoint: fetchSingleton.bind(null, 'duda'),\n\t\temailEndpoint: fetchSingleton.bind(null, 'email'),\n\t\temailUserEndpoint: fetchSingleton.bind(null, 'emailUser'),\n\t\tecommerceEndpoint: fetchSingleton.bind(null, 'ecommerce'),\n\t\tforwarding: fetchSingleton.bind(null, 'forwarding'),\n\t\tforwardingDomain: fetchSingleton.bind(null, 'forwardingDomain'),\n\t\tforwardingEmail: fetchSingleton.bind(null, 'forwardingEmail'),\n\t\tforwardingEndpoint: fetchSingleton.bind(null, 'forwarding'),\n\t\thostingEndpoint: fetchSingleton.bind(null, 'hosting'),\n\t\thubspotEndpoint: fetchSingleton.bind(null, 'hubspot'),\n\t\tinvoiceEndpoint: fetchSingleton.bind(null, 'invoice'),\n\t\tlcnInvoiceEndpoint: fetchSingleton.bind(null, 'lcnInvoice'),\n\t\tlogosEndpoint: fetchSingleton.bind(null, 'logos'),\n\t\tmacalyEndpoint: fetchSingleton.bind(null, 'macaly'),\n\t\toffice365Endpoint: fetchSingleton.bind(null, 'office365'),\n\t\tonlineComplianceEndpoint: fetchSingleton.bind(null, 'onlineCompliance'),\n\t\tonlineComplianceScannerEndpoint: fetchSingleton.bind(null, 'onlineComplianceScanner'),\n\t\torder: fetchSingleton.bind(null, 'order'),\n\t\torderEndpoint: fetchSingleton.bind(null, 'order'),\n\t\tpackageEndpoint: fetchSingleton.bind(null, 'package'),\n\t\tpackageActivationEndpoint: fetchSingleton.bind(null, 'packageActivation'),\n\t\tpackageAllocationEndpoint: fetchSingleton.bind(null, 'packageAllocation'),\n\t\tproduct: fetchSingleton.bind(null, 'product'),\n\t\tproductEndpoint: fetchSingleton.bind(null, 'product'),\n\t\tquotaEndpoint: fetchSingleton.bind(null, 'quota'),\n\t\tmailboxEndpoint: fetchSingleton.bind(null, 'mailbox'),\n\t\trebill: fetchSingleton.bind(null, 'rebill'),\n\t\taddressFinder: fetchSingleton.bind(null, 'addressFinder'),\n\t\tresellerHostingDataEndpoint: fetchSingleton.bind(null, 'resellerHostingData'),\n\t\tserviceEndpoint: fetchSingleton.bind(null, 'service'),\n\t\tsetupEndpoint: fetchSingleton.bind(null, 'setup'),\n\t\tsimplybookEndpoint: fetchSingleton.bind(null, 'simplybook'),\n\t\tsitemakerEndpoint: fetchSingleton.bind(null, 'sitemaker'),\n\t\tsuffix: fetchSingleton.bind(null, 'suffix'),\n\t\tsuffixEndpoint: fetchSingleton.bind(null, 'suffix'),\n\t\tticketEndpoint: fetchSingleton.bind(null, 'ticket'),\n\t\twebAccessibilityEndpoint: fetchSingleton.bind(null, 'webAccessibility')\n\t};\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/dada-rest-api/src/api.js\n// module id = 7\n// module chunks = 4","\"use strict\";\nvar old;\nif (typeof Promise !== \"undefined\") old = Promise;\nfunction noConflict() {\n    try { if (Promise === bluebird) Promise = old; }\n    catch (e) {}\n    return bluebird;\n}\nvar bluebird = require(\"./promise\")();\nbluebird.noConflict = noConflict;\nmodule.exports = bluebird;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/bluebird.js\n// module id = 10\n// module chunks = 4","/*!\n * jQuery JavaScript Library v3.7.1\n * https://jquery.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2023-08-28T13:37Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket trac-14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\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\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n\t\t// Support: Chrome <=57, Firefox <=52\n\t\t// In some browsers, typeof returns \"function\" for HTML <object> elements\n\t\t// (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n\t\t// We don't want to classify *any* DOM node as a function.\n\t\t// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5\n\t\t// Plus for old WebKit, typeof returns \"function\" for HTML collections\n\t\t// (e.g., `typeof document.getElementsByTagName(\"div\") === \"function\"`). (gh-4756)\n\t\treturn typeof obj === \"function\" && typeof obj.nodeType !== \"number\" &&\n\t\t\ttypeof obj.item !== \"function\";\n\t};\n\n\nvar isWindow = function isWindow( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t};\n\n\nvar document = window.document;\n\n\n\n\tvar preservedScriptAttributes = {\n\t\ttype: true,\n\t\tsrc: true,\n\t\tnonce: true,\n\t\tnoModule: true\n\t};\n\n\tfunction DOMEval( code, node, doc ) {\n\t\tdoc = doc || document;\n\n\t\tvar i, val,\n\t\t\tscript = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tif ( node ) {\n\t\t\tfor ( i in preservedScriptAttributes ) {\n\n\t\t\t\t// Support: Firefox 64+, Edge 18+\n\t\t\t\t// Some browsers don't support the \"nonce\" property on scripts.\n\t\t\t\t// On the other hand, just using `getAttribute` is not enough as\n\t\t\t\t// the `nonce` attribute is reset to an empty string whenever it\n\t\t\t\t// becomes browsing-context connected.\n\t\t\t\t// See https://github.com/whatwg/html/issues/2369\n\t\t\t\t// See https://html.spec.whatwg.org/#nonce-attributes\n\t\t\t\t// The `node.getAttribute` check was added for the sake of\n\t\t\t\t// `jQuery.globalEval` so that it can fake a nonce-containing node\n\t\t\t\t// via an object.\n\t\t\t\tval = node[ i ] || node.getAttribute && node.getAttribute( i );\n\t\t\t\tif ( val ) {\n\t\t\t\t\tscript.setAttribute( i, val );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\t// Support: Android <=2.3 only (functionish RegExp)\n\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof 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\nvar version = \"3.7.1\",\n\n\trhtmlSuffix = /HTML$/i,\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\n\t// Retrieve the text value of an array of DOM nodes\n\ttext: function( elem ) {\n\t\tvar node,\n\t\t\tret = \"\",\n\t\t\ti = 0,\n\t\t\tnodeType = elem.nodeType;\n\n\t\tif ( !nodeType ) {\n\n\t\t\t// If no nodeType, this is expected to be an array\n\t\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t\t// Do not traverse comment nodes\n\t\t\t\tret += jQuery.text( node );\n\t\t\t}\n\t\t}\n\t\tif ( nodeType === 1 || nodeType === 11 ) {\n\t\t\treturn elem.textContent;\n\t\t}\n\t\tif ( nodeType === 9 ) {\n\t\t\treturn elem.documentElement.textContent;\n\t\t}\n\t\tif ( nodeType === 3 || nodeType === 4 ) {\n\t\t\treturn elem.nodeValue;\n\t\t}\n\n\t\t// Do not include comment or processing instruction nodes\n\n\t\treturn ret;\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tisXMLDoc: function( elem ) {\n\t\tvar namespace = elem && elem.namespaceURI,\n\t\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t\t// Assume HTML when documentElement doesn't yet exist, such as inside\n\t\t// document fragments.\n\t\treturn !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n\t},\n\n\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t// push.apply(_, arraylike) throws on ancient WebKit\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\n\tfunction( _i, name ) {\n\t\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\t} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: real iOS 8.2 only (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( isFunction( obj ) || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\n\n\nfunction nodeName( elem, name ) {\n\n\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n}\nvar pop = arr.pop;\n\n\nvar sort = arr.sort;\n\n\nvar splice = arr.splice;\n\n\nvar whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\";\n\n\nvar rtrimCSS = new RegExp(\n\t\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\",\n\t\"g\"\n);\n\n\n\n\n// Note: an element does not contain itself\njQuery.contains = function( a, b ) {\n\tvar bup = b && b.parentNode;\n\n\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE doesn't have `contains` on SVG.\n\t\ta.contains ?\n\t\t\ta.contains( bup ) :\n\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t) );\n};\n\n\n\n\n// CSS string/identifier serialization\n// https://drafts.csswg.org/cssom/#common-serializing-idioms\nvar rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g;\n\nfunction fcssescape( ch, asCodePoint ) {\n\tif ( asCodePoint ) {\n\n\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\tif ( ch === \"\\0\" ) {\n\t\t\treturn \"\\uFFFD\";\n\t\t}\n\n\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t}\n\n\t// Other potentially-special ASCII characters get backslash-escaped\n\treturn \"\\\\\" + ch;\n}\n\njQuery.escapeSelector = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\n\n\n\nvar preferredDoc = document,\n\tpushNative = push;\n\n( function() {\n\nvar i,\n\tExpr,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\tpush = pushNative,\n\n\t// Local document vars\n\tdocument,\n\tdocumentElement,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\tmatches,\n\n\t// Instance-specific data\n\texpando = jQuery.expando,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|\" +\n\t\t\"loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n\tidentifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n\t// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\t\twhitespace + \"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trleadingCombinator = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" +\n\t\twhitespace + \"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\tID: new RegExp( \"^#(\" + identifier + \")\" ),\n\t\tCLASS: new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\tTAG: new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\tATTR: new RegExp( \"^\" + attributes ),\n\t\tPSEUDO: new RegExp( \"^\" + pseudos ),\n\t\tCHILD: new RegExp(\n\t\t\t\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\tbool: new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\tneedsContext: new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\tif ( nonHex ) {\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\treturn nonHex;\n\t\t}\n\n\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t// Support: IE <=11+\n\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t// surrogate pair\n\t\treturn high < 0 ?\n\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// Used for iframes; see `setDocument`.\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE/Edge.\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && nodeName( elem, \"fieldset\" );\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Support: IE <=9 only\n// Accessing document.activeElement can throw unexpectedly\n// https://bugs.jquery.com/ticket/13393\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t( arr = slice.call( preferredDoc.childNodes ) ),\n\t\tpreferredDoc.childNodes\n\t);\n\n\t// Support: Android <=4.0\n\t// Detect silently failing push.apply\n\t// eslint-disable-next-line no-unused-expressions\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = {\n\t\tapply: function( target, els ) {\n\t\t\tpushNative.apply( target, slice.call( els ) );\n\t\t},\n\t\tcall: function( target ) {\n\t\t\tpushNative.apply( target, slice.call( arguments, 1 ) );\n\t\t}\n\t};\n}\n\nfunction find( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\n\t\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tfind.contains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( !nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// We can use :scope instead of the ID hack if the browser\n\t\t\t\t\t// supports it & if we're not changing the context.\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when\n\t\t\t\t\t// strict-comparing two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( newContext != context || !support.scope ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = jQuery.escapeSelector( nid );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrimCSS, \"$1\" ), context, results, seed );\n}\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 */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties\n\t\t// (see https://github.com/jquery/sizzle/issues/157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by jQuery selector module\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement( \"fieldset\" );\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch ( e ) {\n\t\treturn false;\n\t} finally {\n\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn nodeName( elem, \"input\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn ( nodeName( elem, \"input\" ) || nodeName( elem, \"button\" ) ) &&\n\t\t\telem.type === type;\n\t};\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 */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11+\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Checks a node for validity as a jQuery selector context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [node] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nfunction setDocument( node ) {\n\tvar subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocumentElement = document.documentElement;\n\tdocumentIsHTML = !jQuery.isXMLDoc( document );\n\n\t// Support: iOS 7 only, IE 9 - 11+\n\t// Older browsers didn't support unprefixed `matches`.\n\tmatches = documentElement.matches ||\n\t\tdocumentElement.webkitMatchesSelector ||\n\t\tdocumentElement.msMatchesSelector;\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors\n\t// (see trac-13936).\n\t// Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`,\n\t// all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well.\n\tif ( documentElement.msMatchesSelector &&\n\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tpreferredDoc != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t\tsubWindow.addEventListener( \"unload\", unloadHandler );\n\t}\n\n\t// Support: IE <10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert( function( el ) {\n\t\tdocumentElement.appendChild( el ).id = jQuery.expando;\n\t\treturn !document.getElementsByName ||\n\t\t\t!document.getElementsByName( jQuery.expando ).length;\n\t} );\n\n\t// Support: IE 9 only\n\t// Check to see if it's possible to do matchesSelector\n\t// on a disconnected node.\n\tsupport.disconnectedMatch = assert( function( el ) {\n\t\treturn matches.call( el, \"*\" );\n\t} );\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// IE/Edge don't support the :scope pseudo-class.\n\tsupport.scope = assert( function() {\n\t\treturn document.querySelectorAll( \":scope\" );\n\t} );\n\n\t// Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only\n\t// Make sure the `:has()` argument is parsed unforgivingly.\n\t// We include `*` in the test to detect buggy implementations that are\n\t// _selectively_ forgiving (specifically when the list includes at least\n\t// one valid selector).\n\t// Note that we treat complete lack of support for `:has()` as if it were\n\t// spec-compliant support, which is fine because use of `:has()` in such\n\t// environments will fail in the qSA path and fall back to jQuery traversal\n\t// anyway.\n\tsupport.cssHas = assert( function() {\n\t\ttry {\n\t\t\tdocument.querySelector( \":has(*,:jqfake)\" );\n\t\t\treturn false;\n\t\t} catch ( e ) {\n\t\t\treturn true;\n\t\t}\n\t} );\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter.ID = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter.ID =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode( \"id\" );\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( ( elem = elems[ i++ ] ) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find.TAG = function( tag, context ) {\n\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t// DocumentFragment nodes don't have gEBTN\n\t\t} else {\n\t\t\treturn context.querySelectorAll( tag );\n\t\t}\n\t};\n\n\t// Class\n\tExpr.find.CLASS = function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\trbuggyQSA = [];\n\n\t// Build QSA regex\n\t// Regex strategy adopted from Diego Perini\n\tassert( function( el ) {\n\n\t\tvar input;\n\n\t\tdocumentElement.appendChild( el ).innerHTML =\n\t\t\t\"<a id='\" + expando + \"' href='' disabled='disabled'></a>\" +\n\t\t\t\"<select id='\" + expando + \"-\\r\\\\' disabled='disabled'>\" +\n\t\t\t\"<option selected=''></option></select>\";\n\n\t\t// Support: iOS <=7 - 8 only\n\t\t// Boolean attributes and \"value\" are not treated correctly in some XML documents\n\t\tif ( !el.querySelectorAll( \"[selected]\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t}\n\n\t\t// Support: iOS <=7 - 8 only\n\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\trbuggyQSA.push( \"~=\" );\n\t\t}\n\n\t\t// Support: iOS 8 only\n\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\trbuggyQSA.push( \".#.+[+~]\" );\n\t\t}\n\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tif ( !el.querySelectorAll( \":checked\" ).length ) {\n\t\t\trbuggyQSA.push( \":checked\" );\n\t\t}\n\n\t\t// Support: Windows 8 Native Apps\n\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tdocumentElement.appendChild( el ).disabled = true;\n\t\tif ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\n\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t}\n\n\t\t// Support: IE 11+, Edge 15 - 18+\n\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t// Adding a temporary attribute to the document before the selection works\n\t\t// around the issue.\n\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"name\", \"\" );\n\t\tel.appendChild( input );\n\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\n\t\t}\n\t} );\n\n\tif ( !support.cssHas ) {\n\n\t\t// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+\n\t\t// Our regular `try-catch` mechanism fails to detect natively-unsupported\n\t\t// pseudo-classes inside `:has()` (such as `:has(:contains(\"Foo\"))`)\n\t\t// in browsers that parse the `:has()` argument as a forgiving selector list.\n\t\t// https://drafts.csswg.org/selectors/#relational now requires the argument\n\t\t// to be parsed unforgivingly, but browsers have not yet fully adjusted.\n\t\trbuggyQSA.push( \":has\" );\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = function( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( a === document || a.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, a ) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( b === document || b.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, b ) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t};\n\n\treturn document;\n}\n\nfind.matches = function( expr, elements ) {\n\treturn find( expr, null, null, elements );\n};\n\nfind.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn find( expr, document, null, [ elem ] ).length > 0;\n};\n\nfind.contains = function( context, elem ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( context.ownerDocument || context ) != document ) {\n\t\tsetDocument( context );\n\t}\n\treturn jQuery.contains( context, elem );\n};\n\n\nfind.attr = function( elem, name ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( elem.ownerDocument || elem ) != document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\n\t\t// Don't get fooled by Object.prototype properties (see trac-13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\tif ( val !== undefined ) {\n\t\treturn val;\n\t}\n\n\treturn elem.getAttribute( name );\n};\n\nfind.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\njQuery.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\t//\n\t// Support: Android <=4.0+\n\t// Testing for detecting duplicates is unpredictable so instead assume we can't\n\t// depend on duplicate detection in all browsers without a stable sort.\n\thasDuplicate = !support.sortStable;\n\tsortInput = !support.sortStable && slice.call( results, 0 );\n\tsort.call( results, sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tsplice.call( results, duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\njQuery.fn.uniqueSort = function() {\n\treturn this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );\n};\n\nExpr = jQuery.expr = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\tATTR: function( match ) {\n\t\t\tmatch[ 1 ] = match[ 1 ].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || \"\" )\n\t\t\t\t.replace( runescape, funescape );\n\n\t\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\tCHILD: function( match ) {\n\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" )\n\t\t\t\t);\n\t\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[ 3 ] ) {\n\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\tPSEUDO: function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\t\tif ( matchExpr.CHILD.test( match[ 0 ] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[ 3 ] ) {\n\t\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length ) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\tTAG: function( nodeNameSelector ) {\n\t\t\tvar expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn nodeName( elem, expectedNodeName );\n\t\t\t\t};\n\t\t},\n\n\t\tCLASS: function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace + \")\" + className +\n\t\t\t\t\t\"(\" + whitespace + \"|$)\" ) ) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\tATTR: function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = find.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\tif ( operator === \"=\" ) {\n\t\t\t\t\treturn result === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"!=\" ) {\n\t\t\t\t\treturn result !== check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"^=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) === 0;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"*=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"$=\" ) {\n\t\t\t\t\treturn check && result.slice( -check.length ) === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"~=\" ) {\n\t\t\t\t\treturn ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" )\n\t\t\t\t\t\t.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"|=\" ) {\n\t\t\t\t\treturn result === check || result.slice( 0, check.length + 1 ) === check + \"-\";\n\t\t\t\t}\n\n\t\t\t\treturn false;\n\t\t\t};\n\t\t},\n\n\t\tCHILD: function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\t\t\t\t\t\t\touterCache = parent[ expando ] || ( parent[ expando ] = {} );\n\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\t\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ expando ] = {} );\n\t\t\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\tPSEUDO: function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// https://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tfind.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as jQuery does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction( function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf.call( seed, matched[ i ] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[ i ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} ) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\tnot: markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrimCSS, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element\n\t\t\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\thas: markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn find( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\tcontains: markFunction( function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// https://www.w3.org/TR/selectors/#lang-pseudo\n\t\tlang: markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tfind.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\ttarget: function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\troot: function( elem ) {\n\t\t\treturn elem === documentElement;\n\t\t},\n\n\t\tfocus: function( elem ) {\n\t\t\treturn elem === safeActiveElement() &&\n\t\t\t\tdocument.hasFocus() &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\tenabled: createDisabledPseudo( false ),\n\t\tdisabled: createDisabledPseudo( true ),\n\n\t\tchecked: function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\treturn ( nodeName( elem, \"input\" ) && !!elem.checked ) ||\n\t\t\t\t( nodeName( elem, \"option\" ) && !!elem.selected );\n\t\t},\n\n\t\tselected: function( elem ) {\n\n\t\t\t// Support: IE <=11+\n\t\t\t// Accessing the selectedIndex property\n\t\t\t// forces the browser to treat the default option as\n\t\t\t// selected when in an optgroup.\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\tempty: function( elem ) {\n\n\t\t\t// https://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\tparent: function( elem ) {\n\t\t\treturn !Expr.pseudos.empty( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\theader: function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\tinput: function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\tbutton: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"button\" ||\n\t\t\t\tnodeName( elem, \"button\" );\n\t\t},\n\n\t\ttext: function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"text\" &&\n\n\t\t\t\t// Support: IE <10 only\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear\n\t\t\t\t// with elem.type === \"text\"\n\t\t\t\t( ( attr = elem.getAttribute( \"type\" ) ) == null ||\n\t\t\t\t\tattr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\tfirst: createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\tlast: createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\teq: createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\teven: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\todd: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tlt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i;\n\n\t\t\tif ( argument < 0 ) {\n\t\t\t\ti = argument + length;\n\t\t\t} else if ( argument > length ) {\n\t\t\t\ti = length;\n\t\t\t} else {\n\t\t\t\ti = argument;\n\t\t\t}\n\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tgt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\nExpr.pseudos.nth = Expr.pseudos.eq;\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\nfunction tokenize( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rleadingCombinator.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrimCSS, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\tif ( parseOnly ) {\n\t\treturn soFar.length;\n\t}\n\n\treturn soFar ?\n\t\tfind.error( selector ) :\n\n\t\t// Cache the tokens\n\t\ttokenCache( selector, groups ).slice( 0 );\n}\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\n\t\t\t\t\t\tif ( skip && nodeName( elem, skip ) ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = outerCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\touterCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tfind( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem, matcherOut,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed ||\n\t\t\t\tmultipleContexts( selector || \"*\",\n\t\t\t\t\tcontext.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems;\n\n\t\tif ( matcher ) {\n\n\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter\n\t\t\t// or preexisting results,\n\t\t\tmatcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t[] :\n\n\t\t\t\t// ...otherwise use results directly\n\t\t\t\tresults;\n\n\t\t\t// Find primary matches\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t} else {\n\t\t\tmatcherOut = matcherIn;\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf.call( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tvar ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element\n\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 )\n\t\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrimCSS, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find.TAG( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: iOS <=7 - 9 only\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching\n\t\t\t// elements by id. (see trac-14142)\n\t\t\tfor ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tjQuery.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\nfunction compile( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n}\n\n/**\n * A low-level selection function that works with jQuery's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with jQuery selector compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nfunction select( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find.ID(\n\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\tcontext\n\t\t\t) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = Expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) || context\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n}\n\n// One-time assignments\n\n// Support: Android <=4.0 - 4.1+\n// Sort stability\nsupport.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Android <=4.0 - 4.1+\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert( function( el ) {\n\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement( \"fieldset\" ) ) & 1;\n} );\n\njQuery.find = find;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.unique = jQuery.uniqueSort;\n\n// These have always been private, but they used to be documented as part of\n// Sizzle so let's maintain them for now for backwards compatibility purposes.\nfind.compile = compile;\nfind.select = select;\nfind.setDocument = setDocument;\nfind.tokenize = tokenize;\n\nfind.escape = jQuery.escapeSelector;\nfind.getText = jQuery.text;\nfind.isXML = jQuery.isXMLDoc;\nfind.selectors = jQuery.expr;\nfind.support = jQuery.support;\nfind.uniqueSort = jQuery.uniqueSort;\n\n\t/* eslint-enable */\n\n} )();\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\nvar rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\n\n\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)\n\t// Strict HTML recognition (trac-11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to jQuery#find\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// <object> elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\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 */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && isFunction( ( method = value.promise ) ) ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && isFunction( ( method = value.then ) ) ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\n\t\t// Support: Android 4.0 only\n\t\t// Strict mode functions invoked without .call/.apply get global-object context\n\t\treject.apply( undefined, [ value ] );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\t\"catch\": function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( _i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( isFunction( then ) ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.error );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the error, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getErrorHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getErrorHook();\n\n\t\t\t\t\t\t\t\t// The deprecated alias of the above. While the name suggests\n\t\t\t\t\t\t\t\t// returning the stack, not an error instance, jQuery just passes\n\t\t\t\t\t\t\t\t// it directly to `console.warn` so both will work; an instance\n\t\t\t\t\t\t\t\t// just better cooperates with source maps.\n\t\t\t\t\t\t\t\t} else if ( jQuery.Deferred.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getStackHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onProgress ) ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onFulfilled ) ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onRejected ) ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the primary Deferred\n\t\t\tprimary = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tprimary.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( primary.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn primary.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );\n\t\t}\n\n\t\treturn primary.promise();\n\t}\n} );\n\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error\n// captured before the async barrier to get the original error cause\n// which may otherwise be hidden.\njQuery.Deferred.exceptionHook = function( error, asyncError ) {\n\n\t// Support: IE 8 - 9 only\n\t// Console exists when dev tools are open, which can happen at any time\n\tif ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn( \"jQuery.Deferred exception: \" + error.message,\n\t\t\terror.stack, asyncError );\n\t}\n};\n\n\n\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n\n\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See trac-6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\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\nif ( document.readyState === \"complete\" ||\n\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, _key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\t\tvalue :\n\t\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n};\n\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\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 (trac-9572)\nfunction camelCase( string ) {\n\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n}\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see trac-8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\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\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11 only\n\t\t\t\t\t\t// The attrs elements can be null (trac-14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar documentElement = document.documentElement;\n\n\n\n\tvar isAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t\t},\n\t\tcomposed = { composed: true };\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n\t// Check attachment across shadow DOM boundaries when possible (gh-3504)\n\t// Support: iOS 10.0-10.2 only\n\t// Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n\t// leading to errors. We need to check for `getRootNode`.\n\tif ( documentElement.getRootNode ) {\n\t\tisAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t\t};\n\t}\nvar isHiddenWithinTree = function( elem, el ) {\n\n\t\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\n\t\t// Inline style trumps all\n\t\treturn elem.style.display === \"none\" ||\n\t\t\telem.style.display === \"\" &&\n\n\t\t\t// Otherwise, check computed style\n\t\t\t// Support: Firefox <=43 - 45\n\t\t\t// Disconnected elements can have computed display: none, so first confirm that elem is\n\t\t\t// in the document.\n\t\t\tisAttached( elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = elem.nodeType &&\n\t\t\t( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i );\n\nvar rscriptType = ( /^$|^module$|\\/(?:java|ecma)script/i );\n\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0 - 4.3 only\n\t// Check state lost if the name is set (trac-11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (trac-14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Android <=4.1 only\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE <=11 only\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\n\t// Support: IE <=9 only\n\t// IE <=9 replaces <option> tags with their contents when inserted outside of\n\t// the select element.\n\tdiv.innerHTML = \"<option></option>\";\n\tsupport.option = !!div.lastChild;\n} )();\n\n\n// We have to close these tags to support XHTML (trac-13200)\nvar wrapMap = {\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n// Support: IE <=9 only\nif ( !support.option ) {\n\twrapMap.optgroup = wrapMap.option = [ 1, \"<select multiple='multiple'>\", \"</select>\" ];\n}\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11 only\n\t// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\tret = context.getElementsByTagName( tag || \"*\" );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, attached, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (trac-12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tattached = isAttached( elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( attached ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\nvar rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\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 */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = Object.create( null );\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t)[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: IE <=9\n\t\t\t// Black-hole SVG <use> instance trees (trac-13180)\n\t\t\tcur.nodeType &&\n\n\t\t\t// Support: Firefox <=42\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11 only\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (trac-13208)\n\t\t\t\t// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (trac-13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", true );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\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.\nfunction leverageNative( el, type, isSetup ) {\n\n\t// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !isSetup ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\tif ( !saved ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object), so this array\n\t\t\t\t\t// will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tdataPriv.set( this, type, false );\n\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\n\t\t\t\t\t\treturn result;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling surrogate\n\t\t\t\t// (focus or blur), assume that the surrogate already propagated from triggering\n\t\t\t\t// the native event and prevent that from happening again here.\n\t\t\t\t// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n\t\t\t\t// bubbling surrogate propagates *after* the non-bubbling base), but that seems\n\t\t\t\t// less bad than duplication.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order\n\t\t\t// Fire an inner synthetic event with the original arguments\n\t\t\t} else if ( saved ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, jQuery.event.trigger(\n\t\t\t\t\tsaved[ 0 ],\n\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\tthis\n\t\t\t\t) );\n\n\t\t\t\t// Abort handling of the native event by all jQuery handlers while allowing\n\t\t\t\t// native handlers on the same element to run. On target, this is achieved\n\t\t\t\t// by stopping immediate propagation just on the jQuery event. However,\n\t\t\t\t// the native event is re-wrapped by a jQuery one on each level of the\n\t\t\t\t// propagation so the only way to stop it for jQuery is to stop it for\n\t\t\t\t// everyone via native `stopPropagation()`. This is not a problem for\n\t\t\t\t// focus/blur which don't bubble, but it does also stop click on checkboxes\n\t\t\t\t// and radios. We accept this limitation.\n\t\t\t\tevent.stopPropagation();\n\t\t\t\tevent.isImmediatePropagationStopped = returnTrue;\n\t\t\t}\n\t\t}\n\t} );\n}\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android <=2.3 only\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\t// Support: Safari <=6 - 7 only\n\t\t// Target should not be a text node (trac-504, trac-13143)\n\t\tthis.target = ( src.target && src.target.nodeType === 3 ) ?\n\t\t\tsrc.target.parentNode :\n\t\t\tsrc.target;\n\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\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\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcode: true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\twhich: true\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\n\tfunction focusMappedHandler( nativeEvent ) {\n\t\tif ( document.documentMode ) {\n\n\t\t\t// Support: IE 11+\n\t\t\t// Attach a single focusin/focusout handler on the document while someone wants\n\t\t\t// focus/blur. This is because the former are synchronous in IE while the latter\n\t\t\t// are async. In other browsers, all those handlers are invoked synchronously.\n\n\t\t\t// `handle` from private data would already wrap the event, but we need\n\t\t\t// to change the `type` here.\n\t\t\tvar handle = dataPriv.get( this, \"handle\" ),\n\t\t\t\tevent = jQuery.event.fix( nativeEvent );\n\t\t\tevent.type = nativeEvent.type === \"focusin\" ? \"focus\" : \"blur\";\n\t\t\tevent.isSimulated = true;\n\n\t\t\t// First, handle focusin/focusout\n\t\t\thandle( nativeEvent );\n\n\t\t\t// ...then, handle focus/blur\n\t\t\t//\n\t\t\t// focus/blur don't bubble while focusin/focusout do; simulate the former by only\n\t\t\t// invoking the handler at the lower level.\n\t\t\tif ( event.target === event.currentTarget ) {\n\n\t\t\t\t// The setup part calls `leverageNative`, which, in turn, calls\n\t\t\t\t// `jQuery.event.add`, so event handle will already have been set\n\t\t\t\t// by this point.\n\t\t\t\thandle( event );\n\t\t\t}\n\t\t} else {\n\n\t\t\t// For non-IE browsers, attach a single capturing handler on the document\n\t\t\t// while someone wants focusin/focusout.\n\t\t\tjQuery.event.simulate( delegateType, nativeEvent.target,\n\t\t\t\tjQuery.event.fix( nativeEvent ) );\n\t\t}\n\t}\n\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\tvar attaches;\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, true );\n\n\t\t\tif ( document.documentMode ) {\n\n\t\t\t\t// Support: IE 9 - 11+\n\t\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\t\tattaches = dataPriv.get( this, delegateType );\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t}\n\t\t\t\tdataPriv.set( this, delegateType, ( attaches || 0 ) + 1 );\n\t\t\t} else {\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tvar attaches;\n\n\t\t\tif ( document.documentMode ) {\n\t\t\t\tattaches = dataPriv.get( this, delegateType ) - 1;\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t\tdataPriv.remove( this, delegateType );\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.set( this, delegateType, attaches );\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Return false to indicate standard teardown should be applied\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\n\t\t// Suppress native focus or blur if we're currently inside\n\t\t// a leveraged native-event stack\n\t\t_default: function( event ) {\n\t\t\treturn dataPriv.get( event.target, type );\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n\n\t// Support: Firefox <=44\n\t// Firefox doesn't have focus(in | out) events\n\t// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n\t//\n\t// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n\t// focus(in | out) events fire after focus & blur events,\n\t// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n\t// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\n\t//\n\t// Support: IE 9 - 11+\n\t// To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch,\n\t// attach a single handler for both events in IE.\n\tjQuery.event.special[ delegateType ] = {\n\t\tsetup: function() {\n\n\t\t\t// Handle: regular nodes (via `this.ownerDocument`), window\n\t\t\t// (via `this.document`) & document (via `this`).\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType );\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.addEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t}\n\t\t\tdataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 );\n\t\t},\n\t\tteardown: function() {\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType ) - 1;\n\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.removeEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( dataHolder, delegateType );\n\t\t\t} else {\n\t\t\t\tdataPriv.set( dataHolder, delegateType, attaches );\n\t\t\t}\n\t\t}\n\t};\n} );\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).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\n\t// Support: IE <=10 - 11, Edge 12 - 13 only\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\n\trcleanScript = /^\\s*<!\\[CDATA\\[|\\]\\]>\\s*$/g;\n\n// Prefer a tbody over its parent table for containing new rows\nfunction manipulationTarget( elem, content ) {\n\tif ( nodeName( elem, \"table\" ) &&\n\t\tnodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\n\n\t\treturn jQuery( elem ).children( \"tbody\" )[ 0 ] || elem;\n\t}\n\n\treturn elem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.get( src );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdataPriv.remove( dest, \"handle events\" );\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = flat( args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( valueIsFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (trac-8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Re-enable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce || node.getAttribute( \"nonce\" )\n\t\t\t\t\t\t\t\t}, doc );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Unwrap a CDATA section containing script contents. This shouldn't be\n\t\t\t\t\t\t\t// needed as in XML documents they're already not visible when\n\t\t\t\t\t\t\t// inspecting element contents and in HTML documents they have no\n\t\t\t\t\t\t\t// meaning but we're preserving that logic for backwards compatibility.\n\t\t\t\t\t\t\t// This will be removed completely in 4.0. See gh-4904.\n\t\t\t\t\t\t\tDOMEval( node.textContent.replace( rcleanScript, \"\" ), node, doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && isAttached( node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html;\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = isAttached( elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew jQuery#find here for performance reasons:\n\t\t\t// https://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t// .get() because push.apply(_, arraylike) throws on ancient WebKit\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar rcustomProp = /^--/;\n\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar swap = function( elem, options, callback ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.call( elem );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\nvar rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\n\n\n\n( function() {\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\n\t\t// This is a singleton, we need to execute it only once\n\t\tif ( !div ) {\n\t\t\treturn;\n\t\t}\n\n\t\tcontainer.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n\t\t\t\"margin-top:1px;padding:0;border:0\";\n\t\tdiv.style.cssText =\n\t\t\t\"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"width:60%;top:1%\";\n\t\tdocumentElement.appendChild( container ).appendChild( div );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\n\t\t// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\t\treliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;\n\n\t\t// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.right = \"60%\";\n\t\tpixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\n\n\t\t// Support: IE 9 - 11 only\n\t\t// Detect misreporting of content dimensions for box-sizing:border-box elements\n\t\tboxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\n\n\t\t// Support: IE 9 only\n\t\t// Detect overflow:scroll screwiness (gh-3699)\n\t\t// Support: Chrome <=64\n\t\t// Don't get tricked when zoom affects offsetWidth (gh-4029)\n\t\tdiv.style.position = \"absolute\";\n\t\tscrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;\n\n\t\tdocumentElement.removeChild( container );\n\n\t\t// Nullify the div so it wouldn't be stored in the memory and\n\t\t// it will also be a sign that checks already performed\n\t\tdiv = null;\n\t}\n\n\tfunction roundPixelMeasures( measure ) {\n\t\treturn Math.round( parseFloat( measure ) );\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\n\t\treliableTrDimensionsVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE <=9 - 11 only\n\t// Style of cloned element affects source element cloned (trac-8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tjQuery.extend( support, {\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelBoxStyles: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelBoxStylesVal;\n\t\t},\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\tscrollboxSize: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn scrollboxSizeVal;\n\t\t},\n\n\t\t// Support: IE 9 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Behavior in IE 9 is more subtle than in newer versions & it passes\n\t\t// some versions of this test; make sure not to make it pass there!\n\t\t//\n\t\t// Support: Firefox 70+\n\t\t// Only Firefox includes border widths\n\t\t// in computed dimensions. (gh-4529)\n\t\treliableTrDimensions: function() {\n\t\t\tvar table, tr, trChild, trStyle;\n\t\t\tif ( reliableTrDimensionsVal == null ) {\n\t\t\t\ttable = document.createElement( \"table\" );\n\t\t\t\ttr = document.createElement( \"tr\" );\n\t\t\t\ttrChild = document.createElement( \"div\" );\n\n\t\t\t\ttable.style.cssText = \"position:absolute;left:-11111px;border-collapse:separate\";\n\t\t\t\ttr.style.cssText = \"box-sizing:content-box;border:1px solid\";\n\n\t\t\t\t// Support: Chrome 86+\n\t\t\t\t// Height set through cssText does not get applied.\n\t\t\t\t// Computed height then comes back as 0.\n\t\t\t\ttr.style.height = \"1px\";\n\t\t\t\ttrChild.style.height = \"9px\";\n\n\t\t\t\t// Support: Android 8 Chrome 86+\n\t\t\t\t// In our bodyBackground.html iframe,\n\t\t\t\t// display for all div elements is set to \"inline\",\n\t\t\t\t// which causes a problem only in Android 8 Chrome 86.\n\t\t\t\t// Ensuring the div is `display: block`\n\t\t\t\t// gets around this issue.\n\t\t\t\ttrChild.style.display = \"block\";\n\n\t\t\t\tdocumentElement\n\t\t\t\t\t.appendChild( table )\n\t\t\t\t\t.appendChild( tr )\n\t\t\t\t\t.appendChild( trChild );\n\n\t\t\t\ttrStyle = window.getComputedStyle( tr );\n\t\t\t\treliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderTopWidth, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;\n\n\t\t\t\tdocumentElement.removeChild( table );\n\t\t\t}\n\t\t\treturn reliableTrDimensionsVal;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\t\tisCustomProp = rcustomProp.test( name ),\n\n\t\t// Support: Firefox 51+\n\t\t// Retrieving style before computed somehow\n\t\t// fixes an issue with getting wrong values\n\t\t// on detached elements\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for:\n\t//   .css('filter') (IE 9 only, trac-12537)\n\t//   .css('--customProperty) (gh-3144)\n\tif ( computed ) {\n\n\t\t// Support: IE <=9 - 11+\n\t\t// IE only supports `\"float\"` in `getPropertyValue`; in computed styles\n\t\t// it's only available as `\"cssFloat\"`. We no longer modify properties\n\t\t// sent to `.css()` apart from camelCasing, so we need to check both.\n\t\t// Normally, this would create difference in behavior: if\n\t\t// `getPropertyValue` returns an empty string, the value returned\n\t\t// by `.css()` would be `undefined`. This is usually the case for\n\t\t// disconnected elements. However, in IE even disconnected elements\n\t\t// with no styles return `\"none\"` for `getPropertyValue( \"float\" )`\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( isCustomProp && ret ) {\n\n\t\t\t// Support: Firefox 105+, Chrome <=105+\n\t\t\t// Spec requires trimming whitespace for custom properties (gh-4926).\n\t\t\t// Firefox only trims leading whitespace. Chrome just collapses\n\t\t\t// both leading & trailing whitespace to a single space.\n\t\t\t//\n\t\t\t// Fall back to `undefined` if empty string returned.\n\t\t\t// This collapses a missing definition with property defined\n\t\t\t// and set to an empty string but there's no standard API\n\t\t\t// allowing us to differentiate them without a performance penalty\n\t\t\t// and returning `undefined` aligns with older jQuery.\n\t\t\t//\n\t\t\t// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED\n\t\t\t// as whitespace while CSS does not, but this is not a problem\n\t\t\t// because CSS preprocessing replaces them with U+000A LINE FEED\n\t\t\t// (which *is* CSS whitespace)\n\t\t\t// https://www.w3.org/TR/css-syntax-3/#input-preprocessing\n\t\t\tret = ret.replace( rtrimCSS, \"$1\" ) || undefined;\n\t\t}\n\n\t\tif ( ret === \"\" && !isAttached( elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// https://drafts.csswg.org/cssom/#resolved-values\n\t\tif ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11 only\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style,\n\tvendorProps = {};\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a potentially-mapped jQuery.cssProps or vendor prefixed property\nfunction finalPropName( name ) {\n\tvar final = jQuery.cssProps[ name ] || vendorProps[ name ];\n\n\tif ( final ) {\n\t\treturn final;\n\t}\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorProps[ name ] = vendorPropName( name ) || name;\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t};\n\nfunction setPositiveNumber( _elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0,\n\t\tmarginDelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\t// Count margin delta separately to only add it after scroll gutter adjustment.\n\t\t// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).\n\t\tif ( box === \"margin\" ) {\n\t\t\tmarginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta + marginDelta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = !support.boxSizingReliable() || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Support: Firefox <=54\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\t// Support: IE 9 - 11 only\n\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t// In those cases, the computed value can be trusted to be border-box.\n\tif ( ( !support.boxSizingReliable() && isBorderBox ||\n\n\t\t// Support: IE 10 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Interestingly, in some cases IE 9 doesn't suffer from this issue.\n\t\t!support.reliableTrDimensions() && nodeName( elem, \"tr\" ) ||\n\n\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\tval === \"auto\" ||\n\n\t\t// Support: Android <=4.1 - 4.3 only\n\t\t// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n\t\t!parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\tanimationIterationCount: true,\n\t\taspectRatio: true,\n\t\tborderImageSlice: true,\n\t\tcolumnCount: true,\n\t\tflexGrow: true,\n\t\tflexShrink: true,\n\t\tfontWeight: true,\n\t\tgridArea: true,\n\t\tgridColumn: true,\n\t\tgridColumnEnd: true,\n\t\tgridColumnStart: true,\n\t\tgridRow: true,\n\t\tgridRowEnd: true,\n\t\tgridRowStart: true,\n\t\tlineHeight: true,\n\t\topacity: true,\n\t\torder: true,\n\t\torphans: true,\n\t\tscale: true,\n\t\twidows: true,\n\t\tzIndex: true,\n\t\tzoom: true,\n\n\t\t// SVG-related\n\t\tfillOpacity: true,\n\t\tfloodOpacity: true,\n\t\tstopOpacity: true,\n\t\tstrokeMiterlimit: true,\n\t\tstrokeOpacity: true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (trac-7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug trac-9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (trac-7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\t// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n\t\t\t// \"px\" to a few hardcoded values.\n\t\t\tif ( type === \"number\" && !isCustomProp ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\n\t\t\t\t\t// Support: Safari 8+\n\t\t\t\t\t// Table columns in Safari have non-zero offsetWidth & zero\n\t\t\t\t\t// getBoundingClientRect().width unless display is changed.\n\t\t\t\t\t// Support: IE <=11 only\n\t\t\t\t\t// Running getBoundingClientRect on a disconnected node\n\t\t\t\t\t// in IE throws an error.\n\t\t\t\t\t( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\n\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t} ) :\n\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\n\t\t\t\t// Only read styles.position if the test has a chance to fail\n\t\t\t\t// to avoid forcing a reflow.\n\t\t\t\tscrollboxSizeBuggy = !support.scrollboxSize() &&\n\t\t\t\t\tstyles.position === \"absolute\",\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tboxSizingNeeded = scrollboxSizeBuggy || extra,\n\t\t\t\tisBorderBox = boxSizingNeeded &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Account for unreliable border-box dimensions by comparing offset* to computed and\n\t\t\t// faking a content-box to get border and padding (gh-3699)\n\t\t\tif ( isBorderBox && scrollboxSizeBuggy ) {\n\t\t\t\tsubtract -= Math.ceil(\n\t\t\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\t\t\tparseFloat( styles[ dimension ] ) -\n\t\t\t\t\tboxModelAdjustment( elem, dimension, \"border\", false, styles ) -\n\t\t\t\t\t0.5\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 && (\n\t\t\t\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE <=9 only\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, jQuery.fx.interval );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11, Edge 12 - 15\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY and Edge just mirrors\n\t\t// the overflowX value there.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t/* eslint-disable no-loop-func */\n\n\t\t\tanim.done( function() {\n\n\t\t\t\t/* eslint-enable no-loop-func */\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3 only\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tisFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !isFunction( easing ) && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\n\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: Android <=4.3 only\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE <=11 only\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: IE <=11 only\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tnodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( _i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle,\n\t\t\tlowercaseName = name.toLowerCase();\n\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ lowercaseName ];\n\t\t\tattrHandle[ lowercaseName ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tlowercaseName :\n\t\t\t\tnull;\n\t\t\tattrHandle[ lowercaseName ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11 only\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// Use proper attribute retrieval (trac-12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\trclickable.test( elem.nodeName ) &&\n\t\t\t\t\telem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\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\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\n\t// Strip and collapse whitespace according to HTML spec\n\t// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\tfunction stripAndCollapse( value ) {\n\t\tvar tokens = value.match( rnothtmlwhite ) || [];\n\t\treturn tokens.join( \" \" );\n\t}\n\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + className + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += className + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + className + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + className + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar classNames, className, i, self,\n\t\t\ttype = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\treturn this.each( function() {\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\tself = jQuery( this );\n\n\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle most common string cases\n\t\t\t\tif ( typeof ret === \"string\" ) {\n\t\t\t\t\treturn ret.replace( rreturn, \"\" );\n\t\t\t\t}\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE <=10 - 11 only\n\t\t\t\t\t// option.text throws exceptions (trac-14686, trac-14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (trac-2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t/* eslint-disable no-cond-assign */\n\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t/* eslint-enable no-cond-assign */\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\nvar location = window.location;\n\nvar nonce = { guid: Date.now() };\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, parserErrorElem;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11 only\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {}\n\n\tparserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\n\tif ( !xml || parserErrorElem ) {\n\t\tjQuery.error( \"Invalid XML: \" + (\n\t\t\tparserErrorElem ?\n\t\t\t\tjQuery.map( parserErrorElem.childNodes, function( el ) {\n\t\t\t\t\treturn el.textContent;\n\t\t\t\t} ).join( \"\\n\" ) :\n\t\t\t\tdata\n\t\t) );\n\t}\n\treturn xml;\n};\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (trac-9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || Object.create( null ) )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (trac-6170)\n\t\t\t\tif ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = isFunction( valueOrFunction ) ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\tif ( a == null ) {\n\t\treturn \"\";\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} ).filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} ).map( function( _i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// trac-7653, trac-8125, trac-8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\noriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes trac-9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\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 */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( match[ 2 ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() + \" \" ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match.join( \", \" );\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (trac-10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket trac-12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11, Edge 12 - 15\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11 only\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// trac-9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce.guid++ ) +\n\t\t\t\t\tuncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Use a noop converter for missing script but not if jsonp\n\t\t\tif ( !isSuccess &&\n\t\t\t\tjQuery.inArray( \"script\", s.dataTypes ) > -1 &&\n\t\t\t\tjQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\n\njQuery._evalUrl = function( url, options, doc ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (trac-11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( isFunction( html ) ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\n\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE <=9 only\n\t\t// trac-1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.ontimeout =\n\t\t\t\t\t\t\t\t\txhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see trac-8605, trac-14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t\t// Support: IE 9 only\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// trac-14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain or forced-by-attrs requests\n\tif ( s.crossDomain || s.scriptAttrs ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" )\n\t\t\t\t\t.attr( s.scriptAttrs || {} )\n\t\t\t\t\t.prop( { charset: s.scriptCharset, src: s.url } )\n\t\t\t\t\t.on( \"load error\", callback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce.guid++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\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\nsupport.createHTMLDocument = ( function() {\n\tvar body = document.implementation.createHTMLDocument( \"\" ).body;\n\tbody.innerHTML = \"<form></form><form></form>\";\n\treturn body.childNodes.length === 2;\n} )();\n\n\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\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( typeof data !== \"string\" ) {\n\t\treturn [];\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\n\tvar base, parsed, scripts;\n\n\tif ( !context ) {\n\n\t\t// Stop scripts or inline event handlers from being executed immediately\n\t\t// by using document.implementation\n\t\tif ( support.createHTMLDocument ) {\n\t\t\tcontext = document.implementation.createHTMLDocument( \"\" );\n\n\t\t\t// Set the base href for the created document\n\t\t\t// so any parsed elements with URLs\n\t\t\t// are based on the document's URL (gh-2965)\n\t\t\tbase = context.createElement( \"base\" );\n\t\t\tbase.href = document.location.href;\n\t\t\tcontext.head.appendChild( base );\n\t\t} else {\n\t\t\tcontext = document;\n\t\t}\n\t}\n\n\tparsed = rsingleTag.exec( data );\n\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = stripAndCollapse( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\njQuery.expr.pseudos.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\n\t// offset() relates an element's border box to the document origin\n\toffset: function( options ) {\n\n\t\t// Preserve chaining for setter\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar rect, win,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !elem ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n\t\t// Support: IE <=11 only\n\t\t// Running getBoundingClientRect on a\n\t\t// disconnected node in IE throws an error\n\t\tif ( !elem.getClientRects().length ) {\n\t\t\treturn { top: 0, left: 0 };\n\t\t}\n\n\t\t// Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\t\trect = elem.getBoundingClientRect();\n\t\twin = elem.ownerDocument.defaultView;\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset,\n\t\t\tleft: rect.left + win.pageXOffset\n\t\t};\n\t},\n\n\t// position() relates an element's margin box to its offset parent's padding box\n\t// This corresponds to the behavior of CSS absolute positioning\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset, doc,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// position:fixed elements are offset from the viewport, which itself always has zero offset\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume position:fixed implies availability of getBoundingClientRect\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\t\t\toffset = this.offset();\n\n\t\t\t// Account for the *real* offset parent, which can be the document or its root element\n\t\t\t// when a statically positioned element is identified\n\t\t\tdoc = elem.ownerDocument;\n\t\t\toffsetParent = elem.offsetParent || doc.documentElement;\n\t\t\twhile ( offsetParent &&\n\t\t\t\t( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\n\t\t\t\toffsetParent = offsetParent.parentNode;\n\t\t\t}\n\t\t\tif ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\n\n\t\t\t\t// Incorporate borders into its offset, since they are outside its content origin\n\t\t\t\tparentOffset = jQuery( offsetParent ).offset();\n\t\t\t\tparentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\n\t\t\t\tparentOffset.left += jQuery.css( offsetParent, \"borderLeftWidth\", true );\n\t\t\t}\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\n\t\t\t// Coalesce documents and windows\n\t\t\tvar win;\n\t\t\tif ( isWindow( elem ) ) {\n\t\t\t\twin = elem;\n\t\t\t} else if ( elem.nodeType === 9 ) {\n\t\t\t\twin = elem.defaultView;\n\t\t\t}\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\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\njQuery.each( [ \"top\", \"left\" ], function( _i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( {\n\t\tpadding: \"inner\" + name,\n\t\tcontent: type,\n\t\t\"\": \"outer\" + name\n\t}, function( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( isWindow( elem ) ) {\n\n\t\t\t\t\t// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n\t\t\t\t\treturn funcName.indexOf( \"outer\" ) === 0 ?\n\t\t\t\t\t\telem[ \"inner\" + name ] :\n\t\t\t\t\t\telem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable );\n\t\t};\n\t} );\n} );\n\n\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( _i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t},\n\n\thover: function( fnOver, fnOut ) {\n\t\treturn this\n\t\t\t.on( \"mouseenter\", fnOver )\n\t\t\t.on( \"mouseleave\", fnOut || fnOver );\n\t}\n} );\n\njQuery.each(\n\t( \"blur focus focusin focusout resize scroll click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\n\tfunction( _i, name ) {\n\n\t\t// Handle event binding\n\t\tjQuery.fn[ name ] = function( data, fn ) {\n\t\t\treturn arguments.length > 0 ?\n\t\t\t\tthis.on( name, null, data, fn ) :\n\t\t\t\tthis.trigger( name );\n\t\t};\n\t}\n);\n\n\n\n\n// Support: Android <=4.0 only\n// Make sure we trim BOM and NBSP\n// Require that the \"whitespace run\" starts from a non-whitespace\n// to avoid O(N^2) behavior when the engine would try matching \"\\s+$\" at each space position.\nvar rtrim = /^[\\s\\uFEFF\\xA0]+|([^\\s\\uFEFF\\xA0])[\\s\\uFEFF\\xA0]+$/g;\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\njQuery.proxy = function( fn, context ) {\n\tvar tmp, args, proxy;\n\n\tif ( typeof context === \"string\" ) {\n\t\ttmp = fn[ context ];\n\t\tcontext = fn;\n\t\tfn = tmp;\n\t}\n\n\t// Quick check to determine if target is callable, in the spec\n\t// this throws a TypeError, but we will just return undefined.\n\tif ( !isFunction( fn ) ) {\n\t\treturn undefined;\n\t}\n\n\t// Simulated bind\n\targs = slice.call( arguments, 2 );\n\tproxy = function() {\n\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t};\n\n\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\treturn proxy;\n};\n\njQuery.holdReady = function( hold ) {\n\tif ( hold ) {\n\t\tjQuery.readyWait++;\n\t} else {\n\t\tjQuery.ready( true );\n\t}\n};\njQuery.isArray = Array.isArray;\njQuery.parseJSON = JSON.parse;\njQuery.nodeName = nodeName;\njQuery.isFunction = isFunction;\njQuery.isWindow = isWindow;\njQuery.camelCase = camelCase;\njQuery.type = toType;\n\njQuery.now = Date.now;\n\njQuery.isNumeric = function( obj ) {\n\n\t// As of jQuery 3.0, isNumeric is limited to\n\t// strings and numbers (primitives or objects)\n\t// that can be coerced to finite numbers (gh-2662)\n\tvar type = jQuery.type( obj );\n\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t!isNaN( obj - parseFloat( obj ) );\n};\n\njQuery.trim = function( text ) {\n\treturn text == null ?\n\t\t\"\" :\n\t\t( text + \"\" ).replace( rtrim, \"$1\" );\n};\n\n\n\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\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\nif ( typeof define === \"function\" && define.amd ) {\n\tdefine( \"jquery\", [], function() {\n\t\treturn jQuery;\n\t} );\n}\n\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (trac-13566)\nif ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/jquery/dist/jquery.js\n// module id = 18\n// module chunks = 4","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js\n// module id = 25\n// module chunks = 4","\"use strict\";\nvar es5 = require(\"./es5\");\nvar Objectfreeze = es5.freeze;\nvar util = require(\"./util\");\nvar inherits = util.inherits;\nvar notEnumerableProp = util.notEnumerableProp;\n\nfunction subError(nameProperty, defaultMessage) {\n    function SubError(message) {\n        if (!(this instanceof SubError)) return new SubError(message);\n        notEnumerableProp(this, \"message\",\n            typeof message === \"string\" ? message : defaultMessage);\n        notEnumerableProp(this, \"name\", nameProperty);\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, this.constructor);\n        } else {\n            Error.call(this);\n        }\n    }\n    inherits(SubError, Error);\n    return SubError;\n}\n\nvar _TypeError, _RangeError;\nvar Warning = subError(\"Warning\", \"warning\");\nvar CancellationError = subError(\"CancellationError\", \"cancellation error\");\nvar TimeoutError = subError(\"TimeoutError\", \"timeout error\");\nvar AggregateError = subError(\"AggregateError\", \"aggregate error\");\ntry {\n    _TypeError = TypeError;\n    _RangeError = RangeError;\n} catch(e) {\n    _TypeError = subError(\"TypeError\", \"type error\");\n    _RangeError = subError(\"RangeError\", \"range error\");\n}\n\nvar methods = (\"join pop push shift unshift slice filter forEach some \" +\n    \"every map indexOf lastIndexOf reduce reduceRight sort reverse\").split(\" \");\n\nfor (var i = 0; i < methods.length; ++i) {\n    if (typeof Array.prototype[methods[i]] === \"function\") {\n        AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];\n    }\n}\n\nes5.defineProperty(AggregateError.prototype, \"length\", {\n    value: 0,\n    configurable: false,\n    writable: true,\n    enumerable: true\n});\nAggregateError.prototype[\"isOperational\"] = true;\nvar level = 0;\nAggregateError.prototype.toString = function() {\n    var indent = Array(level * 4 + 1).join(\" \");\n    var ret = \"\\n\" + indent + \"AggregateError of:\" + \"\\n\";\n    level++;\n    indent = Array(level * 4 + 1).join(\" \");\n    for (var i = 0; i < this.length; ++i) {\n        var str = this[i] === this ? \"[Circular AggregateError]\" : this[i] + \"\";\n        var lines = str.split(\"\\n\");\n        for (var j = 0; j < lines.length; ++j) {\n            lines[j] = indent + lines[j];\n        }\n        str = lines.join(\"\\n\");\n        ret += str + \"\\n\";\n    }\n    level--;\n    return ret;\n};\n\nfunction OperationalError(message) {\n    if (!(this instanceof OperationalError))\n        return new OperationalError(message);\n    notEnumerableProp(this, \"name\", \"OperationalError\");\n    notEnumerableProp(this, \"message\", message);\n    this.cause = message;\n    this[\"isOperational\"] = true;\n\n    if (message instanceof Error) {\n        notEnumerableProp(this, \"message\", message.message);\n        notEnumerableProp(this, \"stack\", message.stack);\n    } else if (Error.captureStackTrace) {\n        Error.captureStackTrace(this, this.constructor);\n    }\n\n}\ninherits(OperationalError, Error);\n\nvar errorTypes = Error[\"__BluebirdErrorTypes__\"];\nif (!errorTypes) {\n    errorTypes = Objectfreeze({\n        CancellationError: CancellationError,\n        TimeoutError: TimeoutError,\n        OperationalError: OperationalError,\n        RejectionError: OperationalError,\n        AggregateError: AggregateError\n    });\n    es5.defineProperty(Error, \"__BluebirdErrorTypes__\", {\n        value: errorTypes,\n        writable: false,\n        enumerable: false,\n        configurable: false\n    });\n}\n\nmodule.exports = {\n    Error: Error,\n    TypeError: _TypeError,\n    RangeError: _RangeError,\n    CancellationError: errorTypes.CancellationError,\n    OperationalError: errorTypes.OperationalError,\n    TimeoutError: errorTypes.TimeoutError,\n    AggregateError: errorTypes.AggregateError,\n    Warning: Warning\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/errors.js\n// module id = 26\n// module chunks = 4","/* globals define */\n'use strict';\n/**\n * Provide deferred promises.\n */\n\n/**\n * UMD Loader from https://github.com/umdjs/umd/blob/master/amdWeb.js\n */\n(function (root, factory) {\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD. Register as an anonymous module.\n\t\tdefine(factory);\n\t} else {\n\t\t// Browser globals\n\t\troot.Deferred = factory;\n\t}\n}(this, function () {\n\treturn function () {\n\t\tvar deferred = {};\n\t\tdeferred.promise = new Promise(function (resolve, reject) {\n\t\t\tdeferred.resolve = resolve;\n\t\t\tdeferred.reject = reject;\n\t\t});\n\t\treturn deferred;\n\t};\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/dada-deferred/src/deferred.js\n// module id = 27\n// module chunks = 4","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 31\n// module chunks = 4","var isES5 = (function(){\n    \"use strict\";\n    return this === undefined;\n})();\n\nif (isES5) {\n    module.exports = {\n        freeze: Object.freeze,\n        defineProperty: Object.defineProperty,\n        getDescriptor: Object.getOwnPropertyDescriptor,\n        keys: Object.keys,\n        names: Object.getOwnPropertyNames,\n        getPrototypeOf: Object.getPrototypeOf,\n        isArray: Array.isArray,\n        isES5: isES5,\n        propertyIsWritable: function(obj, prop) {\n            var descriptor = Object.getOwnPropertyDescriptor(obj, prop);\n            return !!(!descriptor || descriptor.writable || descriptor.set);\n        }\n    };\n} else {\n    var has = {}.hasOwnProperty;\n    var str = {}.toString;\n    var proto = {}.constructor.prototype;\n\n    var ObjectKeys = function (o) {\n        var ret = [];\n        for (var key in o) {\n            if (has.call(o, key)) {\n                ret.push(key);\n            }\n        }\n        return ret;\n    };\n\n    var ObjectGetDescriptor = function(o, key) {\n        return {value: o[key]};\n    };\n\n    var ObjectDefineProperty = function (o, key, desc) {\n        o[key] = desc.value;\n        return o;\n    };\n\n    var ObjectFreeze = function (obj) {\n        return obj;\n    };\n\n    var ObjectGetPrototypeOf = function (obj) {\n        try {\n            return Object(obj).constructor.prototype;\n        }\n        catch (e) {\n            return proto;\n        }\n    };\n\n    var ArrayIsArray = function (obj) {\n        try {\n            return str.call(obj) === \"[object Array]\";\n        }\n        catch(e) {\n            return false;\n        }\n    };\n\n    module.exports = {\n        isArray: ArrayIsArray,\n        keys: ObjectKeys,\n        names: ObjectKeys,\n        defineProperty: ObjectDefineProperty,\n        getDescriptor: ObjectGetDescriptor,\n        freeze: ObjectFreeze,\n        getPrototypeOf: ObjectGetPrototypeOf,\n        isES5: isES5,\n        propertyIsWritable: function() {\n            return true;\n        }\n    };\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/es5.js\n// module id = 32\n// module chunks = 4","/* globals define */\n'use strict';\n/**\n * UMD Loader from https://github.com/umdjs/umd/blob/master/amdWeb.js\n */\n(function (root, factory) {\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD. Register as an anonymous module.\n\t\tdefine(['underscore'], factory);\n\t} else {\n\t\t// Browser globals\n\t\troot.Class = factory(root._);\n\t}\n}(this, function (_) {\n\t/**\n\t * Root extendable Class object.\n\t *\n\t * Based on Backbone.js. Requires Underscore.js.\n\t */\n\tvar Class = function () {\n\t\tthis.initialize.apply(this, arguments);\n\t};\n\t_.extend(Class.prototype, {initialize: function () {}});\n\n\t/**\n\t * Subclass via extend.\n\t *\n\t * @param object props   An object of all prototype properties to set.\n\t * @param object statics An object of all class static properties to set.\n\t *\n\t * prototype properties are most usually functions and are shared across all\n\t * instances of your class. If you have attributes set as prototype properties\n\t * (instead of initializing them in initialize) then they will be shared across\n\t * all instances of the class in the same way - like static attributes in PHP\n\t * classes. Unless overridden, they are also available to all subclasses.\n\t *\n\t * static properties are properties set on the class Function itself. This\n\t * allows you to use the constructor Function like an object.\n\t *\n\t * props object also supports the following special properties run during 'new':\n\t *   constructor: Run before anything else. Can entirely replace all normal setup\n\t *                 including skipping the running of all init. Use with care.\n\t *   initialize: Run last in the 'new' process. This is the function you would\n\t *                 usually use to do setting up of attributes and defaults.\n\t *\n\t * The resulting object can be used with 'new' like a normal\n\t * prototype/Function constructor.\n\t *\n\t * The object supports this._super() to call the parent a-la:\n\t * http://ejohn.org/blog/simple-javascript-inheritance/\n\t *\n\t * The object supports this.__super__ to access the parent class (but usually\n\t * you would use this._super()). You CANNOT use this.__super__ to get to a\n\t * parent's parent so be very careful - it can easily cause infinite loops.\n\t *\n\t * @return object\n\t */\n\n\tClass.extend = function (props, statics) {\n\t\tvar unImplementedSuper = function (method) { throw new Error('Super does not implement this method: ' + method); };\n\t\tvar parent = this;\n\t\tvar child;\n\t\tvar _super = parent.prototype;\n\t\tvar fnTest = /\\b_super\\b/;\n\t\tif (props && _.has(props, 'constructor')) {\n\t\t\tchild = props.constructor;\n\t\t} else {\n\t\t\tchild = function () { return parent.apply(this, arguments); };\n\t\t}\n\t\t_.extend(child, parent, statics);\n\t\tvar Surrogate = function () { this.constructor = child; };\n\t\tSurrogate.prototype = _super;\n\t\tchild.prototype = new Surrogate();\n\t\t_.extend(child.prototype, props, {__super__: _super});\n\t\t// Copy the properties over onto the new prototype\n\t\tfor (var name in props) {\n\t\t\t// Check if we're overwriting an existing function\n\t\t\tif (typeof props[name] === 'function' && fnTest.test(props[name])) {\n\t\t\t\tchild.prototype[name] = (function (name, fn) {\n\t\t\t\t\tvar wrapper = function () {\n\t\t\t\t\t\tvar tmp = this._super;\n\t\t\t\t\t\t// Add a new ._super() method that is the same method but on the super-class\n\t\t\t\t\t\tthis._super = _super[name] || unImplementedSuper(name);\n\t\t\t\t\t\t// The method only need to be bound temporarily, so we remove it when we're done executing\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tvar ret = fn.apply(this, arguments);\n\t\t\t\t\t\t} finally {\n\t\t\t\t\t\t\tthis._super = tmp;\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn ret;\n\t\t\t\t\t};\n\t\t\t\t\t// we must move properties from old function to new\n\t\t\t\t\tfor (var prop in fn) {\n\t\t\t\t\t\twrapper[prop] = fn[prop];\n\t\t\t\t\t\tdelete fn[prop];\n\t\t\t\t\t}\n\t\t\t\t\treturn wrapper;\n\t\t\t\t})(name, props[name]);\n\t\t\t}\n\t\t}\n\t\treturn child;\n\t};\n\n\treturn Class;\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/dada-class/src/class.js\n// module id = 64\n// module chunks = 4","\"use strict\";\nmodule.exports = function(NEXT_FILTER) {\nvar util = require(\"./util\");\nvar getKeys = require(\"./es5\").keys;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\n\nfunction catchFilter(instances, cb, promise) {\n    return function(e) {\n        var boundTo = promise._boundValue();\n        predicateLoop: for (var i = 0; i < instances.length; ++i) {\n            var item = instances[i];\n\n            if (item === Error ||\n                (item != null && item.prototype instanceof Error)) {\n                if (e instanceof item) {\n                    return tryCatch(cb).call(boundTo, e);\n                }\n            } else if (typeof item === \"function\") {\n                var matchesPredicate = tryCatch(item).call(boundTo, e);\n                if (matchesPredicate === errorObj) {\n                    return matchesPredicate;\n                } else if (matchesPredicate) {\n                    return tryCatch(cb).call(boundTo, e);\n                }\n            } else if (util.isObject(e)) {\n                var keys = getKeys(item);\n                for (var j = 0; j < keys.length; ++j) {\n                    var key = keys[j];\n                    if (item[key] != e[key]) {\n                        continue predicateLoop;\n                    }\n                }\n                return tryCatch(cb).call(boundTo, e);\n            }\n        }\n        return NEXT_FILTER;\n    };\n}\n\nreturn catchFilter;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/catch_filter.js\n// module id = 132\n// module chunks = 4","\"use strict\";\nvar util = require(\"./util\");\nvar maybeWrapAsError = util.maybeWrapAsError;\nvar errors = require(\"./errors\");\nvar OperationalError = errors.OperationalError;\nvar es5 = require(\"./es5\");\n\nfunction isUntypedError(obj) {\n    return obj instanceof Error &&\n        es5.getPrototypeOf(obj) === Error.prototype;\n}\n\nvar rErrorKey = /^(?:name|message|stack|cause)$/;\nfunction wrapAsOperationalError(obj) {\n    var ret;\n    if (isUntypedError(obj)) {\n        ret = new OperationalError(obj);\n        ret.name = obj.name;\n        ret.message = obj.message;\n        ret.stack = obj.stack;\n        var keys = es5.keys(obj);\n        for (var i = 0; i < keys.length; ++i) {\n            var key = keys[i];\n            if (!rErrorKey.test(key)) {\n                ret[key] = obj[key];\n            }\n        }\n        return ret;\n    }\n    util.markAsOriginatingFromRejection(obj);\n    return obj;\n}\n\nfunction nodebackForPromise(promise, multiArgs) {\n    return function(err, value) {\n        if (promise === null) return;\n        if (err) {\n            var wrapped = wrapAsOperationalError(maybeWrapAsError(err));\n            promise._attachExtraTrace(wrapped);\n            promise._reject(wrapped);\n        } else if (!multiArgs) {\n            promise._fulfill(value);\n        } else {\n            var $_len = arguments.length;var args = new Array(Math.max($_len - 1, 0)); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];};\n            promise._fulfill(args);\n        }\n        promise = null;\n    };\n}\n\nmodule.exports = nodebackForPromise;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/nodeback.js\n// module id = 133\n// module chunks = 4","\"use strict\";\nmodule.exports = function() {\nvar makeSelfResolutionError = function () {\n    return new TypeError(\"circular promise resolution chain\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n};\nvar reflectHandler = function() {\n    return new Promise.PromiseInspection(this._target());\n};\nvar apiRejection = function(msg) {\n    return Promise.reject(new TypeError(msg));\n};\nfunction Proxyable() {}\nvar UNDEFINED_BINDING = {};\nvar util = require(\"./util\");\n\nvar getDomain;\nif (util.isNode) {\n    getDomain = function() {\n        var ret = process.domain;\n        if (ret === undefined) ret = null;\n        return ret;\n    };\n} else {\n    getDomain = function() {\n        return null;\n    };\n}\nutil.notEnumerableProp(Promise, \"_getDomain\", getDomain);\n\nvar es5 = require(\"./es5\");\nvar Async = require(\"./async\");\nvar async = new Async();\nes5.defineProperty(Promise, \"_async\", {value: async});\nvar errors = require(\"./errors\");\nvar TypeError = Promise.TypeError = errors.TypeError;\nPromise.RangeError = errors.RangeError;\nvar CancellationError = Promise.CancellationError = errors.CancellationError;\nPromise.TimeoutError = errors.TimeoutError;\nPromise.OperationalError = errors.OperationalError;\nPromise.RejectionError = errors.OperationalError;\nPromise.AggregateError = errors.AggregateError;\nvar INTERNAL = function(){};\nvar APPLY = {};\nvar NEXT_FILTER = {};\nvar tryConvertToPromise = require(\"./thenables\")(Promise, INTERNAL);\nvar PromiseArray =\n    require(\"./promise_array\")(Promise, INTERNAL,\n                               tryConvertToPromise, apiRejection, Proxyable);\nvar Context = require(\"./context\")(Promise);\n /*jshint unused:false*/\nvar createContext = Context.create;\nvar debug = require(\"./debuggability\")(Promise, Context);\nvar CapturedTrace = debug.CapturedTrace;\nvar PassThroughHandlerContext =\n    require(\"./finally\")(Promise, tryConvertToPromise, NEXT_FILTER);\nvar catchFilter = require(\"./catch_filter\")(NEXT_FILTER);\nvar nodebackForPromise = require(\"./nodeback\");\nvar errorObj = util.errorObj;\nvar tryCatch = util.tryCatch;\nfunction check(self, executor) {\n    if (self == null || self.constructor !== Promise) {\n        throw new TypeError(\"the promise constructor cannot be invoked directly\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    if (typeof executor !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(executor));\n    }\n\n}\n\nfunction Promise(executor) {\n    if (executor !== INTERNAL) {\n        check(this, executor);\n    }\n    this._bitField = 0;\n    this._fulfillmentHandler0 = undefined;\n    this._rejectionHandler0 = undefined;\n    this._promise0 = undefined;\n    this._receiver0 = undefined;\n    this._resolveFromExecutor(executor);\n    this._promiseCreated();\n    this._fireEvent(\"promiseCreated\", this);\n}\n\nPromise.prototype.toString = function () {\n    return \"[object Promise]\";\n};\n\nPromise.prototype.caught = Promise.prototype[\"catch\"] = function (fn) {\n    var len = arguments.length;\n    if (len > 1) {\n        var catchInstances = new Array(len - 1),\n            j = 0, i;\n        for (i = 0; i < len - 1; ++i) {\n            var item = arguments[i];\n            if (util.isObject(item)) {\n                catchInstances[j++] = item;\n            } else {\n                return apiRejection(\"Catch statement predicate: \" +\n                    \"expecting an object but got \" + util.classString(item));\n            }\n        }\n        catchInstances.length = j;\n        fn = arguments[i];\n\n        if (typeof fn !== \"function\") {\n            throw new TypeError(\"The last argument to .catch() \" +\n                \"must be a function, got \" + util.toString(fn));\n        }\n        return this.then(undefined, catchFilter(catchInstances, fn, this));\n    }\n    return this.then(undefined, fn);\n};\n\nPromise.prototype.reflect = function () {\n    return this._then(reflectHandler,\n        reflectHandler, undefined, this, undefined);\n};\n\nPromise.prototype.then = function (didFulfill, didReject) {\n    if (debug.warnings() && arguments.length > 0 &&\n        typeof didFulfill !== \"function\" &&\n        typeof didReject !== \"function\") {\n        var msg = \".then() only accepts functions but was passed: \" +\n                util.classString(didFulfill);\n        if (arguments.length > 1) {\n            msg += \", \" + util.classString(didReject);\n        }\n        this._warn(msg);\n    }\n    return this._then(didFulfill, didReject, undefined, undefined, undefined);\n};\n\nPromise.prototype.done = function (didFulfill, didReject) {\n    var promise =\n        this._then(didFulfill, didReject, undefined, undefined, undefined);\n    promise._setIsFinal();\n};\n\nPromise.prototype.spread = function (fn) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    return this.all()._then(fn, undefined, undefined, APPLY, undefined);\n};\n\nPromise.prototype.toJSON = function () {\n    var ret = {\n        isFulfilled: false,\n        isRejected: false,\n        fulfillmentValue: undefined,\n        rejectionReason: undefined\n    };\n    if (this.isFulfilled()) {\n        ret.fulfillmentValue = this.value();\n        ret.isFulfilled = true;\n    } else if (this.isRejected()) {\n        ret.rejectionReason = this.reason();\n        ret.isRejected = true;\n    }\n    return ret;\n};\n\nPromise.prototype.all = function () {\n    if (arguments.length > 0) {\n        this._warn(\".all() was passed arguments but it does not take any\");\n    }\n    return new PromiseArray(this).promise();\n};\n\nPromise.prototype.error = function (fn) {\n    return this.caught(util.originatesFromRejection, fn);\n};\n\nPromise.getNewLibraryCopy = module.exports;\n\nPromise.is = function (val) {\n    return val instanceof Promise;\n};\n\nPromise.fromNode = Promise.fromCallback = function(fn) {\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs\n                                         : false;\n    var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));\n    if (result === errorObj) {\n        ret._rejectCallback(result.e, true);\n    }\n    if (!ret._isFateSealed()) ret._setAsyncGuaranteed();\n    return ret;\n};\n\nPromise.all = function (promises) {\n    return new PromiseArray(promises).promise();\n};\n\nPromise.cast = function (obj) {\n    var ret = tryConvertToPromise(obj);\n    if (!(ret instanceof Promise)) {\n        ret = new Promise(INTERNAL);\n        ret._captureStackTrace();\n        ret._setFulfilled();\n        ret._rejectionHandler0 = obj;\n    }\n    return ret;\n};\n\nPromise.resolve = Promise.fulfilled = Promise.cast;\n\nPromise.reject = Promise.rejected = function (reason) {\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    ret._rejectCallback(reason, true);\n    return ret;\n};\n\nPromise.setScheduler = function(fn) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    return async.setScheduler(fn);\n};\n\nPromise.prototype._then = function (\n    didFulfill,\n    didReject,\n    _,    receiver,\n    internalData\n) {\n    var haveInternalData = internalData !== undefined;\n    var promise = haveInternalData ? internalData : new Promise(INTERNAL);\n    var target = this._target();\n    var bitField = target._bitField;\n\n    if (!haveInternalData) {\n        promise._propagateFrom(this, 3);\n        promise._captureStackTrace();\n        if (receiver === undefined &&\n            ((this._bitField & 2097152) !== 0)) {\n            if (!((bitField & 50397184) === 0)) {\n                receiver = this._boundValue();\n            } else {\n                receiver = target === this ? undefined : this._boundTo;\n            }\n        }\n        this._fireEvent(\"promiseChained\", this, promise);\n    }\n\n    var domain = getDomain();\n    if (!((bitField & 50397184) === 0)) {\n        var handler, value, settler = target._settlePromiseCtx;\n        if (((bitField & 33554432) !== 0)) {\n            value = target._rejectionHandler0;\n            handler = didFulfill;\n        } else if (((bitField & 16777216) !== 0)) {\n            value = target._fulfillmentHandler0;\n            handler = didReject;\n            target._unsetRejectionIsUnhandled();\n        } else {\n            settler = target._settlePromiseLateCancellationObserver;\n            value = new CancellationError(\"late cancellation observer\");\n            target._attachExtraTrace(value);\n            handler = didReject;\n        }\n\n        async.invoke(settler, target, {\n            handler: domain === null ? handler\n                : (typeof handler === \"function\" &&\n                    util.domainBind(domain, handler)),\n            promise: promise,\n            receiver: receiver,\n            value: value\n        });\n    } else {\n        target._addCallbacks(didFulfill, didReject, promise, receiver, domain);\n    }\n\n    return promise;\n};\n\nPromise.prototype._length = function () {\n    return this._bitField & 65535;\n};\n\nPromise.prototype._isFateSealed = function () {\n    return (this._bitField & 117506048) !== 0;\n};\n\nPromise.prototype._isFollowing = function () {\n    return (this._bitField & 67108864) === 67108864;\n};\n\nPromise.prototype._setLength = function (len) {\n    this._bitField = (this._bitField & -65536) |\n        (len & 65535);\n};\n\nPromise.prototype._setFulfilled = function () {\n    this._bitField = this._bitField | 33554432;\n    this._fireEvent(\"promiseFulfilled\", this);\n};\n\nPromise.prototype._setRejected = function () {\n    this._bitField = this._bitField | 16777216;\n    this._fireEvent(\"promiseRejected\", this);\n};\n\nPromise.prototype._setFollowing = function () {\n    this._bitField = this._bitField | 67108864;\n    this._fireEvent(\"promiseResolved\", this);\n};\n\nPromise.prototype._setIsFinal = function () {\n    this._bitField = this._bitField | 4194304;\n};\n\nPromise.prototype._isFinal = function () {\n    return (this._bitField & 4194304) > 0;\n};\n\nPromise.prototype._unsetCancelled = function() {\n    this._bitField = this._bitField & (~65536);\n};\n\nPromise.prototype._setCancelled = function() {\n    this._bitField = this._bitField | 65536;\n    this._fireEvent(\"promiseCancelled\", this);\n};\n\nPromise.prototype._setWillBeCancelled = function() {\n    this._bitField = this._bitField | 8388608;\n};\n\nPromise.prototype._setAsyncGuaranteed = function() {\n    if (async.hasCustomScheduler()) return;\n    this._bitField = this._bitField | 134217728;\n};\n\nPromise.prototype._receiverAt = function (index) {\n    var ret = index === 0 ? this._receiver0 : this[\n            index * 4 - 4 + 3];\n    if (ret === UNDEFINED_BINDING) {\n        return undefined;\n    } else if (ret === undefined && this._isBound()) {\n        return this._boundValue();\n    }\n    return ret;\n};\n\nPromise.prototype._promiseAt = function (index) {\n    return this[\n            index * 4 - 4 + 2];\n};\n\nPromise.prototype._fulfillmentHandlerAt = function (index) {\n    return this[\n            index * 4 - 4 + 0];\n};\n\nPromise.prototype._rejectionHandlerAt = function (index) {\n    return this[\n            index * 4 - 4 + 1];\n};\n\nPromise.prototype._boundValue = function() {};\n\nPromise.prototype._migrateCallback0 = function (follower) {\n    var bitField = follower._bitField;\n    var fulfill = follower._fulfillmentHandler0;\n    var reject = follower._rejectionHandler0;\n    var promise = follower._promise0;\n    var receiver = follower._receiverAt(0);\n    if (receiver === undefined) receiver = UNDEFINED_BINDING;\n    this._addCallbacks(fulfill, reject, promise, receiver, null);\n};\n\nPromise.prototype._migrateCallbackAt = function (follower, index) {\n    var fulfill = follower._fulfillmentHandlerAt(index);\n    var reject = follower._rejectionHandlerAt(index);\n    var promise = follower._promiseAt(index);\n    var receiver = follower._receiverAt(index);\n    if (receiver === undefined) receiver = UNDEFINED_BINDING;\n    this._addCallbacks(fulfill, reject, promise, receiver, null);\n};\n\nPromise.prototype._addCallbacks = function (\n    fulfill,\n    reject,\n    promise,\n    receiver,\n    domain\n) {\n    var index = this._length();\n\n    if (index >= 65535 - 4) {\n        index = 0;\n        this._setLength(0);\n    }\n\n    if (index === 0) {\n        this._promise0 = promise;\n        this._receiver0 = receiver;\n        if (typeof fulfill === \"function\") {\n            this._fulfillmentHandler0 =\n                domain === null ? fulfill : util.domainBind(domain, fulfill);\n        }\n        if (typeof reject === \"function\") {\n            this._rejectionHandler0 =\n                domain === null ? reject : util.domainBind(domain, reject);\n        }\n    } else {\n        var base = index * 4 - 4;\n        this[base + 2] = promise;\n        this[base + 3] = receiver;\n        if (typeof fulfill === \"function\") {\n            this[base + 0] =\n                domain === null ? fulfill : util.domainBind(domain, fulfill);\n        }\n        if (typeof reject === \"function\") {\n            this[base + 1] =\n                domain === null ? reject : util.domainBind(domain, reject);\n        }\n    }\n    this._setLength(index + 1);\n    return index;\n};\n\nPromise.prototype._proxy = function (proxyable, arg) {\n    this._addCallbacks(undefined, undefined, arg, proxyable, null);\n};\n\nPromise.prototype._resolveCallback = function(value, shouldBind) {\n    if (((this._bitField & 117506048) !== 0)) return;\n    if (value === this)\n        return this._rejectCallback(makeSelfResolutionError(), false);\n    var maybePromise = tryConvertToPromise(value, this);\n    if (!(maybePromise instanceof Promise)) return this._fulfill(value);\n\n    if (shouldBind) this._propagateFrom(maybePromise, 2);\n\n    var promise = maybePromise._target();\n\n    if (promise === this) {\n        this._reject(makeSelfResolutionError());\n        return;\n    }\n\n    var bitField = promise._bitField;\n    if (((bitField & 50397184) === 0)) {\n        var len = this._length();\n        if (len > 0) promise._migrateCallback0(this);\n        for (var i = 1; i < len; ++i) {\n            promise._migrateCallbackAt(this, i);\n        }\n        this._setFollowing();\n        this._setLength(0);\n        this._setFollowee(promise);\n    } else if (((bitField & 33554432) !== 0)) {\n        this._fulfill(promise._value());\n    } else if (((bitField & 16777216) !== 0)) {\n        this._reject(promise._reason());\n    } else {\n        var reason = new CancellationError(\"late cancellation observer\");\n        promise._attachExtraTrace(reason);\n        this._reject(reason);\n    }\n};\n\nPromise.prototype._rejectCallback =\nfunction(reason, synchronous, ignoreNonErrorWarnings) {\n    var trace = util.ensureErrorObject(reason);\n    var hasStack = trace === reason;\n    if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {\n        var message = \"a promise was rejected with a non-error: \" +\n            util.classString(reason);\n        this._warn(message, true);\n    }\n    this._attachExtraTrace(trace, synchronous ? hasStack : false);\n    this._reject(reason);\n};\n\nPromise.prototype._resolveFromExecutor = function (executor) {\n    if (executor === INTERNAL) return;\n    var promise = this;\n    this._captureStackTrace();\n    this._pushContext();\n    var synchronous = true;\n    var r = this._execute(executor, function(value) {\n        promise._resolveCallback(value);\n    }, function (reason) {\n        promise._rejectCallback(reason, synchronous);\n    });\n    synchronous = false;\n    this._popContext();\n\n    if (r !== undefined) {\n        promise._rejectCallback(r, true);\n    }\n};\n\nPromise.prototype._settlePromiseFromHandler = function (\n    handler, receiver, value, promise\n) {\n    var bitField = promise._bitField;\n    if (((bitField & 65536) !== 0)) return;\n    promise._pushContext();\n    var x;\n    if (receiver === APPLY) {\n        if (!value || typeof value.length !== \"number\") {\n            x = errorObj;\n            x.e = new TypeError(\"cannot .spread() a non-array: \" +\n                                    util.classString(value));\n        } else {\n            x = tryCatch(handler).apply(this._boundValue(), value);\n        }\n    } else {\n        x = tryCatch(handler).call(receiver, value);\n    }\n    var promiseCreated = promise._popContext();\n    bitField = promise._bitField;\n    if (((bitField & 65536) !== 0)) return;\n\n    if (x === NEXT_FILTER) {\n        promise._reject(value);\n    } else if (x === errorObj) {\n        promise._rejectCallback(x.e, false);\n    } else {\n        debug.checkForgottenReturns(x, promiseCreated, \"\",  promise, this);\n        promise._resolveCallback(x);\n    }\n};\n\nPromise.prototype._target = function() {\n    var ret = this;\n    while (ret._isFollowing()) ret = ret._followee();\n    return ret;\n};\n\nPromise.prototype._followee = function() {\n    return this._rejectionHandler0;\n};\n\nPromise.prototype._setFollowee = function(promise) {\n    this._rejectionHandler0 = promise;\n};\n\nPromise.prototype._settlePromise = function(promise, handler, receiver, value) {\n    var isPromise = promise instanceof Promise;\n    var bitField = this._bitField;\n    var asyncGuaranteed = ((bitField & 134217728) !== 0);\n    if (((bitField & 65536) !== 0)) {\n        if (isPromise) promise._invokeInternalOnCancel();\n\n        if (receiver instanceof PassThroughHandlerContext &&\n            receiver.isFinallyHandler()) {\n            receiver.cancelPromise = promise;\n            if (tryCatch(handler).call(receiver, value) === errorObj) {\n                promise._reject(errorObj.e);\n            }\n        } else if (handler === reflectHandler) {\n            promise._fulfill(reflectHandler.call(receiver));\n        } else if (receiver instanceof Proxyable) {\n            receiver._promiseCancelled(promise);\n        } else if (isPromise || promise instanceof PromiseArray) {\n            promise._cancel();\n        } else {\n            receiver.cancel();\n        }\n    } else if (typeof handler === \"function\") {\n        if (!isPromise) {\n            handler.call(receiver, value, promise);\n        } else {\n            if (asyncGuaranteed) promise._setAsyncGuaranteed();\n            this._settlePromiseFromHandler(handler, receiver, value, promise);\n        }\n    } else if (receiver instanceof Proxyable) {\n        if (!receiver._isResolved()) {\n            if (((bitField & 33554432) !== 0)) {\n                receiver._promiseFulfilled(value, promise);\n            } else {\n                receiver._promiseRejected(value, promise);\n            }\n        }\n    } else if (isPromise) {\n        if (asyncGuaranteed) promise._setAsyncGuaranteed();\n        if (((bitField & 33554432) !== 0)) {\n            promise._fulfill(value);\n        } else {\n            promise._reject(value);\n        }\n    }\n};\n\nPromise.prototype._settlePromiseLateCancellationObserver = function(ctx) {\n    var handler = ctx.handler;\n    var promise = ctx.promise;\n    var receiver = ctx.receiver;\n    var value = ctx.value;\n    if (typeof handler === \"function\") {\n        if (!(promise instanceof Promise)) {\n            handler.call(receiver, value, promise);\n        } else {\n            this._settlePromiseFromHandler(handler, receiver, value, promise);\n        }\n    } else if (promise instanceof Promise) {\n        promise._reject(value);\n    }\n};\n\nPromise.prototype._settlePromiseCtx = function(ctx) {\n    this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);\n};\n\nPromise.prototype._settlePromise0 = function(handler, value, bitField) {\n    var promise = this._promise0;\n    var receiver = this._receiverAt(0);\n    this._promise0 = undefined;\n    this._receiver0 = undefined;\n    this._settlePromise(promise, handler, receiver, value);\n};\n\nPromise.prototype._clearCallbackDataAtIndex = function(index) {\n    var base = index * 4 - 4;\n    this[base + 2] =\n    this[base + 3] =\n    this[base + 0] =\n    this[base + 1] = undefined;\n};\n\nPromise.prototype._fulfill = function (value) {\n    var bitField = this._bitField;\n    if (((bitField & 117506048) >>> 16)) return;\n    if (value === this) {\n        var err = makeSelfResolutionError();\n        this._attachExtraTrace(err);\n        return this._reject(err);\n    }\n    this._setFulfilled();\n    this._rejectionHandler0 = value;\n\n    if ((bitField & 65535) > 0) {\n        if (((bitField & 134217728) !== 0)) {\n            this._settlePromises();\n        } else {\n            async.settlePromises(this);\n        }\n        this._dereferenceTrace();\n    }\n};\n\nPromise.prototype._reject = function (reason) {\n    var bitField = this._bitField;\n    if (((bitField & 117506048) >>> 16)) return;\n    this._setRejected();\n    this._fulfillmentHandler0 = reason;\n\n    if (this._isFinal()) {\n        return async.fatalError(reason, util.isNode);\n    }\n\n    if ((bitField & 65535) > 0) {\n        async.settlePromises(this);\n    } else {\n        this._ensurePossibleRejectionHandled();\n    }\n};\n\nPromise.prototype._fulfillPromises = function (len, value) {\n    for (var i = 1; i < len; i++) {\n        var handler = this._fulfillmentHandlerAt(i);\n        var promise = this._promiseAt(i);\n        var receiver = this._receiverAt(i);\n        this._clearCallbackDataAtIndex(i);\n        this._settlePromise(promise, handler, receiver, value);\n    }\n};\n\nPromise.prototype._rejectPromises = function (len, reason) {\n    for (var i = 1; i < len; i++) {\n        var handler = this._rejectionHandlerAt(i);\n        var promise = this._promiseAt(i);\n        var receiver = this._receiverAt(i);\n        this._clearCallbackDataAtIndex(i);\n        this._settlePromise(promise, handler, receiver, reason);\n    }\n};\n\nPromise.prototype._settlePromises = function () {\n    var bitField = this._bitField;\n    var len = (bitField & 65535);\n\n    if (len > 0) {\n        if (((bitField & 16842752) !== 0)) {\n            var reason = this._fulfillmentHandler0;\n            this._settlePromise0(this._rejectionHandler0, reason, bitField);\n            this._rejectPromises(len, reason);\n        } else {\n            var value = this._rejectionHandler0;\n            this._settlePromise0(this._fulfillmentHandler0, value, bitField);\n            this._fulfillPromises(len, value);\n        }\n        this._setLength(0);\n    }\n    this._clearCancellationData();\n};\n\nPromise.prototype._settledValue = function() {\n    var bitField = this._bitField;\n    if (((bitField & 33554432) !== 0)) {\n        return this._rejectionHandler0;\n    } else if (((bitField & 16777216) !== 0)) {\n        return this._fulfillmentHandler0;\n    }\n};\n\nif (typeof Symbol !== \"undefined\" && Symbol.toStringTag) {\n    es5.defineProperty(Promise.prototype, Symbol.toStringTag, {\n        get: function () {\n            return \"Object\";\n        }\n    });\n}\n\nfunction deferResolve(v) {this.promise._resolveCallback(v);}\nfunction deferReject(v) {this.promise._rejectCallback(v, false);}\n\nPromise.defer = Promise.pending = function() {\n    debug.deprecated(\"Promise.defer\", \"new Promise\");\n    var promise = new Promise(INTERNAL);\n    return {\n        promise: promise,\n        resolve: deferResolve,\n        reject: deferReject\n    };\n};\n\nutil.notEnumerableProp(Promise,\n                       \"_makeSelfResolutionError\",\n                       makeSelfResolutionError);\n\nrequire(\"./method\")(Promise, INTERNAL, tryConvertToPromise, apiRejection,\n    debug);\nrequire(\"./bind\")(Promise, INTERNAL, tryConvertToPromise, debug);\nrequire(\"./cancel\")(Promise, PromiseArray, apiRejection, debug);\nrequire(\"./direct_resolve\")(Promise);\nrequire(\"./synchronous_inspection\")(Promise);\nrequire(\"./join\")(\n    Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain);\nPromise.Promise = Promise;\nPromise.version = \"3.5.5\";\nrequire('./call_get.js')(Promise);\nrequire('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);\nrequire('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);\nrequire('./nodeify.js')(Promise);\nrequire('./promisify.js')(Promise, INTERNAL);\nrequire('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);\nrequire('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);\nrequire('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);\nrequire('./settle.js')(Promise, PromiseArray, debug);\nrequire('./some.js')(Promise, PromiseArray, apiRejection);\nrequire('./timers.js')(Promise, INTERNAL, debug);\nrequire('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);\nrequire('./any.js')(Promise);\nrequire('./each.js')(Promise, INTERNAL);\nrequire('./filter.js')(Promise, INTERNAL);\n                                                         \n    util.toFastProperties(Promise);                                          \n    util.toFastProperties(Promise.prototype);                                \n    function fillTypes(value) {                                              \n        var p = new Promise(INTERNAL);                                       \n        p._fulfillmentHandler0 = value;                                      \n        p._rejectionHandler0 = value;                                        \n        p._promise0 = value;                                                 \n        p._receiver0 = value;                                                \n    }                                                                        \n    // Complete slack tracking, opt out of field-type tracking and           \n    // stabilize map                                                         \n    fillTypes({a: 1});                                                       \n    fillTypes({b: 2});                                                       \n    fillTypes({c: 3});                                                       \n    fillTypes(1);                                                            \n    fillTypes(function(){});                                                 \n    fillTypes(undefined);                                                    \n    fillTypes(false);                                                        \n    fillTypes(new Promise(INTERNAL));                                        \n    debug.setBounds(Async.firstLineError, util.lastLineError);               \n    return Promise;                                                          \n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/promise.js\n// module id = 141\n// module chunks = 4","\"use strict\";\nvar firstLineError;\ntry {throw new Error(); } catch (e) {firstLineError = e;}\nvar schedule = require(\"./schedule\");\nvar Queue = require(\"./queue\");\nvar util = require(\"./util\");\n\nfunction Async() {\n    this._customScheduler = false;\n    this._isTickUsed = false;\n    this._lateQueue = new Queue(16);\n    this._normalQueue = new Queue(16);\n    this._haveDrainedQueues = false;\n    this._trampolineEnabled = true;\n    var self = this;\n    this.drainQueues = function () {\n        self._drainQueues();\n    };\n    this._schedule = schedule;\n}\n\nAsync.prototype.setScheduler = function(fn) {\n    var prev = this._schedule;\n    this._schedule = fn;\n    this._customScheduler = true;\n    return prev;\n};\n\nAsync.prototype.hasCustomScheduler = function() {\n    return this._customScheduler;\n};\n\nAsync.prototype.enableTrampoline = function() {\n    this._trampolineEnabled = true;\n};\n\nAsync.prototype.disableTrampolineIfNecessary = function() {\n    if (util.hasDevTools) {\n        this._trampolineEnabled = false;\n    }\n};\n\nAsync.prototype.haveItemsQueued = function () {\n    return this._isTickUsed || this._haveDrainedQueues;\n};\n\n\nAsync.prototype.fatalError = function(e, isNode) {\n    if (isNode) {\n        process.stderr.write(\"Fatal \" + (e instanceof Error ? e.stack : e) +\n            \"\\n\");\n        process.exit(2);\n    } else {\n        this.throwLater(e);\n    }\n};\n\nAsync.prototype.throwLater = function(fn, arg) {\n    if (arguments.length === 1) {\n        arg = fn;\n        fn = function () { throw arg; };\n    }\n    if (typeof setTimeout !== \"undefined\") {\n        setTimeout(function() {\n            fn(arg);\n        }, 0);\n    } else try {\n        this._schedule(function() {\n            fn(arg);\n        });\n    } catch (e) {\n        throw new Error(\"No async scheduler available\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n};\n\nfunction AsyncInvokeLater(fn, receiver, arg) {\n    this._lateQueue.push(fn, receiver, arg);\n    this._queueTick();\n}\n\nfunction AsyncInvoke(fn, receiver, arg) {\n    this._normalQueue.push(fn, receiver, arg);\n    this._queueTick();\n}\n\nfunction AsyncSettlePromises(promise) {\n    this._normalQueue._pushOne(promise);\n    this._queueTick();\n}\n\nif (!util.hasDevTools) {\n    Async.prototype.invokeLater = AsyncInvokeLater;\n    Async.prototype.invoke = AsyncInvoke;\n    Async.prototype.settlePromises = AsyncSettlePromises;\n} else {\n    Async.prototype.invokeLater = function (fn, receiver, arg) {\n        if (this._trampolineEnabled) {\n            AsyncInvokeLater.call(this, fn, receiver, arg);\n        } else {\n            this._schedule(function() {\n                setTimeout(function() {\n                    fn.call(receiver, arg);\n                }, 100);\n            });\n        }\n    };\n\n    Async.prototype.invoke = function (fn, receiver, arg) {\n        if (this._trampolineEnabled) {\n            AsyncInvoke.call(this, fn, receiver, arg);\n        } else {\n            this._schedule(function() {\n                fn.call(receiver, arg);\n            });\n        }\n    };\n\n    Async.prototype.settlePromises = function(promise) {\n        if (this._trampolineEnabled) {\n            AsyncSettlePromises.call(this, promise);\n        } else {\n            this._schedule(function() {\n                promise._settlePromises();\n            });\n        }\n    };\n}\n\nfunction _drainQueue(queue) {\n    while (queue.length() > 0) {\n        _drainQueueStep(queue);\n    }\n}\n\nfunction _drainQueueStep(queue) {\n    var fn = queue.shift();\n    if (typeof fn !== \"function\") {\n        fn._settlePromises();\n    } else {\n        var receiver = queue.shift();\n        var arg = queue.shift();\n        fn.call(receiver, arg);\n    }\n}\n\nAsync.prototype._drainQueues = function () {\n    _drainQueue(this._normalQueue);\n    this._reset();\n    this._haveDrainedQueues = true;\n    _drainQueue(this._lateQueue);\n};\n\nAsync.prototype._queueTick = function () {\n    if (!this._isTickUsed) {\n        this._isTickUsed = true;\n        this._schedule(this.drainQueues);\n    }\n};\n\nAsync.prototype._reset = function () {\n    this._isTickUsed = false;\n};\n\nmodule.exports = Async;\nmodule.exports.firstLineError = firstLineError;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/async.js\n// module id = 142\n// module chunks = 4","\"use strict\";\nvar util = require(\"./util\");\nvar schedule;\nvar noAsyncScheduler = function() {\n    throw new Error(\"No async scheduler available\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n};\nvar NativePromise = util.getNativePromise();\nif (util.isNode && typeof MutationObserver === \"undefined\") {\n    var GlobalSetImmediate = global.setImmediate;\n    var ProcessNextTick = process.nextTick;\n    schedule = util.isRecentNode\n                ? function(fn) { GlobalSetImmediate.call(global, fn); }\n                : function(fn) { ProcessNextTick.call(process, fn); };\n} else if (typeof NativePromise === \"function\" &&\n           typeof NativePromise.resolve === \"function\") {\n    var nativePromise = NativePromise.resolve();\n    schedule = function(fn) {\n        nativePromise.then(fn);\n    };\n} else if ((typeof MutationObserver !== \"undefined\") &&\n          !(typeof window !== \"undefined\" &&\n            window.navigator &&\n            (window.navigator.standalone || window.cordova)) &&\n          (\"classList\" in document.documentElement)) {\n    schedule = (function() {\n        var div = document.createElement(\"div\");\n        var opts = {attributes: true};\n        var toggleScheduled = false;\n        var div2 = document.createElement(\"div\");\n        var o2 = new MutationObserver(function() {\n            div.classList.toggle(\"foo\");\n            toggleScheduled = false;\n        });\n        o2.observe(div2, opts);\n\n        var scheduleToggle = function() {\n            if (toggleScheduled) return;\n            toggleScheduled = true;\n            div2.classList.toggle(\"foo\");\n        };\n\n        return function schedule(fn) {\n            var o = new MutationObserver(function() {\n                o.disconnect();\n                fn();\n            });\n            o.observe(div, opts);\n            scheduleToggle();\n        };\n    })();\n} else if (typeof setImmediate !== \"undefined\") {\n    schedule = function (fn) {\n        setImmediate(fn);\n    };\n} else if (typeof setTimeout !== \"undefined\") {\n    schedule = function (fn) {\n        setTimeout(fn, 0);\n    };\n} else {\n    schedule = noAsyncScheduler;\n}\nmodule.exports = schedule;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/schedule.js\n// module id = 143\n// module chunks = 4","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/.pnpm/timers-browserify@2.0.12/node_modules/timers-browserify/main.js\n// module id = 144\n// module chunks = 4","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/.pnpm/timers-browserify@2.0.12/node_modules/setimmediate/setImmediate.js\n// module id = 145\n// module chunks = 4","\"use strict\";\nfunction arrayMove(src, srcIndex, dst, dstIndex, len) {\n    for (var j = 0; j < len; ++j) {\n        dst[j + dstIndex] = src[j + srcIndex];\n        src[j + srcIndex] = void 0;\n    }\n}\n\nfunction Queue(capacity) {\n    this._capacity = capacity;\n    this._length = 0;\n    this._front = 0;\n}\n\nQueue.prototype._willBeOverCapacity = function (size) {\n    return this._capacity < size;\n};\n\nQueue.prototype._pushOne = function (arg) {\n    var length = this.length();\n    this._checkCapacity(length + 1);\n    var i = (this._front + length) & (this._capacity - 1);\n    this[i] = arg;\n    this._length = length + 1;\n};\n\nQueue.prototype.push = function (fn, receiver, arg) {\n    var length = this.length() + 3;\n    if (this._willBeOverCapacity(length)) {\n        this._pushOne(fn);\n        this._pushOne(receiver);\n        this._pushOne(arg);\n        return;\n    }\n    var j = this._front + length - 3;\n    this._checkCapacity(length);\n    var wrapMask = this._capacity - 1;\n    this[(j + 0) & wrapMask] = fn;\n    this[(j + 1) & wrapMask] = receiver;\n    this[(j + 2) & wrapMask] = arg;\n    this._length = length;\n};\n\nQueue.prototype.shift = function () {\n    var front = this._front,\n        ret = this[front];\n\n    this[front] = undefined;\n    this._front = (front + 1) & (this._capacity - 1);\n    this._length--;\n    return ret;\n};\n\nQueue.prototype.length = function () {\n    return this._length;\n};\n\nQueue.prototype._checkCapacity = function (size) {\n    if (this._capacity < size) {\n        this._resizeTo(this._capacity << 1);\n    }\n};\n\nQueue.prototype._resizeTo = function (capacity) {\n    var oldCapacity = this._capacity;\n    this._capacity = capacity;\n    var front = this._front;\n    var length = this._length;\n    var moveItemsCount = (front + length) & (oldCapacity - 1);\n    arrayMove(this, 0, this, oldCapacity, moveItemsCount);\n};\n\nmodule.exports = Queue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/queue.js\n// module id = 146\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar util = require(\"./util\");\nvar errorObj = util.errorObj;\nvar isObject = util.isObject;\n\nfunction tryConvertToPromise(obj, context) {\n    if (isObject(obj)) {\n        if (obj instanceof Promise) return obj;\n        var then = getThen(obj);\n        if (then === errorObj) {\n            if (context) context._pushContext();\n            var ret = Promise.reject(then.e);\n            if (context) context._popContext();\n            return ret;\n        } else if (typeof then === \"function\") {\n            if (isAnyBluebirdPromise(obj)) {\n                var ret = new Promise(INTERNAL);\n                obj._then(\n                    ret._fulfill,\n                    ret._reject,\n                    undefined,\n                    ret,\n                    null\n                );\n                return ret;\n            }\n            return doThenable(obj, then, context);\n        }\n    }\n    return obj;\n}\n\nfunction doGetThen(obj) {\n    return obj.then;\n}\n\nfunction getThen(obj) {\n    try {\n        return doGetThen(obj);\n    } catch (e) {\n        errorObj.e = e;\n        return errorObj;\n    }\n}\n\nvar hasProp = {}.hasOwnProperty;\nfunction isAnyBluebirdPromise(obj) {\n    try {\n        return hasProp.call(obj, \"_promise0\");\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction doThenable(x, then, context) {\n    var promise = new Promise(INTERNAL);\n    var ret = promise;\n    if (context) context._pushContext();\n    promise._captureStackTrace();\n    if (context) context._popContext();\n    var synchronous = true;\n    var result = util.tryCatch(then).call(x, resolve, reject);\n    synchronous = false;\n\n    if (promise && result === errorObj) {\n        promise._rejectCallback(result.e, true, true);\n        promise = null;\n    }\n\n    function resolve(value) {\n        if (!promise) return;\n        promise._resolveCallback(value);\n        promise = null;\n    }\n\n    function reject(reason) {\n        if (!promise) return;\n        promise._rejectCallback(reason, synchronous, true);\n        promise = null;\n    }\n    return ret;\n}\n\nreturn tryConvertToPromise;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/thenables.js\n// module id = 147\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, INTERNAL, tryConvertToPromise,\n    apiRejection, Proxyable) {\nvar util = require(\"./util\");\nvar isArray = util.isArray;\n\nfunction toResolutionValue(val) {\n    switch(val) {\n    case -2: return [];\n    case -3: return {};\n    case -6: return new Map();\n    }\n}\n\nfunction PromiseArray(values) {\n    var promise = this._promise = new Promise(INTERNAL);\n    if (values instanceof Promise) {\n        promise._propagateFrom(values, 3);\n    }\n    promise._setOnCancel(this);\n    this._values = values;\n    this._length = 0;\n    this._totalResolved = 0;\n    this._init(undefined, -2);\n}\nutil.inherits(PromiseArray, Proxyable);\n\nPromiseArray.prototype.length = function () {\n    return this._length;\n};\n\nPromiseArray.prototype.promise = function () {\n    return this._promise;\n};\n\nPromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {\n    var values = tryConvertToPromise(this._values, this._promise);\n    if (values instanceof Promise) {\n        values = values._target();\n        var bitField = values._bitField;\n        ;\n        this._values = values;\n\n        if (((bitField & 50397184) === 0)) {\n            this._promise._setAsyncGuaranteed();\n            return values._then(\n                init,\n                this._reject,\n                undefined,\n                this,\n                resolveValueIfEmpty\n           );\n        } else if (((bitField & 33554432) !== 0)) {\n            values = values._value();\n        } else if (((bitField & 16777216) !== 0)) {\n            return this._reject(values._reason());\n        } else {\n            return this._cancel();\n        }\n    }\n    values = util.asArray(values);\n    if (values === null) {\n        var err = apiRejection(\n            \"expecting an array or an iterable object but got \" + util.classString(values)).reason();\n        this._promise._rejectCallback(err, false);\n        return;\n    }\n\n    if (values.length === 0) {\n        if (resolveValueIfEmpty === -5) {\n            this._resolveEmptyArray();\n        }\n        else {\n            this._resolve(toResolutionValue(resolveValueIfEmpty));\n        }\n        return;\n    }\n    this._iterate(values);\n};\n\nPromiseArray.prototype._iterate = function(values) {\n    var len = this.getActualLength(values.length);\n    this._length = len;\n    this._values = this.shouldCopyValues() ? new Array(len) : this._values;\n    var result = this._promise;\n    var isResolved = false;\n    var bitField = null;\n    for (var i = 0; i < len; ++i) {\n        var maybePromise = tryConvertToPromise(values[i], result);\n\n        if (maybePromise instanceof Promise) {\n            maybePromise = maybePromise._target();\n            bitField = maybePromise._bitField;\n        } else {\n            bitField = null;\n        }\n\n        if (isResolved) {\n            if (bitField !== null) {\n                maybePromise.suppressUnhandledRejections();\n            }\n        } else if (bitField !== null) {\n            if (((bitField & 50397184) === 0)) {\n                maybePromise._proxy(this, i);\n                this._values[i] = maybePromise;\n            } else if (((bitField & 33554432) !== 0)) {\n                isResolved = this._promiseFulfilled(maybePromise._value(), i);\n            } else if (((bitField & 16777216) !== 0)) {\n                isResolved = this._promiseRejected(maybePromise._reason(), i);\n            } else {\n                isResolved = this._promiseCancelled(i);\n            }\n        } else {\n            isResolved = this._promiseFulfilled(maybePromise, i);\n        }\n    }\n    if (!isResolved) result._setAsyncGuaranteed();\n};\n\nPromiseArray.prototype._isResolved = function () {\n    return this._values === null;\n};\n\nPromiseArray.prototype._resolve = function (value) {\n    this._values = null;\n    this._promise._fulfill(value);\n};\n\nPromiseArray.prototype._cancel = function() {\n    if (this._isResolved() || !this._promise._isCancellable()) return;\n    this._values = null;\n    this._promise._cancel();\n};\n\nPromiseArray.prototype._reject = function (reason) {\n    this._values = null;\n    this._promise._rejectCallback(reason, false);\n};\n\nPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    this._values[index] = value;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        this._resolve(this._values);\n        return true;\n    }\n    return false;\n};\n\nPromiseArray.prototype._promiseCancelled = function() {\n    this._cancel();\n    return true;\n};\n\nPromiseArray.prototype._promiseRejected = function (reason) {\n    this._totalResolved++;\n    this._reject(reason);\n    return true;\n};\n\nPromiseArray.prototype._resultCancelled = function() {\n    if (this._isResolved()) return;\n    var values = this._values;\n    this._cancel();\n    if (values instanceof Promise) {\n        values.cancel();\n    } else {\n        for (var i = 0; i < values.length; ++i) {\n            if (values[i] instanceof Promise) {\n                values[i].cancel();\n            }\n        }\n    }\n};\n\nPromiseArray.prototype.shouldCopyValues = function () {\n    return true;\n};\n\nPromiseArray.prototype.getActualLength = function (len) {\n    return len;\n};\n\nreturn PromiseArray;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/promise_array.js\n// module id = 148\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise) {\nvar longStackTraces = false;\nvar contextStack = [];\n\nPromise.prototype._promiseCreated = function() {};\nPromise.prototype._pushContext = function() {};\nPromise.prototype._popContext = function() {return null;};\nPromise._peekContext = Promise.prototype._peekContext = function() {};\n\nfunction Context() {\n    this._trace = new Context.CapturedTrace(peekContext());\n}\nContext.prototype._pushContext = function () {\n    if (this._trace !== undefined) {\n        this._trace._promiseCreated = null;\n        contextStack.push(this._trace);\n    }\n};\n\nContext.prototype._popContext = function () {\n    if (this._trace !== undefined) {\n        var trace = contextStack.pop();\n        var ret = trace._promiseCreated;\n        trace._promiseCreated = null;\n        return ret;\n    }\n    return null;\n};\n\nfunction createContext() {\n    if (longStackTraces) return new Context();\n}\n\nfunction peekContext() {\n    var lastIndex = contextStack.length - 1;\n    if (lastIndex >= 0) {\n        return contextStack[lastIndex];\n    }\n    return undefined;\n}\nContext.CapturedTrace = null;\nContext.create = createContext;\nContext.deactivateLongStackTraces = function() {};\nContext.activateLongStackTraces = function() {\n    var Promise_pushContext = Promise.prototype._pushContext;\n    var Promise_popContext = Promise.prototype._popContext;\n    var Promise_PeekContext = Promise._peekContext;\n    var Promise_peekContext = Promise.prototype._peekContext;\n    var Promise_promiseCreated = Promise.prototype._promiseCreated;\n    Context.deactivateLongStackTraces = function() {\n        Promise.prototype._pushContext = Promise_pushContext;\n        Promise.prototype._popContext = Promise_popContext;\n        Promise._peekContext = Promise_PeekContext;\n        Promise.prototype._peekContext = Promise_peekContext;\n        Promise.prototype._promiseCreated = Promise_promiseCreated;\n        longStackTraces = false;\n    };\n    longStackTraces = true;\n    Promise.prototype._pushContext = Context.prototype._pushContext;\n    Promise.prototype._popContext = Context.prototype._popContext;\n    Promise._peekContext = Promise.prototype._peekContext = peekContext;\n    Promise.prototype._promiseCreated = function() {\n        var ctx = this._peekContext();\n        if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;\n    };\n};\nreturn Context;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/context.js\n// module id = 149\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, Context) {\nvar getDomain = Promise._getDomain;\nvar async = Promise._async;\nvar Warning = require(\"./errors\").Warning;\nvar util = require(\"./util\");\nvar es5 = require(\"./es5\");\nvar canAttachTrace = util.canAttachTrace;\nvar unhandledRejectionHandled;\nvar possiblyUnhandledRejection;\nvar bluebirdFramePattern =\n    /[\\\\\\/]bluebird[\\\\\\/]js[\\\\\\/](release|debug|instrumented)/;\nvar nodeFramePattern = /\\((?:timers\\.js):\\d+:\\d+\\)/;\nvar parseLinePattern = /[\\/<\\(](.+?):(\\d+):(\\d+)\\)?\\s*$/;\nvar stackFramePattern = null;\nvar formatStack = null;\nvar indentStackFrames = false;\nvar printWarning;\nvar debugging = !!(util.env(\"BLUEBIRD_DEBUG\") != 0 &&\n                        (false ||\n                         util.env(\"BLUEBIRD_DEBUG\") ||\n                         util.env(\"NODE_ENV\") === \"development\"));\n\nvar warnings = !!(util.env(\"BLUEBIRD_WARNINGS\") != 0 &&\n    (debugging || util.env(\"BLUEBIRD_WARNINGS\")));\n\nvar longStackTraces = !!(util.env(\"BLUEBIRD_LONG_STACK_TRACES\") != 0 &&\n    (debugging || util.env(\"BLUEBIRD_LONG_STACK_TRACES\")));\n\nvar wForgottenReturn = util.env(\"BLUEBIRD_W_FORGOTTEN_RETURN\") != 0 &&\n    (warnings || !!util.env(\"BLUEBIRD_W_FORGOTTEN_RETURN\"));\n\nPromise.prototype.suppressUnhandledRejections = function() {\n    var target = this._target();\n    target._bitField = ((target._bitField & (~1048576)) |\n                      524288);\n};\n\nPromise.prototype._ensurePossibleRejectionHandled = function () {\n    if ((this._bitField & 524288) !== 0) return;\n    this._setRejectionIsUnhandled();\n    var self = this;\n    setTimeout(function() {\n        self._notifyUnhandledRejection();\n    }, 1);\n};\n\nPromise.prototype._notifyUnhandledRejectionIsHandled = function () {\n    fireRejectionEvent(\"rejectionHandled\",\n                                  unhandledRejectionHandled, undefined, this);\n};\n\nPromise.prototype._setReturnedNonUndefined = function() {\n    this._bitField = this._bitField | 268435456;\n};\n\nPromise.prototype._returnedNonUndefined = function() {\n    return (this._bitField & 268435456) !== 0;\n};\n\nPromise.prototype._notifyUnhandledRejection = function () {\n    if (this._isRejectionUnhandled()) {\n        var reason = this._settledValue();\n        this._setUnhandledRejectionIsNotified();\n        fireRejectionEvent(\"unhandledRejection\",\n                                      possiblyUnhandledRejection, reason, this);\n    }\n};\n\nPromise.prototype._setUnhandledRejectionIsNotified = function () {\n    this._bitField = this._bitField | 262144;\n};\n\nPromise.prototype._unsetUnhandledRejectionIsNotified = function () {\n    this._bitField = this._bitField & (~262144);\n};\n\nPromise.prototype._isUnhandledRejectionNotified = function () {\n    return (this._bitField & 262144) > 0;\n};\n\nPromise.prototype._setRejectionIsUnhandled = function () {\n    this._bitField = this._bitField | 1048576;\n};\n\nPromise.prototype._unsetRejectionIsUnhandled = function () {\n    this._bitField = this._bitField & (~1048576);\n    if (this._isUnhandledRejectionNotified()) {\n        this._unsetUnhandledRejectionIsNotified();\n        this._notifyUnhandledRejectionIsHandled();\n    }\n};\n\nPromise.prototype._isRejectionUnhandled = function () {\n    return (this._bitField & 1048576) > 0;\n};\n\nPromise.prototype._warn = function(message, shouldUseOwnTrace, promise) {\n    return warn(message, shouldUseOwnTrace, promise || this);\n};\n\nPromise.onPossiblyUnhandledRejection = function (fn) {\n    var domain = getDomain();\n    possiblyUnhandledRejection =\n        typeof fn === \"function\" ? (domain === null ?\n                                            fn : util.domainBind(domain, fn))\n                                 : undefined;\n};\n\nPromise.onUnhandledRejectionHandled = function (fn) {\n    var domain = getDomain();\n    unhandledRejectionHandled =\n        typeof fn === \"function\" ? (domain === null ?\n                                            fn : util.domainBind(domain, fn))\n                                 : undefined;\n};\n\nvar disableLongStackTraces = function() {};\nPromise.longStackTraces = function () {\n    if (async.haveItemsQueued() && !config.longStackTraces) {\n        throw new Error(\"cannot enable long stack traces after promises have been created\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    if (!config.longStackTraces && longStackTracesIsSupported()) {\n        var Promise_captureStackTrace = Promise.prototype._captureStackTrace;\n        var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;\n        var Promise_dereferenceTrace = Promise.prototype._dereferenceTrace;\n        config.longStackTraces = true;\n        disableLongStackTraces = function() {\n            if (async.haveItemsQueued() && !config.longStackTraces) {\n                throw new Error(\"cannot enable long stack traces after promises have been created\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n            }\n            Promise.prototype._captureStackTrace = Promise_captureStackTrace;\n            Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;\n            Promise.prototype._dereferenceTrace = Promise_dereferenceTrace;\n            Context.deactivateLongStackTraces();\n            async.enableTrampoline();\n            config.longStackTraces = false;\n        };\n        Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;\n        Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;\n        Promise.prototype._dereferenceTrace = longStackTracesDereferenceTrace;\n        Context.activateLongStackTraces();\n        async.disableTrampolineIfNecessary();\n    }\n};\n\nPromise.hasLongStackTraces = function () {\n    return config.longStackTraces && longStackTracesIsSupported();\n};\n\nvar fireDomEvent = (function() {\n    try {\n        if (typeof CustomEvent === \"function\") {\n            var event = new CustomEvent(\"CustomEvent\");\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                var eventData = {\n                    detail: event,\n                    cancelable: true\n                };\n                es5.defineProperty(\n                    eventData, \"promise\", {value: event.promise});\n                es5.defineProperty(eventData, \"reason\", {value: event.reason});\n                var domEvent = new CustomEvent(name.toLowerCase(), eventData);\n                return !util.global.dispatchEvent(domEvent);\n            };\n        } else if (typeof Event === \"function\") {\n            var event = new Event(\"CustomEvent\");\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                var domEvent = new Event(name.toLowerCase(), {\n                    cancelable: true\n                });\n                domEvent.detail = event;\n                es5.defineProperty(domEvent, \"promise\", {value: event.promise});\n                es5.defineProperty(domEvent, \"reason\", {value: event.reason});\n                return !util.global.dispatchEvent(domEvent);\n            };\n        } else {\n            var event = document.createEvent(\"CustomEvent\");\n            event.initCustomEvent(\"testingtheevent\", false, true, {});\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                var domEvent = document.createEvent(\"CustomEvent\");\n                domEvent.initCustomEvent(name.toLowerCase(), false, true,\n                    event);\n                return !util.global.dispatchEvent(domEvent);\n            };\n        }\n    } catch (e) {}\n    return function() {\n        return false;\n    };\n})();\n\nvar fireGlobalEvent = (function() {\n    if (util.isNode) {\n        return function() {\n            return process.emit.apply(process, arguments);\n        };\n    } else {\n        if (!util.global) {\n            return function() {\n                return false;\n            };\n        }\n        return function(name) {\n            var methodName = \"on\" + name.toLowerCase();\n            var method = util.global[methodName];\n            if (!method) return false;\n            method.apply(util.global, [].slice.call(arguments, 1));\n            return true;\n        };\n    }\n})();\n\nfunction generatePromiseLifecycleEventObject(name, promise) {\n    return {promise: promise};\n}\n\nvar eventToObjectGenerator = {\n    promiseCreated: generatePromiseLifecycleEventObject,\n    promiseFulfilled: generatePromiseLifecycleEventObject,\n    promiseRejected: generatePromiseLifecycleEventObject,\n    promiseResolved: generatePromiseLifecycleEventObject,\n    promiseCancelled: generatePromiseLifecycleEventObject,\n    promiseChained: function(name, promise, child) {\n        return {promise: promise, child: child};\n    },\n    warning: function(name, warning) {\n        return {warning: warning};\n    },\n    unhandledRejection: function (name, reason, promise) {\n        return {reason: reason, promise: promise};\n    },\n    rejectionHandled: generatePromiseLifecycleEventObject\n};\n\nvar activeFireEvent = function (name) {\n    var globalEventFired = false;\n    try {\n        globalEventFired = fireGlobalEvent.apply(null, arguments);\n    } catch (e) {\n        async.throwLater(e);\n        globalEventFired = true;\n    }\n\n    var domEventFired = false;\n    try {\n        domEventFired = fireDomEvent(name,\n                    eventToObjectGenerator[name].apply(null, arguments));\n    } catch (e) {\n        async.throwLater(e);\n        domEventFired = true;\n    }\n\n    return domEventFired || globalEventFired;\n};\n\nPromise.config = function(opts) {\n    opts = Object(opts);\n    if (\"longStackTraces\" in opts) {\n        if (opts.longStackTraces) {\n            Promise.longStackTraces();\n        } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {\n            disableLongStackTraces();\n        }\n    }\n    if (\"warnings\" in opts) {\n        var warningsOption = opts.warnings;\n        config.warnings = !!warningsOption;\n        wForgottenReturn = config.warnings;\n\n        if (util.isObject(warningsOption)) {\n            if (\"wForgottenReturn\" in warningsOption) {\n                wForgottenReturn = !!warningsOption.wForgottenReturn;\n            }\n        }\n    }\n    if (\"cancellation\" in opts && opts.cancellation && !config.cancellation) {\n        if (async.haveItemsQueued()) {\n            throw new Error(\n                \"cannot enable cancellation after promises are in use\");\n        }\n        Promise.prototype._clearCancellationData =\n            cancellationClearCancellationData;\n        Promise.prototype._propagateFrom = cancellationPropagateFrom;\n        Promise.prototype._onCancel = cancellationOnCancel;\n        Promise.prototype._setOnCancel = cancellationSetOnCancel;\n        Promise.prototype._attachCancellationCallback =\n            cancellationAttachCancellationCallback;\n        Promise.prototype._execute = cancellationExecute;\n        propagateFromFunction = cancellationPropagateFrom;\n        config.cancellation = true;\n    }\n    if (\"monitoring\" in opts) {\n        if (opts.monitoring && !config.monitoring) {\n            config.monitoring = true;\n            Promise.prototype._fireEvent = activeFireEvent;\n        } else if (!opts.monitoring && config.monitoring) {\n            config.monitoring = false;\n            Promise.prototype._fireEvent = defaultFireEvent;\n        }\n    }\n    return Promise;\n};\n\nfunction defaultFireEvent() { return false; }\n\nPromise.prototype._fireEvent = defaultFireEvent;\nPromise.prototype._execute = function(executor, resolve, reject) {\n    try {\n        executor(resolve, reject);\n    } catch (e) {\n        return e;\n    }\n};\nPromise.prototype._onCancel = function () {};\nPromise.prototype._setOnCancel = function (handler) { ; };\nPromise.prototype._attachCancellationCallback = function(onCancel) {\n    ;\n};\nPromise.prototype._captureStackTrace = function () {};\nPromise.prototype._attachExtraTrace = function () {};\nPromise.prototype._dereferenceTrace = function () {};\nPromise.prototype._clearCancellationData = function() {};\nPromise.prototype._propagateFrom = function (parent, flags) {\n    ;\n    ;\n};\n\nfunction cancellationExecute(executor, resolve, reject) {\n    var promise = this;\n    try {\n        executor(resolve, reject, function(onCancel) {\n            if (typeof onCancel !== \"function\") {\n                throw new TypeError(\"onCancel must be a function, got: \" +\n                                    util.toString(onCancel));\n            }\n            promise._attachCancellationCallback(onCancel);\n        });\n    } catch (e) {\n        return e;\n    }\n}\n\nfunction cancellationAttachCancellationCallback(onCancel) {\n    if (!this._isCancellable()) return this;\n\n    var previousOnCancel = this._onCancel();\n    if (previousOnCancel !== undefined) {\n        if (util.isArray(previousOnCancel)) {\n            previousOnCancel.push(onCancel);\n        } else {\n            this._setOnCancel([previousOnCancel, onCancel]);\n        }\n    } else {\n        this._setOnCancel(onCancel);\n    }\n}\n\nfunction cancellationOnCancel() {\n    return this._onCancelField;\n}\n\nfunction cancellationSetOnCancel(onCancel) {\n    this._onCancelField = onCancel;\n}\n\nfunction cancellationClearCancellationData() {\n    this._cancellationParent = undefined;\n    this._onCancelField = undefined;\n}\n\nfunction cancellationPropagateFrom(parent, flags) {\n    if ((flags & 1) !== 0) {\n        this._cancellationParent = parent;\n        var branchesRemainingToCancel = parent._branchesRemainingToCancel;\n        if (branchesRemainingToCancel === undefined) {\n            branchesRemainingToCancel = 0;\n        }\n        parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;\n    }\n    if ((flags & 2) !== 0 && parent._isBound()) {\n        this._setBoundTo(parent._boundTo);\n    }\n}\n\nfunction bindingPropagateFrom(parent, flags) {\n    if ((flags & 2) !== 0 && parent._isBound()) {\n        this._setBoundTo(parent._boundTo);\n    }\n}\nvar propagateFromFunction = bindingPropagateFrom;\n\nfunction boundValueFunction() {\n    var ret = this._boundTo;\n    if (ret !== undefined) {\n        if (ret instanceof Promise) {\n            if (ret.isFulfilled()) {\n                return ret.value();\n            } else {\n                return undefined;\n            }\n        }\n    }\n    return ret;\n}\n\nfunction longStackTracesCaptureStackTrace() {\n    this._trace = new CapturedTrace(this._peekContext());\n}\n\nfunction longStackTracesAttachExtraTrace(error, ignoreSelf) {\n    if (canAttachTrace(error)) {\n        var trace = this._trace;\n        if (trace !== undefined) {\n            if (ignoreSelf) trace = trace._parent;\n        }\n        if (trace !== undefined) {\n            trace.attachExtraTrace(error);\n        } else if (!error.__stackCleaned__) {\n            var parsed = parseStackAndMessage(error);\n            util.notEnumerableProp(error, \"stack\",\n                parsed.message + \"\\n\" + parsed.stack.join(\"\\n\"));\n            util.notEnumerableProp(error, \"__stackCleaned__\", true);\n        }\n    }\n}\n\nfunction longStackTracesDereferenceTrace() {\n    this._trace = undefined;\n}\n\nfunction checkForgottenReturns(returnValue, promiseCreated, name, promise,\n                               parent) {\n    if (returnValue === undefined && promiseCreated !== null &&\n        wForgottenReturn) {\n        if (parent !== undefined && parent._returnedNonUndefined()) return;\n        if ((promise._bitField & 65535) === 0) return;\n\n        if (name) name = name + \" \";\n        var handlerLine = \"\";\n        var creatorLine = \"\";\n        if (promiseCreated._trace) {\n            var traceLines = promiseCreated._trace.stack.split(\"\\n\");\n            var stack = cleanStack(traceLines);\n            for (var i = stack.length - 1; i >= 0; --i) {\n                var line = stack[i];\n                if (!nodeFramePattern.test(line)) {\n                    var lineMatches = line.match(parseLinePattern);\n                    if (lineMatches) {\n                        handlerLine  = \"at \" + lineMatches[1] +\n                            \":\" + lineMatches[2] + \":\" + lineMatches[3] + \" \";\n                    }\n                    break;\n                }\n            }\n\n            if (stack.length > 0) {\n                var firstUserLine = stack[0];\n                for (var i = 0; i < traceLines.length; ++i) {\n\n                    if (traceLines[i] === firstUserLine) {\n                        if (i > 0) {\n                            creatorLine = \"\\n\" + traceLines[i - 1];\n                        }\n                        break;\n                    }\n                }\n\n            }\n        }\n        var msg = \"a promise was created in a \" + name +\n            \"handler \" + handlerLine + \"but was not returned from it, \" +\n            \"see http://goo.gl/rRqMUw\" +\n            creatorLine;\n        promise._warn(msg, true, promiseCreated);\n    }\n}\n\nfunction deprecated(name, replacement) {\n    var message = name +\n        \" is deprecated and will be removed in a future version.\";\n    if (replacement) message += \" Use \" + replacement + \" instead.\";\n    return warn(message);\n}\n\nfunction warn(message, shouldUseOwnTrace, promise) {\n    if (!config.warnings) return;\n    var warning = new Warning(message);\n    var ctx;\n    if (shouldUseOwnTrace) {\n        promise._attachExtraTrace(warning);\n    } else if (config.longStackTraces && (ctx = Promise._peekContext())) {\n        ctx.attachExtraTrace(warning);\n    } else {\n        var parsed = parseStackAndMessage(warning);\n        warning.stack = parsed.message + \"\\n\" + parsed.stack.join(\"\\n\");\n    }\n\n    if (!activeFireEvent(\"warning\", warning)) {\n        formatAndLogError(warning, \"\", true);\n    }\n}\n\nfunction reconstructStack(message, stacks) {\n    for (var i = 0; i < stacks.length - 1; ++i) {\n        stacks[i].push(\"From previous event:\");\n        stacks[i] = stacks[i].join(\"\\n\");\n    }\n    if (i < stacks.length) {\n        stacks[i] = stacks[i].join(\"\\n\");\n    }\n    return message + \"\\n\" + stacks.join(\"\\n\");\n}\n\nfunction removeDuplicateOrEmptyJumps(stacks) {\n    for (var i = 0; i < stacks.length; ++i) {\n        if (stacks[i].length === 0 ||\n            ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {\n            stacks.splice(i, 1);\n            i--;\n        }\n    }\n}\n\nfunction removeCommonRoots(stacks) {\n    var current = stacks[0];\n    for (var i = 1; i < stacks.length; ++i) {\n        var prev = stacks[i];\n        var currentLastIndex = current.length - 1;\n        var currentLastLine = current[currentLastIndex];\n        var commonRootMeetPoint = -1;\n\n        for (var j = prev.length - 1; j >= 0; --j) {\n            if (prev[j] === currentLastLine) {\n                commonRootMeetPoint = j;\n                break;\n            }\n        }\n\n        for (var j = commonRootMeetPoint; j >= 0; --j) {\n            var line = prev[j];\n            if (current[currentLastIndex] === line) {\n                current.pop();\n                currentLastIndex--;\n            } else {\n                break;\n            }\n        }\n        current = prev;\n    }\n}\n\nfunction cleanStack(stack) {\n    var ret = [];\n    for (var i = 0; i < stack.length; ++i) {\n        var line = stack[i];\n        var isTraceLine = \"    (No stack trace)\" === line ||\n            stackFramePattern.test(line);\n        var isInternalFrame = isTraceLine && shouldIgnore(line);\n        if (isTraceLine && !isInternalFrame) {\n            if (indentStackFrames && line.charAt(0) !== \" \") {\n                line = \"    \" + line;\n            }\n            ret.push(line);\n        }\n    }\n    return ret;\n}\n\nfunction stackFramesAsArray(error) {\n    var stack = error.stack.replace(/\\s+$/g, \"\").split(\"\\n\");\n    for (var i = 0; i < stack.length; ++i) {\n        var line = stack[i];\n        if (\"    (No stack trace)\" === line || stackFramePattern.test(line)) {\n            break;\n        }\n    }\n    if (i > 0 && error.name != \"SyntaxError\") {\n        stack = stack.slice(i);\n    }\n    return stack;\n}\n\nfunction parseStackAndMessage(error) {\n    var stack = error.stack;\n    var message = error.toString();\n    stack = typeof stack === \"string\" && stack.length > 0\n                ? stackFramesAsArray(error) : [\"    (No stack trace)\"];\n    return {\n        message: message,\n        stack: error.name == \"SyntaxError\" ? stack : cleanStack(stack)\n    };\n}\n\nfunction formatAndLogError(error, title, isSoft) {\n    if (typeof console !== \"undefined\") {\n        var message;\n        if (util.isObject(error)) {\n            var stack = error.stack;\n            message = title + formatStack(stack, error);\n        } else {\n            message = title + String(error);\n        }\n        if (typeof printWarning === \"function\") {\n            printWarning(message, isSoft);\n        } else if (typeof console.log === \"function\" ||\n            typeof console.log === \"object\") {\n            console.log(message);\n        }\n    }\n}\n\nfunction fireRejectionEvent(name, localHandler, reason, promise) {\n    var localEventFired = false;\n    try {\n        if (typeof localHandler === \"function\") {\n            localEventFired = true;\n            if (name === \"rejectionHandled\") {\n                localHandler(promise);\n            } else {\n                localHandler(reason, promise);\n            }\n        }\n    } catch (e) {\n        async.throwLater(e);\n    }\n\n    if (name === \"unhandledRejection\") {\n        if (!activeFireEvent(name, reason, promise) && !localEventFired) {\n            formatAndLogError(reason, \"Unhandled rejection \");\n        }\n    } else {\n        activeFireEvent(name, promise);\n    }\n}\n\nfunction formatNonError(obj) {\n    var str;\n    if (typeof obj === \"function\") {\n        str = \"[function \" +\n            (obj.name || \"anonymous\") +\n            \"]\";\n    } else {\n        str = obj && typeof obj.toString === \"function\"\n            ? obj.toString() : util.toString(obj);\n        var ruselessToString = /\\[object [a-zA-Z0-9$_]+\\]/;\n        if (ruselessToString.test(str)) {\n            try {\n                var newStr = JSON.stringify(obj);\n                str = newStr;\n            }\n            catch(e) {\n\n            }\n        }\n        if (str.length === 0) {\n            str = \"(empty array)\";\n        }\n    }\n    return (\"(<\" + snip(str) + \">, no stack trace)\");\n}\n\nfunction snip(str) {\n    var maxChars = 41;\n    if (str.length < maxChars) {\n        return str;\n    }\n    return str.substr(0, maxChars - 3) + \"...\";\n}\n\nfunction longStackTracesIsSupported() {\n    return typeof captureStackTrace === \"function\";\n}\n\nvar shouldIgnore = function() { return false; };\nvar parseLineInfoRegex = /[\\/<\\(]([^:\\/]+):(\\d+):(?:\\d+)\\)?\\s*$/;\nfunction parseLineInfo(line) {\n    var matches = line.match(parseLineInfoRegex);\n    if (matches) {\n        return {\n            fileName: matches[1],\n            line: parseInt(matches[2], 10)\n        };\n    }\n}\n\nfunction setBounds(firstLineError, lastLineError) {\n    if (!longStackTracesIsSupported()) return;\n    var firstStackLines = (firstLineError.stack || \"\").split(\"\\n\");\n    var lastStackLines = (lastLineError.stack || \"\").split(\"\\n\");\n    var firstIndex = -1;\n    var lastIndex = -1;\n    var firstFileName;\n    var lastFileName;\n    for (var i = 0; i < firstStackLines.length; ++i) {\n        var result = parseLineInfo(firstStackLines[i]);\n        if (result) {\n            firstFileName = result.fileName;\n            firstIndex = result.line;\n            break;\n        }\n    }\n    for (var i = 0; i < lastStackLines.length; ++i) {\n        var result = parseLineInfo(lastStackLines[i]);\n        if (result) {\n            lastFileName = result.fileName;\n            lastIndex = result.line;\n            break;\n        }\n    }\n    if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||\n        firstFileName !== lastFileName || firstIndex >= lastIndex) {\n        return;\n    }\n\n    shouldIgnore = function(line) {\n        if (bluebirdFramePattern.test(line)) return true;\n        var info = parseLineInfo(line);\n        if (info) {\n            if (info.fileName === firstFileName &&\n                (firstIndex <= info.line && info.line <= lastIndex)) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\n\nfunction CapturedTrace(parent) {\n    this._parent = parent;\n    this._promisesCreated = 0;\n    var length = this._length = 1 + (parent === undefined ? 0 : parent._length);\n    captureStackTrace(this, CapturedTrace);\n    if (length > 32) this.uncycle();\n}\nutil.inherits(CapturedTrace, Error);\nContext.CapturedTrace = CapturedTrace;\n\nCapturedTrace.prototype.uncycle = function() {\n    var length = this._length;\n    if (length < 2) return;\n    var nodes = [];\n    var stackToIndex = {};\n\n    for (var i = 0, node = this; node !== undefined; ++i) {\n        nodes.push(node);\n        node = node._parent;\n    }\n    length = this._length = i;\n    for (var i = length - 1; i >= 0; --i) {\n        var stack = nodes[i].stack;\n        if (stackToIndex[stack] === undefined) {\n            stackToIndex[stack] = i;\n        }\n    }\n    for (var i = 0; i < length; ++i) {\n        var currentStack = nodes[i].stack;\n        var index = stackToIndex[currentStack];\n        if (index !== undefined && index !== i) {\n            if (index > 0) {\n                nodes[index - 1]._parent = undefined;\n                nodes[index - 1]._length = 1;\n            }\n            nodes[i]._parent = undefined;\n            nodes[i]._length = 1;\n            var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;\n\n            if (index < length - 1) {\n                cycleEdgeNode._parent = nodes[index + 1];\n                cycleEdgeNode._parent.uncycle();\n                cycleEdgeNode._length =\n                    cycleEdgeNode._parent._length + 1;\n            } else {\n                cycleEdgeNode._parent = undefined;\n                cycleEdgeNode._length = 1;\n            }\n            var currentChildLength = cycleEdgeNode._length + 1;\n            for (var j = i - 2; j >= 0; --j) {\n                nodes[j]._length = currentChildLength;\n                currentChildLength++;\n            }\n            return;\n        }\n    }\n};\n\nCapturedTrace.prototype.attachExtraTrace = function(error) {\n    if (error.__stackCleaned__) return;\n    this.uncycle();\n    var parsed = parseStackAndMessage(error);\n    var message = parsed.message;\n    var stacks = [parsed.stack];\n\n    var trace = this;\n    while (trace !== undefined) {\n        stacks.push(cleanStack(trace.stack.split(\"\\n\")));\n        trace = trace._parent;\n    }\n    removeCommonRoots(stacks);\n    removeDuplicateOrEmptyJumps(stacks);\n    util.notEnumerableProp(error, \"stack\", reconstructStack(message, stacks));\n    util.notEnumerableProp(error, \"__stackCleaned__\", true);\n};\n\nvar captureStackTrace = (function stackDetection() {\n    var v8stackFramePattern = /^\\s*at\\s*/;\n    var v8stackFormatter = function(stack, error) {\n        if (typeof stack === \"string\") return stack;\n\n        if (error.name !== undefined &&\n            error.message !== undefined) {\n            return error.toString();\n        }\n        return formatNonError(error);\n    };\n\n    if (typeof Error.stackTraceLimit === \"number\" &&\n        typeof Error.captureStackTrace === \"function\") {\n        Error.stackTraceLimit += 6;\n        stackFramePattern = v8stackFramePattern;\n        formatStack = v8stackFormatter;\n        var captureStackTrace = Error.captureStackTrace;\n\n        shouldIgnore = function(line) {\n            return bluebirdFramePattern.test(line);\n        };\n        return function(receiver, ignoreUntil) {\n            Error.stackTraceLimit += 6;\n            captureStackTrace(receiver, ignoreUntil);\n            Error.stackTraceLimit -= 6;\n        };\n    }\n    var err = new Error();\n\n    if (typeof err.stack === \"string\" &&\n        err.stack.split(\"\\n\")[0].indexOf(\"stackDetection@\") >= 0) {\n        stackFramePattern = /@/;\n        formatStack = v8stackFormatter;\n        indentStackFrames = true;\n        return function captureStackTrace(o) {\n            o.stack = new Error().stack;\n        };\n    }\n\n    var hasStackAfterThrow;\n    try { throw new Error(); }\n    catch(e) {\n        hasStackAfterThrow = (\"stack\" in e);\n    }\n    if (!(\"stack\" in err) && hasStackAfterThrow &&\n        typeof Error.stackTraceLimit === \"number\") {\n        stackFramePattern = v8stackFramePattern;\n        formatStack = v8stackFormatter;\n        return function captureStackTrace(o) {\n            Error.stackTraceLimit += 6;\n            try { throw new Error(); }\n            catch(e) { o.stack = e.stack; }\n            Error.stackTraceLimit -= 6;\n        };\n    }\n\n    formatStack = function(stack, error) {\n        if (typeof stack === \"string\") return stack;\n\n        if ((typeof error === \"object\" ||\n            typeof error === \"function\") &&\n            error.name !== undefined &&\n            error.message !== undefined) {\n            return error.toString();\n        }\n        return formatNonError(error);\n    };\n\n    return null;\n\n})([]);\n\nif (typeof console !== \"undefined\" && typeof console.warn !== \"undefined\") {\n    printWarning = function (message) {\n        console.warn(message);\n    };\n    if (util.isNode && process.stderr.isTTY) {\n        printWarning = function(message, isSoft) {\n            var color = isSoft ? \"\\u001b[33m\" : \"\\u001b[31m\";\n            console.warn(color + message + \"\\u001b[0m\\n\");\n        };\n    } else if (!util.isNode && typeof (new Error().stack) === \"string\") {\n        printWarning = function(message, isSoft) {\n            console.warn(\"%c\" + message,\n                        isSoft ? \"color: darkorange\" : \"color: red\");\n        };\n    }\n}\n\nvar config = {\n    warnings: warnings,\n    longStackTraces: false,\n    cancellation: false,\n    monitoring: false\n};\n\nif (longStackTraces) Promise.longStackTraces();\n\nreturn {\n    longStackTraces: function() {\n        return config.longStackTraces;\n    },\n    warnings: function() {\n        return config.warnings;\n    },\n    cancellation: function() {\n        return config.cancellation;\n    },\n    monitoring: function() {\n        return config.monitoring;\n    },\n    propagateFromFunction: function() {\n        return propagateFromFunction;\n    },\n    boundValueFunction: function() {\n        return boundValueFunction;\n    },\n    checkForgottenReturns: checkForgottenReturns,\n    setBounds: setBounds,\n    warn: warn,\n    deprecated: deprecated,\n    CapturedTrace: CapturedTrace,\n    fireDomEvent: fireDomEvent,\n    fireGlobalEvent: fireGlobalEvent\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/debuggability.js\n// module id = 150\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {\nvar util = require(\"./util\");\nvar CancellationError = Promise.CancellationError;\nvar errorObj = util.errorObj;\nvar catchFilter = require(\"./catch_filter\")(NEXT_FILTER);\n\nfunction PassThroughHandlerContext(promise, type, handler) {\n    this.promise = promise;\n    this.type = type;\n    this.handler = handler;\n    this.called = false;\n    this.cancelPromise = null;\n}\n\nPassThroughHandlerContext.prototype.isFinallyHandler = function() {\n    return this.type === 0;\n};\n\nfunction FinallyHandlerCancelReaction(finallyHandler) {\n    this.finallyHandler = finallyHandler;\n}\n\nFinallyHandlerCancelReaction.prototype._resultCancelled = function() {\n    checkCancel(this.finallyHandler);\n};\n\nfunction checkCancel(ctx, reason) {\n    if (ctx.cancelPromise != null) {\n        if (arguments.length > 1) {\n            ctx.cancelPromise._reject(reason);\n        } else {\n            ctx.cancelPromise._cancel();\n        }\n        ctx.cancelPromise = null;\n        return true;\n    }\n    return false;\n}\n\nfunction succeed() {\n    return finallyHandler.call(this, this.promise._target()._settledValue());\n}\nfunction fail(reason) {\n    if (checkCancel(this, reason)) return;\n    errorObj.e = reason;\n    return errorObj;\n}\nfunction finallyHandler(reasonOrValue) {\n    var promise = this.promise;\n    var handler = this.handler;\n\n    if (!this.called) {\n        this.called = true;\n        var ret = this.isFinallyHandler()\n            ? handler.call(promise._boundValue())\n            : handler.call(promise._boundValue(), reasonOrValue);\n        if (ret === NEXT_FILTER) {\n            return ret;\n        } else if (ret !== undefined) {\n            promise._setReturnedNonUndefined();\n            var maybePromise = tryConvertToPromise(ret, promise);\n            if (maybePromise instanceof Promise) {\n                if (this.cancelPromise != null) {\n                    if (maybePromise._isCancelled()) {\n                        var reason =\n                            new CancellationError(\"late cancellation observer\");\n                        promise._attachExtraTrace(reason);\n                        errorObj.e = reason;\n                        return errorObj;\n                    } else if (maybePromise.isPending()) {\n                        maybePromise._attachCancellationCallback(\n                            new FinallyHandlerCancelReaction(this));\n                    }\n                }\n                return maybePromise._then(\n                    succeed, fail, undefined, this, undefined);\n            }\n        }\n    }\n\n    if (promise.isRejected()) {\n        checkCancel(this);\n        errorObj.e = reasonOrValue;\n        return errorObj;\n    } else {\n        checkCancel(this);\n        return reasonOrValue;\n    }\n}\n\nPromise.prototype._passThrough = function(handler, type, success, fail) {\n    if (typeof handler !== \"function\") return this.then();\n    return this._then(success,\n                      fail,\n                      undefined,\n                      new PassThroughHandlerContext(this, type, handler),\n                      undefined);\n};\n\nPromise.prototype.lastly =\nPromise.prototype[\"finally\"] = function (handler) {\n    return this._passThrough(handler,\n                             0,\n                             finallyHandler,\n                             finallyHandler);\n};\n\n\nPromise.prototype.tap = function (handler) {\n    return this._passThrough(handler, 1, finallyHandler);\n};\n\nPromise.prototype.tapCatch = function (handlerOrPredicate) {\n    var len = arguments.length;\n    if(len === 1) {\n        return this._passThrough(handlerOrPredicate,\n                                 1,\n                                 undefined,\n                                 finallyHandler);\n    } else {\n         var catchInstances = new Array(len - 1),\n            j = 0, i;\n        for (i = 0; i < len - 1; ++i) {\n            var item = arguments[i];\n            if (util.isObject(item)) {\n                catchInstances[j++] = item;\n            } else {\n                return Promise.reject(new TypeError(\n                    \"tapCatch statement predicate: \"\n                    + \"expecting an object but got \" + util.classString(item)\n                ));\n            }\n        }\n        catchInstances.length = j;\n        var handler = arguments[i];\n        return this._passThrough(catchFilter(catchInstances, handler, this),\n                                 1,\n                                 undefined,\n                                 finallyHandler);\n    }\n\n};\n\nreturn PassThroughHandlerContext;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/finally.js\n// module id = 151\n// module chunks = 4","\"use strict\";\nmodule.exports =\nfunction(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {\nvar util = require(\"./util\");\nvar tryCatch = util.tryCatch;\n\nPromise.method = function (fn) {\n    if (typeof fn !== \"function\") {\n        throw new Promise.TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    return function () {\n        var ret = new Promise(INTERNAL);\n        ret._captureStackTrace();\n        ret._pushContext();\n        var value = tryCatch(fn).apply(this, arguments);\n        var promiseCreated = ret._popContext();\n        debug.checkForgottenReturns(\n            value, promiseCreated, \"Promise.method\", ret);\n        ret._resolveFromSyncValue(value);\n        return ret;\n    };\n};\n\nPromise.attempt = Promise[\"try\"] = function (fn) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    ret._pushContext();\n    var value;\n    if (arguments.length > 1) {\n        debug.deprecated(\"calling Promise.try with more than 1 argument\");\n        var arg = arguments[1];\n        var ctx = arguments[2];\n        value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)\n                                  : tryCatch(fn).call(ctx, arg);\n    } else {\n        value = tryCatch(fn)();\n    }\n    var promiseCreated = ret._popContext();\n    debug.checkForgottenReturns(\n        value, promiseCreated, \"Promise.try\", ret);\n    ret._resolveFromSyncValue(value);\n    return ret;\n};\n\nPromise.prototype._resolveFromSyncValue = function (value) {\n    if (value === util.errorObj) {\n        this._rejectCallback(value.e, false);\n    } else {\n        this._resolveCallback(value, true);\n    }\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/method.js\n// module id = 152\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {\nvar calledBind = false;\nvar rejectThis = function(_, e) {\n    this._reject(e);\n};\n\nvar targetRejected = function(e, context) {\n    context.promiseRejectionQueued = true;\n    context.bindingPromise._then(rejectThis, rejectThis, null, this, e);\n};\n\nvar bindingResolved = function(thisArg, context) {\n    if (((this._bitField & 50397184) === 0)) {\n        this._resolveCallback(context.target);\n    }\n};\n\nvar bindingRejected = function(e, context) {\n    if (!context.promiseRejectionQueued) this._reject(e);\n};\n\nPromise.prototype.bind = function (thisArg) {\n    if (!calledBind) {\n        calledBind = true;\n        Promise.prototype._propagateFrom = debug.propagateFromFunction();\n        Promise.prototype._boundValue = debug.boundValueFunction();\n    }\n    var maybePromise = tryConvertToPromise(thisArg);\n    var ret = new Promise(INTERNAL);\n    ret._propagateFrom(this, 1);\n    var target = this._target();\n    ret._setBoundTo(maybePromise);\n    if (maybePromise instanceof Promise) {\n        var context = {\n            promiseRejectionQueued: false,\n            promise: ret,\n            target: target,\n            bindingPromise: maybePromise\n        };\n        target._then(INTERNAL, targetRejected, undefined, ret, context);\n        maybePromise._then(\n            bindingResolved, bindingRejected, undefined, ret, context);\n        ret._setOnCancel(maybePromise);\n    } else {\n        ret._resolveCallback(target);\n    }\n    return ret;\n};\n\nPromise.prototype._setBoundTo = function (obj) {\n    if (obj !== undefined) {\n        this._bitField = this._bitField | 2097152;\n        this._boundTo = obj;\n    } else {\n        this._bitField = this._bitField & (~2097152);\n    }\n};\n\nPromise.prototype._isBound = function () {\n    return (this._bitField & 2097152) === 2097152;\n};\n\nPromise.bind = function (thisArg, value) {\n    return Promise.resolve(value).bind(thisArg);\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/bind.js\n// module id = 153\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, PromiseArray, apiRejection, debug) {\nvar util = require(\"./util\");\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar async = Promise._async;\n\nPromise.prototype[\"break\"] = Promise.prototype.cancel = function() {\n    if (!debug.cancellation()) return this._warn(\"cancellation is disabled\");\n\n    var promise = this;\n    var child = promise;\n    while (promise._isCancellable()) {\n        if (!promise._cancelBy(child)) {\n            if (child._isFollowing()) {\n                child._followee().cancel();\n            } else {\n                child._cancelBranched();\n            }\n            break;\n        }\n\n        var parent = promise._cancellationParent;\n        if (parent == null || !parent._isCancellable()) {\n            if (promise._isFollowing()) {\n                promise._followee().cancel();\n            } else {\n                promise._cancelBranched();\n            }\n            break;\n        } else {\n            if (promise._isFollowing()) promise._followee().cancel();\n            promise._setWillBeCancelled();\n            child = promise;\n            promise = parent;\n        }\n    }\n};\n\nPromise.prototype._branchHasCancelled = function() {\n    this._branchesRemainingToCancel--;\n};\n\nPromise.prototype._enoughBranchesHaveCancelled = function() {\n    return this._branchesRemainingToCancel === undefined ||\n           this._branchesRemainingToCancel <= 0;\n};\n\nPromise.prototype._cancelBy = function(canceller) {\n    if (canceller === this) {\n        this._branchesRemainingToCancel = 0;\n        this._invokeOnCancel();\n        return true;\n    } else {\n        this._branchHasCancelled();\n        if (this._enoughBranchesHaveCancelled()) {\n            this._invokeOnCancel();\n            return true;\n        }\n    }\n    return false;\n};\n\nPromise.prototype._cancelBranched = function() {\n    if (this._enoughBranchesHaveCancelled()) {\n        this._cancel();\n    }\n};\n\nPromise.prototype._cancel = function() {\n    if (!this._isCancellable()) return;\n    this._setCancelled();\n    async.invoke(this._cancelPromises, this, undefined);\n};\n\nPromise.prototype._cancelPromises = function() {\n    if (this._length() > 0) this._settlePromises();\n};\n\nPromise.prototype._unsetOnCancel = function() {\n    this._onCancelField = undefined;\n};\n\nPromise.prototype._isCancellable = function() {\n    return this.isPending() && !this._isCancelled();\n};\n\nPromise.prototype.isCancellable = function() {\n    return this.isPending() && !this.isCancelled();\n};\n\nPromise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {\n    if (util.isArray(onCancelCallback)) {\n        for (var i = 0; i < onCancelCallback.length; ++i) {\n            this._doInvokeOnCancel(onCancelCallback[i], internalOnly);\n        }\n    } else if (onCancelCallback !== undefined) {\n        if (typeof onCancelCallback === \"function\") {\n            if (!internalOnly) {\n                var e = tryCatch(onCancelCallback).call(this._boundValue());\n                if (e === errorObj) {\n                    this._attachExtraTrace(e.e);\n                    async.throwLater(e.e);\n                }\n            }\n        } else {\n            onCancelCallback._resultCancelled(this);\n        }\n    }\n};\n\nPromise.prototype._invokeOnCancel = function() {\n    var onCancelCallback = this._onCancel();\n    this._unsetOnCancel();\n    async.invoke(this._doInvokeOnCancel, this, onCancelCallback);\n};\n\nPromise.prototype._invokeInternalOnCancel = function() {\n    if (this._isCancellable()) {\n        this._doInvokeOnCancel(this._onCancel(), true);\n        this._unsetOnCancel();\n    }\n};\n\nPromise.prototype._resultCancelled = function() {\n    this.cancel();\n};\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/cancel.js\n// module id = 154\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise) {\nfunction returner() {\n    return this.value;\n}\nfunction thrower() {\n    throw this.reason;\n}\n\nPromise.prototype[\"return\"] =\nPromise.prototype.thenReturn = function (value) {\n    if (value instanceof Promise) value.suppressUnhandledRejections();\n    return this._then(\n        returner, undefined, undefined, {value: value}, undefined);\n};\n\nPromise.prototype[\"throw\"] =\nPromise.prototype.thenThrow = function (reason) {\n    return this._then(\n        thrower, undefined, undefined, {reason: reason}, undefined);\n};\n\nPromise.prototype.catchThrow = function (reason) {\n    if (arguments.length <= 1) {\n        return this._then(\n            undefined, thrower, undefined, {reason: reason}, undefined);\n    } else {\n        var _reason = arguments[1];\n        var handler = function() {throw _reason;};\n        return this.caught(reason, handler);\n    }\n};\n\nPromise.prototype.catchReturn = function (value) {\n    if (arguments.length <= 1) {\n        if (value instanceof Promise) value.suppressUnhandledRejections();\n        return this._then(\n            undefined, returner, undefined, {value: value}, undefined);\n    } else {\n        var _value = arguments[1];\n        if (_value instanceof Promise) _value.suppressUnhandledRejections();\n        var handler = function() {return _value;};\n        return this.caught(value, handler);\n    }\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/direct_resolve.js\n// module id = 155\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise) {\nfunction PromiseInspection(promise) {\n    if (promise !== undefined) {\n        promise = promise._target();\n        this._bitField = promise._bitField;\n        this._settledValueField = promise._isFateSealed()\n            ? promise._settledValue() : undefined;\n    }\n    else {\n        this._bitField = 0;\n        this._settledValueField = undefined;\n    }\n}\n\nPromiseInspection.prototype._settledValue = function() {\n    return this._settledValueField;\n};\n\nvar value = PromiseInspection.prototype.value = function () {\n    if (!this.isFulfilled()) {\n        throw new TypeError(\"cannot get fulfillment value of a non-fulfilled promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    return this._settledValue();\n};\n\nvar reason = PromiseInspection.prototype.error =\nPromiseInspection.prototype.reason = function () {\n    if (!this.isRejected()) {\n        throw new TypeError(\"cannot get rejection reason of a non-rejected promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    return this._settledValue();\n};\n\nvar isFulfilled = PromiseInspection.prototype.isFulfilled = function() {\n    return (this._bitField & 33554432) !== 0;\n};\n\nvar isRejected = PromiseInspection.prototype.isRejected = function () {\n    return (this._bitField & 16777216) !== 0;\n};\n\nvar isPending = PromiseInspection.prototype.isPending = function () {\n    return (this._bitField & 50397184) === 0;\n};\n\nvar isResolved = PromiseInspection.prototype.isResolved = function () {\n    return (this._bitField & 50331648) !== 0;\n};\n\nPromiseInspection.prototype.isCancelled = function() {\n    return (this._bitField & 8454144) !== 0;\n};\n\nPromise.prototype.__isCancelled = function() {\n    return (this._bitField & 65536) === 65536;\n};\n\nPromise.prototype._isCancelled = function() {\n    return this._target().__isCancelled();\n};\n\nPromise.prototype.isCancelled = function() {\n    return (this._target()._bitField & 8454144) !== 0;\n};\n\nPromise.prototype.isPending = function() {\n    return isPending.call(this._target());\n};\n\nPromise.prototype.isRejected = function() {\n    return isRejected.call(this._target());\n};\n\nPromise.prototype.isFulfilled = function() {\n    return isFulfilled.call(this._target());\n};\n\nPromise.prototype.isResolved = function() {\n    return isResolved.call(this._target());\n};\n\nPromise.prototype.value = function() {\n    return value.call(this._target());\n};\n\nPromise.prototype.reason = function() {\n    var target = this._target();\n    target._unsetRejectionIsUnhandled();\n    return reason.call(target);\n};\n\nPromise.prototype._value = function() {\n    return this._settledValue();\n};\n\nPromise.prototype._reason = function() {\n    this._unsetRejectionIsUnhandled();\n    return this._settledValue();\n};\n\nPromise.PromiseInspection = PromiseInspection;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/synchronous_inspection.js\n// module id = 156\n// module chunks = 4","\"use strict\";\nmodule.exports =\nfunction(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async,\n         getDomain) {\nvar util = require(\"./util\");\nvar canEvaluate = util.canEvaluate;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar reject;\n\nif (!false) {\nif (canEvaluate) {\n    var thenCallback = function(i) {\n        return new Function(\"value\", \"holder\", \"                             \\n\\\n            'use strict';                                                    \\n\\\n            holder.pIndex = value;                                           \\n\\\n            holder.checkFulfillment(this);                                   \\n\\\n            \".replace(/Index/g, i));\n    };\n\n    var promiseSetter = function(i) {\n        return new Function(\"promise\", \"holder\", \"                           \\n\\\n            'use strict';                                                    \\n\\\n            holder.pIndex = promise;                                         \\n\\\n            \".replace(/Index/g, i));\n    };\n\n    var generateHolderClass = function(total) {\n        var props = new Array(total);\n        for (var i = 0; i < props.length; ++i) {\n            props[i] = \"this.p\" + (i+1);\n        }\n        var assignment = props.join(\" = \") + \" = null;\";\n        var cancellationCode= \"var promise;\\n\" + props.map(function(prop) {\n            return \"                                                         \\n\\\n                promise = \" + prop + \";                                      \\n\\\n                if (promise instanceof Promise) {                            \\n\\\n                    promise.cancel();                                        \\n\\\n                }                                                            \\n\\\n            \";\n        }).join(\"\\n\");\n        var passedArguments = props.join(\", \");\n        var name = \"Holder$\" + total;\n\n\n        var code = \"return function(tryCatch, errorObj, Promise, async) {    \\n\\\n            'use strict';                                                    \\n\\\n            function [TheName](fn) {                                         \\n\\\n                [TheProperties]                                              \\n\\\n                this.fn = fn;                                                \\n\\\n                this.asyncNeeded = true;                                     \\n\\\n                this.now = 0;                                                \\n\\\n            }                                                                \\n\\\n                                                                             \\n\\\n            [TheName].prototype._callFunction = function(promise) {          \\n\\\n                promise._pushContext();                                      \\n\\\n                var ret = tryCatch(this.fn)([ThePassedArguments]);           \\n\\\n                promise._popContext();                                       \\n\\\n                if (ret === errorObj) {                                      \\n\\\n                    promise._rejectCallback(ret.e, false);                   \\n\\\n                } else {                                                     \\n\\\n                    promise._resolveCallback(ret);                           \\n\\\n                }                                                            \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            [TheName].prototype.checkFulfillment = function(promise) {       \\n\\\n                var now = ++this.now;                                        \\n\\\n                if (now === [TheTotal]) {                                    \\n\\\n                    if (this.asyncNeeded) {                                  \\n\\\n                        async.invoke(this._callFunction, this, promise);     \\n\\\n                    } else {                                                 \\n\\\n                        this._callFunction(promise);                         \\n\\\n                    }                                                        \\n\\\n                                                                             \\n\\\n                }                                                            \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            [TheName].prototype._resultCancelled = function() {              \\n\\\n                [CancellationCode]                                           \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            return [TheName];                                                \\n\\\n        }(tryCatch, errorObj, Promise, async);                               \\n\\\n        \";\n\n        code = code.replace(/\\[TheName\\]/g, name)\n            .replace(/\\[TheTotal\\]/g, total)\n            .replace(/\\[ThePassedArguments\\]/g, passedArguments)\n            .replace(/\\[TheProperties\\]/g, assignment)\n            .replace(/\\[CancellationCode\\]/g, cancellationCode);\n\n        return new Function(\"tryCatch\", \"errorObj\", \"Promise\", \"async\", code)\n                           (tryCatch, errorObj, Promise, async);\n    };\n\n    var holderClasses = [];\n    var thenCallbacks = [];\n    var promiseSetters = [];\n\n    for (var i = 0; i < 8; ++i) {\n        holderClasses.push(generateHolderClass(i + 1));\n        thenCallbacks.push(thenCallback(i + 1));\n        promiseSetters.push(promiseSetter(i + 1));\n    }\n\n    reject = function (reason) {\n        this._reject(reason);\n    };\n}}\n\nPromise.join = function () {\n    var last = arguments.length - 1;\n    var fn;\n    if (last > 0 && typeof arguments[last] === \"function\") {\n        fn = arguments[last];\n        if (!false) {\n            if (last <= 8 && canEvaluate) {\n                var ret = new Promise(INTERNAL);\n                ret._captureStackTrace();\n                var HolderClass = holderClasses[last - 1];\n                var holder = new HolderClass(fn);\n                var callbacks = thenCallbacks;\n\n                for (var i = 0; i < last; ++i) {\n                    var maybePromise = tryConvertToPromise(arguments[i], ret);\n                    if (maybePromise instanceof Promise) {\n                        maybePromise = maybePromise._target();\n                        var bitField = maybePromise._bitField;\n                        ;\n                        if (((bitField & 50397184) === 0)) {\n                            maybePromise._then(callbacks[i], reject,\n                                               undefined, ret, holder);\n                            promiseSetters[i](maybePromise, holder);\n                            holder.asyncNeeded = false;\n                        } else if (((bitField & 33554432) !== 0)) {\n                            callbacks[i].call(ret,\n                                              maybePromise._value(), holder);\n                        } else if (((bitField & 16777216) !== 0)) {\n                            ret._reject(maybePromise._reason());\n                        } else {\n                            ret._cancel();\n                        }\n                    } else {\n                        callbacks[i].call(ret, maybePromise, holder);\n                    }\n                }\n\n                if (!ret._isFateSealed()) {\n                    if (holder.asyncNeeded) {\n                        var domain = getDomain();\n                        if (domain !== null) {\n                            holder.fn = util.domainBind(domain, holder.fn);\n                        }\n                    }\n                    ret._setAsyncGuaranteed();\n                    ret._setOnCancel(holder);\n                }\n                return ret;\n            }\n        }\n    }\n    var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];};\n    if (fn) args.pop();\n    var ret = new PromiseArray(args).promise();\n    return fn !== undefined ? ret.spread(fn) : ret;\n};\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/join.js\n// module id = 157\n// module chunks = 4","\"use strict\";\nvar cr = Object.create;\nif (cr) {\n    var callerCache = cr(null);\n    var getterCache = cr(null);\n    callerCache[\" size\"] = getterCache[\" size\"] = 0;\n}\n\nmodule.exports = function(Promise) {\nvar util = require(\"./util\");\nvar canEvaluate = util.canEvaluate;\nvar isIdentifier = util.isIdentifier;\n\nvar getMethodCaller;\nvar getGetter;\nif (!false) {\nvar makeMethodCaller = function (methodName) {\n    return new Function(\"ensureMethod\", \"                                    \\n\\\n        return function(obj) {                                               \\n\\\n            'use strict'                                                     \\n\\\n            var len = this.length;                                           \\n\\\n            ensureMethod(obj, 'methodName');                                 \\n\\\n            switch(len) {                                                    \\n\\\n                case 1: return obj.methodName(this[0]);                      \\n\\\n                case 2: return obj.methodName(this[0], this[1]);             \\n\\\n                case 3: return obj.methodName(this[0], this[1], this[2]);    \\n\\\n                case 0: return obj.methodName();                             \\n\\\n                default:                                                     \\n\\\n                    return obj.methodName.apply(obj, this);                  \\n\\\n            }                                                                \\n\\\n        };                                                                   \\n\\\n        \".replace(/methodName/g, methodName))(ensureMethod);\n};\n\nvar makeGetter = function (propertyName) {\n    return new Function(\"obj\", \"                                             \\n\\\n        'use strict';                                                        \\n\\\n        return obj.propertyName;                                             \\n\\\n        \".replace(\"propertyName\", propertyName));\n};\n\nvar getCompiled = function(name, compiler, cache) {\n    var ret = cache[name];\n    if (typeof ret !== \"function\") {\n        if (!isIdentifier(name)) {\n            return null;\n        }\n        ret = compiler(name);\n        cache[name] = ret;\n        cache[\" size\"]++;\n        if (cache[\" size\"] > 512) {\n            var keys = Object.keys(cache);\n            for (var i = 0; i < 256; ++i) delete cache[keys[i]];\n            cache[\" size\"] = keys.length - 256;\n        }\n    }\n    return ret;\n};\n\ngetMethodCaller = function(name) {\n    return getCompiled(name, makeMethodCaller, callerCache);\n};\n\ngetGetter = function(name) {\n    return getCompiled(name, makeGetter, getterCache);\n};\n}\n\nfunction ensureMethod(obj, methodName) {\n    var fn;\n    if (obj != null) fn = obj[methodName];\n    if (typeof fn !== \"function\") {\n        var message = \"Object \" + util.classString(obj) + \" has no method '\" +\n            util.toString(methodName) + \"'\";\n        throw new Promise.TypeError(message);\n    }\n    return fn;\n}\n\nfunction caller(obj) {\n    var methodName = this.pop();\n    var fn = ensureMethod(obj, methodName);\n    return fn.apply(obj, this);\n}\nPromise.prototype.call = function (methodName) {\n    var $_len = arguments.length;var args = new Array(Math.max($_len - 1, 0)); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];};\n    if (!false) {\n        if (canEvaluate) {\n            var maybeCaller = getMethodCaller(methodName);\n            if (maybeCaller !== null) {\n                return this._then(\n                    maybeCaller, undefined, undefined, args, undefined);\n            }\n        }\n    }\n    args.push(methodName);\n    return this._then(caller, undefined, undefined, args, undefined);\n};\n\nfunction namedGetter(obj) {\n    return obj[this];\n}\nfunction indexedGetter(obj) {\n    var index = +this;\n    if (index < 0) index = Math.max(0, index + obj.length);\n    return obj[index];\n}\nPromise.prototype.get = function (propertyName) {\n    var isIndex = (typeof propertyName === \"number\");\n    var getter;\n    if (!isIndex) {\n        if (canEvaluate) {\n            var maybeGetter = getGetter(propertyName);\n            getter = maybeGetter !== null ? maybeGetter : namedGetter;\n        } else {\n            getter = namedGetter;\n        }\n    } else {\n        getter = indexedGetter;\n    }\n    return this._then(getter, undefined, undefined, propertyName, undefined);\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/call_get.js\n// module id = 158\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise,\n                          apiRejection,\n                          INTERNAL,\n                          tryConvertToPromise,\n                          Proxyable,\n                          debug) {\nvar errors = require(\"./errors\");\nvar TypeError = errors.TypeError;\nvar util = require(\"./util\");\nvar errorObj = util.errorObj;\nvar tryCatch = util.tryCatch;\nvar yieldHandlers = [];\n\nfunction promiseFromYieldHandler(value, yieldHandlers, traceParent) {\n    for (var i = 0; i < yieldHandlers.length; ++i) {\n        traceParent._pushContext();\n        var result = tryCatch(yieldHandlers[i])(value);\n        traceParent._popContext();\n        if (result === errorObj) {\n            traceParent._pushContext();\n            var ret = Promise.reject(errorObj.e);\n            traceParent._popContext();\n            return ret;\n        }\n        var maybePromise = tryConvertToPromise(result, traceParent);\n        if (maybePromise instanceof Promise) return maybePromise;\n    }\n    return null;\n}\n\nfunction PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {\n    if (debug.cancellation()) {\n        var internal = new Promise(INTERNAL);\n        var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);\n        this._promise = internal.lastly(function() {\n            return _finallyPromise;\n        });\n        internal._captureStackTrace();\n        internal._setOnCancel(this);\n    } else {\n        var promise = this._promise = new Promise(INTERNAL);\n        promise._captureStackTrace();\n    }\n    this._stack = stack;\n    this._generatorFunction = generatorFunction;\n    this._receiver = receiver;\n    this._generator = undefined;\n    this._yieldHandlers = typeof yieldHandler === \"function\"\n        ? [yieldHandler].concat(yieldHandlers)\n        : yieldHandlers;\n    this._yieldedPromise = null;\n    this._cancellationPhase = false;\n}\nutil.inherits(PromiseSpawn, Proxyable);\n\nPromiseSpawn.prototype._isResolved = function() {\n    return this._promise === null;\n};\n\nPromiseSpawn.prototype._cleanup = function() {\n    this._promise = this._generator = null;\n    if (debug.cancellation() && this._finallyPromise !== null) {\n        this._finallyPromise._fulfill();\n        this._finallyPromise = null;\n    }\n};\n\nPromiseSpawn.prototype._promiseCancelled = function() {\n    if (this._isResolved()) return;\n    var implementsReturn = typeof this._generator[\"return\"] !== \"undefined\";\n\n    var result;\n    if (!implementsReturn) {\n        var reason = new Promise.CancellationError(\n            \"generator .return() sentinel\");\n        Promise.coroutine.returnSentinel = reason;\n        this._promise._attachExtraTrace(reason);\n        this._promise._pushContext();\n        result = tryCatch(this._generator[\"throw\"]).call(this._generator,\n                                                         reason);\n        this._promise._popContext();\n    } else {\n        this._promise._pushContext();\n        result = tryCatch(this._generator[\"return\"]).call(this._generator,\n                                                          undefined);\n        this._promise._popContext();\n    }\n    this._cancellationPhase = true;\n    this._yieldedPromise = null;\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._promiseFulfilled = function(value) {\n    this._yieldedPromise = null;\n    this._promise._pushContext();\n    var result = tryCatch(this._generator.next).call(this._generator, value);\n    this._promise._popContext();\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._promiseRejected = function(reason) {\n    this._yieldedPromise = null;\n    this._promise._attachExtraTrace(reason);\n    this._promise._pushContext();\n    var result = tryCatch(this._generator[\"throw\"])\n        .call(this._generator, reason);\n    this._promise._popContext();\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._resultCancelled = function() {\n    if (this._yieldedPromise instanceof Promise) {\n        var promise = this._yieldedPromise;\n        this._yieldedPromise = null;\n        promise.cancel();\n    }\n};\n\nPromiseSpawn.prototype.promise = function () {\n    return this._promise;\n};\n\nPromiseSpawn.prototype._run = function () {\n    this._generator = this._generatorFunction.call(this._receiver);\n    this._receiver =\n        this._generatorFunction = undefined;\n    this._promiseFulfilled(undefined);\n};\n\nPromiseSpawn.prototype._continue = function (result) {\n    var promise = this._promise;\n    if (result === errorObj) {\n        this._cleanup();\n        if (this._cancellationPhase) {\n            return promise.cancel();\n        } else {\n            return promise._rejectCallback(result.e, false);\n        }\n    }\n\n    var value = result.value;\n    if (result.done === true) {\n        this._cleanup();\n        if (this._cancellationPhase) {\n            return promise.cancel();\n        } else {\n            return promise._resolveCallback(value);\n        }\n    } else {\n        var maybePromise = tryConvertToPromise(value, this._promise);\n        if (!(maybePromise instanceof Promise)) {\n            maybePromise =\n                promiseFromYieldHandler(maybePromise,\n                                        this._yieldHandlers,\n                                        this._promise);\n            if (maybePromise === null) {\n                this._promiseRejected(\n                    new TypeError(\n                        \"A value %s was yielded that could not be treated as a promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\\u000a\".replace(\"%s\", String(value)) +\n                        \"From coroutine:\\u000a\" +\n                        this._stack.split(\"\\n\").slice(1, -7).join(\"\\n\")\n                    )\n                );\n                return;\n            }\n        }\n        maybePromise = maybePromise._target();\n        var bitField = maybePromise._bitField;\n        ;\n        if (((bitField & 50397184) === 0)) {\n            this._yieldedPromise = maybePromise;\n            maybePromise._proxy(this, null);\n        } else if (((bitField & 33554432) !== 0)) {\n            Promise._async.invoke(\n                this._promiseFulfilled, this, maybePromise._value()\n            );\n        } else if (((bitField & 16777216) !== 0)) {\n            Promise._async.invoke(\n                this._promiseRejected, this, maybePromise._reason()\n            );\n        } else {\n            this._promiseCancelled();\n        }\n    }\n};\n\nPromise.coroutine = function (generatorFunction, options) {\n    if (typeof generatorFunction !== \"function\") {\n        throw new TypeError(\"generatorFunction must be a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var yieldHandler = Object(options).yieldHandler;\n    var PromiseSpawn$ = PromiseSpawn;\n    var stack = new Error().stack;\n    return function () {\n        var generator = generatorFunction.apply(this, arguments);\n        var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,\n                                      stack);\n        var ret = spawn.promise();\n        spawn._generator = generator;\n        spawn._promiseFulfilled(undefined);\n        return ret;\n    };\n};\n\nPromise.coroutine.addYieldHandler = function(fn) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    yieldHandlers.push(fn);\n};\n\nPromise.spawn = function (generatorFunction) {\n    debug.deprecated(\"Promise.spawn()\", \"Promise.coroutine()\");\n    if (typeof generatorFunction !== \"function\") {\n        return apiRejection(\"generatorFunction must be a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var spawn = new PromiseSpawn(generatorFunction, this);\n    var ret = spawn.promise();\n    spawn._run(Promise.spawn);\n    return ret;\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/generators.js\n// module id = 159\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise,\n                          PromiseArray,\n                          apiRejection,\n                          tryConvertToPromise,\n                          INTERNAL,\n                          debug) {\nvar getDomain = Promise._getDomain;\nvar util = require(\"./util\");\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar async = Promise._async;\n\nfunction MappingPromiseArray(promises, fn, limit, _filter) {\n    this.constructor$(promises);\n    this._promise._captureStackTrace();\n    var domain = getDomain();\n    this._callback = domain === null ? fn : util.domainBind(domain, fn);\n    this._preservedValues = _filter === INTERNAL\n        ? new Array(this.length())\n        : null;\n    this._limit = limit;\n    this._inFlight = 0;\n    this._queue = [];\n    async.invoke(this._asyncInit, this, undefined);\n}\nutil.inherits(MappingPromiseArray, PromiseArray);\n\nMappingPromiseArray.prototype._asyncInit = function() {\n    this._init$(undefined, -2);\n};\n\nMappingPromiseArray.prototype._init = function () {};\n\nMappingPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    var values = this._values;\n    var length = this.length();\n    var preservedValues = this._preservedValues;\n    var limit = this._limit;\n\n    if (index < 0) {\n        index = (index * -1) - 1;\n        values[index] = value;\n        if (limit >= 1) {\n            this._inFlight--;\n            this._drainQueue();\n            if (this._isResolved()) return true;\n        }\n    } else {\n        if (limit >= 1 && this._inFlight >= limit) {\n            values[index] = value;\n            this._queue.push(index);\n            return false;\n        }\n        if (preservedValues !== null) preservedValues[index] = value;\n\n        var promise = this._promise;\n        var callback = this._callback;\n        var receiver = promise._boundValue();\n        promise._pushContext();\n        var ret = tryCatch(callback).call(receiver, value, index, length);\n        var promiseCreated = promise._popContext();\n        debug.checkForgottenReturns(\n            ret,\n            promiseCreated,\n            preservedValues !== null ? \"Promise.filter\" : \"Promise.map\",\n            promise\n        );\n        if (ret === errorObj) {\n            this._reject(ret.e);\n            return true;\n        }\n\n        var maybePromise = tryConvertToPromise(ret, this._promise);\n        if (maybePromise instanceof Promise) {\n            maybePromise = maybePromise._target();\n            var bitField = maybePromise._bitField;\n            ;\n            if (((bitField & 50397184) === 0)) {\n                if (limit >= 1) this._inFlight++;\n                values[index] = maybePromise;\n                maybePromise._proxy(this, (index + 1) * -1);\n                return false;\n            } else if (((bitField & 33554432) !== 0)) {\n                ret = maybePromise._value();\n            } else if (((bitField & 16777216) !== 0)) {\n                this._reject(maybePromise._reason());\n                return true;\n            } else {\n                this._cancel();\n                return true;\n            }\n        }\n        values[index] = ret;\n    }\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= length) {\n        if (preservedValues !== null) {\n            this._filter(values, preservedValues);\n        } else {\n            this._resolve(values);\n        }\n        return true;\n    }\n    return false;\n};\n\nMappingPromiseArray.prototype._drainQueue = function () {\n    var queue = this._queue;\n    var limit = this._limit;\n    var values = this._values;\n    while (queue.length > 0 && this._inFlight < limit) {\n        if (this._isResolved()) return;\n        var index = queue.pop();\n        this._promiseFulfilled(values[index], index);\n    }\n};\n\nMappingPromiseArray.prototype._filter = function (booleans, values) {\n    var len = values.length;\n    var ret = new Array(len);\n    var j = 0;\n    for (var i = 0; i < len; ++i) {\n        if (booleans[i]) ret[j++] = values[i];\n    }\n    ret.length = j;\n    this._resolve(ret);\n};\n\nMappingPromiseArray.prototype.preservedValues = function () {\n    return this._preservedValues;\n};\n\nfunction map(promises, fn, options, _filter) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n\n    var limit = 0;\n    if (options !== undefined) {\n        if (typeof options === \"object\" && options !== null) {\n            if (typeof options.concurrency !== \"number\") {\n                return Promise.reject(\n                    new TypeError(\"'concurrency' must be a number but it is \" +\n                                    util.classString(options.concurrency)));\n            }\n            limit = options.concurrency;\n        } else {\n            return Promise.reject(new TypeError(\n                            \"options argument must be an object but it is \" +\n                             util.classString(options)));\n        }\n    }\n    limit = typeof limit === \"number\" &&\n        isFinite(limit) && limit >= 1 ? limit : 0;\n    return new MappingPromiseArray(promises, fn, limit, _filter).promise();\n}\n\nPromise.prototype.map = function (fn, options) {\n    return map(this, fn, options, null);\n};\n\nPromise.map = function (promises, fn, options, _filter) {\n    return map(promises, fn, options, _filter);\n};\n\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/map.js\n// module id = 160\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise) {\nvar util = require(\"./util\");\nvar async = Promise._async;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\n\nfunction spreadAdapter(val, nodeback) {\n    var promise = this;\n    if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);\n    var ret =\n        tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\n\nfunction successAdapter(val, nodeback) {\n    var promise = this;\n    var receiver = promise._boundValue();\n    var ret = val === undefined\n        ? tryCatch(nodeback).call(receiver, null)\n        : tryCatch(nodeback).call(receiver, null, val);\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\nfunction errorAdapter(reason, nodeback) {\n    var promise = this;\n    if (!reason) {\n        var newReason = new Error(reason + \"\");\n        newReason.cause = reason;\n        reason = newReason;\n    }\n    var ret = tryCatch(nodeback).call(promise._boundValue(), reason);\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\n\nPromise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,\n                                                                     options) {\n    if (typeof nodeback == \"function\") {\n        var adapter = successAdapter;\n        if (options !== undefined && Object(options).spread) {\n            adapter = spreadAdapter;\n        }\n        this._then(\n            adapter,\n            errorAdapter,\n            undefined,\n            this,\n            nodeback\n        );\n    }\n    return this;\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/nodeify.js\n// module id = 161\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar THIS = {};\nvar util = require(\"./util\");\nvar nodebackForPromise = require(\"./nodeback\");\nvar withAppended = util.withAppended;\nvar maybeWrapAsError = util.maybeWrapAsError;\nvar canEvaluate = util.canEvaluate;\nvar TypeError = require(\"./errors\").TypeError;\nvar defaultSuffix = \"Async\";\nvar defaultPromisified = {__isPromisified__: true};\nvar noCopyProps = [\n    \"arity\",    \"length\",\n    \"name\",\n    \"arguments\",\n    \"caller\",\n    \"callee\",\n    \"prototype\",\n    \"__isPromisified__\"\n];\nvar noCopyPropsPattern = new RegExp(\"^(?:\" + noCopyProps.join(\"|\") + \")$\");\n\nvar defaultFilter = function(name) {\n    return util.isIdentifier(name) &&\n        name.charAt(0) !== \"_\" &&\n        name !== \"constructor\";\n};\n\nfunction propsFilter(key) {\n    return !noCopyPropsPattern.test(key);\n}\n\nfunction isPromisified(fn) {\n    try {\n        return fn.__isPromisified__ === true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n\nfunction hasPromisified(obj, key, suffix) {\n    var val = util.getDataPropertyOrDefault(obj, key + suffix,\n                                            defaultPromisified);\n    return val ? isPromisified(val) : false;\n}\nfunction checkValid(ret, suffix, suffixRegexp) {\n    for (var i = 0; i < ret.length; i += 2) {\n        var key = ret[i];\n        if (suffixRegexp.test(key)) {\n            var keyWithoutAsyncSuffix = key.replace(suffixRegexp, \"\");\n            for (var j = 0; j < ret.length; j += 2) {\n                if (ret[j] === keyWithoutAsyncSuffix) {\n                    throw new TypeError(\"Cannot promisify an API that has normal methods with '%s'-suffix\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\"\n                        .replace(\"%s\", suffix));\n                }\n            }\n        }\n    }\n}\n\nfunction promisifiableMethods(obj, suffix, suffixRegexp, filter) {\n    var keys = util.inheritedDataKeys(obj);\n    var ret = [];\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var value = obj[key];\n        var passesDefaultFilter = filter === defaultFilter\n            ? true : defaultFilter(key, value, obj);\n        if (typeof value === \"function\" &&\n            !isPromisified(value) &&\n            !hasPromisified(obj, key, suffix) &&\n            filter(key, value, obj, passesDefaultFilter)) {\n            ret.push(key, value);\n        }\n    }\n    checkValid(ret, suffix, suffixRegexp);\n    return ret;\n}\n\nvar escapeIdentRegex = function(str) {\n    return str.replace(/([$])/, \"\\\\$\");\n};\n\nvar makeNodePromisifiedEval;\nif (!false) {\nvar switchCaseArgumentOrder = function(likelyArgumentCount) {\n    var ret = [likelyArgumentCount];\n    var min = Math.max(0, likelyArgumentCount - 1 - 3);\n    for(var i = likelyArgumentCount - 1; i >= min; --i) {\n        ret.push(i);\n    }\n    for(var i = likelyArgumentCount + 1; i <= 3; ++i) {\n        ret.push(i);\n    }\n    return ret;\n};\n\nvar argumentSequence = function(argumentCount) {\n    return util.filledRange(argumentCount, \"_arg\", \"\");\n};\n\nvar parameterDeclaration = function(parameterCount) {\n    return util.filledRange(\n        Math.max(parameterCount, 3), \"_arg\", \"\");\n};\n\nvar parameterCount = function(fn) {\n    if (typeof fn.length === \"number\") {\n        return Math.max(Math.min(fn.length, 1023 + 1), 0);\n    }\n    return 0;\n};\n\nmakeNodePromisifiedEval =\nfunction(callback, receiver, originalName, fn, _, multiArgs) {\n    var newParameterCount = Math.max(0, parameterCount(fn) - 1);\n    var argumentOrder = switchCaseArgumentOrder(newParameterCount);\n    var shouldProxyThis = typeof callback === \"string\" || receiver === THIS;\n\n    function generateCallForArgumentCount(count) {\n        var args = argumentSequence(count).join(\", \");\n        var comma = count > 0 ? \", \" : \"\";\n        var ret;\n        if (shouldProxyThis) {\n            ret = \"ret = callback.call(this, {{args}}, nodeback); break;\\n\";\n        } else {\n            ret = receiver === undefined\n                ? \"ret = callback({{args}}, nodeback); break;\\n\"\n                : \"ret = callback.call(receiver, {{args}}, nodeback); break;\\n\";\n        }\n        return ret.replace(\"{{args}}\", args).replace(\", \", comma);\n    }\n\n    function generateArgumentSwitchCase() {\n        var ret = \"\";\n        for (var i = 0; i < argumentOrder.length; ++i) {\n            ret += \"case \" + argumentOrder[i] +\":\" +\n                generateCallForArgumentCount(argumentOrder[i]);\n        }\n\n        ret += \"                                                             \\n\\\n        default:                                                             \\n\\\n            var args = new Array(len + 1);                                   \\n\\\n            var i = 0;                                                       \\n\\\n            for (var i = 0; i < len; ++i) {                                  \\n\\\n               args[i] = arguments[i];                                       \\n\\\n            }                                                                \\n\\\n            args[i] = nodeback;                                              \\n\\\n            [CodeForCall]                                                    \\n\\\n            break;                                                           \\n\\\n        \".replace(\"[CodeForCall]\", (shouldProxyThis\n                                ? \"ret = callback.apply(this, args);\\n\"\n                                : \"ret = callback.apply(receiver, args);\\n\"));\n        return ret;\n    }\n\n    var getFunctionCode = typeof callback === \"string\"\n                                ? (\"this != null ? this['\"+callback+\"'] : fn\")\n                                : \"fn\";\n    var body = \"'use strict';                                                \\n\\\n        var ret = function (Parameters) {                                    \\n\\\n            'use strict';                                                    \\n\\\n            var len = arguments.length;                                      \\n\\\n            var promise = new Promise(INTERNAL);                             \\n\\\n            promise._captureStackTrace();                                    \\n\\\n            var nodeback = nodebackForPromise(promise, \" + multiArgs + \");   \\n\\\n            var ret;                                                         \\n\\\n            var callback = tryCatch([GetFunctionCode]);                      \\n\\\n            switch(len) {                                                    \\n\\\n                [CodeForSwitchCase]                                          \\n\\\n            }                                                                \\n\\\n            if (ret === errorObj) {                                          \\n\\\n                promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\\n\\\n            }                                                                \\n\\\n            if (!promise._isFateSealed()) promise._setAsyncGuaranteed();     \\n\\\n            return promise;                                                  \\n\\\n        };                                                                   \\n\\\n        notEnumerableProp(ret, '__isPromisified__', true);                   \\n\\\n        return ret;                                                          \\n\\\n    \".replace(\"[CodeForSwitchCase]\", generateArgumentSwitchCase())\n        .replace(\"[GetFunctionCode]\", getFunctionCode);\n    body = body.replace(\"Parameters\", parameterDeclaration(newParameterCount));\n    return new Function(\"Promise\",\n                        \"fn\",\n                        \"receiver\",\n                        \"withAppended\",\n                        \"maybeWrapAsError\",\n                        \"nodebackForPromise\",\n                        \"tryCatch\",\n                        \"errorObj\",\n                        \"notEnumerableProp\",\n                        \"INTERNAL\",\n                        body)(\n                    Promise,\n                    fn,\n                    receiver,\n                    withAppended,\n                    maybeWrapAsError,\n                    nodebackForPromise,\n                    util.tryCatch,\n                    util.errorObj,\n                    util.notEnumerableProp,\n                    INTERNAL);\n};\n}\n\nfunction makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {\n    var defaultThis = (function() {return this;})();\n    var method = callback;\n    if (typeof method === \"string\") {\n        callback = fn;\n    }\n    function promisified() {\n        var _receiver = receiver;\n        if (receiver === THIS) _receiver = this;\n        var promise = new Promise(INTERNAL);\n        promise._captureStackTrace();\n        var cb = typeof method === \"string\" && this !== defaultThis\n            ? this[method] : callback;\n        var fn = nodebackForPromise(promise, multiArgs);\n        try {\n            cb.apply(_receiver, withAppended(arguments, fn));\n        } catch(e) {\n            promise._rejectCallback(maybeWrapAsError(e), true, true);\n        }\n        if (!promise._isFateSealed()) promise._setAsyncGuaranteed();\n        return promise;\n    }\n    util.notEnumerableProp(promisified, \"__isPromisified__\", true);\n    return promisified;\n}\n\nvar makeNodePromisified = canEvaluate\n    ? makeNodePromisifiedEval\n    : makeNodePromisifiedClosure;\n\nfunction promisifyAll(obj, suffix, filter, promisifier, multiArgs) {\n    var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + \"$\");\n    var methods =\n        promisifiableMethods(obj, suffix, suffixRegexp, filter);\n\n    for (var i = 0, len = methods.length; i < len; i+= 2) {\n        var key = methods[i];\n        var fn = methods[i+1];\n        var promisifiedKey = key + suffix;\n        if (promisifier === makeNodePromisified) {\n            obj[promisifiedKey] =\n                makeNodePromisified(key, THIS, key, fn, suffix, multiArgs);\n        } else {\n            var promisified = promisifier(fn, function() {\n                return makeNodePromisified(key, THIS, key,\n                                           fn, suffix, multiArgs);\n            });\n            util.notEnumerableProp(promisified, \"__isPromisified__\", true);\n            obj[promisifiedKey] = promisified;\n        }\n    }\n    util.toFastProperties(obj);\n    return obj;\n}\n\nfunction promisify(callback, receiver, multiArgs) {\n    return makeNodePromisified(callback, receiver, undefined,\n                                callback, null, multiArgs);\n}\n\nPromise.promisify = function (fn, options) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    if (isPromisified(fn)) {\n        return fn;\n    }\n    options = Object(options);\n    var receiver = options.context === undefined ? THIS : options.context;\n    var multiArgs = !!options.multiArgs;\n    var ret = promisify(fn, receiver, multiArgs);\n    util.copyDescriptors(fn, ret, propsFilter);\n    return ret;\n};\n\nPromise.promisifyAll = function (target, options) {\n    if (typeof target !== \"function\" && typeof target !== \"object\") {\n        throw new TypeError(\"the target of promisifyAll must be an object or a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    options = Object(options);\n    var multiArgs = !!options.multiArgs;\n    var suffix = options.suffix;\n    if (typeof suffix !== \"string\") suffix = defaultSuffix;\n    var filter = options.filter;\n    if (typeof filter !== \"function\") filter = defaultFilter;\n    var promisifier = options.promisifier;\n    if (typeof promisifier !== \"function\") promisifier = makeNodePromisified;\n\n    if (!util.isIdentifier(suffix)) {\n        throw new RangeError(\"suffix must be a valid identifier\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n\n    var keys = util.inheritedDataKeys(target);\n    for (var i = 0; i < keys.length; ++i) {\n        var value = target[keys[i]];\n        if (keys[i] !== \"constructor\" &&\n            util.isClass(value)) {\n            promisifyAll(value.prototype, suffix, filter, promisifier,\n                multiArgs);\n            promisifyAll(value, suffix, filter, promisifier, multiArgs);\n        }\n    }\n\n    return promisifyAll(target, suffix, filter, promisifier, multiArgs);\n};\n};\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/promisify.js\n// module id = 162\n// module chunks = 4","\"use strict\";\nmodule.exports = function(\n    Promise, PromiseArray, tryConvertToPromise, apiRejection) {\nvar util = require(\"./util\");\nvar isObject = util.isObject;\nvar es5 = require(\"./es5\");\nvar Es6Map;\nif (typeof Map === \"function\") Es6Map = Map;\n\nvar mapToEntries = (function() {\n    var index = 0;\n    var size = 0;\n\n    function extractEntry(value, key) {\n        this[index] = value;\n        this[index + size] = key;\n        index++;\n    }\n\n    return function mapToEntries(map) {\n        size = map.size;\n        index = 0;\n        var ret = new Array(map.size * 2);\n        map.forEach(extractEntry, ret);\n        return ret;\n    };\n})();\n\nvar entriesToMap = function(entries) {\n    var ret = new Es6Map();\n    var length = entries.length / 2 | 0;\n    for (var i = 0; i < length; ++i) {\n        var key = entries[length + i];\n        var value = entries[i];\n        ret.set(key, value);\n    }\n    return ret;\n};\n\nfunction PropertiesPromiseArray(obj) {\n    var isMap = false;\n    var entries;\n    if (Es6Map !== undefined && obj instanceof Es6Map) {\n        entries = mapToEntries(obj);\n        isMap = true;\n    } else {\n        var keys = es5.keys(obj);\n        var len = keys.length;\n        entries = new Array(len * 2);\n        for (var i = 0; i < len; ++i) {\n            var key = keys[i];\n            entries[i] = obj[key];\n            entries[i + len] = key;\n        }\n    }\n    this.constructor$(entries);\n    this._isMap = isMap;\n    this._init$(undefined, isMap ? -6 : -3);\n}\nutil.inherits(PropertiesPromiseArray, PromiseArray);\n\nPropertiesPromiseArray.prototype._init = function () {};\n\nPropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    this._values[index] = value;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        var val;\n        if (this._isMap) {\n            val = entriesToMap(this._values);\n        } else {\n            val = {};\n            var keyOffset = this.length();\n            for (var i = 0, len = this.length(); i < len; ++i) {\n                val[this._values[i + keyOffset]] = this._values[i];\n            }\n        }\n        this._resolve(val);\n        return true;\n    }\n    return false;\n};\n\nPropertiesPromiseArray.prototype.shouldCopyValues = function () {\n    return false;\n};\n\nPropertiesPromiseArray.prototype.getActualLength = function (len) {\n    return len >> 1;\n};\n\nfunction props(promises) {\n    var ret;\n    var castValue = tryConvertToPromise(promises);\n\n    if (!isObject(castValue)) {\n        return apiRejection(\"cannot await properties of a non-object\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    } else if (castValue instanceof Promise) {\n        ret = castValue._then(\n            Promise.props, undefined, undefined, undefined, undefined);\n    } else {\n        ret = new PropertiesPromiseArray(castValue).promise();\n    }\n\n    if (castValue instanceof Promise) {\n        ret._propagateFrom(castValue, 2);\n    }\n    return ret;\n}\n\nPromise.prototype.props = function () {\n    return props(this);\n};\n\nPromise.props = function (promises) {\n    return props(promises);\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/props.js\n// module id = 163\n// module chunks = 4","\"use strict\";\nmodule.exports = function(\n    Promise, INTERNAL, tryConvertToPromise, apiRejection) {\nvar util = require(\"./util\");\n\nvar raceLater = function (promise) {\n    return promise.then(function(array) {\n        return race(array, promise);\n    });\n};\n\nfunction race(promises, parent) {\n    var maybePromise = tryConvertToPromise(promises);\n\n    if (maybePromise instanceof Promise) {\n        return raceLater(maybePromise);\n    } else {\n        promises = util.asArray(promises);\n        if (promises === null)\n            return apiRejection(\"expecting an array or an iterable object but got \" + util.classString(promises));\n    }\n\n    var ret = new Promise(INTERNAL);\n    if (parent !== undefined) {\n        ret._propagateFrom(parent, 3);\n    }\n    var fulfill = ret._fulfill;\n    var reject = ret._reject;\n    for (var i = 0, len = promises.length; i < len; ++i) {\n        var val = promises[i];\n\n        if (val === undefined && !(i in promises)) {\n            continue;\n        }\n\n        Promise.cast(val)._then(fulfill, reject, undefined, ret, null);\n    }\n    return ret;\n}\n\nPromise.race = function (promises) {\n    return race(promises, undefined);\n};\n\nPromise.prototype.race = function () {\n    return race(this, undefined);\n};\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/race.js\n// module id = 164\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise,\n                          PromiseArray,\n                          apiRejection,\n                          tryConvertToPromise,\n                          INTERNAL,\n                          debug) {\nvar getDomain = Promise._getDomain;\nvar util = require(\"./util\");\nvar tryCatch = util.tryCatch;\n\nfunction ReductionPromiseArray(promises, fn, initialValue, _each) {\n    this.constructor$(promises);\n    var domain = getDomain();\n    this._fn = domain === null ? fn : util.domainBind(domain, fn);\n    if (initialValue !== undefined) {\n        initialValue = Promise.resolve(initialValue);\n        initialValue._attachCancellationCallback(this);\n    }\n    this._initialValue = initialValue;\n    this._currentCancellable = null;\n    if(_each === INTERNAL) {\n        this._eachValues = Array(this._length);\n    } else if (_each === 0) {\n        this._eachValues = null;\n    } else {\n        this._eachValues = undefined;\n    }\n    this._promise._captureStackTrace();\n    this._init$(undefined, -5);\n}\nutil.inherits(ReductionPromiseArray, PromiseArray);\n\nReductionPromiseArray.prototype._gotAccum = function(accum) {\n    if (this._eachValues !== undefined && \n        this._eachValues !== null && \n        accum !== INTERNAL) {\n        this._eachValues.push(accum);\n    }\n};\n\nReductionPromiseArray.prototype._eachComplete = function(value) {\n    if (this._eachValues !== null) {\n        this._eachValues.push(value);\n    }\n    return this._eachValues;\n};\n\nReductionPromiseArray.prototype._init = function() {};\n\nReductionPromiseArray.prototype._resolveEmptyArray = function() {\n    this._resolve(this._eachValues !== undefined ? this._eachValues\n                                                 : this._initialValue);\n};\n\nReductionPromiseArray.prototype.shouldCopyValues = function () {\n    return false;\n};\n\nReductionPromiseArray.prototype._resolve = function(value) {\n    this._promise._resolveCallback(value);\n    this._values = null;\n};\n\nReductionPromiseArray.prototype._resultCancelled = function(sender) {\n    if (sender === this._initialValue) return this._cancel();\n    if (this._isResolved()) return;\n    this._resultCancelled$();\n    if (this._currentCancellable instanceof Promise) {\n        this._currentCancellable.cancel();\n    }\n    if (this._initialValue instanceof Promise) {\n        this._initialValue.cancel();\n    }\n};\n\nReductionPromiseArray.prototype._iterate = function (values) {\n    this._values = values;\n    var value;\n    var i;\n    var length = values.length;\n    if (this._initialValue !== undefined) {\n        value = this._initialValue;\n        i = 0;\n    } else {\n        value = Promise.resolve(values[0]);\n        i = 1;\n    }\n\n    this._currentCancellable = value;\n\n    if (!value.isRejected()) {\n        for (; i < length; ++i) {\n            var ctx = {\n                accum: null,\n                value: values[i],\n                index: i,\n                length: length,\n                array: this\n            };\n            value = value._then(gotAccum, undefined, undefined, ctx, undefined);\n        }\n    }\n\n    if (this._eachValues !== undefined) {\n        value = value\n            ._then(this._eachComplete, undefined, undefined, this, undefined);\n    }\n    value._then(completed, completed, undefined, value, this);\n};\n\nPromise.prototype.reduce = function (fn, initialValue) {\n    return reduce(this, fn, initialValue, null);\n};\n\nPromise.reduce = function (promises, fn, initialValue, _each) {\n    return reduce(promises, fn, initialValue, _each);\n};\n\nfunction completed(valueOrReason, array) {\n    if (this.isFulfilled()) {\n        array._resolve(valueOrReason);\n    } else {\n        array._reject(valueOrReason);\n    }\n}\n\nfunction reduce(promises, fn, initialValue, _each) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    var array = new ReductionPromiseArray(promises, fn, initialValue, _each);\n    return array.promise();\n}\n\nfunction gotAccum(accum) {\n    this.accum = accum;\n    this.array._gotAccum(accum);\n    var value = tryConvertToPromise(this.value, this.array._promise);\n    if (value instanceof Promise) {\n        this.array._currentCancellable = value;\n        return value._then(gotValue, undefined, undefined, this, undefined);\n    } else {\n        return gotValue.call(this, value);\n    }\n}\n\nfunction gotValue(value) {\n    var array = this.array;\n    var promise = array._promise;\n    var fn = tryCatch(array._fn);\n    promise._pushContext();\n    var ret;\n    if (array._eachValues !== undefined) {\n        ret = fn.call(promise._boundValue(), value, this.index, this.length);\n    } else {\n        ret = fn.call(promise._boundValue(),\n                              this.accum, value, this.index, this.length);\n    }\n    if (ret instanceof Promise) {\n        array._currentCancellable = ret;\n    }\n    var promiseCreated = promise._popContext();\n    debug.checkForgottenReturns(\n        ret,\n        promiseCreated,\n        array._eachValues !== undefined ? \"Promise.each\" : \"Promise.reduce\",\n        promise\n    );\n    return ret;\n}\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/reduce.js\n// module id = 165\n// module chunks = 4","\"use strict\";\nmodule.exports =\n    function(Promise, PromiseArray, debug) {\nvar PromiseInspection = Promise.PromiseInspection;\nvar util = require(\"./util\");\n\nfunction SettledPromiseArray(values) {\n    this.constructor$(values);\n}\nutil.inherits(SettledPromiseArray, PromiseArray);\n\nSettledPromiseArray.prototype._promiseResolved = function (index, inspection) {\n    this._values[index] = inspection;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        this._resolve(this._values);\n        return true;\n    }\n    return false;\n};\n\nSettledPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    var ret = new PromiseInspection();\n    ret._bitField = 33554432;\n    ret._settledValueField = value;\n    return this._promiseResolved(index, ret);\n};\nSettledPromiseArray.prototype._promiseRejected = function (reason, index) {\n    var ret = new PromiseInspection();\n    ret._bitField = 16777216;\n    ret._settledValueField = reason;\n    return this._promiseResolved(index, ret);\n};\n\nPromise.settle = function (promises) {\n    debug.deprecated(\".settle()\", \".reflect()\");\n    return new SettledPromiseArray(promises).promise();\n};\n\nPromise.prototype.settle = function () {\n    return Promise.settle(this);\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/settle.js\n// module id = 166\n// module chunks = 4","\"use strict\";\nmodule.exports =\nfunction(Promise, PromiseArray, apiRejection) {\nvar util = require(\"./util\");\nvar RangeError = require(\"./errors\").RangeError;\nvar AggregateError = require(\"./errors\").AggregateError;\nvar isArray = util.isArray;\nvar CANCELLATION = {};\n\n\nfunction SomePromiseArray(values) {\n    this.constructor$(values);\n    this._howMany = 0;\n    this._unwrap = false;\n    this._initialized = false;\n}\nutil.inherits(SomePromiseArray, PromiseArray);\n\nSomePromiseArray.prototype._init = function () {\n    if (!this._initialized) {\n        return;\n    }\n    if (this._howMany === 0) {\n        this._resolve([]);\n        return;\n    }\n    this._init$(undefined, -5);\n    var isArrayResolved = isArray(this._values);\n    if (!this._isResolved() &&\n        isArrayResolved &&\n        this._howMany > this._canPossiblyFulfill()) {\n        this._reject(this._getRangeError(this.length()));\n    }\n};\n\nSomePromiseArray.prototype.init = function () {\n    this._initialized = true;\n    this._init();\n};\n\nSomePromiseArray.prototype.setUnwrap = function () {\n    this._unwrap = true;\n};\n\nSomePromiseArray.prototype.howMany = function () {\n    return this._howMany;\n};\n\nSomePromiseArray.prototype.setHowMany = function (count) {\n    this._howMany = count;\n};\n\nSomePromiseArray.prototype._promiseFulfilled = function (value) {\n    this._addFulfilled(value);\n    if (this._fulfilled() === this.howMany()) {\n        this._values.length = this.howMany();\n        if (this.howMany() === 1 && this._unwrap) {\n            this._resolve(this._values[0]);\n        } else {\n            this._resolve(this._values);\n        }\n        return true;\n    }\n    return false;\n\n};\nSomePromiseArray.prototype._promiseRejected = function (reason) {\n    this._addRejected(reason);\n    return this._checkOutcome();\n};\n\nSomePromiseArray.prototype._promiseCancelled = function () {\n    if (this._values instanceof Promise || this._values == null) {\n        return this._cancel();\n    }\n    this._addRejected(CANCELLATION);\n    return this._checkOutcome();\n};\n\nSomePromiseArray.prototype._checkOutcome = function() {\n    if (this.howMany() > this._canPossiblyFulfill()) {\n        var e = new AggregateError();\n        for (var i = this.length(); i < this._values.length; ++i) {\n            if (this._values[i] !== CANCELLATION) {\n                e.push(this._values[i]);\n            }\n        }\n        if (e.length > 0) {\n            this._reject(e);\n        } else {\n            this._cancel();\n        }\n        return true;\n    }\n    return false;\n};\n\nSomePromiseArray.prototype._fulfilled = function () {\n    return this._totalResolved;\n};\n\nSomePromiseArray.prototype._rejected = function () {\n    return this._values.length - this.length();\n};\n\nSomePromiseArray.prototype._addRejected = function (reason) {\n    this._values.push(reason);\n};\n\nSomePromiseArray.prototype._addFulfilled = function (value) {\n    this._values[this._totalResolved++] = value;\n};\n\nSomePromiseArray.prototype._canPossiblyFulfill = function () {\n    return this.length() - this._rejected();\n};\n\nSomePromiseArray.prototype._getRangeError = function (count) {\n    var message = \"Input array must contain at least \" +\n            this._howMany + \" items but contains only \" + count + \" items\";\n    return new RangeError(message);\n};\n\nSomePromiseArray.prototype._resolveEmptyArray = function () {\n    this._reject(this._getRangeError(0));\n};\n\nfunction some(promises, howMany) {\n    if ((howMany | 0) !== howMany || howMany < 0) {\n        return apiRejection(\"expecting a positive integer\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var ret = new SomePromiseArray(promises);\n    var promise = ret.promise();\n    ret.setHowMany(howMany);\n    ret.init();\n    return promise;\n}\n\nPromise.some = function (promises, howMany) {\n    return some(promises, howMany);\n};\n\nPromise.prototype.some = function (howMany) {\n    return some(this, howMany);\n};\n\nPromise._SomePromiseArray = SomePromiseArray;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/some.js\n// module id = 167\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, INTERNAL, debug) {\nvar util = require(\"./util\");\nvar TimeoutError = Promise.TimeoutError;\n\nfunction HandleWrapper(handle)  {\n    this.handle = handle;\n}\n\nHandleWrapper.prototype._resultCancelled = function() {\n    clearTimeout(this.handle);\n};\n\nvar afterValue = function(value) { return delay(+this).thenReturn(value); };\nvar delay = Promise.delay = function (ms, value) {\n    var ret;\n    var handle;\n    if (value !== undefined) {\n        ret = Promise.resolve(value)\n                ._then(afterValue, null, null, ms, undefined);\n        if (debug.cancellation() && value instanceof Promise) {\n            ret._setOnCancel(value);\n        }\n    } else {\n        ret = new Promise(INTERNAL);\n        handle = setTimeout(function() { ret._fulfill(); }, +ms);\n        if (debug.cancellation()) {\n            ret._setOnCancel(new HandleWrapper(handle));\n        }\n        ret._captureStackTrace();\n    }\n    ret._setAsyncGuaranteed();\n    return ret;\n};\n\nPromise.prototype.delay = function (ms) {\n    return delay(ms, this);\n};\n\nvar afterTimeout = function (promise, message, parent) {\n    var err;\n    if (typeof message !== \"string\") {\n        if (message instanceof Error) {\n            err = message;\n        } else {\n            err = new TimeoutError(\"operation timed out\");\n        }\n    } else {\n        err = new TimeoutError(message);\n    }\n    util.markAsOriginatingFromRejection(err);\n    promise._attachExtraTrace(err);\n    promise._reject(err);\n\n    if (parent != null) {\n        parent.cancel();\n    }\n};\n\nfunction successClear(value) {\n    clearTimeout(this.handle);\n    return value;\n}\n\nfunction failureClear(reason) {\n    clearTimeout(this.handle);\n    throw reason;\n}\n\nPromise.prototype.timeout = function (ms, message) {\n    ms = +ms;\n    var ret, parent;\n\n    var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() {\n        if (ret.isPending()) {\n            afterTimeout(ret, message, parent);\n        }\n    }, ms));\n\n    if (debug.cancellation()) {\n        parent = this.then();\n        ret = parent._then(successClear, failureClear,\n                            undefined, handleWrapper, undefined);\n        ret._setOnCancel(handleWrapper);\n    } else {\n        ret = this._then(successClear, failureClear,\n                            undefined, handleWrapper, undefined);\n    }\n\n    return ret;\n};\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/timers.js\n// module id = 168\n// module chunks = 4","\"use strict\";\nmodule.exports = function (Promise, apiRejection, tryConvertToPromise,\n    createContext, INTERNAL, debug) {\n    var util = require(\"./util\");\n    var TypeError = require(\"./errors\").TypeError;\n    var inherits = require(\"./util\").inherits;\n    var errorObj = util.errorObj;\n    var tryCatch = util.tryCatch;\n    var NULL = {};\n\n    function thrower(e) {\n        setTimeout(function(){throw e;}, 0);\n    }\n\n    function castPreservingDisposable(thenable) {\n        var maybePromise = tryConvertToPromise(thenable);\n        if (maybePromise !== thenable &&\n            typeof thenable._isDisposable === \"function\" &&\n            typeof thenable._getDisposer === \"function\" &&\n            thenable._isDisposable()) {\n            maybePromise._setDisposable(thenable._getDisposer());\n        }\n        return maybePromise;\n    }\n    function dispose(resources, inspection) {\n        var i = 0;\n        var len = resources.length;\n        var ret = new Promise(INTERNAL);\n        function iterator() {\n            if (i >= len) return ret._fulfill();\n            var maybePromise = castPreservingDisposable(resources[i++]);\n            if (maybePromise instanceof Promise &&\n                maybePromise._isDisposable()) {\n                try {\n                    maybePromise = tryConvertToPromise(\n                        maybePromise._getDisposer().tryDispose(inspection),\n                        resources.promise);\n                } catch (e) {\n                    return thrower(e);\n                }\n                if (maybePromise instanceof Promise) {\n                    return maybePromise._then(iterator, thrower,\n                                              null, null, null);\n                }\n            }\n            iterator();\n        }\n        iterator();\n        return ret;\n    }\n\n    function Disposer(data, promise, context) {\n        this._data = data;\n        this._promise = promise;\n        this._context = context;\n    }\n\n    Disposer.prototype.data = function () {\n        return this._data;\n    };\n\n    Disposer.prototype.promise = function () {\n        return this._promise;\n    };\n\n    Disposer.prototype.resource = function () {\n        if (this.promise().isFulfilled()) {\n            return this.promise().value();\n        }\n        return NULL;\n    };\n\n    Disposer.prototype.tryDispose = function(inspection) {\n        var resource = this.resource();\n        var context = this._context;\n        if (context !== undefined) context._pushContext();\n        var ret = resource !== NULL\n            ? this.doDispose(resource, inspection) : null;\n        if (context !== undefined) context._popContext();\n        this._promise._unsetDisposable();\n        this._data = null;\n        return ret;\n    };\n\n    Disposer.isDisposer = function (d) {\n        return (d != null &&\n                typeof d.resource === \"function\" &&\n                typeof d.tryDispose === \"function\");\n    };\n\n    function FunctionDisposer(fn, promise, context) {\n        this.constructor$(fn, promise, context);\n    }\n    inherits(FunctionDisposer, Disposer);\n\n    FunctionDisposer.prototype.doDispose = function (resource, inspection) {\n        var fn = this.data();\n        return fn.call(resource, resource, inspection);\n    };\n\n    function maybeUnwrapDisposer(value) {\n        if (Disposer.isDisposer(value)) {\n            this.resources[this.index]._setDisposable(value);\n            return value.promise();\n        }\n        return value;\n    }\n\n    function ResourceList(length) {\n        this.length = length;\n        this.promise = null;\n        this[length-1] = null;\n    }\n\n    ResourceList.prototype._resultCancelled = function() {\n        var len = this.length;\n        for (var i = 0; i < len; ++i) {\n            var item = this[i];\n            if (item instanceof Promise) {\n                item.cancel();\n            }\n        }\n    };\n\n    Promise.using = function () {\n        var len = arguments.length;\n        if (len < 2) return apiRejection(\n                        \"you must pass at least 2 arguments to Promise.using\");\n        var fn = arguments[len - 1];\n        if (typeof fn !== \"function\") {\n            return apiRejection(\"expecting a function but got \" + util.classString(fn));\n        }\n        var input;\n        var spreadArgs = true;\n        if (len === 2 && Array.isArray(arguments[0])) {\n            input = arguments[0];\n            len = input.length;\n            spreadArgs = false;\n        } else {\n            input = arguments;\n            len--;\n        }\n        var resources = new ResourceList(len);\n        for (var i = 0; i < len; ++i) {\n            var resource = input[i];\n            if (Disposer.isDisposer(resource)) {\n                var disposer = resource;\n                resource = resource.promise();\n                resource._setDisposable(disposer);\n            } else {\n                var maybePromise = tryConvertToPromise(resource);\n                if (maybePromise instanceof Promise) {\n                    resource =\n                        maybePromise._then(maybeUnwrapDisposer, null, null, {\n                            resources: resources,\n                            index: i\n                    }, undefined);\n                }\n            }\n            resources[i] = resource;\n        }\n\n        var reflectedResources = new Array(resources.length);\n        for (var i = 0; i < reflectedResources.length; ++i) {\n            reflectedResources[i] = Promise.resolve(resources[i]).reflect();\n        }\n\n        var resultPromise = Promise.all(reflectedResources)\n            .then(function(inspections) {\n                for (var i = 0; i < inspections.length; ++i) {\n                    var inspection = inspections[i];\n                    if (inspection.isRejected()) {\n                        errorObj.e = inspection.error();\n                        return errorObj;\n                    } else if (!inspection.isFulfilled()) {\n                        resultPromise.cancel();\n                        return;\n                    }\n                    inspections[i] = inspection.value();\n                }\n                promise._pushContext();\n\n                fn = tryCatch(fn);\n                var ret = spreadArgs\n                    ? fn.apply(undefined, inspections) : fn(inspections);\n                var promiseCreated = promise._popContext();\n                debug.checkForgottenReturns(\n                    ret, promiseCreated, \"Promise.using\", promise);\n                return ret;\n            });\n\n        var promise = resultPromise.lastly(function() {\n            var inspection = new Promise.PromiseInspection(resultPromise);\n            return dispose(resources, inspection);\n        });\n        resources.promise = promise;\n        promise._setOnCancel(resources);\n        return promise;\n    };\n\n    Promise.prototype._setDisposable = function (disposer) {\n        this._bitField = this._bitField | 131072;\n        this._disposer = disposer;\n    };\n\n    Promise.prototype._isDisposable = function () {\n        return (this._bitField & 131072) > 0;\n    };\n\n    Promise.prototype._getDisposer = function () {\n        return this._disposer;\n    };\n\n    Promise.prototype._unsetDisposable = function () {\n        this._bitField = this._bitField & (~131072);\n        this._disposer = undefined;\n    };\n\n    Promise.prototype.disposer = function (fn) {\n        if (typeof fn === \"function\") {\n            return new FunctionDisposer(fn, this, createContext());\n        }\n        throw new TypeError();\n    };\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/using.js\n// module id = 169\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise) {\nvar SomePromiseArray = Promise._SomePromiseArray;\nfunction any(promises) {\n    var ret = new SomePromiseArray(promises);\n    var promise = ret.promise();\n    ret.setHowMany(1);\n    ret.setUnwrap();\n    ret.init();\n    return promise;\n}\n\nPromise.any = function (promises) {\n    return any(promises);\n};\n\nPromise.prototype.any = function () {\n    return any(this);\n};\n\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/any.js\n// module id = 170\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar PromiseReduce = Promise.reduce;\nvar PromiseAll = Promise.all;\n\nfunction promiseAllThis() {\n    return PromiseAll(this);\n}\n\nfunction PromiseMapSeries(promises, fn) {\n    return PromiseReduce(promises, fn, INTERNAL, INTERNAL);\n}\n\nPromise.prototype.each = function (fn) {\n    return PromiseReduce(this, fn, INTERNAL, 0)\n              ._then(promiseAllThis, undefined, undefined, this, undefined);\n};\n\nPromise.prototype.mapSeries = function (fn) {\n    return PromiseReduce(this, fn, INTERNAL, INTERNAL);\n};\n\nPromise.each = function (promises, fn) {\n    return PromiseReduce(promises, fn, INTERNAL, 0)\n              ._then(promiseAllThis, undefined, undefined, promises, undefined);\n};\n\nPromise.mapSeries = PromiseMapSeries;\n};\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/each.js\n// module id = 171\n// module chunks = 4","\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar PromiseMap = Promise.map;\n\nPromise.prototype.filter = function (fn, options) {\n    return PromiseMap(this, fn, options, INTERNAL);\n};\n\nPromise.filter = function (promises, fn, options) {\n    return PromiseMap(promises, fn, options, INTERNAL);\n};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/bluebird/js/release/filter.js\n// module id = 172\n// module chunks = 4","/*!\n * jQuery Cookie Plugin v1.4.1\n * https://github.com/carhartl/jquery-cookie\n *\n * Copyright 2013 Klaus Hartl\n * Released under the MIT license\n */\n(function (factory) {\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD\n\t\tdefine(['jquery'], factory);\n\t} else if (typeof exports === 'object') {\n\t\t// CommonJS\n\t\tfactory(require('jquery'));\n\t} else {\n\t\t// Browser globals\n\t\tfactory(jQuery);\n\t}\n}(function ($) {\n\n\tvar pluses = /\\+/g;\n\n\tfunction encode(s) {\n\t\treturn config.raw ? s : encodeURIComponent(s);\n\t}\n\n\tfunction decode(s) {\n\t\treturn config.raw ? s : decodeURIComponent(s);\n\t}\n\n\tfunction stringifyCookieValue(value) {\n\t\treturn encode(config.json ? JSON.stringify(value) : String(value));\n\t}\n\n\tfunction parseCookieValue(s) {\n\t\tif (s.indexOf('\"') === 0) {\n\t\t\t// This is a quoted cookie as according to RFC2068, unescape...\n\t\t\ts = s.slice(1, -1).replace(/\\\\\"/g, '\"').replace(/\\\\\\\\/g, '\\\\');\n\t\t}\n\n\t\ttry {\n\t\t\t// Replace server-side written pluses with spaces.\n\t\t\t// If we can't decode the cookie, ignore it, it's unusable.\n\t\t\t// If we can't parse the cookie, ignore it, it's unusable.\n\t\t\ts = decodeURIComponent(s.replace(pluses, ' '));\n\t\t\treturn config.json ? JSON.parse(s) : s;\n\t\t} catch(e) {}\n\t}\n\n\tfunction read(s, converter) {\n\t\tvar value = config.raw ? s : parseCookieValue(s);\n\t\treturn $.isFunction(converter) ? converter(value) : value;\n\t}\n\n\tvar config = $.cookie = function (key, value, options) {\n\n\t\t// Write\n\n\t\tif (value !== undefined && !$.isFunction(value)) {\n\t\t\toptions = $.extend({}, config.defaults, options);\n\n\t\t\tif (typeof options.expires === 'number') {\n\t\t\t\tvar days = options.expires, t = options.expires = new Date();\n\t\t\t\tt.setTime(+t + days * 864e+5);\n\t\t\t}\n\n\t\t\treturn (document.cookie = [\n\t\t\t\tencode(key), '=', stringifyCookieValue(value),\n\t\t\t\toptions.expires ? '; expires=' + options.expires.toUTCString() : '', // use expires attribute, max-age is not supported by IE\n\t\t\t\toptions.path    ? '; path=' + options.path : '',\n\t\t\t\toptions.domain  ? '; domain=' + options.domain : '',\n\t\t\t\toptions.secure  ? '; secure' : ''\n\t\t\t].join(''));\n\t\t}\n\n\t\t// Read\n\n\t\tvar result = key ? undefined : {};\n\n\t\t// To prevent the for loop in the first place assign an empty array\n\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t// calling $.cookie().\n\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\n\t\tfor (var i = 0, l = cookies.length; i < l; i++) {\n\t\t\tvar parts = cookies[i].split('=');\n\t\t\tvar name = decode(parts.shift());\n\t\t\tvar cookie = parts.join('=');\n\n\t\t\tif (key && key === name) {\n\t\t\t\t// If second argument (value) is a function it's a converter...\n\t\t\t\tresult = read(cookie, value);\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\t// Prevent storing a cookie that we couldn't decode.\n\t\t\tif (!key && (cookie = read(cookie)) !== undefined) {\n\t\t\t\tresult[name] = cookie;\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t};\n\n\tconfig.defaults = {};\n\n\t$.removeCookie = function (key, options) {\n\t\tif ($.cookie(key) === undefined) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Must not alter options, thus extending a fresh object...\n\t\t$.cookie(key, '', $.extend({}, options, { expires: -1 }));\n\t\treturn !$.cookie(key);\n\t};\n\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/jquery.cookie/jquery.cookie.js\n// module id = 173\n// module chunks = 4"],"sourceRoot":""}