{"version":3,"file":"polyfills.bb6105feed5778bf.js","mappings":"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","names":["window","global","Buffer","require","process","jQuery","$","exports","byteLength","b64","lens","getLens","placeHoldersLen","toByteArray","tmp","i","validLen","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","tripletToBase64","num","start","end","output","base64","ieee754","customInspectSymbol","Symbol","for","SlowBuffer","alloc","K_MAX_LENGTH","createBuffer","RangeError","buf","Object","setPrototypeOf","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","fromString","string","encoding","isEncoding","actual","write","slice","ArrayBuffer","isView","fromArrayView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","SharedArrayBuffer","valueOf","b","fromObject","obj","isBuffer","checked","undefined","numberIsNaN","type","isArray","data","toPrimitive","assertSize","size","array","toString","mustMatch","arguments","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","this","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","val","dir","arrayIndexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","read","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","str","byteArray","base64Write","ucs2Write","utf16leToBytes","units","c","hi","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","TYPED_ARRAY_SUPPORT","typedArraySupport","proto","foo","console","error","defineProperty","enumerable","get","poolSize","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","INSPECT_MAX_BYTES","replace","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","INVALID_BASE64_RE","Infinity","leadSurrogate","base64clean","split","src","dst","constructor","name","alphabet","table","i16","isLE","mLen","nBytes","e","eLen","eMax","eBias","nBits","d","s","NaN","rt","abs","isNaN","floor","log","LN2","__WEBPACK_AMD_DEFINE_RESULT__","factory","module","document","w","noGlobal","getProto","getPrototypeOf","flat","class2type","hasOwn","hasOwnProperty","fnToString","ObjectFunctionString","support","isFunction","nodeType","isWindow","preservedScriptAttributes","nonce","noModule","DOMEval","node","doc","script","createElement","text","getAttribute","setAttribute","head","appendChild","parentNode","removeChild","toType","selector","context","fn","init","isArrayLike","jquery","toArray","pushStack","elems","merge","prevObject","each","callback","map","elem","first","eq","last","even","grep","_elem","odd","sort","splice","extend","options","copyIsArray","clone","deep","isPlainObject","expando","random","isReady","msg","noop","Ctor","isEmptyObject","globalEval","makeArray","results","inArray","second","invert","matches","callbackExpect","guid","iterator","_i","Sizzle","Expr","getText","isXML","tokenize","compile","select","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","contains","Date","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","pop","pushNative","booleans","whitespace","identifier","attributes","pseudos","rwhitespace","RegExp","rtrim","rcomma","rcombinators","rdescend","rpseudo","ridentifier","matchExpr","ID","CLASS","TAG","ATTR","PSEUDO","CHILD","bool","needsContext","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escape","nonHex","high","rcssescape","fcssescape","ch","asCodePoint","unloadHandler","inDisabledFieldset","addCombinator","disabled","nodeName","next","childNodes","els","seed","nid","match","groups","newSelector","newContext","ownerDocument","exec","getElementById","id","getElementsByTagName","getElementsByClassName","qsa","test","testContext","scope","toSelector","querySelectorAll","removeAttribute","keys","cache","key","cacheLength","shift","markFunction","assert","el","addHandle","attrs","handler","attrHandle","siblingCheck","cur","diff","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","documentElement","namespaceURI","hasCompare","subWindow","defaultView","top","addEventListener","attachEvent","className","createComment","getById","getElementsByName","filter","attrId","find","getAttributeNode","tag","input","innerHTML","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","sortDetached","aup","ap","bp","unshift","expr","elements","attr","specified","sel","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","firstChild","nodeValue","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","check","result","what","_argument","simple","forward","ofType","_context","xml","uniqueCache","outerCache","nodeIndex","parent","useCache","lastChild","uniqueID","pseudo","args","setFilters","idx","matched","not","matcher","unmatched","has","lang","elemLang","hash","location","root","focus","activeElement","hasFocus","href","tabIndex","enabled","selected","empty","header","button","_matchIndexes","lt","gt","nth","radio","checkbox","file","password","image","submit","reset","tokens","combinator","base","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","multipleContexts","contexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","filters","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","matcherFromGroupMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","token","compiled","_name","defaultValue","unique","isXMLDoc","escapeSelector","until","truncate","is","siblings","rneedsContext","rsingleTag","winnow","qualifier","self","rootjQuery","parseHTML","ready","rparentsprev","guaranteedUnique","children","contents","prev","sibling","targets","l","closest","index","prevAll","add","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","content","reverse","rnothtmlwhite","Identity","v","Thrower","ex","adoptValue","resolve","reject","noValue","method","promise","fail","then","Callbacks","createOptions","object","_","flag","firing","memory","fired","locked","queue","firingIndex","fire","once","stopOnFalse","remove","disable","lock","fireWith","Deferred","func","tuples","state","always","deferred","catch","pipe","fns","newDefer","tuple","returned","progress","notify","onFulfilled","onRejected","onProgress","maxDepth","depth","special","that","mightThrow","notifyWith","resolveWith","exceptionHook","stackTrace","rejectWith","getStackHook","setTimeout","stateString","when","singleValue","resolveContexts","resolveValues","master","updateFunc","rerrorNames","stack","warn","message","readyException","readyList","completed","removeEventListener","readyWait","wait","readyState","doScroll","access","chainable","emptyGet","raw","bulk","_key","rmsPrefix","rdashAlpha","fcamelCase","_all","letter","toUpperCase","camelCase","acceptData","owner","Data","uid","configurable","prop","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","getData","JSON","parse","removeData","_data","_removeData","dequeue","startLength","hooks","_queueHooks","stop","setter","clearQueue","count","defer","pnum","source","rcssNum","cssExpand","isAttached","composed","getRootNode","isHiddenWithinTree","style","display","css","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","initial","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","body","showHide","show","values","hide","toggle","div","rcheckableType","rtagName","rscriptType","createDocumentFragment","checkClone","cloneNode","noCloneChecked","option","wrapMap","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","tbody","tfoot","colgroup","caption","th","optgroup","buildFragment","scripts","selection","ignored","wrap","attached","fragment","nodes","htmlPrefilter","createTextNode","rkeyEvent","rmouseEvent","rtypenamespace","returnTrue","returnFalse","expectSync","safeActiveElement","on","types","one","origFn","event","off","leverageNative","namespace","notAsync","saved","isTrigger","delegateType","stopPropagation","stopImmediatePropagation","preventDefault","trigger","Event","handleObjIn","eventHandle","events","t","handleObj","handlers","namespaces","origType","elemData","create","handle","triggered","dispatch","bindType","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","postDispatch","matchedHandlers","matchedSelectors","addProp","hook","originalEvent","writable","load","noBubble","click","beforeunload","returnValue","props","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","now","isSimulated","altKey","bubbles","cancelable","changedTouches","ctrlKey","detail","eventPhase","metaKey","pageX","pageY","shiftKey","view","char","charCode","keyCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","which","blur","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","valueIsFunction","html","_evalUrl","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","append","prepend","insertBefore","before","after","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","original","insert","rnumnonpx","getStyles","opener","getComputedStyle","old","rboxStyle","curCSS","computed","width","minWidth","maxWidth","getPropertyValue","pixelBoxStyles","addGetHookIf","conditionFn","hookFn","computeStyleTests","container","cssText","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","marginLeft","right","pixelBoxStylesVal","boxSizingReliableVal","position","scrollboxSizeVal","offsetWidth","measure","round","parseFloat","reliableTrDimensionsVal","backgroundClip","clearCloneStyle","boxSizingReliable","pixelPosition","reliableMarginLeft","scrollboxSize","reliableTrDimensions","trChild","trStyle","height","cssPrefixes","emptyStyle","vendorProps","finalPropName","cssProps","vendorPropName","capName","rdisplayswap","rcustomProp","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","boxModelAdjustment","dimension","box","isBorderBox","styles","computedVal","extra","delta","ceil","getWidthOrHeight","valueIsBorderBox","offsetProp","getClientRects","Tween","easing","cssHooks","opacity","animationIterationCount","columnCount","fillOpacity","flexGrow","flexShrink","gridArea","gridColumn","gridColumnEnd","gridColumnStart","gridRow","gridRowEnd","gridRowStart","lineHeight","order","orphans","widows","zIndex","zoom","origName","isCustomProp","setProperty","getBoundingClientRect","scrollboxSizeBuggy","left","margin","padding","border","prefix","suffix","expand","expanded","propHooks","run","percent","eased","duration","step","fx","scrollTop","scrollLeft","linear","p","swing","cos","PI","fxNow","inProgress","rfxtypes","rrun","schedule","hidden","requestAnimationFrame","interval","tick","createFxNow","genFx","includeWidth","createTween","animation","Animation","tweeners","properties","stopped","prefilters","currentTime","startTime","tweens","opts","specialEasing","originalProperties","originalOptions","gotoEnd","propFilter","bind","complete","timer","anim","tweener","defaultPrefilter","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","speed","opt","speeds","fadeTo","to","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","delay","time","timeout","clearTimeout","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","attrNames","getter","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","classesToArray","removeProp","propFix","tabindex","class","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","isValidValue","classNames","hasClass","rreturn","valHooks","selectedIndex","optionSet","focusin","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","simulate","triggerHandler","attaches","rquery","parseXML","DOMParser","parseFromString","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","param","valueOrFunction","encodeURIComponent","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","transports","allTypes","originAnchor","addToPrefiltersOrTransports","structure","dataTypeExpression","dataType","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","active","lastModified","etag","url","isLocal","protocol","processData","async","contentType","accepts","json","responseFields","converters","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","urlAnchor","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeaders","requestHeadersNames","strAbort","getResponseHeader","getAllResponseHeaders","setRequestHeader","overrideMimeType","mimeType","status","abort","statusText","finalText","crossDomain","host","hasContent","ifModified","headers","beforeSend","success","send","nativeStatusText","responses","isSuccess","response","modified","ajaxHandleResponses","ct","finalDataType","firstDataType","ajaxConvert","conv2","current","conv","dataFilter","throws","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","offsetHeight","xhr","XMLHttpRequest","xhrSuccessStatus","xhrSupported","cors","errorCallback","open","username","xhrFields","onload","onerror","onabort","ontimeout","onreadystatechange","responseType","responseText","binary","scriptAttrs","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","params","animated","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","unbind","delegate","undelegate","hover","fnOver","fnOut","proxy","holdReady","hold","parseJSON","isNumeric","_jQuery","_$","noConflict","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","runClearTimeout","marker","Item","nextTick","title","browser","env","argv","version","versions","addListener","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","performance","mark","performanceMeasure","label","symbolPrefix","__Zone_symbol_prefix","__symbol__","checkDuplicate","Zone","static","assertZonePatched","Promise","patches","ZoneAwarePromise","zone","_currentZoneFrame","currentTask","_currentTask","__load_patch","ignoreDuplicate","perfName","_api","_parent","zoneSpec","_properties","_zoneDelegate","_ZoneDelegate","getZoneWith","fork","_callback","intercept","runGuarded","applyThis","applyArgs","invoke","handleError","runTask","task","NO_ZONE","notScheduled","eventTask","macroTask","reEntryGuard","running","_transitionTo","scheduled","runCount","previousTask","isPeriodic","cancelFn","invokeTask","unknown","_updateTaskCount","scheduleTask","newZone","scheduling","zoneDelegates","_zoneDelegates","_zone","err","scheduleMicroTask","customSchedule","ZoneTask","microTask","scheduleMacroTask","customCancel","scheduleEventTask","cancelTask","canceling","DELEGATE_ZS","onHasTask","hasTaskState","hasTask","onScheduleTask","onInvokeTask","onCancelTask","parentDelegate","_taskCounts","_parentDelegate","_forkZS","onFork","_forkDlgt","_forkCurrZone","_interceptZS","onIntercept","_interceptDlgt","_interceptCurrZone","_invokeZS","onInvoke","_invokeDlgt","_invokeCurrZone","_handleErrorZS","onHandleError","_handleErrorDlgt","_handleErrorCurrZone","_scheduleTaskZS","_scheduleTaskDlgt","_scheduleTaskCurrZone","_invokeTaskZS","_invokeTaskDlgt","_invokeTaskCurrZone","_cancelTaskZS","_cancelTaskDlgt","_cancelTaskCurrZone","_hasTaskZS","_hasTaskDlgt","_hasTaskDlgtOwner","_hasTaskCurrZone","zoneSpecHasTask","targetZone","returnTask","scheduleFn","isEmpty","counts","change","_state","useG","_numberOfNestedTaskFrames","drainMicroTaskQueue","cancelScheduleRequest","toState","fromState1","fromState2","handleId","symbolSetTimeout","symbolPromise","symbolThen","nativeMicroTaskQueuePromise","_microTaskQueue","_isDrainingMicrotaskQueue","nativeScheduleMicroTask","nativeThen","onUnhandledError","microtaskDrainDone","symbol","currentZoneFrame","showUncaughtError","patchEventTarget","patchOnProperties","patchMethod","bindArguments","patchThen","patchMacroTask","patchEventPrototype","isIEOrEdge","getGlobalObjects","ObjectDefineProperty","ObjectGetOwnPropertyDescriptor","ObjectCreate","ArraySlice","patchClass","wrapWithCurrentZone","filterProperties","attachOriginToPatched","_redefineProperty","patchCallbacks","getOwnPropertyDescriptor","ObjectGetPrototypeOf","ADD_EVENT_LISTENER_STR","REMOVE_EVENT_LISTENER_STR","ZONE_SYMBOL_ADD_EVENT_LISTENER","ZONE_SYMBOL_REMOVE_EVENT_LISTENER","TRUE_STR","FALSE_STR","ZONE_SYMBOL_PREFIX","scheduleMacroTaskWithCurrentZone","zoneSymbol","isWindowExists","internalWindow","_global","REMOVE_ATTRIBUTE","isPropertyWritable","propertyDesc","isWebWorker","WorkerGlobalScope","isNode","isBrowser","HTMLElement","isMix","zoneSymbolEventNames$1","wrapFn","eventNameSymbol","listener","filename","lineno","colno","patchProperty","desc","onPropPatchedSymbol","originalDescGet","originalDescSet","eventName","newValue","onProperties","originalInstanceKey","OriginalClass","instance","patchFn","delegateName","patchDelegate","metaCreator","setNative","cbIdx","meta","patched","isDetectedIEOrEdge","ieOrEdge","ua","navigator","userAgent","api","_uncaughtPromiseErrors","isDisableWrappingUncaughtPromiseRejection","creationTrace","rejection","uncaughtPromiseError","throwOriginal","handleUnhandledRejection","UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL","isThenable","forwardResolution","forwardRejection","symbolState","symbolValue","symbolFinally","symbolParentPromiseValue","symbolParentPromiseState","UNRESOLVED","RESOLVED","REJECTED","REJECTED_NO_CATCH","makeResolver","resolvePromise","wasCalled","wrappedFunction","TYPE_ERROR","CURRENT_TASK_TRACE_SYMBOL","onceWrapper","clearRejectedNoCatch","trace","scheduleResolveOrReject","readableObjectToString","stringify","REJECTION_HANDLED_HANDLER","chainPromise","promiseState","parentPromiseValue","isFinallyPromise","AggregateError","any","promises","finished","errors","race","rej","onResolve","onReject","all","allWithCallback","allSettled","thenCallback","reason","unresolvedCount","valueIndex","resolvedValues","curValueIndex","thenErr","executor","toStringTag","species","C","finally","onFinally","NativePromise","symbolThenPatched","originalThen","zoneify","resultPromise","ctor","originalFunctionToString","Function","ORIGINAL_DELEGATE_SYMBOL","PROMISE_SYMBOL","ERROR_SYMBOL","newFunctionToString","originalDelegate","nativePromise","nativeError","originalObjectToString","passiveSupported","OPTIMIZED_ZONE_EVENT_TASK_DATA","zoneSymbolEventNames","globalSources","EVENT_NAME_SYMBOL_REGX","IMMEDIATE_PROPAGATION_SYMBOL","prepareEventNames","eventNameToString","falseEventName","trueEventName","symbolCapture","apis","patchOptions","ADD_EVENT_LISTENER","REMOVE_EVENT_LISTENER","rm","LISTENERS_EVENT_LISTENER","REMOVE_ALL_LISTENERS_EVENT_LISTENER","rmAll","zoneSymbolAddEventListener","ADD_EVENT_LISTENER_SOURCE","PREPEND_EVENT_LISTENER","PREPEND_EVENT_LISTENER_SOURCE","isRemoved","handleEvent","globalCallback","isCapture","tasks","copyTasks","globalZoneAwareCallback","globalZoneAwareCaptureCallback","patchEventTargetMethods","useGlobalCallback","validateHandler","vh","chkDup","returnTarget","taskData","nativeAddEventListener","nativeRemoveEventListener","nativeListeners","nativeRemoveAllListeners","nativePrependEventListener","isExisting","capture","symbolEventNames","symbolEventName","existingTasks","allRemoved","typeOfDelegate","unpatchedEvents","passiveEvents","makeAddListener","nativeListener","addSource","customScheduleFn","customCancelFn","transferEventName","isHandleEvent","passive","buildEventListenerOptions","constructorName","targetSource","existingTask","findEventTasks","captureTasks","removeTasks","evtName","foundTasks","captureFalseTasks","captureTrueTasks","targetName","callbacks","nativeDelegate","forEach","descriptor","ignoreProperties","tip","ip","targetIgnoreProperties","op","patchFilteredProperties","getOnEventNames","getOwnPropertyNames","startsWith","substring","eventNames","SYMBOL_BLACK_LISTED_EVENTS","SYMBOL_UNPATCHED_EVENTS","taskSymbol","patchTimer","setName","cancelName","nameSuffix","clearNative","tasksByHandleId","clearTask","ref","unref","legacyPatch","clear","blockingMethods","patchEvent","eventTargetPatch","EVENT_TARGET","EventTarget","XMLHttpRequestEventTarget","propertyDescriptorPatch","__Zone_ignore_on_properties","patchTargets","ignoreErrorProperties","isIE","patchCustomElements","customElements","patchXHR","XMLHttpRequestPrototype","oriAddListener","oriRemoveListener","XMLHttpRequestEventTargetPrototype","READY_STATE_CHANGE","SCHEDULED","XHR_SCHEDULED","XHR_ERROR_BEFORE_SCHEDULED","XHR_LISTENER","newListener","DONE","aborted","loadTasks","oriInvoke","XHR_TASK","sendNative","placeholderCallback","abortNative","openNative","XHR_SYNC","XHR_URL","fetchTaskAborting","fetchTaskScheduling","findPendingTask","geolocation","patchPrototype","fnNames","findPromiseRejectionHandler","PromiseRejectionEvent","patchQueueMicrotask"],"sourceRoot":"webpack:///","sources":["./projects/public/src/polyfills.ts","./node_modules/base64-js/index.js","./node_modules/buffer/index.js","./node_modules/ieee754/index.js","./node_modules/jquery/dist/jquery.js","./node_modules/process/browser.js","./node_modules/zone.js/fesm2015/zone.js"],"sourcesContent":["/**\n * This file includes polyfills needed by Angular and is loaded before the app.\n * You can add your own extra polyfills to this file.\n *\n * This file is divided into 2 sections:\n *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.\n *   2. Application imports. Files imported after ZoneJS that should be loaded before your main\n *      file.\n *\n * The current setup is for so-called \"evergreen\" browsers; the last versions of browsers that\n * automatically update themselves. This includes recent versions of Safari, Chrome (including\n * Opera), Edge on the desktop, and iOS and Chrome on mobile.\n *\n * Learn more in https://angular.io/guide/browser-support\n */\n\n/***************************************************************************************************\n * BROWSER POLYFILLS\n */\n\n/**\n * By default, zone.js will patch all possible macroTask and DomEvents\n * user can disable parts of macroTask/DomEvents patch by setting following flags\n * because those flags need to be set before `zone.js` being loaded, and webpack\n * will put import in the top of bundle, so user need to create a separate file\n * in this directory (for example: zone-flags.ts), and put the following flags\n * into that file, and then add the following code before importing zone.js.\n * import './zone-flags';\n *\n * The flags allowed in zone-flags.ts are listed here.\n *\n * The following flags will work for all browsers.\n *\n * (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame\n * (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick\n * (window as any).__zone_symbol__UNPATCHED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames\n *\n *  in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js\n *  with the following flag, it will bypass `zone.js` patch for IE/Edge\n *\n *  (window as any).__Zone_enable_cross_context_check = true;\n *\n */\n\n/***************************************************************************************************\n * Zone JS is required by default for Angular itself.\n */\nimport 'zone.js';  // Included with Angular CLI.\n\n\n/***************************************************************************************************\n * APPLICATION IMPORTS\n */\n// https://github.com/angular/angular-cli/issues/8160#issuecomment-386153833\n// Add global to window, assigning the value of window itself.\n(window as any).global = window;\n\n// https://stackoverflow.com/questions/50371593/angular-6-uncaught-referenceerror-buffer-is-not-defined\nglobal.Buffer = global.Buffer || require('buffer').Buffer;\n\n// https://stackoverflow.com/questions/50313745/angular-6-process-is-not-defined-when-trying-to-serve-application\nglobal.process = require('process');\n\n// legacy usage of jquery\nimport * as $ from 'jquery';\n(window as any).jQuery = $;\n(window as any).$ = $;\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nvar K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    var arr = new Uint8Array(1)\n    var proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  var buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  var valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  var b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(\n      value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n    )\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  var length = byteLength(string, encoding) | 0\n  var buf = createBuffer(length)\n\n  var actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  var buf = createBuffer(length)\n  for (var i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    var copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  var buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    var buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        Buffer.from(buf).copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  var len = string.length\n  var mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  var strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return asciiWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (var i = 0; i < bytes.length - 1; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    var len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nvar hexSliceLookupTable = (function () {\n  var alphabet = '0123456789abcdef'\n  var table = new Array(256)\n  for (var i = 0; i < 16; ++i) {\n    var i16 = i * 16\n    for (var j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","/*!\n * jQuery JavaScript Library v3.5.1\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2020-05-04T22:49Z\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 #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      // Support: Chrome <=57, Firefox <=52\n      // In some browsers, typeof returns \"function\" for HTML <object> elements\n      // (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n      // We don't want to classify *any* DOM node as a function.\n      return typeof obj === \"function\" && typeof obj.nodeType !== \"number\";\n  };\n\n\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\n\tversion = \"3.5.1\",\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\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[ 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\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( \" \" ),\nfunction( _i, name ) {\n\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n} );\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}\nvar Sizzle =\n/*!\n * Sizzle CSS Selector Engine v2.3.5\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://js.foundation/\n *\n * Date: 2020-03-14\n */\n( function( window ) {\nvar i,\n\tsupport,\n\tExpr,\n\tgetText,\n\tisXML,\n\ttokenize,\n\tcompile,\n\tselect,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\n\t// Local document vars\n\tsetDocument,\n\tdocument,\n\tdocElem,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\trbuggyMatches,\n\tmatches,\n\tcontains,\n\n\t// Instance-specific data\n\texpando = \"sizzle\" + 1 * new Date(),\n\tpreferredDoc = window.document,\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\t// Instance methods\n\thasOwn = ( {} ).hasOwnProperty,\n\tarr = [],\n\tpop = arr.pop,\n\tpushNative = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\n\t// Use a stripped-down indexOf as it's faster than native\n\t// https://jsperf.com/thor-indexof-vs-for/5\n\tindexOf = function( list, elem ) {\n\t\tvar i = 0,\n\t\t\tlen = list.length;\n\t\tfor ( ; i < len; i++ ) {\n\t\t\tif ( list[ i ] === elem ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|\" +\n\t\t\"ismap|loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// http://www.w3.org/TR/css3-selectors/#whitespace\n\twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\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: http://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]\n\t\t// 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\trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" +\n\t\twhitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace +\n\t\t\"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\t\"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\n\t\t\"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\t\"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": 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\t\"needsContext\": 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\trhtml = /HTML$/i,\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\trnative = /^[^{]+\\{\\s*\\[native \\w/,\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// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\treturn nonHex ?\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\tnonHex :\n\n\t\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t\t// Support: IE <=11+\n\t\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t\t// surrogate pair\n\t\t\thigh < 0 ?\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// CSS string/identifier serialization\n\t// https://drafts.csswg.org/cssom/#common-serializing-idioms\n\trcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n\tfcssescape = function( ch, asCodePoint ) {\n\t\tif ( asCodePoint ) {\n\n\t\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\t\tif ( ch === \"\\0\" ) {\n\t\t\t\treturn \"\\uFFFD\";\n\t\t\t}\n\n\t\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\t\treturn ch.slice( 0, -1 ) + \"\\\\\" +\n\t\t\t\tch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t\t}\n\n\t\t// Other potentially-special ASCII characters get backslash-escaped\n\t\treturn \"\\\\\" + ch;\n\t},\n\n\t// Used for iframes\n\t// See setDocument()\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\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 = { apply: arr.length ?\n\n\t\t// Leverage slice if possible\n\t\tfunction( target, els ) {\n\t\t\tpushNative.apply( target, slice.call( els ) );\n\t\t} :\n\n\t\t// Support: IE<9\n\t\t// Otherwise append directly\n\t\tfunction( target, els ) {\n\t\t\tvar j = target.length,\n\t\t\t\ti = 0;\n\n\t\t\t// Can't trust NodeList.length\n\t\t\twhile ( ( target[ j++ ] = els[ i++ ] ) ) {}\n\t\t\ttarget.length = j - 1;\n\t\t}\n\t};\n}\n\nfunction Sizzle( 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, Opera, Webkit\n\t\t\t\t\t\t\t// TODO: identify versions\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\tresults.push( 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, Opera, Webkit\n\t\t\t\t\t\t// TODO: identify versions\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\tcontains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tresults.push( 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 ] ) && support.getElementsByClassName &&\n\t\t\t\t\tcontext.getElementsByClassName ) {\n\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 ( support.qsa &&\n\t\t\t\t!nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&\n\n\t\t\t\t// Support: IE 8 only\n\t\t\t\t// Exclude object elements\n\t\t\t\t( nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\" ) ) {\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 ) || rcombinators.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\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 = nid.replace( rcssescape, fcssescape );\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( rtrim, \"$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 (see Issue #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 Sizzle\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 * Adds the same handler for all of the specified attrs\n * @param {String} attrs Pipe-separated list of attributes\n * @param {Function} handler The method that will be applied\n */\nfunction addHandle( attrs, handler ) {\n\tvar arr = attrs.split( \"|\" ),\n\t\ti = arr.length;\n\n\twhile ( i-- ) {\n\t\tExpr.attrHandle[ arr[ i ] ] = handler;\n\t}\n}\n\n/**\n * Checks document order of two siblings\n * @param {Element} a\n * @param {Element} b\n * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n */\nfunction siblingCheck( a, b ) {\n\tvar cur = b && a,\n\t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\t\t\ta.sourceIndex - b.sourceIndex;\n\n\t// Use IE sourceIndex if available on both nodes\n\tif ( diff ) {\n\t\treturn diff;\n\t}\n\n\t// Check if b follows a\n\tif ( cur ) {\n\t\twhile ( ( cur = cur.nextSibling ) ) {\n\t\t\tif ( cur === b ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a ? 1 : -1;\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\tvar name = elem.nodeName.toLowerCase();\n\t\treturn name === \"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\tvar name = elem.nodeName.toLowerCase();\n\t\treturn ( name === \"input\" || name === \"button\" ) && elem.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\t/* jshint -W018 */\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\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 Sizzle 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// Expose support vars for convenience\nsupport = Sizzle.support = {};\n\n/**\n * Detects XML nodes\n * @param {Element|Object} elem An element or a document\n * @returns {Boolean} True iff elem is a non-HTML XML node\n */\nisXML = Sizzle.isXML = function( elem ) {\n\tvar namespace = elem.namespaceURI,\n\t\tdocElem = ( elem.ownerDocument || elem ).documentElement;\n\n\t// Support: IE <=8\n\t// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\n\t// https://bugs.jquery.com/ticket/4833\n\treturn !rhtml.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n};\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [doc] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nsetDocument = Sizzle.setDocument = function( node ) {\n\tvar hasCompare, 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\tdocElem = document.documentElement;\n\tdocumentIsHTML = !isXML( document );\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\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 ( preferredDoc != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 11, Edge\n\t\tif ( subWindow.addEventListener ) {\n\t\t\tsubWindow.addEventListener( \"unload\", unloadHandler, false );\n\n\t\t// Support: IE 9 - 10 only\n\t\t} else if ( subWindow.attachEvent ) {\n\t\t\tsubWindow.attachEvent( \"onunload\", unloadHandler );\n\t\t}\n\t}\n\n\t// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,\n\t// Safari 4 - 5 only, Opera <=11.6 - 12.x only\n\t// IE/Edge & older browsers don't support the :scope pseudo-class.\n\t// Support: Safari 6.0 only\n\t// Safari 6.0 supports :scope but it's an alias of :root there.\n\tsupport.scope = assert( function( el ) {\n\t\tdocElem.appendChild( el ).appendChild( document.createElement( \"div\" ) );\n\t\treturn typeof el.querySelectorAll !== \"undefined\" &&\n\t\t\t!el.querySelectorAll( \":scope fieldset div\" ).length;\n\t} );\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert( function( el ) {\n\t\tel.className = \"i\";\n\t\treturn !el.getAttribute( \"className\" );\n\t} );\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert( function( el ) {\n\t\tel.appendChild( document.createComment( \"\" ) );\n\t\treturn !el.getElementsByTagName( \"*\" ).length;\n\t} );\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\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\tdocElem.appendChild( el ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\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\" ] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\n\t\t\t\t// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n\t\t\t\tresults = context.getElementsByTagName( tag );\n\n\t\t\t// Filter out possible comments\n\t\t\tif ( tag === \"*\" ) {\n\t\t\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\ttmp.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\treturn results;\n\t\t};\n\n\t// Class\n\tExpr.find[ \"CLASS\" ] = support.getElementsByClassName && 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\t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\trbuggyMatches = [];\n\n\t// qSa(:focus) reports false when true (Chrome 21)\n\t// We allow this because of a bug in IE8/9 that throws an error\n\t// whenever `document.activeElement` is accessed on an iframe\n\t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\t// See https://bugs.jquery.com/ticket/13378\n\trbuggyQSA = [];\n\n\tif ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {\n\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert( function( el ) {\n\n\t\t\tvar input;\n\n\t\t\t// Select is set to empty string on purpose\n\t\t\t// This is to test IE's treatment of not explicitly\n\t\t\t// setting a boolean content attribute,\n\t\t\t// since its presence should be enough\n\t\t\t// https://bugs.jquery.com/ticket/12359\n\t\t\tdocElem.appendChild( el ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n\t\t\t\t\"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n\t\t\t\t\"<option selected=''></option></select>\";\n\n\t\t\t// Support: IE8, Opera 11-12.16\n\t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\t\t\t// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\t\t\tif ( el.querySelectorAll( \"[msallowcapture^='']\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Support: IE8\n\t\t\t// Boolean attributes and \"value\" are not treated correctly\n\t\t\tif ( !el.querySelectorAll( \"[selected]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t\t}\n\n\t\t\t// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\t\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"~=\" );\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 15 - 18+\n\t\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t\t// Adding a temporary attribute to the document before the selection works\n\t\t\t// around the issue.\n\t\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\t\tinput = document.createElement( \"input\" );\n\t\t\tinput.setAttribute( \"name\", \"\" );\n\t\t\tel.appendChild( input );\n\t\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Webkit/Opera - :checked should return selected option elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !el.querySelectorAll( \":checked\" ).length ) {\n\t\t\t\trbuggyQSA.push( \":checked\" );\n\t\t\t}\n\n\t\t\t// Support: Safari 8+, iOS 8+\n\t\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\t\trbuggyQSA.push( \".#.+[+~]\" );\n\t\t\t}\n\n\t\t\t// Support: Firefox <=3.6 - 5 only\n\t\t\t// Old Firefox doesn't throw on a badly-escaped identifier.\n\t\t\tel.querySelectorAll( \"\\\\\\f\" );\n\t\t\trbuggyQSA.push( \"[\\\\r\\\\n\\\\f]\" );\n\t\t} );\n\n\t\tassert( function( el ) {\n\t\t\tel.innerHTML = \"<a href='' disabled='disabled'></a>\" +\n\t\t\t\t\"<select disabled='disabled'><option/></select>\";\n\n\t\t\t// Support: Windows 8 Native Apps\n\t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\t\tvar input = document.createElement( \"input\" );\n\t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t\t// Support: IE8\n\t\t\t// Enforce case-sensitivity of name attribute\n\t\t\tif ( el.querySelectorAll( \"[name=d]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\t\t\t}\n\n\t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( el.querySelectorAll( \":enabled\" ).length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: IE9-11+\n\t\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t\tdocElem.appendChild( el ).disabled = true;\n\t\t\tif ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: Opera 10 - 11 only\n\t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\t\t\tel.querySelectorAll( \"*,:x\" );\n\t\t\trbuggyQSA.push( \",.*:\" );\n\t\t} );\n\t}\n\n\tif ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||\n\t\tdocElem.webkitMatchesSelector ||\n\t\tdocElem.mozMatchesSelector ||\n\t\tdocElem.oMatchesSelector ||\n\t\tdocElem.msMatchesSelector ) ) ) ) {\n\n\t\tassert( function( el ) {\n\n\t\t\t// Check to see if it's possible to do matchesSelector\n\t\t\t// on a disconnected node (IE 9)\n\t\t\tsupport.disconnectedMatch = matches.call( el, \"*\" );\n\n\t\t\t// This should fail with an exception\n\t\t\t// Gecko does not error, returns false instead\n\t\t\tmatches.call( el, \"[s!='']:x\" );\n\t\t\trbuggyMatches.push( \"!=\", pseudos );\n\t\t} );\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\n\trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( \"|\" ) );\n\n\t/* Contains\n\t---------------------------------------------------------------------- */\n\thasCompare = rnative.test( docElem.compareDocumentPosition );\n\n\t// Element contains another\n\t// Purposefully self-exclusive\n\t// As in, an element does not contain itself\n\tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\t\tfunction( a, b ) {\n\t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\t\t\t\tbup = b && b.parentNode;\n\t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\t\t\t\tadown.contains ?\n\t\t\t\t\tadown.contains( bup ) :\n\t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t\t) );\n\t\t} :\n\t\tfunction( a, b ) {\n\t\t\tif ( b ) {\n\t\t\t\twhile ( ( b = b.parentNode ) ) {\n\t\t\t\t\tif ( b === a ) {\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\treturn false;\n\t\t};\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = hasCompare ?\n\tfunction( 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\tcontains( 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\tcontains( 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( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t} :\n\tfunction( a, b ) {\n\n\t\t// Exit early if the nodes are identical\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\taup = a.parentNode,\n\t\t\tbup = b.parentNode,\n\t\t\tap = [ a ],\n\t\t\tbp = [ b ];\n\n\t\t// Parentless nodes are either documents or disconnected\n\t\tif ( !aup || !bup ) {\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 eqeqeq */\n\t\t\treturn a == document ? -1 :\n\t\t\t\tb == document ? 1 :\n\t\t\t\t/* eslint-enable eqeqeq */\n\t\t\t\taup ? -1 :\n\t\t\t\tbup ? 1 :\n\t\t\t\tsortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\n\t\t// If the nodes are siblings, we can do a quick check\n\t\t} else if ( aup === bup ) {\n\t\t\treturn siblingCheck( a, b );\n\t\t}\n\n\t\t// Otherwise we need full lists of their ancestors for comparison\n\t\tcur = a;\n\t\twhile ( ( cur = cur.parentNode ) ) {\n\t\t\tap.unshift( cur );\n\t\t}\n\t\tcur = b;\n\t\twhile ( ( cur = cur.parentNode ) ) {\n\t\t\tbp.unshift( cur );\n\t\t}\n\n\t\t// Walk down the tree looking for a discrepancy\n\t\twhile ( ap[ i ] === bp[ i ] ) {\n\t\t\ti++;\n\t\t}\n\n\t\treturn i ?\n\n\t\t\t// Do a sibling check if the nodes have a common ancestor\n\t\t\tsiblingCheck( ap[ i ], bp[ i ] ) :\n\n\t\t\t// Otherwise nodes in our document sort first\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 eqeqeq */\n\t\t\tap[ i ] == preferredDoc ? -1 :\n\t\t\tbp[ i ] == preferredDoc ? 1 :\n\t\t\t/* eslint-enable eqeqeq */\n\t\t\t0;\n\t};\n\n\treturn document;\n};\n\nSizzle.matches = function( expr, elements ) {\n\treturn Sizzle( expr, null, null, elements );\n};\n\nSizzle.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyMatches || !rbuggyMatches.test( 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// As well, disconnected nodes are said to be in a document\n\t\t\t\t// fragment in IE 9\n\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 Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.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 contains( context, elem );\n};\n\nSizzle.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 (jQuery #13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\treturn val !== undefined ?\n\t\tval :\n\t\tsupport.attributes || !documentIsHTML ?\n\t\t\telem.getAttribute( name ) :\n\t\t\t( val = elem.getAttributeNode( name ) ) && val.specified ?\n\t\t\t\tval.value :\n\t\t\t\tnull;\n};\n\nSizzle.escape = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\nSizzle.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 */\nSizzle.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\thasDuplicate = !support.detectDuplicates;\n\tsortInput = !support.sortStable && results.slice( 0 );\n\tresults.sort( 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\tresults.splice( 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\n/**\n * Utility function for retrieving the text value of an array of DOM nodes\n * @param {Array|Element} elem\n */\ngetText = Sizzle.getText = function( elem ) {\n\tvar node,\n\t\tret = \"\",\n\t\ti = 0,\n\t\tnodeType = elem.nodeType;\n\n\tif ( !nodeType ) {\n\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t// Do not traverse comment nodes\n\t\t\tret += getText( node );\n\t\t}\n\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\n\t\t// Use textContent for elements\n\t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\t\tif ( typeof elem.textContent === \"string\" ) {\n\t\t\treturn elem.textContent;\n\t\t} else {\n\n\t\t\t// Traverse its children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tret += getText( elem );\n\t\t\t}\n\t\t}\n\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\treturn elem.nodeValue;\n\t}\n\n\t// Do not include comment or processing instruction nodes\n\n\treturn ret;\n};\n\nExpr = Sizzle.selectors = {\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\t\"ATTR\": 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 ] ||\n\t\t\t\tmatch[ 5 ] || \"\" ).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\t\"CHILD\": 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\tSizzle.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\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[ 3 ] ) {\n\t\t\t\tSizzle.error( match[ 0 ] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\t\"PSEUDO\": 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\t\"TAG\": function( nodeNameSelector ) {\n\t\t\tvar nodeName = 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 elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\t\t\t\t};\n\t\t},\n\n\t\t\"CLASS\": function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace +\n\t\t\t\t\t\")\" + className + \"(\" + whitespace + \"|$)\" ) ) && classCache(\n\t\t\t\t\t\tclassName, function( elem ) {\n\t\t\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\t\"ATTR\": function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = Sizzle.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\t/* eslint-disable max-len */\n\n\t\t\t\treturn operator === \"=\" ? result === check :\n\t\t\t\t\toperator === \"!=\" ? result !== check :\n\t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\t\t\t\t\toperator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\t\t\t\t\tfalse;\n\t\t\t\t/* eslint-enable max-len */\n\n\t\t\t};\n\t\t},\n\n\t\t\"CHILD\": 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, uniqueCache, 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\tnode.nodeName.toLowerCase() === 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\n\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\tnode = parent;\n\t\t\t\t\t\t\touterCache = node[ expando ] || ( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\tcache = uniqueCache[ 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\tuniqueCache[ 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\n\t\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\touterCache = node[ expando ] || ( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\t\tcache = uniqueCache[ 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\tnode.nodeName.toLowerCase() === 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\n\t\t\t\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache[ 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\t\"PSEUDO\": function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// http://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\tSizzle.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 Sizzle 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( 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\t\"not\": 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( rtrim, \"$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 (issue #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\t\"has\": markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\t\"contains\": markFunction( function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || getText( 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// http://www.w3.org/TR/selectors/#lang-pseudo\n\t\t\"lang\": 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\tSizzle.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\t\"target\": 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\t\"root\": function( elem ) {\n\t\t\treturn elem === docElem;\n\t\t},\n\n\t\t\"focus\": function( elem ) {\n\t\t\treturn elem === document.activeElement &&\n\t\t\t\t( !document.hasFocus || document.hasFocus() ) &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\t\"enabled\": createDisabledPseudo( false ),\n\t\t\"disabled\": createDisabledPseudo( true ),\n\n\t\t\"checked\": function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\t\t\treturn ( nodeName === \"input\" && !!elem.checked ) ||\n\t\t\t\t( nodeName === \"option\" && !!elem.selected );\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\n\t\t\t// Accessing this property makes selected-by-default\n\t\t\t// options in Safari work properly\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\t\"empty\": function( elem ) {\n\n\t\t\t// http://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\t\"parent\": function( elem ) {\n\t\t\treturn !Expr.pseudos[ \"empty\" ]( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\t\"header\": function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\t\"input\": function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\t\"button\": function( elem ) {\n\t\t\tvar name = elem.nodeName.toLowerCase();\n\t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\t\t},\n\n\t\t\"text\": function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\t\t\t\telem.type === \"text\" &&\n\n\t\t\t\t// Support: IE<8\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear 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\t\"first\": createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\t\"last\": createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\t\"eq\": createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\t\"even\": 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\t\"odd\": 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\t\"lt\": createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ?\n\t\t\t\targument + length :\n\t\t\t\targument > length ?\n\t\t\t\t\tlength :\n\t\t\t\t\targument;\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\t\"gt\": 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\ntokenize = Sizzle.tokenize = function( 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 = rcombinators.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( rtrim, \" \" )\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\treturn parseOnly ?\n\t\tsoFar.length :\n\t\tsoFar ?\n\t\t\tSizzle.error( selector ) :\n\n\t\t\t// Cache the tokens\n\t\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, uniqueCache, 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\t// Support: IE <9 only\n\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\tuniqueCache = outerCache[ elem.uniqueID ] ||\n\t\t\t\t\t\t\t( outerCache[ elem.uniqueID ] = {} );\n\n\t\t\t\t\t\tif ( skip && skip === elem.nodeName.toLowerCase() ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = uniqueCache[ 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\tuniqueCache[ 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\tSizzle( 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,\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 || multipleContexts(\n\t\t\t\tselector || \"*\",\n\t\t\t\tcontext.nodeType ? [ context ] : context,\n\t\t\t\t[]\n\t\t\t),\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\t\tmatcherOut = matcher ?\n\n\t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t\t[] :\n\n\t\t\t\t\t// ...otherwise use results directly\n\t\t\t\t\tresults :\n\t\t\t\tmatcherIn;\n\n\t\t// Find primary matches\n\t\tif ( matcher ) {\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\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( 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( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\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 (issue #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// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\ttokens\n\t\t\t\t\t\t.slice( 0, i - 1 )\n\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrim, \"$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: IE<9, Safari\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\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\tresults.push( 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\tSizzle.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\ncompile = Sizzle.compile = function( 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(\n\t\t\tselector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers )\n\t\t);\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 Sizzle's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with Sizzle.compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nselect = Sizzle.select = function( 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\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find[ \"ID\" ]( token.matches[ 0 ]\n\t\t\t\t.replace( runescape, funescape ), context ) || [] )[ 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 ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext\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// Sort stability\nsupport.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\n\n// Support: Chrome 14-35+\n// Always assume duplicates if they aren't passed to the comparison function\nsupport.detectDuplicates = !!hasDuplicate;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\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\n// Support: IE<8\n// Prevent attribute/property \"interpolation\"\n// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !assert( function( el ) {\n\tel.innerHTML = \"<a href='#'></a>\";\n\treturn el.firstChild.getAttribute( \"href\" ) === \"#\";\n} ) ) {\n\taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\t\tif ( !isXML ) {\n\t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\t\t}\n\t} );\n}\n\n// Support: IE<9\n// Use defaultValue in place of getAttribute(\"value\")\nif ( !support.attributes || !assert( function( el ) {\n\tel.innerHTML = \"<input/>\";\n\tel.firstChild.setAttribute( \"value\", \"\" );\n\treturn el.firstChild.getAttribute( \"value\" ) === \"\";\n} ) ) {\n\taddHandle( \"value\", function( elem, _name, isXML ) {\n\t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\t\t\treturn elem.defaultValue;\n\t\t}\n\t} );\n}\n\n// Support: IE<9\n// Use getAttributeNode to fetch booleans when getAttribute lies\nif ( !assert( function( el ) {\n\treturn el.getAttribute( \"disabled\" ) == null;\n} ) ) {\n\taddHandle( booleans, function( elem, name, isXML ) {\n\t\tvar val;\n\t\tif ( !isXML ) {\n\t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\t\t\t\t( val = elem.getAttributeNode( name ) ) && val.specified ?\n\t\t\t\t\tval.value :\n\t\t\t\t\tnull;\n\t\t}\n\t} );\n}\n\nreturn Sizzle;\n\n} )( window );\n\n\n\njQuery.find = Sizzle;\njQuery.expr = Sizzle.selectors;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\njQuery.text = Sizzle.getText;\njQuery.isXMLDoc = Sizzle.isXML;\njQuery.contains = Sizzle.contains;\njQuery.escapeSelector = Sizzle.escape;\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\n\n\nfunction nodeName( elem, name ) {\n\n  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\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 (#9521)\n\t// Strict HTML recognition (#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 Sizzle\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.stackTrace );\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 stack, 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.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.stackTrace = 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 master Deferred\n\t\t\tmaster = 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\tmaster.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, master.done( updateFunc( i ) ).resolve, master.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 ( master.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn master.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 ), master.reject );\n\t\t}\n\n\t\treturn master.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\njQuery.Deferred.exceptionHook = function( error, stack ) {\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, error.stack, stack );\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 #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\tvalue :\n\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 (#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 #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 (#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 (#11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#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 (#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 (#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 (#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\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\n// Support: IE <=9 - 11+\n// focus() and blur() are asynchronous, except when they are no-op.\n// So expect focus to be synchronous when the element is already active,\n// and blur to be synchronous when the element is not already active.\n// (focus and blur are always synchronous in other supported browsers,\n// this just defines when we can count on it).\nfunction expectSync( elem, type ) {\n\treturn ( elem === safeActiveElement() ) === ( type === \"focus\" );\n}\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\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\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\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 (#13208)\n\t\t\t\t// Don't process clicks on disabled elements (#6911, #8165, #11382, #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 (#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\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\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\", returnTrue );\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, expectSync ) {\n\n\t// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !expectSync ) {\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 notAsync, 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\t// Saved data should be false in such cases, but might be a leftover capture object\n\t\t\t\t// from an async native handler (gh-4350)\n\t\t\t\tif ( !saved.length ) {\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\t// Support: IE <=9 - 11+\n\t\t\t\t\t// focus() and blur() are asynchronous\n\t\t\t\t\tnotAsync = expectSync( this, type );\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tif ( saved !== result || notAsync ) {\n\t\t\t\t\t\tdataPriv.set( this, type, false );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresult = {};\n\t\t\t\t\t}\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\t\t\t\t\t\treturn result.value;\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 the\n\t\t\t\t// 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.length ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, {\n\t\t\t\t\tvalue: jQuery.event.trigger(\n\n\t\t\t\t\t\t// Support: IE <=9 - 11+\n\t\t\t\t\t\t// Extend with the prototype to reset the above stopImmediatePropagation()\n\t\t\t\t\t\tjQuery.extend( saved[ 0 ], jQuery.Event.prototype ),\n\t\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\t\tthis\n\t\t\t\t\t)\n\t\t\t\t} );\n\n\t\t\t\t// Abort handling of the native event\n\t\t\t\tevent.stopImmediatePropagation();\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 (#504, #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\n\twhich: function( event ) {\n\t\tvar button = event.button;\n\n\t\t// Add which for key events\n\t\tif ( event.which == null && rkeyEvent.test( event.type ) ) {\n\t\t\treturn event.charCode != null ? event.charCode : event.keyCode;\n\t\t}\n\n\t\t// Add which for click: 1 === left; 2 === middle; 3 === right\n\t\tif ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {\n\t\t\tif ( button & 1 ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\tif ( button & 2 ) {\n\t\t\t\treturn 3;\n\t\t\t}\n\n\t\t\tif ( button & 4 ) {\n\t\t\t\treturn 2;\n\t\t\t}\n\n\t\t\treturn 0;\n\t\t}\n\n\t\treturn event.which;\n\t}\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\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\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, expectSync );\n\n\t\t\t// Return false to allow normal processing in the caller\n\t\t\treturn false;\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\tdelegateType: delegateType\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\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 (#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// Reenable 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\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 Sizzle here for performance reasons: 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 getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (#15098, #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 (#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\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\";\n\t\t\t\ttr.style.height = \"1px\";\n\t\t\t\ttrChild.style.height = \"9px\";\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 ) > 3;\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\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, #12537)\n\t//   .css('--customProperty) (#3144)\n\tif ( computed ) {\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\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\trcustomProp = /^--/,\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\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\tif ( box === \"margin\" ) {\n\t\t\tdelta += 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;\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\t\"animationIterationCount\": true,\n\t\t\"columnCount\": true,\n\t\t\"fillOpacity\": true,\n\t\t\"flexGrow\": true,\n\t\t\"flexShrink\": true,\n\t\t\"fontWeight\": true,\n\t\t\"gridArea\": true,\n\t\t\"gridColumn\": true,\n\t\t\"gridColumnEnd\": true,\n\t\t\"gridColumnStart\": true,\n\t\t\"gridRow\": true,\n\t\t\"gridRowEnd\": true,\n\t\t\"gridRowStart\": true,\n\t\t\"lineHeight\": true,\n\t\t\"opacity\": true,\n\t\t\"order\": true,\n\t\t\"orphans\": true,\n\t\t\"widows\": true,\n\t\t\"zIndex\": true,\n\t\t\"zoom\": 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 (#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 #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 (#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\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t\t} ) :\n\t\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\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\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/* 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 )` (#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\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\t\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.\n// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\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// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n\t\t\t\t// Use proper attribute retrieval(#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 classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\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\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + clazz + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += clazz + \" \";\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\telem.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 classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\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\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + clazz + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + clazz + \" \", \" \" );\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\telem.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 type = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\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\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\treturn this.each( function() {\n\t\t\tvar className, i, self, classNames;\n\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\ti = 0;\n\t\t\t\tself = jQuery( this );\n\t\t\t\tclassNames = classesToArray( value );\n\n\t\t\t\twhile ( ( className = 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\"\" :\n\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\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 (#14686, #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 (#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\n\n\nsupport.focusin = \"onfocusin\" in window;\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 (#9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (#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 = (\n\t\t\t\t\tdataPriv.get( cur, \"events\" ) || Object.create( null )\n\t\t\t\t)[ 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 (#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\n// Support: Firefox <=44\n// Firefox doesn't have focus(in | out) events\n// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n//\n// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n// focus(in | out) events fire after focus & blur events,\n// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\nif ( !support.focusin ) {\n\tjQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\n\n\t\t// Attach a single capturing handler on the document while someone wants focusin/focusout\n\t\tvar handler = function( event ) {\n\t\t\tjQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );\n\t\t};\n\n\t\tjQuery.event.special[ fix ] = {\n\t\t\tsetup: function() {\n\n\t\t\t\t// Handle: regular nodes (via `this.ownerDocument`), window\n\t\t\t\t// (via `this.document`) & document (via `this`).\n\t\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix );\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.addEventListener( orig, handler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.access( doc, fix, ( attaches || 0 ) + 1 );\n\t\t\t},\n\t\t\tteardown: function() {\n\t\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix ) - 1;\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.removeEventListener( orig, handler, true );\n\t\t\t\t\tdataPriv.remove( doc, fix );\n\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.access( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\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;\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\t\txml = undefined;\n\t}\n\n\tif ( !xml || xml.getElementsByTagName( \"parsererror\" ).length ) {\n\t\tjQuery.error( \"Invalid XML: \" + data );\n\t}\n\treturn xml;\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} )\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} )\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// #7653, #8125, #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 (#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\toriginAnchor.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 #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\t\tjQuery( callbackContext ) :\n\t\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 (#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 #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 (#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// #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\n\t\t\tif ( !isSuccess && jQuery.inArray( \"script\", s.dataTypes ) > -1 ) {\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 (#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// #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 #8605, #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// #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\tif ( typeof props.top === \"number\" ) {\n\t\t\t\tprops.top += \"px\";\n\t\t\t}\n\t\t\tif ( typeof props.left === \"number\" ) {\n\t\t\t\tprops.left += \"px\";\n\t\t\t}\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( { padding: \"inner\" + name, content: type, \"\": \"outer\" + name },\n\t\tfunction( 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.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\njQuery.each( ( \"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// Support: Android <=4.0 only\n// Make sure we trim BOM and NBSP\nvar rtrim = /^[\\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, \"\" );\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// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (#13566)\nif ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\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","'use strict';\n/**\n * @license Angular v<unknown>\n * (c) 2010-2022 Google LLC. https://angular.io/\n * License: MIT\n */\n((function (global) {\n    const performance = global['performance'];\n    function mark(name) {\n        performance && performance['mark'] && performance['mark'](name);\n    }\n    function performanceMeasure(name, label) {\n        performance && performance['measure'] && performance['measure'](name, label);\n    }\n    mark('Zone');\n    // Initialize before it's accessed below.\n    // __Zone_symbol_prefix global can be used to override the default zone\n    // symbol prefix with a custom one if needed.\n    const symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__';\n    function __symbol__(name) {\n        return symbolPrefix + name;\n    }\n    const checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true;\n    if (global['Zone']) {\n        // if global['Zone'] already exists (maybe zone.js was already loaded or\n        // some other lib also registered a global object named Zone), we may need\n        // to throw an error, but sometimes user may not want this error.\n        // For example,\n        // we have two web pages, page1 includes zone.js, page2 doesn't.\n        // and the 1st time user load page1 and page2, everything work fine,\n        // but when user load page2 again, error occurs because global['Zone'] already exists.\n        // so we add a flag to let user choose whether to throw this error or not.\n        // By default, if existing Zone is from zone.js, we will not throw the error.\n        if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') {\n            throw new Error('Zone already loaded.');\n        }\n        else {\n            return global['Zone'];\n        }\n    }\n    class Zone {\n        // tslint:disable-next-line:require-internal-with-underscore\n        static { this.__symbol__ = __symbol__; }\n        static assertZonePatched() {\n            if (global['Promise'] !== patches['ZoneAwarePromise']) {\n                throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +\n                    'has been overwritten.\\n' +\n                    'Most likely cause is that a Promise polyfill has been loaded ' +\n                    'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +\n                    'If you must load one, do so before loading zone.js.)');\n            }\n        }\n        static get root() {\n            let zone = Zone.current;\n            while (zone.parent) {\n                zone = zone.parent;\n            }\n            return zone;\n        }\n        static get current() {\n            return _currentZoneFrame.zone;\n        }\n        static get currentTask() {\n            return _currentTask;\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        static __load_patch(name, fn, ignoreDuplicate = false) {\n            if (patches.hasOwnProperty(name)) {\n                // `checkDuplicate` option is defined from global variable\n                // so it works for all modules.\n                // `ignoreDuplicate` can work for the specified module\n                if (!ignoreDuplicate && checkDuplicate) {\n                    throw Error('Already loaded patch: ' + name);\n                }\n            }\n            else if (!global['__Zone_disable_' + name]) {\n                const perfName = 'Zone:' + name;\n                mark(perfName);\n                patches[name] = fn(global, Zone, _api);\n                performanceMeasure(perfName, perfName);\n            }\n        }\n        get parent() {\n            return this._parent;\n        }\n        get name() {\n            return this._name;\n        }\n        constructor(parent, zoneSpec) {\n            this._parent = parent;\n            this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';\n            this._properties = zoneSpec && zoneSpec.properties || {};\n            this._zoneDelegate =\n                new _ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);\n        }\n        get(key) {\n            const zone = this.getZoneWith(key);\n            if (zone)\n                return zone._properties[key];\n        }\n        getZoneWith(key) {\n            let current = this;\n            while (current) {\n                if (current._properties.hasOwnProperty(key)) {\n                    return current;\n                }\n                current = current._parent;\n            }\n            return null;\n        }\n        fork(zoneSpec) {\n            if (!zoneSpec)\n                throw new Error('ZoneSpec required!');\n            return this._zoneDelegate.fork(this, zoneSpec);\n        }\n        wrap(callback, source) {\n            if (typeof callback !== 'function') {\n                throw new Error('Expecting function got: ' + callback);\n            }\n            const _callback = this._zoneDelegate.intercept(this, callback, source);\n            const zone = this;\n            return function () {\n                return zone.runGuarded(_callback, this, arguments, source);\n            };\n        }\n        run(callback, applyThis, applyArgs, source) {\n            _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n            try {\n                return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n            }\n            finally {\n                _currentZoneFrame = _currentZoneFrame.parent;\n            }\n        }\n        runGuarded(callback, applyThis = null, applyArgs, source) {\n            _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n            try {\n                try {\n                    return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n                }\n                catch (error) {\n                    if (this._zoneDelegate.handleError(this, error)) {\n                        throw error;\n                    }\n                }\n            }\n            finally {\n                _currentZoneFrame = _currentZoneFrame.parent;\n            }\n        }\n        runTask(task, applyThis, applyArgs) {\n            if (task.zone != this) {\n                throw new Error('A task can only be run in the zone of creation! (Creation: ' +\n                    (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');\n            }\n            // https://github.com/angular/zone.js/issues/778, sometimes eventTask\n            // will run in notScheduled(canceled) state, we should not try to\n            // run such kind of task but just return\n            if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) {\n                return;\n            }\n            const reEntryGuard = task.state != running;\n            reEntryGuard && task._transitionTo(running, scheduled);\n            task.runCount++;\n            const previousTask = _currentTask;\n            _currentTask = task;\n            _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n            try {\n                if (task.type == macroTask && task.data && !task.data.isPeriodic) {\n                    task.cancelFn = undefined;\n                }\n                try {\n                    return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);\n                }\n                catch (error) {\n                    if (this._zoneDelegate.handleError(this, error)) {\n                        throw error;\n                    }\n                }\n            }\n            finally {\n                // if the task's state is notScheduled or unknown, then it has already been cancelled\n                // we should not reset the state to scheduled\n                if (task.state !== notScheduled && task.state !== unknown) {\n                    if (task.type == eventTask || (task.data && task.data.isPeriodic)) {\n                        reEntryGuard && task._transitionTo(scheduled, running);\n                    }\n                    else {\n                        task.runCount = 0;\n                        this._updateTaskCount(task, -1);\n                        reEntryGuard &&\n                            task._transitionTo(notScheduled, running, notScheduled);\n                    }\n                }\n                _currentZoneFrame = _currentZoneFrame.parent;\n                _currentTask = previousTask;\n            }\n        }\n        scheduleTask(task) {\n            if (task.zone && task.zone !== this) {\n                // check if the task was rescheduled, the newZone\n                // should not be the children of the original zone\n                let newZone = this;\n                while (newZone) {\n                    if (newZone === task.zone) {\n                        throw Error(`can not reschedule task to ${this.name} which is descendants of the original zone ${task.zone.name}`);\n                    }\n                    newZone = newZone.parent;\n                }\n            }\n            task._transitionTo(scheduling, notScheduled);\n            const zoneDelegates = [];\n            task._zoneDelegates = zoneDelegates;\n            task._zone = this;\n            try {\n                task = this._zoneDelegate.scheduleTask(this, task);\n            }\n            catch (err) {\n                // should set task's state to unknown when scheduleTask throw error\n                // because the err may from reschedule, so the fromState maybe notScheduled\n                task._transitionTo(unknown, scheduling, notScheduled);\n                // TODO: @JiaLiPassion, should we check the result from handleError?\n                this._zoneDelegate.handleError(this, err);\n                throw err;\n            }\n            if (task._zoneDelegates === zoneDelegates) {\n                // we have to check because internally the delegate can reschedule the task.\n                this._updateTaskCount(task, 1);\n            }\n            if (task.state == scheduling) {\n                task._transitionTo(scheduled, scheduling);\n            }\n            return task;\n        }\n        scheduleMicroTask(source, callback, data, customSchedule) {\n            return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));\n        }\n        scheduleMacroTask(source, callback, data, customSchedule, customCancel) {\n            return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));\n        }\n        scheduleEventTask(source, callback, data, customSchedule, customCancel) {\n            return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));\n        }\n        cancelTask(task) {\n            if (task.zone != this)\n                throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' +\n                    (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');\n            if (task.state !== scheduled && task.state !== running) {\n                return;\n            }\n            task._transitionTo(canceling, scheduled, running);\n            try {\n                this._zoneDelegate.cancelTask(this, task);\n            }\n            catch (err) {\n                // if error occurs when cancelTask, transit the state to unknown\n                task._transitionTo(unknown, canceling);\n                this._zoneDelegate.handleError(this, err);\n                throw err;\n            }\n            this._updateTaskCount(task, -1);\n            task._transitionTo(notScheduled, canceling);\n            task.runCount = 0;\n            return task;\n        }\n        _updateTaskCount(task, count) {\n            const zoneDelegates = task._zoneDelegates;\n            if (count == -1) {\n                task._zoneDelegates = null;\n            }\n            for (let i = 0; i < zoneDelegates.length; i++) {\n                zoneDelegates[i]._updateTaskCount(task.type, count);\n            }\n        }\n    }\n    const DELEGATE_ZS = {\n        name: '',\n        onHasTask: (delegate, _, target, hasTaskState) => delegate.hasTask(target, hasTaskState),\n        onScheduleTask: (delegate, _, target, task) => delegate.scheduleTask(target, task),\n        onInvokeTask: (delegate, _, target, task, applyThis, applyArgs) => delegate.invokeTask(target, task, applyThis, applyArgs),\n        onCancelTask: (delegate, _, target, task) => delegate.cancelTask(target, task)\n    };\n    class _ZoneDelegate {\n        constructor(zone, parentDelegate, zoneSpec) {\n            this._taskCounts = { 'microTask': 0, 'macroTask': 0, 'eventTask': 0 };\n            this.zone = zone;\n            this._parentDelegate = parentDelegate;\n            this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);\n            this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);\n            this._forkCurrZone =\n                zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate._forkCurrZone);\n            this._interceptZS =\n                zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);\n            this._interceptDlgt =\n                zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);\n            this._interceptCurrZone =\n                zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate._interceptCurrZone);\n            this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);\n            this._invokeDlgt =\n                zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);\n            this._invokeCurrZone =\n                zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate._invokeCurrZone);\n            this._handleErrorZS =\n                zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);\n            this._handleErrorDlgt =\n                zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);\n            this._handleErrorCurrZone =\n                zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate._handleErrorCurrZone);\n            this._scheduleTaskZS =\n                zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);\n            this._scheduleTaskDlgt = zoneSpec &&\n                (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);\n            this._scheduleTaskCurrZone =\n                zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate._scheduleTaskCurrZone);\n            this._invokeTaskZS =\n                zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);\n            this._invokeTaskDlgt =\n                zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);\n            this._invokeTaskCurrZone =\n                zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate._invokeTaskCurrZone);\n            this._cancelTaskZS =\n                zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);\n            this._cancelTaskDlgt =\n                zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);\n            this._cancelTaskCurrZone =\n                zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate._cancelTaskCurrZone);\n            this._hasTaskZS = null;\n            this._hasTaskDlgt = null;\n            this._hasTaskDlgtOwner = null;\n            this._hasTaskCurrZone = null;\n            const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;\n            const parentHasTask = parentDelegate && parentDelegate._hasTaskZS;\n            if (zoneSpecHasTask || parentHasTask) {\n                // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such\n                // a case all task related interceptors must go through this ZD. We can't short circuit it.\n                this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;\n                this._hasTaskDlgt = parentDelegate;\n                this._hasTaskDlgtOwner = this;\n                this._hasTaskCurrZone = zone;\n                if (!zoneSpec.onScheduleTask) {\n                    this._scheduleTaskZS = DELEGATE_ZS;\n                    this._scheduleTaskDlgt = parentDelegate;\n                    this._scheduleTaskCurrZone = this.zone;\n                }\n                if (!zoneSpec.onInvokeTask) {\n                    this._invokeTaskZS = DELEGATE_ZS;\n                    this._invokeTaskDlgt = parentDelegate;\n                    this._invokeTaskCurrZone = this.zone;\n                }\n                if (!zoneSpec.onCancelTask) {\n                    this._cancelTaskZS = DELEGATE_ZS;\n                    this._cancelTaskDlgt = parentDelegate;\n                    this._cancelTaskCurrZone = this.zone;\n                }\n            }\n        }\n        fork(targetZone, zoneSpec) {\n            return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :\n                new Zone(targetZone, zoneSpec);\n        }\n        intercept(targetZone, callback, source) {\n            return this._interceptZS ?\n                this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :\n                callback;\n        }\n        invoke(targetZone, callback, applyThis, applyArgs, source) {\n            return this._invokeZS ? this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :\n                callback.apply(applyThis, applyArgs);\n        }\n        handleError(targetZone, error) {\n            return this._handleErrorZS ?\n                this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :\n                true;\n        }\n        scheduleTask(targetZone, task) {\n            let returnTask = task;\n            if (this._scheduleTaskZS) {\n                if (this._hasTaskZS) {\n                    returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);\n                }\n                // clang-format off\n                returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);\n                // clang-format on\n                if (!returnTask)\n                    returnTask = task;\n            }\n            else {\n                if (task.scheduleFn) {\n                    task.scheduleFn(task);\n                }\n                else if (task.type == microTask) {\n                    scheduleMicroTask(task);\n                }\n                else {\n                    throw new Error('Task is missing scheduleFn.');\n                }\n            }\n            return returnTask;\n        }\n        invokeTask(targetZone, task, applyThis, applyArgs) {\n            return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :\n                task.callback.apply(applyThis, applyArgs);\n        }\n        cancelTask(targetZone, task) {\n            let value;\n            if (this._cancelTaskZS) {\n                value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);\n            }\n            else {\n                if (!task.cancelFn) {\n                    throw Error('Task is not cancelable');\n                }\n                value = task.cancelFn(task);\n            }\n            return value;\n        }\n        hasTask(targetZone, isEmpty) {\n            // hasTask should not throw error so other ZoneDelegate\n            // can still trigger hasTask callback\n            try {\n                this._hasTaskZS &&\n                    this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);\n            }\n            catch (err) {\n                this.handleError(targetZone, err);\n            }\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        _updateTaskCount(type, count) {\n            const counts = this._taskCounts;\n            const prev = counts[type];\n            const next = counts[type] = prev + count;\n            if (next < 0) {\n                throw new Error('More tasks executed then were scheduled.');\n            }\n            if (prev == 0 || next == 0) {\n                const isEmpty = {\n                    microTask: counts['microTask'] > 0,\n                    macroTask: counts['macroTask'] > 0,\n                    eventTask: counts['eventTask'] > 0,\n                    change: type\n                };\n                this.hasTask(this.zone, isEmpty);\n            }\n        }\n    }\n    class ZoneTask {\n        constructor(type, source, callback, options, scheduleFn, cancelFn) {\n            // tslint:disable-next-line:require-internal-with-underscore\n            this._zone = null;\n            this.runCount = 0;\n            // tslint:disable-next-line:require-internal-with-underscore\n            this._zoneDelegates = null;\n            // tslint:disable-next-line:require-internal-with-underscore\n            this._state = 'notScheduled';\n            this.type = type;\n            this.source = source;\n            this.data = options;\n            this.scheduleFn = scheduleFn;\n            this.cancelFn = cancelFn;\n            if (!callback) {\n                throw new Error('callback is not defined');\n            }\n            this.callback = callback;\n            const self = this;\n            // TODO: @JiaLiPassion options should have interface\n            if (type === eventTask && options && options.useG) {\n                this.invoke = ZoneTask.invokeTask;\n            }\n            else {\n                this.invoke = function () {\n                    return ZoneTask.invokeTask.call(global, self, this, arguments);\n                };\n            }\n        }\n        static invokeTask(task, target, args) {\n            if (!task) {\n                task = this;\n            }\n            _numberOfNestedTaskFrames++;\n            try {\n                task.runCount++;\n                return task.zone.runTask(task, target, args);\n            }\n            finally {\n                if (_numberOfNestedTaskFrames == 1) {\n                    drainMicroTaskQueue();\n                }\n                _numberOfNestedTaskFrames--;\n            }\n        }\n        get zone() {\n            return this._zone;\n        }\n        get state() {\n            return this._state;\n        }\n        cancelScheduleRequest() {\n            this._transitionTo(notScheduled, scheduling);\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        _transitionTo(toState, fromState1, fromState2) {\n            if (this._state === fromState1 || this._state === fromState2) {\n                this._state = toState;\n                if (toState == notScheduled) {\n                    this._zoneDelegates = null;\n                }\n            }\n            else {\n                throw new Error(`${this.type} '${this.source}': can not transition to '${toState}', expecting state '${fromState1}'${fromState2 ? ' or \\'' + fromState2 + '\\'' : ''}, was '${this._state}'.`);\n            }\n        }\n        toString() {\n            if (this.data && typeof this.data.handleId !== 'undefined') {\n                return this.data.handleId.toString();\n            }\n            else {\n                return Object.prototype.toString.call(this);\n            }\n        }\n        // add toJSON method to prevent cyclic error when\n        // call JSON.stringify(zoneTask)\n        toJSON() {\n            return {\n                type: this.type,\n                state: this.state,\n                source: this.source,\n                zone: this.zone.name,\n                runCount: this.runCount\n            };\n        }\n    }\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    ///  MICROTASK QUEUE\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    const symbolSetTimeout = __symbol__('setTimeout');\n    const symbolPromise = __symbol__('Promise');\n    const symbolThen = __symbol__('then');\n    let _microTaskQueue = [];\n    let _isDrainingMicrotaskQueue = false;\n    let nativeMicroTaskQueuePromise;\n    function nativeScheduleMicroTask(func) {\n        if (!nativeMicroTaskQueuePromise) {\n            if (global[symbolPromise]) {\n                nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0);\n            }\n        }\n        if (nativeMicroTaskQueuePromise) {\n            let nativeThen = nativeMicroTaskQueuePromise[symbolThen];\n            if (!nativeThen) {\n                // native Promise is not patchable, we need to use `then` directly\n                // issue 1078\n                nativeThen = nativeMicroTaskQueuePromise['then'];\n            }\n            nativeThen.call(nativeMicroTaskQueuePromise, func);\n        }\n        else {\n            global[symbolSetTimeout](func, 0);\n        }\n    }\n    function scheduleMicroTask(task) {\n        // if we are not running in any task, and there has not been anything scheduled\n        // we must bootstrap the initial task creation by manually scheduling the drain\n        if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {\n            // We are not running in Task, so we need to kickstart the microtask queue.\n            nativeScheduleMicroTask(drainMicroTaskQueue);\n        }\n        task && _microTaskQueue.push(task);\n    }\n    function drainMicroTaskQueue() {\n        if (!_isDrainingMicrotaskQueue) {\n            _isDrainingMicrotaskQueue = true;\n            while (_microTaskQueue.length) {\n                const queue = _microTaskQueue;\n                _microTaskQueue = [];\n                for (let i = 0; i < queue.length; i++) {\n                    const task = queue[i];\n                    try {\n                        task.zone.runTask(task, null, null);\n                    }\n                    catch (error) {\n                        _api.onUnhandledError(error);\n                    }\n                }\n            }\n            _api.microtaskDrainDone();\n            _isDrainingMicrotaskQueue = false;\n        }\n    }\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    ///  BOOTSTRAP\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    const NO_ZONE = { name: 'NO ZONE' };\n    const notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling', unknown = 'unknown';\n    const microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask';\n    const patches = {};\n    const _api = {\n        symbol: __symbol__,\n        currentZoneFrame: () => _currentZoneFrame,\n        onUnhandledError: noop,\n        microtaskDrainDone: noop,\n        scheduleMicroTask: scheduleMicroTask,\n        showUncaughtError: () => !Zone[__symbol__('ignoreConsoleErrorUncaughtError')],\n        patchEventTarget: () => [],\n        patchOnProperties: noop,\n        patchMethod: () => noop,\n        bindArguments: () => [],\n        patchThen: () => noop,\n        patchMacroTask: () => noop,\n        patchEventPrototype: () => noop,\n        isIEOrEdge: () => false,\n        getGlobalObjects: () => undefined,\n        ObjectDefineProperty: () => noop,\n        ObjectGetOwnPropertyDescriptor: () => undefined,\n        ObjectCreate: () => undefined,\n        ArraySlice: () => [],\n        patchClass: () => noop,\n        wrapWithCurrentZone: () => noop,\n        filterProperties: () => [],\n        attachOriginToPatched: () => noop,\n        _redefineProperty: () => noop,\n        patchCallbacks: () => noop,\n        nativeScheduleMicroTask: nativeScheduleMicroTask\n    };\n    let _currentZoneFrame = { parent: null, zone: new Zone(null, null) };\n    let _currentTask = null;\n    let _numberOfNestedTaskFrames = 0;\n    function noop() { }\n    performanceMeasure('Zone', 'Zone');\n    return global['Zone'] = Zone;\n}))(typeof window !== 'undefined' && window || typeof self !== 'undefined' && self || global);\n\n/**\n * Suppress closure compiler errors about unknown 'Zone' variable\n * @fileoverview\n * @suppress {undefinedVars,globalThis,missingRequire}\n */\n/// <reference types=\"node\"/>\n// issue #989, to reduce bundle size, use short name\n/** Object.getOwnPropertyDescriptor */\nconst ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n/** Object.defineProperty */\nconst ObjectDefineProperty = Object.defineProperty;\n/** Object.getPrototypeOf */\nconst ObjectGetPrototypeOf = Object.getPrototypeOf;\n/** Object.create */\nconst ObjectCreate = Object.create;\n/** Array.prototype.slice */\nconst ArraySlice = Array.prototype.slice;\n/** addEventListener string const */\nconst ADD_EVENT_LISTENER_STR = 'addEventListener';\n/** removeEventListener string const */\nconst REMOVE_EVENT_LISTENER_STR = 'removeEventListener';\n/** zoneSymbol addEventListener */\nconst ZONE_SYMBOL_ADD_EVENT_LISTENER = Zone.__symbol__(ADD_EVENT_LISTENER_STR);\n/** zoneSymbol removeEventListener */\nconst ZONE_SYMBOL_REMOVE_EVENT_LISTENER = Zone.__symbol__(REMOVE_EVENT_LISTENER_STR);\n/** true string const */\nconst TRUE_STR = 'true';\n/** false string const */\nconst FALSE_STR = 'false';\n/** Zone symbol prefix string const. */\nconst ZONE_SYMBOL_PREFIX = Zone.__symbol__('');\nfunction wrapWithCurrentZone(callback, source) {\n    return Zone.current.wrap(callback, source);\n}\nfunction scheduleMacroTaskWithCurrentZone(source, callback, data, customSchedule, customCancel) {\n    return Zone.current.scheduleMacroTask(source, callback, data, customSchedule, customCancel);\n}\nconst zoneSymbol = Zone.__symbol__;\nconst isWindowExists = typeof window !== 'undefined';\nconst internalWindow = isWindowExists ? window : undefined;\nconst _global = isWindowExists && internalWindow || typeof self === 'object' && self || global;\nconst REMOVE_ATTRIBUTE = 'removeAttribute';\nfunction bindArguments(args, source) {\n    for (let i = args.length - 1; i >= 0; i--) {\n        if (typeof args[i] === 'function') {\n            args[i] = wrapWithCurrentZone(args[i], source + '_' + i);\n        }\n    }\n    return args;\n}\nfunction patchPrototype(prototype, fnNames) {\n    const source = prototype.constructor['name'];\n    for (let i = 0; i < fnNames.length; i++) {\n        const name = fnNames[i];\n        const delegate = prototype[name];\n        if (delegate) {\n            const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, name);\n            if (!isPropertyWritable(prototypeDesc)) {\n                continue;\n            }\n            prototype[name] = ((delegate) => {\n                const patched = function () {\n                    return delegate.apply(this, bindArguments(arguments, source + '.' + name));\n                };\n                attachOriginToPatched(patched, delegate);\n                return patched;\n            })(delegate);\n        }\n    }\n}\nfunction isPropertyWritable(propertyDesc) {\n    if (!propertyDesc) {\n        return true;\n    }\n    if (propertyDesc.writable === false) {\n        return false;\n    }\n    return !(typeof propertyDesc.get === 'function' && typeof propertyDesc.set === 'undefined');\n}\nconst isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);\n// Make sure to access `process` through `_global` so that WebPack does not accidentally browserify\n// this code.\nconst isNode = (!('nw' in _global) && typeof _global.process !== 'undefined' &&\n    {}.toString.call(_global.process) === '[object process]');\nconst isBrowser = !isNode && !isWebWorker && !!(isWindowExists && internalWindow['HTMLElement']);\n// we are in electron of nw, so we are both browser and nodejs\n// Make sure to access `process` through `_global` so that WebPack does not accidentally browserify\n// this code.\nconst isMix = typeof _global.process !== 'undefined' &&\n    {}.toString.call(_global.process) === '[object process]' && !isWebWorker &&\n    !!(isWindowExists && internalWindow['HTMLElement']);\nconst zoneSymbolEventNames$1 = {};\nconst wrapFn = function (event) {\n    // https://github.com/angular/zone.js/issues/911, in IE, sometimes\n    // event will be undefined, so we need to use window.event\n    event = event || _global.event;\n    if (!event) {\n        return;\n    }\n    let eventNameSymbol = zoneSymbolEventNames$1[event.type];\n    if (!eventNameSymbol) {\n        eventNameSymbol = zoneSymbolEventNames$1[event.type] = zoneSymbol('ON_PROPERTY' + event.type);\n    }\n    const target = this || event.target || _global;\n    const listener = target[eventNameSymbol];\n    let result;\n    if (isBrowser && target === internalWindow && event.type === 'error') {\n        // window.onerror have different signature\n        // https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onerror#window.onerror\n        // and onerror callback will prevent default when callback return true\n        const errorEvent = event;\n        result = listener &&\n            listener.call(this, errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error);\n        if (result === true) {\n            event.preventDefault();\n        }\n    }\n    else {\n        result = listener && listener.apply(this, arguments);\n        if (result != undefined && !result) {\n            event.preventDefault();\n        }\n    }\n    return result;\n};\nfunction patchProperty(obj, prop, prototype) {\n    let desc = ObjectGetOwnPropertyDescriptor(obj, prop);\n    if (!desc && prototype) {\n        // when patch window object, use prototype to check prop exist or not\n        const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, prop);\n        if (prototypeDesc) {\n            desc = { enumerable: true, configurable: true };\n        }\n    }\n    // if the descriptor not exists or is not configurable\n    // just return\n    if (!desc || !desc.configurable) {\n        return;\n    }\n    const onPropPatchedSymbol = zoneSymbol('on' + prop + 'patched');\n    if (obj.hasOwnProperty(onPropPatchedSymbol) && obj[onPropPatchedSymbol]) {\n        return;\n    }\n    // A property descriptor cannot have getter/setter and be writable\n    // deleting the writable and value properties avoids this error:\n    //\n    // TypeError: property descriptors must not specify a value or be writable when a\n    // getter or setter has been specified\n    delete desc.writable;\n    delete desc.value;\n    const originalDescGet = desc.get;\n    const originalDescSet = desc.set;\n    // slice(2) cuz 'onclick' -> 'click', etc\n    const eventName = prop.slice(2);\n    let eventNameSymbol = zoneSymbolEventNames$1[eventName];\n    if (!eventNameSymbol) {\n        eventNameSymbol = zoneSymbolEventNames$1[eventName] = zoneSymbol('ON_PROPERTY' + eventName);\n    }\n    desc.set = function (newValue) {\n        // in some of windows's onproperty callback, this is undefined\n        // so we need to check it\n        let target = this;\n        if (!target && obj === _global) {\n            target = _global;\n        }\n        if (!target) {\n            return;\n        }\n        const previousValue = target[eventNameSymbol];\n        if (typeof previousValue === 'function') {\n            target.removeEventListener(eventName, wrapFn);\n        }\n        // issue #978, when onload handler was added before loading zone.js\n        // we should remove it with originalDescSet\n        originalDescSet && originalDescSet.call(target, null);\n        target[eventNameSymbol] = newValue;\n        if (typeof newValue === 'function') {\n            target.addEventListener(eventName, wrapFn, false);\n        }\n    };\n    // The getter would return undefined for unassigned properties but the default value of an\n    // unassigned property is null\n    desc.get = function () {\n        // in some of windows's onproperty callback, this is undefined\n        // so we need to check it\n        let target = this;\n        if (!target && obj === _global) {\n            target = _global;\n        }\n        if (!target) {\n            return null;\n        }\n        const listener = target[eventNameSymbol];\n        if (listener) {\n            return listener;\n        }\n        else if (originalDescGet) {\n            // result will be null when use inline event attribute,\n            // such as <button onclick=\"func();\">OK</button>\n            // because the onclick function is internal raw uncompiled handler\n            // the onclick will be evaluated when first time event was triggered or\n            // the property is accessed, https://github.com/angular/zone.js/issues/525\n            // so we should use original native get to retrieve the handler\n            let value = originalDescGet.call(this);\n            if (value) {\n                desc.set.call(this, value);\n                if (typeof target[REMOVE_ATTRIBUTE] === 'function') {\n                    target.removeAttribute(prop);\n                }\n                return value;\n            }\n        }\n        return null;\n    };\n    ObjectDefineProperty(obj, prop, desc);\n    obj[onPropPatchedSymbol] = true;\n}\nfunction patchOnProperties(obj, properties, prototype) {\n    if (properties) {\n        for (let i = 0; i < properties.length; i++) {\n            patchProperty(obj, 'on' + properties[i], prototype);\n        }\n    }\n    else {\n        const onProperties = [];\n        for (const prop in obj) {\n            if (prop.slice(0, 2) == 'on') {\n                onProperties.push(prop);\n            }\n        }\n        for (let j = 0; j < onProperties.length; j++) {\n            patchProperty(obj, onProperties[j], prototype);\n        }\n    }\n}\nconst originalInstanceKey = zoneSymbol('originalInstance');\n// wrap some native API on `window`\nfunction patchClass(className) {\n    const OriginalClass = _global[className];\n    if (!OriginalClass)\n        return;\n    // keep original class in global\n    _global[zoneSymbol(className)] = OriginalClass;\n    _global[className] = function () {\n        const a = bindArguments(arguments, className);\n        switch (a.length) {\n            case 0:\n                this[originalInstanceKey] = new OriginalClass();\n                break;\n            case 1:\n                this[originalInstanceKey] = new OriginalClass(a[0]);\n                break;\n            case 2:\n                this[originalInstanceKey] = new OriginalClass(a[0], a[1]);\n                break;\n            case 3:\n                this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);\n                break;\n            case 4:\n                this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);\n                break;\n            default:\n                throw new Error('Arg list too long.');\n        }\n    };\n    // attach original delegate to patched function\n    attachOriginToPatched(_global[className], OriginalClass);\n    const instance = new OriginalClass(function () { });\n    let prop;\n    for (prop in instance) {\n        // https://bugs.webkit.org/show_bug.cgi?id=44721\n        if (className === 'XMLHttpRequest' && prop === 'responseBlob')\n            continue;\n        (function (prop) {\n            if (typeof instance[prop] === 'function') {\n                _global[className].prototype[prop] = function () {\n                    return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);\n                };\n            }\n            else {\n                ObjectDefineProperty(_global[className].prototype, prop, {\n                    set: function (fn) {\n                        if (typeof fn === 'function') {\n                            this[originalInstanceKey][prop] = wrapWithCurrentZone(fn, className + '.' + prop);\n                            // keep callback in wrapped function so we can\n                            // use it in Function.prototype.toString to return\n                            // the native one.\n                            attachOriginToPatched(this[originalInstanceKey][prop], fn);\n                        }\n                        else {\n                            this[originalInstanceKey][prop] = fn;\n                        }\n                    },\n                    get: function () {\n                        return this[originalInstanceKey][prop];\n                    }\n                });\n            }\n        }(prop));\n    }\n    for (prop in OriginalClass) {\n        if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {\n            _global[className][prop] = OriginalClass[prop];\n        }\n    }\n}\nfunction patchMethod(target, name, patchFn) {\n    let proto = target;\n    while (proto && !proto.hasOwnProperty(name)) {\n        proto = ObjectGetPrototypeOf(proto);\n    }\n    if (!proto && target[name]) {\n        // somehow we did not find it, but we can see it. This happens on IE for Window properties.\n        proto = target;\n    }\n    const delegateName = zoneSymbol(name);\n    let delegate = null;\n    if (proto && (!(delegate = proto[delegateName]) || !proto.hasOwnProperty(delegateName))) {\n        delegate = proto[delegateName] = proto[name];\n        // check whether proto[name] is writable\n        // some property is readonly in safari, such as HtmlCanvasElement.prototype.toBlob\n        const desc = proto && ObjectGetOwnPropertyDescriptor(proto, name);\n        if (isPropertyWritable(desc)) {\n            const patchDelegate = patchFn(delegate, delegateName, name);\n            proto[name] = function () {\n                return patchDelegate(this, arguments);\n            };\n            attachOriginToPatched(proto[name], delegate);\n        }\n    }\n    return delegate;\n}\n// TODO: @JiaLiPassion, support cancel task later if necessary\nfunction patchMacroTask(obj, funcName, metaCreator) {\n    let setNative = null;\n    function scheduleTask(task) {\n        const data = task.data;\n        data.args[data.cbIdx] = function () {\n            task.invoke.apply(this, arguments);\n        };\n        setNative.apply(data.target, data.args);\n        return task;\n    }\n    setNative = patchMethod(obj, funcName, (delegate) => function (self, args) {\n        const meta = metaCreator(self, args);\n        if (meta.cbIdx >= 0 && typeof args[meta.cbIdx] === 'function') {\n            return scheduleMacroTaskWithCurrentZone(meta.name, args[meta.cbIdx], meta, scheduleTask);\n        }\n        else {\n            // cause an error by calling it directly.\n            return delegate.apply(self, args);\n        }\n    });\n}\nfunction attachOriginToPatched(patched, original) {\n    patched[zoneSymbol('OriginalDelegate')] = original;\n}\nlet isDetectedIEOrEdge = false;\nlet ieOrEdge = false;\nfunction isIE() {\n    try {\n        const ua = internalWindow.navigator.userAgent;\n        if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1) {\n            return true;\n        }\n    }\n    catch (error) {\n    }\n    return false;\n}\nfunction isIEOrEdge() {\n    if (isDetectedIEOrEdge) {\n        return ieOrEdge;\n    }\n    isDetectedIEOrEdge = true;\n    try {\n        const ua = internalWindow.navigator.userAgent;\n        if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1 || ua.indexOf('Edge/') !== -1) {\n            ieOrEdge = true;\n        }\n    }\n    catch (error) {\n    }\n    return ieOrEdge;\n}\n\nZone.__load_patch('ZoneAwarePromise', (global, Zone, api) => {\n    const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n    const ObjectDefineProperty = Object.defineProperty;\n    function readableObjectToString(obj) {\n        if (obj && obj.toString === Object.prototype.toString) {\n            const className = obj.constructor && obj.constructor.name;\n            return (className ? className : '') + ': ' + JSON.stringify(obj);\n        }\n        return obj ? obj.toString() : Object.prototype.toString.call(obj);\n    }\n    const __symbol__ = api.symbol;\n    const _uncaughtPromiseErrors = [];\n    const isDisableWrappingUncaughtPromiseRejection = global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] === true;\n    const symbolPromise = __symbol__('Promise');\n    const symbolThen = __symbol__('then');\n    const creationTrace = '__creationTrace__';\n    api.onUnhandledError = (e) => {\n        if (api.showUncaughtError()) {\n            const rejection = e && e.rejection;\n            if (rejection) {\n                console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined);\n            }\n            else {\n                console.error(e);\n            }\n        }\n    };\n    api.microtaskDrainDone = () => {\n        while (_uncaughtPromiseErrors.length) {\n            const uncaughtPromiseError = _uncaughtPromiseErrors.shift();\n            try {\n                uncaughtPromiseError.zone.runGuarded(() => {\n                    if (uncaughtPromiseError.throwOriginal) {\n                        throw uncaughtPromiseError.rejection;\n                    }\n                    throw uncaughtPromiseError;\n                });\n            }\n            catch (error) {\n                handleUnhandledRejection(error);\n            }\n        }\n    };\n    const UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler');\n    function handleUnhandledRejection(e) {\n        api.onUnhandledError(e);\n        try {\n            const handler = Zone[UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL];\n            if (typeof handler === 'function') {\n                handler.call(this, e);\n            }\n        }\n        catch (err) {\n        }\n    }\n    function isThenable(value) {\n        return value && value.then;\n    }\n    function forwardResolution(value) {\n        return value;\n    }\n    function forwardRejection(rejection) {\n        return ZoneAwarePromise.reject(rejection);\n    }\n    const symbolState = __symbol__('state');\n    const symbolValue = __symbol__('value');\n    const symbolFinally = __symbol__('finally');\n    const symbolParentPromiseValue = __symbol__('parentPromiseValue');\n    const symbolParentPromiseState = __symbol__('parentPromiseState');\n    const source = 'Promise.then';\n    const UNRESOLVED = null;\n    const RESOLVED = true;\n    const REJECTED = false;\n    const REJECTED_NO_CATCH = 0;\n    function makeResolver(promise, state) {\n        return (v) => {\n            try {\n                resolvePromise(promise, state, v);\n            }\n            catch (err) {\n                resolvePromise(promise, false, err);\n            }\n            // Do not return value or you will break the Promise spec.\n        };\n    }\n    const once = function () {\n        let wasCalled = false;\n        return function wrapper(wrappedFunction) {\n            return function () {\n                if (wasCalled) {\n                    return;\n                }\n                wasCalled = true;\n                wrappedFunction.apply(null, arguments);\n            };\n        };\n    };\n    const TYPE_ERROR = 'Promise resolved with itself';\n    const CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace');\n    // Promise Resolution\n    function resolvePromise(promise, state, value) {\n        const onceWrapper = once();\n        if (promise === value) {\n            throw new TypeError(TYPE_ERROR);\n        }\n        if (promise[symbolState] === UNRESOLVED) {\n            // should only get value.then once based on promise spec.\n            let then = null;\n            try {\n                if (typeof value === 'object' || typeof value === 'function') {\n                    then = value && value.then;\n                }\n            }\n            catch (err) {\n                onceWrapper(() => {\n                    resolvePromise(promise, false, err);\n                })();\n                return promise;\n            }\n            // if (value instanceof ZoneAwarePromise) {\n            if (state !== REJECTED && value instanceof ZoneAwarePromise &&\n                value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) &&\n                value[symbolState] !== UNRESOLVED) {\n                clearRejectedNoCatch(value);\n                resolvePromise(promise, value[symbolState], value[symbolValue]);\n            }\n            else if (state !== REJECTED && typeof then === 'function') {\n                try {\n                    then.call(value, onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false)));\n                }\n                catch (err) {\n                    onceWrapper(() => {\n                        resolvePromise(promise, false, err);\n                    })();\n                }\n            }\n            else {\n                promise[symbolState] = state;\n                const queue = promise[symbolValue];\n                promise[symbolValue] = value;\n                if (promise[symbolFinally] === symbolFinally) {\n                    // the promise is generated by Promise.prototype.finally\n                    if (state === RESOLVED) {\n                        // the state is resolved, should ignore the value\n                        // and use parent promise value\n                        promise[symbolState] = promise[symbolParentPromiseState];\n                        promise[symbolValue] = promise[symbolParentPromiseValue];\n                    }\n                }\n                // record task information in value when error occurs, so we can\n                // do some additional work such as render longStackTrace\n                if (state === REJECTED && value instanceof Error) {\n                    // check if longStackTraceZone is here\n                    const trace = Zone.currentTask && Zone.currentTask.data &&\n                        Zone.currentTask.data[creationTrace];\n                    if (trace) {\n                        // only keep the long stack trace into error when in longStackTraceZone\n                        ObjectDefineProperty(value, CURRENT_TASK_TRACE_SYMBOL, { configurable: true, enumerable: false, writable: true, value: trace });\n                    }\n                }\n                for (let i = 0; i < queue.length;) {\n                    scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);\n                }\n                if (queue.length == 0 && state == REJECTED) {\n                    promise[symbolState] = REJECTED_NO_CATCH;\n                    let uncaughtPromiseError = value;\n                    try {\n                        // Here we throws a new Error to print more readable error log\n                        // and if the value is not an error, zone.js builds an `Error`\n                        // Object here to attach the stack information.\n                        throw new Error('Uncaught (in promise): ' + readableObjectToString(value) +\n                            (value && value.stack ? '\\n' + value.stack : ''));\n                    }\n                    catch (err) {\n                        uncaughtPromiseError = err;\n                    }\n                    if (isDisableWrappingUncaughtPromiseRejection) {\n                        // If disable wrapping uncaught promise reject\n                        // use the value instead of wrapping it.\n                        uncaughtPromiseError.throwOriginal = true;\n                    }\n                    uncaughtPromiseError.rejection = value;\n                    uncaughtPromiseError.promise = promise;\n                    uncaughtPromiseError.zone = Zone.current;\n                    uncaughtPromiseError.task = Zone.currentTask;\n                    _uncaughtPromiseErrors.push(uncaughtPromiseError);\n                    api.scheduleMicroTask(); // to make sure that it is running\n                }\n            }\n        }\n        // Resolving an already resolved promise is a noop.\n        return promise;\n    }\n    const REJECTION_HANDLED_HANDLER = __symbol__('rejectionHandledHandler');\n    function clearRejectedNoCatch(promise) {\n        if (promise[symbolState] === REJECTED_NO_CATCH) {\n            // if the promise is rejected no catch status\n            // and queue.length > 0, means there is a error handler\n            // here to handle the rejected promise, we should trigger\n            // windows.rejectionhandled eventHandler or nodejs rejectionHandled\n            // eventHandler\n            try {\n                const handler = Zone[REJECTION_HANDLED_HANDLER];\n                if (handler && typeof handler === 'function') {\n                    handler.call(this, { rejection: promise[symbolValue], promise: promise });\n                }\n            }\n            catch (err) {\n            }\n            promise[symbolState] = REJECTED;\n            for (let i = 0; i < _uncaughtPromiseErrors.length; i++) {\n                if (promise === _uncaughtPromiseErrors[i].promise) {\n                    _uncaughtPromiseErrors.splice(i, 1);\n                }\n            }\n        }\n    }\n    function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {\n        clearRejectedNoCatch(promise);\n        const promiseState = promise[symbolState];\n        const delegate = promiseState ?\n            (typeof onFulfilled === 'function') ? onFulfilled : forwardResolution :\n            (typeof onRejected === 'function') ? onRejected :\n                forwardRejection;\n        zone.scheduleMicroTask(source, () => {\n            try {\n                const parentPromiseValue = promise[symbolValue];\n                const isFinallyPromise = !!chainPromise && symbolFinally === chainPromise[symbolFinally];\n                if (isFinallyPromise) {\n                    // if the promise is generated from finally call, keep parent promise's state and value\n                    chainPromise[symbolParentPromiseValue] = parentPromiseValue;\n                    chainPromise[symbolParentPromiseState] = promiseState;\n                }\n                // should not pass value to finally callback\n                const value = zone.run(delegate, undefined, isFinallyPromise && delegate !== forwardRejection && delegate !== forwardResolution ?\n                    [] :\n                    [parentPromiseValue]);\n                resolvePromise(chainPromise, true, value);\n            }\n            catch (error) {\n                // if error occurs, should always return this error\n                resolvePromise(chainPromise, false, error);\n            }\n        }, chainPromise);\n    }\n    const ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';\n    const noop = function () { };\n    const AggregateError = global.AggregateError;\n    class ZoneAwarePromise {\n        static toString() {\n            return ZONE_AWARE_PROMISE_TO_STRING;\n        }\n        static resolve(value) {\n            return resolvePromise(new this(null), RESOLVED, value);\n        }\n        static reject(error) {\n            return resolvePromise(new this(null), REJECTED, error);\n        }\n        static any(values) {\n            if (!values || typeof values[Symbol.iterator] !== 'function') {\n                return Promise.reject(new AggregateError([], 'All promises were rejected'));\n            }\n            const promises = [];\n            let count = 0;\n            try {\n                for (let v of values) {\n                    count++;\n                    promises.push(ZoneAwarePromise.resolve(v));\n                }\n            }\n            catch (err) {\n                return Promise.reject(new AggregateError([], 'All promises were rejected'));\n            }\n            if (count === 0) {\n                return Promise.reject(new AggregateError([], 'All promises were rejected'));\n            }\n            let finished = false;\n            const errors = [];\n            return new ZoneAwarePromise((resolve, reject) => {\n                for (let i = 0; i < promises.length; i++) {\n                    promises[i].then(v => {\n                        if (finished) {\n                            return;\n                        }\n                        finished = true;\n                        resolve(v);\n                    }, err => {\n                        errors.push(err);\n                        count--;\n                        if (count === 0) {\n                            finished = true;\n                            reject(new AggregateError(errors, 'All promises were rejected'));\n                        }\n                    });\n                }\n            });\n        }\n        ;\n        static race(values) {\n            let resolve;\n            let reject;\n            let promise = new this((res, rej) => {\n                resolve = res;\n                reject = rej;\n            });\n            function onResolve(value) {\n                resolve(value);\n            }\n            function onReject(error) {\n                reject(error);\n            }\n            for (let value of values) {\n                if (!isThenable(value)) {\n                    value = this.resolve(value);\n                }\n                value.then(onResolve, onReject);\n            }\n            return promise;\n        }\n        static all(values) {\n            return ZoneAwarePromise.allWithCallback(values);\n        }\n        static allSettled(values) {\n            const P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise;\n            return P.allWithCallback(values, {\n                thenCallback: (value) => ({ status: 'fulfilled', value }),\n                errorCallback: (err) => ({ status: 'rejected', reason: err })\n            });\n        }\n        static allWithCallback(values, callback) {\n            let resolve;\n            let reject;\n            let promise = new this((res, rej) => {\n                resolve = res;\n                reject = rej;\n            });\n            // Start at 2 to prevent prematurely resolving if .then is called immediately.\n            let unresolvedCount = 2;\n            let valueIndex = 0;\n            const resolvedValues = [];\n            for (let value of values) {\n                if (!isThenable(value)) {\n                    value = this.resolve(value);\n                }\n                const curValueIndex = valueIndex;\n                try {\n                    value.then((value) => {\n                        resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value;\n                        unresolvedCount--;\n                        if (unresolvedCount === 0) {\n                            resolve(resolvedValues);\n                        }\n                    }, (err) => {\n                        if (!callback) {\n                            reject(err);\n                        }\n                        else {\n                            resolvedValues[curValueIndex] = callback.errorCallback(err);\n                            unresolvedCount--;\n                            if (unresolvedCount === 0) {\n                                resolve(resolvedValues);\n                            }\n                        }\n                    });\n                }\n                catch (thenErr) {\n                    reject(thenErr);\n                }\n                unresolvedCount++;\n                valueIndex++;\n            }\n            // Make the unresolvedCount zero-based again.\n            unresolvedCount -= 2;\n            if (unresolvedCount === 0) {\n                resolve(resolvedValues);\n            }\n            return promise;\n        }\n        constructor(executor) {\n            const promise = this;\n            if (!(promise instanceof ZoneAwarePromise)) {\n                throw new Error('Must be an instanceof Promise.');\n            }\n            promise[symbolState] = UNRESOLVED;\n            promise[symbolValue] = []; // queue;\n            try {\n                const onceWrapper = once();\n                executor &&\n                    executor(onceWrapper(makeResolver(promise, RESOLVED)), onceWrapper(makeResolver(promise, REJECTED)));\n            }\n            catch (error) {\n                resolvePromise(promise, false, error);\n            }\n        }\n        get [Symbol.toStringTag]() {\n            return 'Promise';\n        }\n        get [Symbol.species]() {\n            return ZoneAwarePromise;\n        }\n        then(onFulfilled, onRejected) {\n            // We must read `Symbol.species` safely because `this` may be anything. For instance, `this`\n            // may be an object without a prototype (created through `Object.create(null)`); thus\n            // `this.constructor` will be undefined. One of the use cases is SystemJS creating\n            // prototype-less objects (modules) via `Object.create(null)`. The SystemJS creates an empty\n            // object and copies promise properties into that object (within the `getOrCreateLoad`\n            // function). The zone.js then checks if the resolved value has the `then` method and invokes\n            // it with the `value` context. Otherwise, this will throw an error: `TypeError: Cannot read\n            // properties of undefined (reading 'Symbol(Symbol.species)')`.\n            let C = this.constructor?.[Symbol.species];\n            if (!C || typeof C !== 'function') {\n                C = this.constructor || ZoneAwarePromise;\n            }\n            const chainPromise = new C(noop);\n            const zone = Zone.current;\n            if (this[symbolState] == UNRESOLVED) {\n                this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);\n            }\n            else {\n                scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);\n            }\n            return chainPromise;\n        }\n        catch(onRejected) {\n            return this.then(null, onRejected);\n        }\n        finally(onFinally) {\n            // See comment on the call to `then` about why thee `Symbol.species` is safely accessed.\n            let C = this.constructor?.[Symbol.species];\n            if (!C || typeof C !== 'function') {\n                C = ZoneAwarePromise;\n            }\n            const chainPromise = new C(noop);\n            chainPromise[symbolFinally] = symbolFinally;\n            const zone = Zone.current;\n            if (this[symbolState] == UNRESOLVED) {\n                this[symbolValue].push(zone, chainPromise, onFinally, onFinally);\n            }\n            else {\n                scheduleResolveOrReject(this, zone, chainPromise, onFinally, onFinally);\n            }\n            return chainPromise;\n        }\n    }\n    // Protect against aggressive optimizers dropping seemingly unused properties.\n    // E.g. Closure Compiler in advanced mode.\n    ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;\n    ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;\n    ZoneAwarePromise['race'] = ZoneAwarePromise.race;\n    ZoneAwarePromise['all'] = ZoneAwarePromise.all;\n    const NativePromise = global[symbolPromise] = global['Promise'];\n    global['Promise'] = ZoneAwarePromise;\n    const symbolThenPatched = __symbol__('thenPatched');\n    function patchThen(Ctor) {\n        const proto = Ctor.prototype;\n        const prop = ObjectGetOwnPropertyDescriptor(proto, 'then');\n        if (prop && (prop.writable === false || !prop.configurable)) {\n            // check Ctor.prototype.then propertyDescriptor is writable or not\n            // in meteor env, writable is false, we should ignore such case\n            return;\n        }\n        const originalThen = proto.then;\n        // Keep a reference to the original method.\n        proto[symbolThen] = originalThen;\n        Ctor.prototype.then = function (onResolve, onReject) {\n            const wrapped = new ZoneAwarePromise((resolve, reject) => {\n                originalThen.call(this, resolve, reject);\n            });\n            return wrapped.then(onResolve, onReject);\n        };\n        Ctor[symbolThenPatched] = true;\n    }\n    api.patchThen = patchThen;\n    function zoneify(fn) {\n        return function (self, args) {\n            let resultPromise = fn.apply(self, args);\n            if (resultPromise instanceof ZoneAwarePromise) {\n                return resultPromise;\n            }\n            let ctor = resultPromise.constructor;\n            if (!ctor[symbolThenPatched]) {\n                patchThen(ctor);\n            }\n            return resultPromise;\n        };\n    }\n    if (NativePromise) {\n        patchThen(NativePromise);\n        patchMethod(global, 'fetch', delegate => zoneify(delegate));\n    }\n    // This is not part of public API, but it is useful for tests, so we expose it.\n    Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;\n    return ZoneAwarePromise;\n});\n\n// override Function.prototype.toString to make zone.js patched function\n// look like native function\nZone.__load_patch('toString', (global) => {\n    // patch Func.prototype.toString to let them look like native\n    const originalFunctionToString = Function.prototype.toString;\n    const ORIGINAL_DELEGATE_SYMBOL = zoneSymbol('OriginalDelegate');\n    const PROMISE_SYMBOL = zoneSymbol('Promise');\n    const ERROR_SYMBOL = zoneSymbol('Error');\n    const newFunctionToString = function toString() {\n        if (typeof this === 'function') {\n            const originalDelegate = this[ORIGINAL_DELEGATE_SYMBOL];\n            if (originalDelegate) {\n                if (typeof originalDelegate === 'function') {\n                    return originalFunctionToString.call(originalDelegate);\n                }\n                else {\n                    return Object.prototype.toString.call(originalDelegate);\n                }\n            }\n            if (this === Promise) {\n                const nativePromise = global[PROMISE_SYMBOL];\n                if (nativePromise) {\n                    return originalFunctionToString.call(nativePromise);\n                }\n            }\n            if (this === Error) {\n                const nativeError = global[ERROR_SYMBOL];\n                if (nativeError) {\n                    return originalFunctionToString.call(nativeError);\n                }\n            }\n        }\n        return originalFunctionToString.call(this);\n    };\n    newFunctionToString[ORIGINAL_DELEGATE_SYMBOL] = originalFunctionToString;\n    Function.prototype.toString = newFunctionToString;\n    // patch Object.prototype.toString to let them look like native\n    const originalObjectToString = Object.prototype.toString;\n    const PROMISE_OBJECT_TO_STRING = '[object Promise]';\n    Object.prototype.toString = function () {\n        if (typeof Promise === 'function' && this instanceof Promise) {\n            return PROMISE_OBJECT_TO_STRING;\n        }\n        return originalObjectToString.call(this);\n    };\n});\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\nlet passiveSupported = false;\nif (typeof window !== 'undefined') {\n    try {\n        const options = Object.defineProperty({}, 'passive', {\n            get: function () {\n                passiveSupported = true;\n            }\n        });\n        // Note: We pass the `options` object as the event handler too. This is not compatible with the\n        // signature of `addEventListener` or `removeEventListener` but enables us to remove the handler\n        // without an actual handler.\n        window.addEventListener('test', options, options);\n        window.removeEventListener('test', options, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n}\n// an identifier to tell ZoneTask do not create a new invoke closure\nconst OPTIMIZED_ZONE_EVENT_TASK_DATA = {\n    useG: true\n};\nconst zoneSymbolEventNames = {};\nconst globalSources = {};\nconst EVENT_NAME_SYMBOL_REGX = new RegExp('^' + ZONE_SYMBOL_PREFIX + '(\\\\w+)(true|false)$');\nconst IMMEDIATE_PROPAGATION_SYMBOL = zoneSymbol('propagationStopped');\nfunction prepareEventNames(eventName, eventNameToString) {\n    const falseEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + FALSE_STR;\n    const trueEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + TRUE_STR;\n    const symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n    const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n    zoneSymbolEventNames[eventName] = {};\n    zoneSymbolEventNames[eventName][FALSE_STR] = symbol;\n    zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;\n}\nfunction patchEventTarget(_global, api, apis, patchOptions) {\n    const ADD_EVENT_LISTENER = (patchOptions && patchOptions.add) || ADD_EVENT_LISTENER_STR;\n    const REMOVE_EVENT_LISTENER = (patchOptions && patchOptions.rm) || REMOVE_EVENT_LISTENER_STR;\n    const LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.listeners) || 'eventListeners';\n    const REMOVE_ALL_LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.rmAll) || 'removeAllListeners';\n    const zoneSymbolAddEventListener = zoneSymbol(ADD_EVENT_LISTENER);\n    const ADD_EVENT_LISTENER_SOURCE = '.' + ADD_EVENT_LISTENER + ':';\n    const PREPEND_EVENT_LISTENER = 'prependListener';\n    const PREPEND_EVENT_LISTENER_SOURCE = '.' + PREPEND_EVENT_LISTENER + ':';\n    const invokeTask = function (task, target, event) {\n        // for better performance, check isRemoved which is set\n        // by removeEventListener\n        if (task.isRemoved) {\n            return;\n        }\n        const delegate = task.callback;\n        if (typeof delegate === 'object' && delegate.handleEvent) {\n            // create the bind version of handleEvent when invoke\n            task.callback = (event) => delegate.handleEvent(event);\n            task.originalDelegate = delegate;\n        }\n        // invoke static task.invoke\n        // need to try/catch error here, otherwise, the error in one event listener\n        // will break the executions of the other event listeners. Also error will\n        // not remove the event listener when `once` options is true.\n        let error;\n        try {\n            task.invoke(task, target, [event]);\n        }\n        catch (err) {\n            error = err;\n        }\n        const options = task.options;\n        if (options && typeof options === 'object' && options.once) {\n            // if options.once is true, after invoke once remove listener here\n            // only browser need to do this, nodejs eventEmitter will cal removeListener\n            // inside EventEmitter.once\n            const delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n            target[REMOVE_EVENT_LISTENER].call(target, event.type, delegate, options);\n        }\n        return error;\n    };\n    function globalCallback(context, event, isCapture) {\n        // https://github.com/angular/zone.js/issues/911, in IE, sometimes\n        // event will be undefined, so we need to use window.event\n        event = event || _global.event;\n        if (!event) {\n            return;\n        }\n        // event.target is needed for Samsung TV and SourceBuffer\n        // || global is needed https://github.com/angular/zone.js/issues/190\n        const target = context || event.target || _global;\n        const tasks = target[zoneSymbolEventNames[event.type][isCapture ? TRUE_STR : FALSE_STR]];\n        if (tasks) {\n            const errors = [];\n            // invoke all tasks which attached to current target with given event.type and capture = false\n            // for performance concern, if task.length === 1, just invoke\n            if (tasks.length === 1) {\n                const err = invokeTask(tasks[0], target, event);\n                err && errors.push(err);\n            }\n            else {\n                // https://github.com/angular/zone.js/issues/836\n                // copy the tasks array before invoke, to avoid\n                // the callback will remove itself or other listener\n                const copyTasks = tasks.slice();\n                for (let i = 0; i < copyTasks.length; i++) {\n                    if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) {\n                        break;\n                    }\n                    const err = invokeTask(copyTasks[i], target, event);\n                    err && errors.push(err);\n                }\n            }\n            // Since there is only one error, we don't need to schedule microTask\n            // to throw the error.\n            if (errors.length === 1) {\n                throw errors[0];\n            }\n            else {\n                for (let i = 0; i < errors.length; i++) {\n                    const err = errors[i];\n                    api.nativeScheduleMicroTask(() => {\n                        throw err;\n                    });\n                }\n            }\n        }\n    }\n    // global shared zoneAwareCallback to handle all event callback with capture = false\n    const globalZoneAwareCallback = function (event) {\n        return globalCallback(this, event, false);\n    };\n    // global shared zoneAwareCallback to handle all event callback with capture = true\n    const globalZoneAwareCaptureCallback = function (event) {\n        return globalCallback(this, event, true);\n    };\n    function patchEventTargetMethods(obj, patchOptions) {\n        if (!obj) {\n            return false;\n        }\n        let useGlobalCallback = true;\n        if (patchOptions && patchOptions.useG !== undefined) {\n            useGlobalCallback = patchOptions.useG;\n        }\n        const validateHandler = patchOptions && patchOptions.vh;\n        let checkDuplicate = true;\n        if (patchOptions && patchOptions.chkDup !== undefined) {\n            checkDuplicate = patchOptions.chkDup;\n        }\n        let returnTarget = false;\n        if (patchOptions && patchOptions.rt !== undefined) {\n            returnTarget = patchOptions.rt;\n        }\n        let proto = obj;\n        while (proto && !proto.hasOwnProperty(ADD_EVENT_LISTENER)) {\n            proto = ObjectGetPrototypeOf(proto);\n        }\n        if (!proto && obj[ADD_EVENT_LISTENER]) {\n            // somehow we did not find it, but we can see it. This happens on IE for Window properties.\n            proto = obj;\n        }\n        if (!proto) {\n            return false;\n        }\n        if (proto[zoneSymbolAddEventListener]) {\n            return false;\n        }\n        const eventNameToString = patchOptions && patchOptions.eventNameToString;\n        // a shared global taskData to pass data for scheduleEventTask\n        // so we do not need to create a new object just for pass some data\n        const taskData = {};\n        const nativeAddEventListener = proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER];\n        const nativeRemoveEventListener = proto[zoneSymbol(REMOVE_EVENT_LISTENER)] =\n            proto[REMOVE_EVENT_LISTENER];\n        const nativeListeners = proto[zoneSymbol(LISTENERS_EVENT_LISTENER)] =\n            proto[LISTENERS_EVENT_LISTENER];\n        const nativeRemoveAllListeners = proto[zoneSymbol(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] =\n            proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER];\n        let nativePrependEventListener;\n        if (patchOptions && patchOptions.prepend) {\n            nativePrependEventListener = proto[zoneSymbol(patchOptions.prepend)] =\n                proto[patchOptions.prepend];\n        }\n        /**\n         * This util function will build an option object with passive option\n         * to handle all possible input from the user.\n         */\n        function buildEventListenerOptions(options, passive) {\n            if (!passiveSupported && typeof options === 'object' && options) {\n                // doesn't support passive but user want to pass an object as options.\n                // this will not work on some old browser, so we just pass a boolean\n                // as useCapture parameter\n                return !!options.capture;\n            }\n            if (!passiveSupported || !passive) {\n                return options;\n            }\n            if (typeof options === 'boolean') {\n                return { capture: options, passive: true };\n            }\n            if (!options) {\n                return { passive: true };\n            }\n            if (typeof options === 'object' && options.passive !== false) {\n                return { ...options, passive: true };\n            }\n            return options;\n        }\n        const customScheduleGlobal = function (task) {\n            // if there is already a task for the eventName + capture,\n            // just return, because we use the shared globalZoneAwareCallback here.\n            if (taskData.isExisting) {\n                return;\n            }\n            return nativeAddEventListener.call(taskData.target, taskData.eventName, taskData.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, taskData.options);\n        };\n        const customCancelGlobal = function (task) {\n            // if task is not marked as isRemoved, this call is directly\n            // from Zone.prototype.cancelTask, we should remove the task\n            // from tasksList of target first\n            if (!task.isRemoved) {\n                const symbolEventNames = zoneSymbolEventNames[task.eventName];\n                let symbolEventName;\n                if (symbolEventNames) {\n                    symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR];\n                }\n                const existingTasks = symbolEventName && task.target[symbolEventName];\n                if (existingTasks) {\n                    for (let i = 0; i < existingTasks.length; i++) {\n                        const existingTask = existingTasks[i];\n                        if (existingTask === task) {\n                            existingTasks.splice(i, 1);\n                            // set isRemoved to data for faster invokeTask check\n                            task.isRemoved = true;\n                            if (existingTasks.length === 0) {\n                                // all tasks for the eventName + capture have gone,\n                                // remove globalZoneAwareCallback and remove the task cache from target\n                                task.allRemoved = true;\n                                task.target[symbolEventName] = null;\n                            }\n                            break;\n                        }\n                    }\n                }\n            }\n            // if all tasks for the eventName + capture have gone,\n            // we will really remove the global event callback,\n            // if not, return\n            if (!task.allRemoved) {\n                return;\n            }\n            return nativeRemoveEventListener.call(task.target, task.eventName, task.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, task.options);\n        };\n        const customScheduleNonGlobal = function (task) {\n            return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n        };\n        const customSchedulePrepend = function (task) {\n            return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n        };\n        const customCancelNonGlobal = function (task) {\n            return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options);\n        };\n        const customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal;\n        const customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal;\n        const compareTaskCallbackVsDelegate = function (task, delegate) {\n            const typeOfDelegate = typeof delegate;\n            return (typeOfDelegate === 'function' && task.callback === delegate) ||\n                (typeOfDelegate === 'object' && task.originalDelegate === delegate);\n        };\n        const compare = (patchOptions && patchOptions.diff) ? patchOptions.diff : compareTaskCallbackVsDelegate;\n        const unpatchedEvents = Zone[zoneSymbol('UNPATCHED_EVENTS')];\n        const passiveEvents = _global[zoneSymbol('PASSIVE_EVENTS')];\n        const makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget = false, prepend = false) {\n            return function () {\n                const target = this || _global;\n                let eventName = arguments[0];\n                if (patchOptions && patchOptions.transferEventName) {\n                    eventName = patchOptions.transferEventName(eventName);\n                }\n                let delegate = arguments[1];\n                if (!delegate) {\n                    return nativeListener.apply(this, arguments);\n                }\n                if (isNode && eventName === 'uncaughtException') {\n                    // don't patch uncaughtException of nodejs to prevent endless loop\n                    return nativeListener.apply(this, arguments);\n                }\n                // don't create the bind delegate function for handleEvent\n                // case here to improve addEventListener performance\n                // we will create the bind delegate when invoke\n                let isHandleEvent = false;\n                if (typeof delegate !== 'function') {\n                    if (!delegate.handleEvent) {\n                        return nativeListener.apply(this, arguments);\n                    }\n                    isHandleEvent = true;\n                }\n                if (validateHandler && !validateHandler(nativeListener, delegate, target, arguments)) {\n                    return;\n                }\n                const passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1;\n                const options = buildEventListenerOptions(arguments[2], passive);\n                if (unpatchedEvents) {\n                    // check unpatched list\n                    for (let i = 0; i < unpatchedEvents.length; i++) {\n                        if (eventName === unpatchedEvents[i]) {\n                            if (passive) {\n                                return nativeListener.call(target, eventName, delegate, options);\n                            }\n                            else {\n                                return nativeListener.apply(this, arguments);\n                            }\n                        }\n                    }\n                }\n                const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n                const once = options && typeof options === 'object' ? options.once : false;\n                const zone = Zone.current;\n                let symbolEventNames = zoneSymbolEventNames[eventName];\n                if (!symbolEventNames) {\n                    prepareEventNames(eventName, eventNameToString);\n                    symbolEventNames = zoneSymbolEventNames[eventName];\n                }\n                const symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n                let existingTasks = target[symbolEventName];\n                let isExisting = false;\n                if (existingTasks) {\n                    // already have task registered\n                    isExisting = true;\n                    if (checkDuplicate) {\n                        for (let i = 0; i < existingTasks.length; i++) {\n                            if (compare(existingTasks[i], delegate)) {\n                                // same callback, same capture, same event name, just return\n                                return;\n                            }\n                        }\n                    }\n                }\n                else {\n                    existingTasks = target[symbolEventName] = [];\n                }\n                let source;\n                const constructorName = target.constructor['name'];\n                const targetSource = globalSources[constructorName];\n                if (targetSource) {\n                    source = targetSource[eventName];\n                }\n                if (!source) {\n                    source = constructorName + addSource +\n                        (eventNameToString ? eventNameToString(eventName) : eventName);\n                }\n                // do not create a new object as task.data to pass those things\n                // just use the global shared one\n                taskData.options = options;\n                if (once) {\n                    // if addEventListener with once options, we don't pass it to\n                    // native addEventListener, instead we keep the once setting\n                    // and handle ourselves.\n                    taskData.options.once = false;\n                }\n                taskData.target = target;\n                taskData.capture = capture;\n                taskData.eventName = eventName;\n                taskData.isExisting = isExisting;\n                const data = useGlobalCallback ? OPTIMIZED_ZONE_EVENT_TASK_DATA : undefined;\n                // keep taskData into data to allow onScheduleEventTask to access the task information\n                if (data) {\n                    data.taskData = taskData;\n                }\n                const task = zone.scheduleEventTask(source, delegate, data, customScheduleFn, customCancelFn);\n                // should clear taskData.target to avoid memory leak\n                // issue, https://github.com/angular/angular/issues/20442\n                taskData.target = null;\n                // need to clear up taskData because it is a global object\n                if (data) {\n                    data.taskData = null;\n                }\n                // have to save those information to task in case\n                // application may call task.zone.cancelTask() directly\n                if (once) {\n                    options.once = true;\n                }\n                if (!(!passiveSupported && typeof task.options === 'boolean')) {\n                    // if not support passive, and we pass an option object\n                    // to addEventListener, we should save the options to task\n                    task.options = options;\n                }\n                task.target = target;\n                task.capture = capture;\n                task.eventName = eventName;\n                if (isHandleEvent) {\n                    // save original delegate for compare to check duplicate\n                    task.originalDelegate = delegate;\n                }\n                if (!prepend) {\n                    existingTasks.push(task);\n                }\n                else {\n                    existingTasks.unshift(task);\n                }\n                if (returnTarget) {\n                    return target;\n                }\n            };\n        };\n        proto[ADD_EVENT_LISTENER] = makeAddListener(nativeAddEventListener, ADD_EVENT_LISTENER_SOURCE, customSchedule, customCancel, returnTarget);\n        if (nativePrependEventListener) {\n            proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true);\n        }\n        proto[REMOVE_EVENT_LISTENER] = function () {\n            const target = this || _global;\n            let eventName = arguments[0];\n            if (patchOptions && patchOptions.transferEventName) {\n                eventName = patchOptions.transferEventName(eventName);\n            }\n            const options = arguments[2];\n            const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n            const delegate = arguments[1];\n            if (!delegate) {\n                return nativeRemoveEventListener.apply(this, arguments);\n            }\n            if (validateHandler &&\n                !validateHandler(nativeRemoveEventListener, delegate, target, arguments)) {\n                return;\n            }\n            const symbolEventNames = zoneSymbolEventNames[eventName];\n            let symbolEventName;\n            if (symbolEventNames) {\n                symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n            }\n            const existingTasks = symbolEventName && target[symbolEventName];\n            if (existingTasks) {\n                for (let i = 0; i < existingTasks.length; i++) {\n                    const existingTask = existingTasks[i];\n                    if (compare(existingTask, delegate)) {\n                        existingTasks.splice(i, 1);\n                        // set isRemoved to data for faster invokeTask check\n                        existingTask.isRemoved = true;\n                        if (existingTasks.length === 0) {\n                            // all tasks for the eventName + capture have gone,\n                            // remove globalZoneAwareCallback and remove the task cache from target\n                            existingTask.allRemoved = true;\n                            target[symbolEventName] = null;\n                            // in the target, we have an event listener which is added by on_property\n                            // such as target.onclick = function() {}, so we need to clear this internal\n                            // property too if all delegates all removed\n                            if (typeof eventName === 'string') {\n                                const onPropertySymbol = ZONE_SYMBOL_PREFIX + 'ON_PROPERTY' + eventName;\n                                target[onPropertySymbol] = null;\n                            }\n                        }\n                        existingTask.zone.cancelTask(existingTask);\n                        if (returnTarget) {\n                            return target;\n                        }\n                        return;\n                    }\n                }\n            }\n            // issue 930, didn't find the event name or callback\n            // from zone kept existingTasks, the callback maybe\n            // added outside of zone, we need to call native removeEventListener\n            // to try to remove it.\n            return nativeRemoveEventListener.apply(this, arguments);\n        };\n        proto[LISTENERS_EVENT_LISTENER] = function () {\n            const target = this || _global;\n            let eventName = arguments[0];\n            if (patchOptions && patchOptions.transferEventName) {\n                eventName = patchOptions.transferEventName(eventName);\n            }\n            const listeners = [];\n            const tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName);\n            for (let i = 0; i < tasks.length; i++) {\n                const task = tasks[i];\n                let delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                listeners.push(delegate);\n            }\n            return listeners;\n        };\n        proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function () {\n            const target = this || _global;\n            let eventName = arguments[0];\n            if (!eventName) {\n                const keys = Object.keys(target);\n                for (let i = 0; i < keys.length; i++) {\n                    const prop = keys[i];\n                    const match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n                    let evtName = match && match[1];\n                    // in nodejs EventEmitter, removeListener event is\n                    // used for monitoring the removeListener call,\n                    // so just keep removeListener eventListener until\n                    // all other eventListeners are removed\n                    if (evtName && evtName !== 'removeListener') {\n                        this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, evtName);\n                    }\n                }\n                // remove removeListener listener finally\n                this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, 'removeListener');\n            }\n            else {\n                if (patchOptions && patchOptions.transferEventName) {\n                    eventName = patchOptions.transferEventName(eventName);\n                }\n                const symbolEventNames = zoneSymbolEventNames[eventName];\n                if (symbolEventNames) {\n                    const symbolEventName = symbolEventNames[FALSE_STR];\n                    const symbolCaptureEventName = symbolEventNames[TRUE_STR];\n                    const tasks = target[symbolEventName];\n                    const captureTasks = target[symbolCaptureEventName];\n                    if (tasks) {\n                        const removeTasks = tasks.slice();\n                        for (let i = 0; i < removeTasks.length; i++) {\n                            const task = removeTasks[i];\n                            let delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                            this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);\n                        }\n                    }\n                    if (captureTasks) {\n                        const removeTasks = captureTasks.slice();\n                        for (let i = 0; i < removeTasks.length; i++) {\n                            const task = removeTasks[i];\n                            let delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                            this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);\n                        }\n                    }\n                }\n            }\n            if (returnTarget) {\n                return this;\n            }\n        };\n        // for native toString patch\n        attachOriginToPatched(proto[ADD_EVENT_LISTENER], nativeAddEventListener);\n        attachOriginToPatched(proto[REMOVE_EVENT_LISTENER], nativeRemoveEventListener);\n        if (nativeRemoveAllListeners) {\n            attachOriginToPatched(proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER], nativeRemoveAllListeners);\n        }\n        if (nativeListeners) {\n            attachOriginToPatched(proto[LISTENERS_EVENT_LISTENER], nativeListeners);\n        }\n        return true;\n    }\n    let results = [];\n    for (let i = 0; i < apis.length; i++) {\n        results[i] = patchEventTargetMethods(apis[i], patchOptions);\n    }\n    return results;\n}\nfunction findEventTasks(target, eventName) {\n    if (!eventName) {\n        const foundTasks = [];\n        for (let prop in target) {\n            const match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n            let evtName = match && match[1];\n            if (evtName && (!eventName || evtName === eventName)) {\n                const tasks = target[prop];\n                if (tasks) {\n                    for (let i = 0; i < tasks.length; i++) {\n                        foundTasks.push(tasks[i]);\n                    }\n                }\n            }\n        }\n        return foundTasks;\n    }\n    let symbolEventName = zoneSymbolEventNames[eventName];\n    if (!symbolEventName) {\n        prepareEventNames(eventName);\n        symbolEventName = zoneSymbolEventNames[eventName];\n    }\n    const captureFalseTasks = target[symbolEventName[FALSE_STR]];\n    const captureTrueTasks = target[symbolEventName[TRUE_STR]];\n    if (!captureFalseTasks) {\n        return captureTrueTasks ? captureTrueTasks.slice() : [];\n    }\n    else {\n        return captureTrueTasks ? captureFalseTasks.concat(captureTrueTasks) :\n            captureFalseTasks.slice();\n    }\n}\nfunction patchEventPrototype(global, api) {\n    const Event = global['Event'];\n    if (Event && Event.prototype) {\n        api.patchMethod(Event.prototype, 'stopImmediatePropagation', (delegate) => function (self, args) {\n            self[IMMEDIATE_PROPAGATION_SYMBOL] = true;\n            // we need to call the native stopImmediatePropagation\n            // in case in some hybrid application, some part of\n            // application will be controlled by zone, some are not\n            delegate && delegate.apply(self, args);\n        });\n    }\n}\n\nfunction patchCallbacks(api, target, targetName, method, callbacks) {\n    const symbol = Zone.__symbol__(method);\n    if (target[symbol]) {\n        return;\n    }\n    const nativeDelegate = target[symbol] = target[method];\n    target[method] = function (name, opts, options) {\n        if (opts && opts.prototype) {\n            callbacks.forEach(function (callback) {\n                const source = `${targetName}.${method}::` + callback;\n                const prototype = opts.prototype;\n                // Note: the `patchCallbacks` is used for patching the `document.registerElement` and\n                // `customElements.define`. We explicitly wrap the patching code into try-catch since\n                // callbacks may be already patched by other web components frameworks (e.g. LWC), and they\n                // make those properties non-writable. This means that patching callback will throw an error\n                // `cannot assign to read-only property`. See this code as an example:\n                // https://github.com/salesforce/lwc/blob/master/packages/@lwc/engine-core/src/framework/base-bridge-element.ts#L180-L186\n                // We don't want to stop the application rendering if we couldn't patch some\n                // callback, e.g. `attributeChangedCallback`.\n                try {\n                    if (prototype.hasOwnProperty(callback)) {\n                        const descriptor = api.ObjectGetOwnPropertyDescriptor(prototype, callback);\n                        if (descriptor && descriptor.value) {\n                            descriptor.value = api.wrapWithCurrentZone(descriptor.value, source);\n                            api._redefineProperty(opts.prototype, callback, descriptor);\n                        }\n                        else if (prototype[callback]) {\n                            prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);\n                        }\n                    }\n                    else if (prototype[callback]) {\n                        prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);\n                    }\n                }\n                catch {\n                    // Note: we leave the catch block empty since there's no way to handle the error related\n                    // to non-writable property.\n                }\n            });\n        }\n        return nativeDelegate.call(target, name, opts, options);\n    };\n    api.attachOriginToPatched(target[method], nativeDelegate);\n}\n\n/**\n * @fileoverview\n * @suppress {globalThis}\n */\nfunction filterProperties(target, onProperties, ignoreProperties) {\n    if (!ignoreProperties || ignoreProperties.length === 0) {\n        return onProperties;\n    }\n    const tip = ignoreProperties.filter(ip => ip.target === target);\n    if (!tip || tip.length === 0) {\n        return onProperties;\n    }\n    const targetIgnoreProperties = tip[0].ignoreProperties;\n    return onProperties.filter(op => targetIgnoreProperties.indexOf(op) === -1);\n}\nfunction patchFilteredProperties(target, onProperties, ignoreProperties, prototype) {\n    // check whether target is available, sometimes target will be undefined\n    // because different browser or some 3rd party plugin.\n    if (!target) {\n        return;\n    }\n    const filteredProperties = filterProperties(target, onProperties, ignoreProperties);\n    patchOnProperties(target, filteredProperties, prototype);\n}\n/**\n * Get all event name properties which the event name startsWith `on`\n * from the target object itself, inherited properties are not considered.\n */\nfunction getOnEventNames(target) {\n    return Object.getOwnPropertyNames(target)\n        .filter(name => name.startsWith('on') && name.length > 2)\n        .map(name => name.substring(2));\n}\nfunction propertyDescriptorPatch(api, _global) {\n    if (isNode && !isMix) {\n        return;\n    }\n    if (Zone[api.symbol('patchEvents')]) {\n        // events are already been patched by legacy patch.\n        return;\n    }\n    const ignoreProperties = _global['__Zone_ignore_on_properties'];\n    // for browsers that we can patch the descriptor:  Chrome & Firefox\n    let patchTargets = [];\n    if (isBrowser) {\n        const internalWindow = window;\n        patchTargets = patchTargets.concat([\n            'Document', 'SVGElement', 'Element', 'HTMLElement', 'HTMLBodyElement', 'HTMLMediaElement',\n            'HTMLFrameSetElement', 'HTMLFrameElement', 'HTMLIFrameElement', 'HTMLMarqueeElement', 'Worker'\n        ]);\n        const ignoreErrorProperties = isIE() ? [{ target: internalWindow, ignoreProperties: ['error'] }] : [];\n        // in IE/Edge, onProp not exist in window object, but in WindowPrototype\n        // so we need to pass WindowPrototype to check onProp exist or not\n        patchFilteredProperties(internalWindow, getOnEventNames(internalWindow), ignoreProperties ? ignoreProperties.concat(ignoreErrorProperties) : ignoreProperties, ObjectGetPrototypeOf(internalWindow));\n    }\n    patchTargets = patchTargets.concat([\n        'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'IDBIndex', 'IDBRequest', 'IDBOpenDBRequest',\n        'IDBDatabase', 'IDBTransaction', 'IDBCursor', 'WebSocket'\n    ]);\n    for (let i = 0; i < patchTargets.length; i++) {\n        const target = _global[patchTargets[i]];\n        target && target.prototype &&\n            patchFilteredProperties(target.prototype, getOnEventNames(target.prototype), ignoreProperties);\n    }\n}\n\nZone.__load_patch('util', (global, Zone, api) => {\n    // Collect native event names by looking at properties\n    // on the global namespace, e.g. 'onclick'.\n    const eventNames = getOnEventNames(global);\n    api.patchOnProperties = patchOnProperties;\n    api.patchMethod = patchMethod;\n    api.bindArguments = bindArguments;\n    api.patchMacroTask = patchMacroTask;\n    // In earlier version of zone.js (<0.9.0), we use env name `__zone_symbol__BLACK_LISTED_EVENTS` to\n    // define which events will not be patched by `Zone.js`.\n    // In newer version (>=0.9.0), we change the env name to `__zone_symbol__UNPATCHED_EVENTS` to keep\n    // the name consistent with angular repo.\n    // The  `__zone_symbol__BLACK_LISTED_EVENTS` is deprecated, but it is still be supported for\n    // backwards compatibility.\n    const SYMBOL_BLACK_LISTED_EVENTS = Zone.__symbol__('BLACK_LISTED_EVENTS');\n    const SYMBOL_UNPATCHED_EVENTS = Zone.__symbol__('UNPATCHED_EVENTS');\n    if (global[SYMBOL_UNPATCHED_EVENTS]) {\n        global[SYMBOL_BLACK_LISTED_EVENTS] = global[SYMBOL_UNPATCHED_EVENTS];\n    }\n    if (global[SYMBOL_BLACK_LISTED_EVENTS]) {\n        Zone[SYMBOL_BLACK_LISTED_EVENTS] = Zone[SYMBOL_UNPATCHED_EVENTS] =\n            global[SYMBOL_BLACK_LISTED_EVENTS];\n    }\n    api.patchEventPrototype = patchEventPrototype;\n    api.patchEventTarget = patchEventTarget;\n    api.isIEOrEdge = isIEOrEdge;\n    api.ObjectDefineProperty = ObjectDefineProperty;\n    api.ObjectGetOwnPropertyDescriptor = ObjectGetOwnPropertyDescriptor;\n    api.ObjectCreate = ObjectCreate;\n    api.ArraySlice = ArraySlice;\n    api.patchClass = patchClass;\n    api.wrapWithCurrentZone = wrapWithCurrentZone;\n    api.filterProperties = filterProperties;\n    api.attachOriginToPatched = attachOriginToPatched;\n    api._redefineProperty = Object.defineProperty;\n    api.patchCallbacks = patchCallbacks;\n    api.getGlobalObjects = () => ({\n        globalSources,\n        zoneSymbolEventNames,\n        eventNames,\n        isBrowser,\n        isMix,\n        isNode,\n        TRUE_STR,\n        FALSE_STR,\n        ZONE_SYMBOL_PREFIX,\n        ADD_EVENT_LISTENER_STR,\n        REMOVE_EVENT_LISTENER_STR\n    });\n});\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\nfunction patchQueueMicrotask(global, api) {\n    api.patchMethod(global, 'queueMicrotask', (delegate) => {\n        return function (self, args) {\n            Zone.current.scheduleMicroTask('queueMicrotask', args[0]);\n        };\n    });\n}\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\nconst taskSymbol = zoneSymbol('zoneTask');\nfunction patchTimer(window, setName, cancelName, nameSuffix) {\n    let setNative = null;\n    let clearNative = null;\n    setName += nameSuffix;\n    cancelName += nameSuffix;\n    const tasksByHandleId = {};\n    function scheduleTask(task) {\n        const data = task.data;\n        data.args[0] = function () {\n            return task.invoke.apply(this, arguments);\n        };\n        data.handleId = setNative.apply(window, data.args);\n        return task;\n    }\n    function clearTask(task) {\n        return clearNative.call(window, task.data.handleId);\n    }\n    setNative =\n        patchMethod(window, setName, (delegate) => function (self, args) {\n            if (typeof args[0] === 'function') {\n                const options = {\n                    isPeriodic: nameSuffix === 'Interval',\n                    delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 :\n                        undefined,\n                    args: args\n                };\n                const callback = args[0];\n                args[0] = function timer() {\n                    try {\n                        return callback.apply(this, arguments);\n                    }\n                    finally {\n                        // issue-934, task will be cancelled\n                        // even it is a periodic task such as\n                        // setInterval\n                        // https://github.com/angular/angular/issues/40387\n                        // Cleanup tasksByHandleId should be handled before scheduleTask\n                        // Since some zoneSpec may intercept and doesn't trigger\n                        // scheduleFn(scheduleTask) provided here.\n                        if (!(options.isPeriodic)) {\n                            if (typeof options.handleId === 'number') {\n                                // in non-nodejs env, we remove timerId\n                                // from local cache\n                                delete tasksByHandleId[options.handleId];\n                            }\n                            else if (options.handleId) {\n                                // Node returns complex objects as handleIds\n                                // we remove task reference from timer object\n                                options.handleId[taskSymbol] = null;\n                            }\n                        }\n                    }\n                };\n                const task = scheduleMacroTaskWithCurrentZone(setName, args[0], options, scheduleTask, clearTask);\n                if (!task) {\n                    return task;\n                }\n                // Node.js must additionally support the ref and unref functions.\n                const handle = task.data.handleId;\n                if (typeof handle === 'number') {\n                    // for non nodejs env, we save handleId: task\n                    // mapping in local cache for clearTimeout\n                    tasksByHandleId[handle] = task;\n                }\n                else if (handle) {\n                    // for nodejs env, we save task\n                    // reference in timerId Object for clearTimeout\n                    handle[taskSymbol] = task;\n                }\n                // check whether handle is null, because some polyfill or browser\n                // may return undefined from setTimeout/setInterval/setImmediate/requestAnimationFrame\n                if (handle && handle.ref && handle.unref && typeof handle.ref === 'function' &&\n                    typeof handle.unref === 'function') {\n                    task.ref = handle.ref.bind(handle);\n                    task.unref = handle.unref.bind(handle);\n                }\n                if (typeof handle === 'number' || handle) {\n                    return handle;\n                }\n                return task;\n            }\n            else {\n                // cause an error by calling it directly.\n                return delegate.apply(window, args);\n            }\n        });\n    clearNative =\n        patchMethod(window, cancelName, (delegate) => function (self, args) {\n            const id = args[0];\n            let task;\n            if (typeof id === 'number') {\n                // non nodejs env.\n                task = tasksByHandleId[id];\n            }\n            else {\n                // nodejs env.\n                task = id && id[taskSymbol];\n                // other environments.\n                if (!task) {\n                    task = id;\n                }\n            }\n            if (task && typeof task.type === 'string') {\n                if (task.state !== 'notScheduled' &&\n                    (task.cancelFn && task.data.isPeriodic || task.runCount === 0)) {\n                    if (typeof id === 'number') {\n                        delete tasksByHandleId[id];\n                    }\n                    else if (id) {\n                        id[taskSymbol] = null;\n                    }\n                    // Do not cancel already canceled functions\n                    task.zone.cancelTask(task);\n                }\n            }\n            else {\n                // cause an error by calling it directly.\n                delegate.apply(window, args);\n            }\n        });\n}\n\nfunction patchCustomElements(_global, api) {\n    const { isBrowser, isMix } = api.getGlobalObjects();\n    if ((!isBrowser && !isMix) || !_global['customElements'] || !('customElements' in _global)) {\n        return;\n    }\n    const callbacks = ['connectedCallback', 'disconnectedCallback', 'adoptedCallback', 'attributeChangedCallback'];\n    api.patchCallbacks(api, _global.customElements, 'customElements', 'define', callbacks);\n}\n\nfunction eventTargetPatch(_global, api) {\n    if (Zone[api.symbol('patchEventTarget')]) {\n        // EventTarget is already patched.\n        return;\n    }\n    const { eventNames, zoneSymbolEventNames, TRUE_STR, FALSE_STR, ZONE_SYMBOL_PREFIX } = api.getGlobalObjects();\n    //  predefine all __zone_symbol__ + eventName + true/false string\n    for (let i = 0; i < eventNames.length; i++) {\n        const eventName = eventNames[i];\n        const falseEventName = eventName + FALSE_STR;\n        const trueEventName = eventName + TRUE_STR;\n        const symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n        const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n        zoneSymbolEventNames[eventName] = {};\n        zoneSymbolEventNames[eventName][FALSE_STR] = symbol;\n        zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;\n    }\n    const EVENT_TARGET = _global['EventTarget'];\n    if (!EVENT_TARGET || !EVENT_TARGET.prototype) {\n        return;\n    }\n    api.patchEventTarget(_global, api, [EVENT_TARGET && EVENT_TARGET.prototype]);\n    return true;\n}\nfunction patchEvent(global, api) {\n    api.patchEventPrototype(global, api);\n}\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\nZone.__load_patch('legacy', (global) => {\n    const legacyPatch = global[Zone.__symbol__('legacyPatch')];\n    if (legacyPatch) {\n        legacyPatch();\n    }\n});\nZone.__load_patch('timers', (global) => {\n    const set = 'set';\n    const clear = 'clear';\n    patchTimer(global, set, clear, 'Timeout');\n    patchTimer(global, set, clear, 'Interval');\n    patchTimer(global, set, clear, 'Immediate');\n});\nZone.__load_patch('requestAnimationFrame', (global) => {\n    patchTimer(global, 'request', 'cancel', 'AnimationFrame');\n    patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame');\n    patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');\n});\nZone.__load_patch('blocking', (global, Zone) => {\n    const blockingMethods = ['alert', 'prompt', 'confirm'];\n    for (let i = 0; i < blockingMethods.length; i++) {\n        const name = blockingMethods[i];\n        patchMethod(global, name, (delegate, symbol, name) => {\n            return function (s, args) {\n                return Zone.current.run(delegate, global, args, name);\n            };\n        });\n    }\n});\nZone.__load_patch('EventTarget', (global, Zone, api) => {\n    patchEvent(global, api);\n    eventTargetPatch(global, api);\n    // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener\n    const XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget'];\n    if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) {\n        api.patchEventTarget(global, api, [XMLHttpRequestEventTarget.prototype]);\n    }\n});\nZone.__load_patch('MutationObserver', (global, Zone, api) => {\n    patchClass('MutationObserver');\n    patchClass('WebKitMutationObserver');\n});\nZone.__load_patch('IntersectionObserver', (global, Zone, api) => {\n    patchClass('IntersectionObserver');\n});\nZone.__load_patch('FileReader', (global, Zone, api) => {\n    patchClass('FileReader');\n});\nZone.__load_patch('on_property', (global, Zone, api) => {\n    propertyDescriptorPatch(api, global);\n});\nZone.__load_patch('customElements', (global, Zone, api) => {\n    patchCustomElements(global, api);\n});\nZone.__load_patch('XHR', (global, Zone) => {\n    // Treat XMLHttpRequest as a macrotask.\n    patchXHR(global);\n    const XHR_TASK = zoneSymbol('xhrTask');\n    const XHR_SYNC = zoneSymbol('xhrSync');\n    const XHR_LISTENER = zoneSymbol('xhrListener');\n    const XHR_SCHEDULED = zoneSymbol('xhrScheduled');\n    const XHR_URL = zoneSymbol('xhrURL');\n    const XHR_ERROR_BEFORE_SCHEDULED = zoneSymbol('xhrErrorBeforeScheduled');\n    function patchXHR(window) {\n        const XMLHttpRequest = window['XMLHttpRequest'];\n        if (!XMLHttpRequest) {\n            // XMLHttpRequest is not available in service worker\n            return;\n        }\n        const XMLHttpRequestPrototype = XMLHttpRequest.prototype;\n        function findPendingTask(target) {\n            return target[XHR_TASK];\n        }\n        let oriAddListener = XMLHttpRequestPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n        let oriRemoveListener = XMLHttpRequestPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n        if (!oriAddListener) {\n            const XMLHttpRequestEventTarget = window['XMLHttpRequestEventTarget'];\n            if (XMLHttpRequestEventTarget) {\n                const XMLHttpRequestEventTargetPrototype = XMLHttpRequestEventTarget.prototype;\n                oriAddListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n                oriRemoveListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n            }\n        }\n        const READY_STATE_CHANGE = 'readystatechange';\n        const SCHEDULED = 'scheduled';\n        function scheduleTask(task) {\n            const data = task.data;\n            const target = data.target;\n            target[XHR_SCHEDULED] = false;\n            target[XHR_ERROR_BEFORE_SCHEDULED] = false;\n            // remove existing event listener\n            const listener = target[XHR_LISTENER];\n            if (!oriAddListener) {\n                oriAddListener = target[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n                oriRemoveListener = target[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n            }\n            if (listener) {\n                oriRemoveListener.call(target, READY_STATE_CHANGE, listener);\n            }\n            const newListener = target[XHR_LISTENER] = () => {\n                if (target.readyState === target.DONE) {\n                    // sometimes on some browsers XMLHttpRequest will fire onreadystatechange with\n                    // readyState=4 multiple times, so we need to check task state here\n                    if (!data.aborted && target[XHR_SCHEDULED] && task.state === SCHEDULED) {\n                        // check whether the xhr has registered onload listener\n                        // if that is the case, the task should invoke after all\n                        // onload listeners finish.\n                        // Also if the request failed without response (status = 0), the load event handler\n                        // will not be triggered, in that case, we should also invoke the placeholder callback\n                        // to close the XMLHttpRequest::send macroTask.\n                        // https://github.com/angular/angular/issues/38795\n                        const loadTasks = target[Zone.__symbol__('loadfalse')];\n                        if (target.status !== 0 && loadTasks && loadTasks.length > 0) {\n                            const oriInvoke = task.invoke;\n                            task.invoke = function () {\n                                // need to load the tasks again, because in other\n                                // load listener, they may remove themselves\n                                const loadTasks = target[Zone.__symbol__('loadfalse')];\n                                for (let i = 0; i < loadTasks.length; i++) {\n                                    if (loadTasks[i] === task) {\n                                        loadTasks.splice(i, 1);\n                                    }\n                                }\n                                if (!data.aborted && task.state === SCHEDULED) {\n                                    oriInvoke.call(task);\n                                }\n                            };\n                            loadTasks.push(task);\n                        }\n                        else {\n                            task.invoke();\n                        }\n                    }\n                    else if (!data.aborted && target[XHR_SCHEDULED] === false) {\n                        // error occurs when xhr.send()\n                        target[XHR_ERROR_BEFORE_SCHEDULED] = true;\n                    }\n                }\n            };\n            oriAddListener.call(target, READY_STATE_CHANGE, newListener);\n            const storedTask = target[XHR_TASK];\n            if (!storedTask) {\n                target[XHR_TASK] = task;\n            }\n            sendNative.apply(target, data.args);\n            target[XHR_SCHEDULED] = true;\n            return task;\n        }\n        function placeholderCallback() { }\n        function clearTask(task) {\n            const data = task.data;\n            // Note - ideally, we would call data.target.removeEventListener here, but it's too late\n            // to prevent it from firing. So instead, we store info for the event listener.\n            data.aborted = true;\n            return abortNative.apply(data.target, data.args);\n        }\n        const openNative = patchMethod(XMLHttpRequestPrototype, 'open', () => function (self, args) {\n            self[XHR_SYNC] = args[2] == false;\n            self[XHR_URL] = args[1];\n            return openNative.apply(self, args);\n        });\n        const XMLHTTPREQUEST_SOURCE = 'XMLHttpRequest.send';\n        const fetchTaskAborting = zoneSymbol('fetchTaskAborting');\n        const fetchTaskScheduling = zoneSymbol('fetchTaskScheduling');\n        const sendNative = patchMethod(XMLHttpRequestPrototype, 'send', () => function (self, args) {\n            if (Zone.current[fetchTaskScheduling] === true) {\n                // a fetch is scheduling, so we are using xhr to polyfill fetch\n                // and because we already schedule macroTask for fetch, we should\n                // not schedule a macroTask for xhr again\n                return sendNative.apply(self, args);\n            }\n            if (self[XHR_SYNC]) {\n                // if the XHR is sync there is no task to schedule, just execute the code.\n                return sendNative.apply(self, args);\n            }\n            else {\n                const options = { target: self, url: self[XHR_URL], isPeriodic: false, args: args, aborted: false };\n                const task = scheduleMacroTaskWithCurrentZone(XMLHTTPREQUEST_SOURCE, placeholderCallback, options, scheduleTask, clearTask);\n                if (self && self[XHR_ERROR_BEFORE_SCHEDULED] === true && !options.aborted &&\n                    task.state === SCHEDULED) {\n                    // xhr request throw error when send\n                    // we should invoke task instead of leaving a scheduled\n                    // pending macroTask\n                    task.invoke();\n                }\n            }\n        });\n        const abortNative = patchMethod(XMLHttpRequestPrototype, 'abort', () => function (self, args) {\n            const task = findPendingTask(self);\n            if (task && typeof task.type == 'string') {\n                // If the XHR has already completed, do nothing.\n                // If the XHR has already been aborted, do nothing.\n                // Fix #569, call abort multiple times before done will cause\n                // macroTask task count be negative number\n                if (task.cancelFn == null || (task.data && task.data.aborted)) {\n                    return;\n                }\n                task.zone.cancelTask(task);\n            }\n            else if (Zone.current[fetchTaskAborting] === true) {\n                // the abort is called from fetch polyfill, we need to call native abort of XHR.\n                return abortNative.apply(self, args);\n            }\n            // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no\n            // task\n            // to cancel. Do nothing.\n        });\n    }\n});\nZone.__load_patch('geolocation', (global) => {\n    /// GEO_LOCATION\n    if (global['navigator'] && global['navigator'].geolocation) {\n        patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);\n    }\n});\nZone.__load_patch('PromiseRejectionEvent', (global, Zone) => {\n    // handle unhandled promise rejection\n    function findPromiseRejectionHandler(evtName) {\n        return function (e) {\n            const eventTasks = findEventTasks(global, evtName);\n            eventTasks.forEach(eventTask => {\n                // windows has added unhandledrejection event listener\n                // trigger the event listener\n                const PromiseRejectionEvent = global['PromiseRejectionEvent'];\n                if (PromiseRejectionEvent) {\n                    const evt = new PromiseRejectionEvent(evtName, { promise: e.promise, reason: e.rejection });\n                    eventTask.invoke(evt);\n                }\n            });\n        };\n    }\n    if (global['PromiseRejectionEvent']) {\n        Zone[zoneSymbol('unhandledPromiseRejectionHandler')] =\n            findPromiseRejectionHandler('unhandledrejection');\n        Zone[zoneSymbol('rejectionHandledHandler')] =\n            findPromiseRejectionHandler('rejectionhandled');\n    }\n});\nZone.__load_patch('queueMicrotask', (global, Zone, api) => {\n    patchQueueMicrotask(global, api);\n});\n"],"x_google_ignoreList":[1,2,3,4,5,6]}