thrownewError('Could not dynamically require "'+target+'". Please configure the dynamicRequireTargets option of @rollup/plugin-commonjs appropriately for this require call to behave properly.');
(function(root,factory){if(module.exports){module.exports=factory();}else{root.moo=factory();}})(commonjsGlobal,function(){varhasOwnProperty=Object.prototype.hasOwnProperty;vartoString=Object.prototype.toString;varhasSticky=typeofnewRegExp().sticky==='boolean';/***************************************************************************/functionisRegExp(o){returno&&toString.call(o)==='[object RegExp]';}functionisObject(o){returno&&typeofo==='object'&&!isRegExp(o)&&!Array.isArray(o);}functionreEscape(s){returns.replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&');}functionreGroups(s){varre=newRegExp('|'+s);returnre.exec('').length-1;}functionreCapture(s){return'('+s+')';}functionreUnion(regexps){if(!regexps.length)return'(?!)';varsource=regexps.map(function(s){return"(?:"+s+")";}).join('|');return"(?:"+source+")";}functionregexpOrLiteral(obj){if(typeofobj==='string'){return'(?:'+reEscape(obj)+')';}elseif(isRegExp(obj)){// TODO: consider /u support
if(obj.ignoreCase)thrownewError('RegExp /i flag not allowed');if(obj.global)thrownewError('RegExp /g flag is implied');if(obj.sticky)thrownewError('RegExp /y flag is implied');if(obj.multiline)thrownewError('RegExp /m flag is implied');returnobj.source;}else{thrownewError('Not a pattern: '+obj);}}functionobjectToRules(object){varkeys=Object.getOwnPropertyNames(object);varresult=[];for(vari=0;i<keys.length;i++){varkey=keys[i];varthing=object[key];varrules=[].concat(thing);if(key==='include'){for(varj=0;j<rules.length;j++){result.push({include:rules[j]});}continue;}varmatch=[];rules.forEach(function(rule){if(isObject(rule)){if(match.length)result.push(ruleOptions(key,match));result.push(ruleOptions(key,rule));match=[];}else{match.push(rule);}});if(match.length)result.push(ruleOptions(key,match));}returnresult;}functionarrayToRules(array){varresult=[];for(vari=0;i<array.length;i++){varobj=array[i];if(obj.include){varinclude=[].concat(obj.include);for(varj=0;j<include.length;j++){result.push({include:include[j]});}continue;}if(!obj.type){thrownewError('Rule has no type: '+JSON.stringify(obj));}result.push(ruleOptions(obj.type,obj));}returnresult;}functionruleOptions(type,obj){if(!isObject(obj)){obj={match:obj};}if(obj.include){thrownewError('Matching rules cannot also include states');}// nb. error and fallback imply lineBreaks
varoptions={defaultType:type,lineBreaks:!!obj.error||!!obj.fallback,pop:false,next:null,push:null,error:false,fallback:false,value:null,type:null,shouldThrow:false};// Avoid Object.assign(), so we support IE9+
for(varkeyinobj){if(hasOwnProperty.call(obj,key)){options[key]=obj[key];}}// type transform cannot be a string
if(typeofoptions.type==='string'&&type!==options.type){thrownewError("Type transform cannot be a string (type '"+options.type+"' for token '"+type+"')");}// convert to array
varmatch=options.match;options.match=Array.isArray(match)?match:match?[match]:[];options.match.sort(function(a,b){returnisRegExp(a)&&isRegExp(b)?0:isRegExp(b)?-1:isRegExp(a)?+1:b.length-a.length;});returnoptions;}functiontoRules(spec){returnArray.isArray(spec)?arrayToRules(spec):objectToRules(spec);}vardefaultErrorRule=ruleOptions('error',{lineBreaks:true,shouldThrow:true});functioncompileRules(rules,hasStates){varerrorRule=null;varfast=Object.create(null);varfastAllowed=true;varunicodeFlag=null;vargroups=[];varparts=[];// If there is a fallback rule, then disable fast matching
for(vari=0;i<rules.length;i++){if(rules[i].fallback){fastAllowed=false;}}for(vari=0;i<rules.length;i++){varoptions=rules[i];if(options.include){// all valid inclusions are removed by states() preprocessor
thrownewError('Inheritance is not allowed in stateless lexers');}if(options.error||options.fallback){// errorRule can only be set once
if(errorRule){if(!options.fallback===!errorRule.fallback){thrownewError("Multiple "+(options.fallback?"fallback":"error")+" rules not allowed (for token '"+options.defaultType+"')");}else{thrownewError("fallback and error are mutually exclusive (for token '"+options.defaultType+"')");}}errorRule=options;}varmatch=options.match.slice();if(fastAllowed){while(match.length&&typeofmatch[0]==='string'&&match[0].length===1){varword=match.shift();fast[word.charCodeAt(0)]=options;}}// Warn about inappropriate state-switching options
if(options.pop||options.push||options.next){if(!hasStates){thrownewError("State-switching options are not allowed in stateless lexers (for token '"+options.defaultType+"')");}if(options.fallback){thrownewError("State-switching options are not allowed on fallback tokens (for token '"+options.defaultType+"')");}}// Only rules with a .match are included in the RegExp
if(match.length===0){continue;}fastAllowed=false;groups.push(options);// Check unicode flag is used everywhere or nowhere
for(varj=0;j<match.length;j++){varobj=match[j];if(!isRegExp(obj)){continue;}if(unicodeFlag===null){unicodeFlag=obj.unicode;}elseif(unicodeFlag!==obj.unicode&&options.fallback===false){thrownewError('If one rule is /u then all must be');}}// convert to RegExp
varregexp=newRegExp(pat);if(regexp.test("")){thrownewError("RegExp matches empty string: "+regexp);}vargroupCount=reGroups(pat);if(groupCount>0){thrownewError("RegExp has capture groups: "+regexp+"\nUse (?: … ) instead");}// try and detect rules matching newlines
if(!options.lineBreaks&®exp.test('\n')){thrownewError('Rule should declare lineBreaks: '+regexp);}// store regex
parts.push(reCapture(pat));}// If there's no fallback rule, use the sticky flag so we only look for
// matches at the current index.
//
// If we don't support the sticky flag, then fake it using an irrefutable
// match (i.e. an empty pattern).
varfallbackRule=errorRule&&errorRule.fallback;varflags=hasSticky&&!fallbackRule?'ym':'gm';varsuffix=hasSticky||fallbackRule?'':'|';if(unicodeFlag===true)flags+="u";varcombined=newRegExp(reUnion(parts)+suffix,flags);return{regexp:combined,groups:groups,fast:fast,error:errorRule||defaultErrorRule};}functioncompile(rules){varresult=compileRules(toRules(rules));returnnewLexer({start:result},'start');}functioncheckStateGroup(g,name,map){varstate=g&&(g.push||g.next);if(state&&!map[state]){thrownewError("Missing state '"+state+"' (in token '"+g.defaultType+"' of state '"+name+"')");}if(g&&g.pop&&+g.pop!==1){thrownewError("pop must be 1 (in token '"+g.defaultType+"' of state '"+name+"')");}}functioncompileStates(states,start){varall=states.$all?toRules(states.$all):[];deletestates.$all;varkeys=Object.getOwnPropertyNames(states);if(!start)start=keys[0];varruleMap=Object.create(null);for(vari=0;i<keys.length;i++){varkey=keys[i];ruleMap[key]=toRules(states[key]).concat(all);}for(vari=0;i<keys.length;i++){varkey=keys[i];varrules=ruleMap[key];varincluded=Object.create(null);for(varj=0;j<rules.length;j++){varrule=rules[j];if(!rule.include)continue;varsplice=[j,1];if(rule.include!==key&&!included[rule.include]){included[rule.include]=true;varnewRules=ruleMap[rule.include];if(!newRules){thrownewError("Cannot include nonexistent state '"+rule.include+"' (in state '"+key+"')");}for(vark=0;k<newRules.length;k++){varnewRule=newRules[k];if(rules.indexOf(newRule)!==-1)continue;splice.push(newRule);}}rules.splice.apply(rules,splice);j--;}}varmap=Object.create(null);for(vari=0;i<keys.length;i++){varkey=keys[i];map[key]=compileRules(ruleMap[key],true);}for(vari=0;i<keys.length;i++){varname=keys[i];varstate=map[name];vargroups=state.groups;for(varj=0;j<groups.length;j++){checkStateGroup(groups[j],name,map);}varfastKeys=Object.getOwnPropertyNames(state.fast);for(varj=0;j<fastKeys.length;j++){checkStateGroup(state.fast[fastKeys[j]],name,map);}}returnnewLexer(map,start);}functionkeywordTransform(map){varreverseMap=Object.create(null);varbyLength=Object.create(null);vartypes=Object.getOwnPropertyNames(map);for(vari=0;i<types.length;i++){vartokenType=types[i];varitem=map[tokenType];varkeywordList=Array.isArray(item)?item:[item];keywordList.forEach(function(keyword){(byLength[keyword.length]=byLength[keyword.length]||[]).push(keyword);if(typeofkeyword!=='string'){thrownewError("keyword must be string (in keyword '"+tokenType+"')");}reverseMap[keyword]=tokenType;});}// fast string lookup
// https://jsperf.com/string-lookups
functionstr(x){returnJSON.stringify(x);}varsource='';source+='switch (value.length) {\n';for(varlengthinbyLength){varkeywords=byLength[length];source+='case '+length+':\n';source+='switch (value) {\n';keywords.forEach(function(keyword){vartokenType=reverseMap[keyword];source+='case '+str(keyword)+': return '+str(tokenType)+'\n';});source+='}\n';}source+='}\n';returnFunction('value',source);// type
}/***************************************************************************/varLexer=function(states,state){this.startState=state;this.states=states;this.buffer='';this.stack=[];this.reset();};Lexer.prototype.reset=function(data,info){this.buffer=data||'';this.index=0;this.line=info?info.line:1;this.col=info?info.col:1;this.queuedToken=info?info.queuedToken:null;this.queuedThrow=info?info.queuedThrow:null;this.setState(info?info.state:this.startState);this.stack=info&&info.stack?info.stack.slice():[];returnthis;};Lexer.prototype.save=function(){return{line:this.line,col:this.col,state:this.state,stack:this.stack.slice(),queuedToken:this.queuedToken,queuedThrow:this.queuedThrow};};Lexer.prototype.setState=function(state){if(!state||this.state===state)return;this.state=state;varinfo=this.states[state];this.groups=info.groups;this.error=info.error;this.re=info.regexp;this.fast=info.fast;};Lexer.prototype.popState=function(){this.setState(this.stack.pop());};Lexer.prototype.pushState=function(state){this.stack.push(this.state);this.setState(state);};vareat=hasSticky?function(re,buffer){// assume re is /y
returnre.exec(buffer);}:function(re,buffer){// assume re is /g
varmatch=re.exec(buffer);// will always match, since we used the |(?:) trick
if(match[0].length===0){returnnull;}returnmatch;};Lexer.prototype._getGroup=function(match){vargroupCount=this.groups.length;for(vari=0;i<groupCount;i++){if(match[i+1]!==undefined){returnthis.groups[i];}}thrownewError('Cannot find token type for matched text');};functiontokenToString(){returnthis.value;}Lexer.prototype.next=function(){varindex=this.index;// If a fallback token matched, we don't need to re-run the RegExp
varre=this.re;re.lastIndex=index;varmatch=eat(re,buffer);// Error tokens match the remaining buffer
varerror=this.error;if(match==null){returnthis._token(error,buffer.slice(index,buffer.length),index);}vargroup=this._getGroup(match);vartext=match[0];if(error.fallback&&match.index!==index){this.queuedGroup=group;this.queuedText=text;// Fallback tokens contain the unmatched portion of the buffer
returnthis._token(error,buffer.slice(index,match.index),index);}returnthis._token(group,text,index);};Lexer.prototype._token=function(group,text,offset){// count line breaks
varlineBreaks=0;if(group.lineBreaks){varmatchNL=/\n/g;varnl=1;if(text==='\n'){lineBreaks=1;}else{while(matchNL.exec(text)){lineBreaks++;nl=matchNL.lastIndex;}}}vartoken={type:typeofgroup.type==='function'&&group.type(text)||group.defaultType,value:typeofgroup.value==='function'?group.value(text):text,text:text,toString:tokenToString,offset:offset,lineBreaks:lineBreaks,line:this.line,col:this.col};// nb. adding more props to token object will make V8 sad!
varsize=text.length;this.index+=size;this.line+=lineBreaks;if(lineBreaks!==0){this.col=size-nl+1;}else{this.col+=size;}// throw, if no rule with {error: true}
if(group.shouldThrow){thrownewError(this.formatError(token,"invalid syntax"));}if(group.pop)this.popState();elseif(group.push)this.pushState(group.push);elseif(group.next)this.setState(group.next);returntoken;};if(typeofSymbol!=='undefined'&&Symbol.iterator){varLexerIterator=function(lexer){this.lexer=lexer;};LexerIterator.prototype.next=function(){vartoken=this.lexer.next();return{value:token,done:!token};};LexerIterator.prototype[Symbol.iterator]=function(){returnthis;};Lexer.prototype[Symbol.iterator]=function(){returnnewLexerIterator(this);};}Lexer.prototype.formatError=function(token,message){if(token==null){// An undefined token indicates EOF
vartext=this.buffer.slice(this.index);vartoken={text:text,offset:this.index,lineBreaks:text.indexOf('\n')===-1?0:1,line:this.line,col:this.col};}varstart=Math.max(0,token.offset-token.col+1);vareol=token.lineBreaks?token.text.indexOf('\n'):token.text.length;varfirstLine=this.buffer.substring(start,token.offset+eol);message+=" at line "+token.line+" col "+token.col+":\n\n";message+=" "+firstLine+"\n";message+=" "+Array(token.col).join(" ")+"^";returnmessage;};Lexer.prototype.clone=function(){returnnewLexer(this.states,this.state);};Lexer.prototype.has=function(tokenType){returntrue;};return{compile:compile,states:compileStates,error:Object.freeze({error:true}),fallback:Object.freeze({fallback:true}),keywords:keywordTransform};});
(function(){/** Used as a safe reference for `undefined` in pre-ES5 environments. */varundefined$1;/** Used as the semantic version number. */varVERSION='4.17.21';/** Used as the size to enable large array optimizations. */varLARGE_ARRAY_SIZE=200;/** Error message constants. */varCORE_ERROR_TEXT='Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',FUNC_ERROR_TEXT='Expected a function',INVALID_TEMPL_VAR_ERROR_TEXT='Invalid `variable` option passed into `_.template`';/** Used to stand-in for `undefined` hash values. */varHASH_UNDEFINED='__lodash_hash_undefined__';/** Used as the maximum memoize cache size. */varMAX_MEMOIZE_SIZE=500;/** Used as the internal argument placeholder. */varPLACEHOLDER='__lodash_placeholder__';/** Used to compose bitmasks for cloning. */varCLONE_DEEP_FLAG=1,CLONE_FLAT_FLAG=2,CLONE_SYMBOLS_FLAG=4;/** Used to compose bitmasks for value comparisons. */varCOMPARE_PARTIAL_FLAG=1,COMPARE_UNORDERED_FLAG=2;/** Used to compose bitmasks for function metadata. */varWRAP_BIND_FLAG=1,WRAP_BIND_KEY_FLAG=2,WRAP_CURRY_BOUND_FLAG=4,WRAP_CURRY_FLAG=8,WRAP_CURRY_RIGHT_FLAG=16,WRAP_PARTIAL_FLAG=32,WRAP_PARTIAL_RIGHT_FLAG=64,WRAP_ARY_FLAG=128,WRAP_REARG_FLAG=256,WRAP_FLIP_FLAG=512;/** Used as default options for `_.truncate`. */varDEFAULT_TRUNC_LENGTH=30,DEFAULT_TRUNC_OMISSION='...';/** Used to detect hot functions by number of calls within a span of milliseconds. */varHOT_COUNT=800,HOT_SPAN=16;/** Used to indicate the type of lazy iteratees. */varLAZY_FILTER_FLAG=1,LAZY_MAP_FLAG=2,LAZY_WHILE_FLAG=3;/** Used as references for various `Number` constants. */varINFINITY=1/0,MAX_SAFE_INTEGER=9007199254740991,MAX_INTEGER=1.7976931348623157e+308,NAN=0/0;/** Used as references for the maximum length and index of an array. */varMAX_ARRAY_LENGTH=4294967295,MAX_ARRAY_INDEX=MAX_ARRAY_LENGTH-1,HALF_MAX_ARRAY_LENGTH=MAX_ARRAY_LENGTH>>>1;/** Used to associate wrap methods with their bit flags. */varwrapFlags=[['ary',WRAP_ARY_FLAG],['bind',WRAP_BIND_FLAG],['bindKey',WRAP_BIND_KEY_FLAG],['curry',WRAP_CURRY_FLAG],['curryRight',WRAP_CURRY_RIGHT_FLAG],['flip',WRAP_FLIP_FLAG],['partial',WRAP_PARTIAL_FLAG],['partialRight',WRAP_PARTIAL_RIGHT_FLAG],['rearg',WRAP_REARG_FLAG]];/** `Object#toString` result references. */varargsTag='[object Arguments]',arrayTag='[object Array]',asyncTag='[object AsyncFunction]',boolTag='[object Boolean]',dateTag='[object Date]',domExcTag='[object DOMException]',errorTag='[object Error]',funcTag='[object Function]',genTag='[object GeneratorFunction]',mapTag='[object Map]',numberTag='[object Number]',nullTag='[object Null]',objectTag='[object Object]',promiseTag='[object Promise]',proxyTag='[object Proxy]',regexpTag='[object RegExp]',setTag='[object Set]',stringTag='[object String]',symbolTag='[object Symbol]',undefinedTag='[object Undefined]',weakMapTag='[object WeakMap]',weakSetTag='[object WeakSet]';vararrayBufferTag='[object ArrayBuffer]',dataViewTag='[object DataView]',float32Tag='[object Float32Array]',float64Tag='[object Float64Array]',int8Tag='[object Int8Array]',int16Tag='[object Int16Array]',int32Tag='[object Int32Array]',uint8Tag='[object Uint8Array]',uint8ClampedTag='[object Uint8ClampedArray]',uint16Tag='[object Uint16Array]',uint32Tag='[object Uint32Array]';/** Used to match empty string literals in compiled template source. */varreEmptyStringLeading=/\b__p \+= '';/g,reEmptyStringMiddle=/\b(__p \+=) '' \+/g,reEmptyStringTrailing=/(__e\(.*?\)|\b__t\)) \+\n'';/g;/** Used to match HTML entities and HTML characters. */varreEscapedHtml=/&(?:amp|lt|gt|quot|#39);/g,reUnescapedHtml=/[&<>"']/g,reHasEscapedHtml=RegExp(reEscapedHtml.source),reHasUnescapedHtml=RegExp(reUnescapedHtml.source);/** Used to match template delimiters. */varreEscape=/<%-([\s\S]+?)%>/g,reEvaluate=/<%([\s\S]+?)%>/g,reInterpolate=/<%=([\s\S]+?)%>/g;/** Used to match property names within property paths. */varreIsDeepProp=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,reIsPlainProp=/^\w*$/,rePropName=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;/
*/var reRegExpChar=/[\\^$.*+?()[\]{}|]/g,reHasRegExpChar=RegExp(reRegExpChar.source);/** Used to match leading whitespace. */varreTrimStart=/^\s+/;/** Used to match a single whitespace character. */varreWhitespace=/\s/;/** Used to match wrap detail comments. */varreWrapComment=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,reWrapDetails=/\{\n\/\* \[wrapped with (.+)\] \*/,reSplitDetails=/,? & /;/** Used to match words composed of alphanumeric characters. */varreAsciiWord=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;/**
*/var reEsTemplate=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;/** Used to match `RegExp` flags from their coerced string values. */varreFlags=/\w*$/;/** Used to detect bad signed hexadecimal string values. */varreIsBadHex=/^[-+]0x[0-9a-f]+$/i;/** Used to detect binary string values. */varreIsBinary=/^0b[01]+$/i;/** Used to detect host constructors (Safari). */varreIsHostCtor=/^\[object .+?Constructor\]$/;/** Used to detect octal string values. */varreIsOctal=/^0o[0-7]+$/i;/** Used to detect unsigned integer values. */varreIsUint=/^(?:0|[1-9]\d*)$/;/** Used to match Latin Unicode letters (excluding mathematical operators). */varreLatin=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;/** Used to ensure capturing order of template delimiters. */varreNoMatch=/($^)/;/** Used to match unescaped characters in compiled string literals. */varreUnescapedString=/['\n\r\u2028\u2029\\]/g;/** Used to compose unicode character classes. */varrsAstralRange='\\ud800-\\udfff',rsComboMarksRange='\\u0300-\\u036f',reComboHalfMarksRange='\\ufe20-\\ufe2f',rsComboSymbolsRange='\\u20d0-\\u20ff',rsComboRange=rsComboMarksRange+reComboHalfMarksRange+rsComboSymbolsRange,rsDingbatRange='\\u2700-\\u27bf',rsLowerRange='a-z\\xdf-\\xf6\\xf8-\\xff',rsMathOpRange='\\xac\\xb1\\xd7\\xf7',rsNonCharRange='\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',rsPunctuationRange='\\u2000-\\u206f',rsSpaceRange=' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',rsUpperRange='A-Z\\xc0-\\xd6\\xd8-\\xde',rsVarRange='\\ufe0e\\ufe0f',rsBreakRange=rsMathOpRange+rsNonCharRange+rsPunctuationRange+rsSpaceRange;/** Used to compose unicode capture groups. */varrsApos="['\u2019]",rsAstral='['+rsAstralRange+']',rsBreak='['+rsBreakRange+']',rsCombo='['+rsComboRange+']',rsDigits='\\d+',rsDingbat='['+rsDingbatRange+']',rsLower='['+rsLowerRange+']',rsMisc='[^'+rsAstralRange+rsBreakRange+rsDigits+rsDingbatRange+rsLowerRange+rsUpperRange+']',rsFitz='\\ud83c[\\udffb-\\udfff]',rsModifier='(?:'+rsCombo+'|'+rsFitz+')',rsNonAstral='[^'+rsAstralRange+']',rsRegional='(?:\\ud83c[\\udde6-\\uddff]){2}',rsSurrPair='[\\ud800-\\udbff][\\udc00-\\udfff]',rsUpper='['+rsUpperRange+']',rsZWJ='\\u200d';/** Used to compose unicode regexes. */varrsMiscLower='(?:'+rsLower+'|'+rsMisc+')',rsMiscUpper='(?:'+rsUpper+'|'+rsMisc+')',rsOptContrLower='(?:'+rsApos+'(?:d|ll|m|re|s|t|ve))?',rsOptContrUpper='(?:'+rsApos+'(?:D|LL|M|RE|S|T|VE))?',reOptMod=rsModifier+'?',rsOptVar='['+rsVarRange+']?',rsOptJoin='(?:'+rsZWJ+'(?:'+[rsNonAstral,rsRegional,rsSurrPair].join('|')+')'+rsOptVar+reOptMod+')*',rsOrdLower='\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',rsOrdUpper='\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',rsSeq=rsOptVar+reOptMod+rsOptJoin,rsEmoji='(?:'+[rsDingbat,rsRegional,rsSurrPair].join('|')+')'+rsSeq,rsSymbol='(?:'+[rsNonAstral+rsCombo+'?',rsCombo,rsRegional,rsSurrPair,rsAstral].join('|')+')';/** Used to match apostrophes. */varreApos=RegExp(rsApos,'g');/**
*/var reComboMark=RegExp(rsCombo,'g');/**Usedtomatch[stringsymbols](https://mathiasbynens.be/notes/javascript-unicode). */var reUnicode=RegExp(rsFitz+'(?='+rsFitz+')|'+rsSymbol+rsSeq,'g');/** Used to match complex or compound words. */var reUnicodeWord=RegExp([rsUpper+'?'+rsLower+'+'+rsOptContrLower+'(?='+[rsBreak,rsUpper,'$'].join('|')+')',rsMiscUpper+'+'+rsOptContrUpper+'(?='+[rsBreak,rsUpper+rsMiscLower,'$'].join('|')+')',rsUpper+'?'+rsMiscLower+'+'+rsOptContrLower,rsUpper+'+'+rsOptContrUpper,rsOrdUpper,rsOrdLower,rsDigits,rsEmoji].join('|'),'g');/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */var reHasUnicode=RegExp('['+rsZWJ+rsAstralRange+rsComboRange+rsVarRange+']');/** Used to detect strings that need a more robust regexp to match words. */var reHasUnicodeWord=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;/** Used to assign default `context` object properties. */var contextProps=['Array','Buffer','DataView','Date','Error','Float32Array','Float64Array','Function','Int8Array','Int16Array','Int32Array','Map','Math','Object','Promise','RegExp','Set','String','Symbol','TypeError','Uint8Array','Uint8ClampedArray','Uint16Array','Uint32Array','WeakMap','_','clearTimeout','isFinite','parseInt','setTimeout'];/** Used to make template sourceURLs easier to identify. */var templateCounter=-1;/** Used to identify `toStringTag` values of typed arrays. */var typedArrayTags={};typedArrayTags[float32Tag]=typedArrayTags[float64Tag]=typedArrayTags[int8Tag]=typedArrayTags[int16Tag]=typedArrayTags[int32Tag]=typedArrayTags[uint8Tag]=typedArrayTags[uint8ClampedTag]=typedArrayTags[uint16Tag]=typedArrayTags[uint32Tag]=true;typedArrayTags[argsTag]=typedArrayTags[arrayTag]=typedArrayTags[arrayBufferTag]=typedArrayTags[boolTag]=typedArrayTags[dataViewTag]=typedArrayTags[dateTag]=typedArrayTags[errorTag]=typedArrayTags[funcTag]=typedArrayTags[mapTag]=typedArrayTags[numberTag]=typedArrayTags[objectTag]=typedArrayTags[regexpTag]=typedArrayTags[setTag]=typedArrayTags[stringTag]=typedArrayTags[weakMapTag]=false;/** Used to identify `toStringTag` values supported by `_.clone`. */var cloneableTags={};cloneableTags[argsTag]=cloneableTags[arrayTag]=cloneableTags[arrayBufferTag]=cloneableTags[dataViewTag]=cloneableTags[boolTag]=cloneableTags[dateTag]=cloneableTags[float32Tag]=cloneableTags[float64Tag]=cloneableTags[int8Tag]=cloneableTags[int16Tag]=cloneableTags[int32Tag]=cloneableTags[mapTag]=cloneableTags[numberTag]=cloneableTags[objectTag]=cloneableTags[regexpTag]=cloneableTags[setTag]=cloneableTags[stringTag]=cloneableTags[symbolTag]=cloneableTags[uint8Tag]=cloneableTags[uint8ClampedTag]=cloneableTags[uint16Tag]=cloneableTags[uint32Tag]=true;cloneableTags[errorTag]=cloneableTags[funcTag]=cloneableTags[weakMapTag]=false;/** Used to map Latin Unicode letters to basic Latin letters. */var deburredLetters={// Latin-1 Supplement block.
'\xc0':'A','\xc1':'A','\xc2':'A','\xc3':'A','\xc4':'A','\xc5':'A','\xe0':'a','\xe1':'a','\xe2':'a','\xe3':'a','\xe4':'a','\xe5':'a','\xc7':'C','\xe7':'c','\xd0':'D','\xf0':'d','\xc8':'E','\xc9':'E','\xca':'E','\xcb':'E','\xe8':'e','\xe9':'e','\xea':'e','\xeb':'e','\xcc':'I','\xcd':'I','\xce':'I','\xcf':'I','\xec':'i','\xed':'i','\xee':'i','\xef':'i','\xd1':'N','\xf1':'n','\xd2':'O','\xd3':'O','\xd4':'O','\xd5':'O','\xd6':'O','\xd8':'O','\xf2':'o','\xf3':'o','\xf4':'o','\xf5':'o','\xf6':'o','\xf8':'o','\xd9':'U','\xda':'U','\xdb':'U','\xdc':'U','\xf9':'u','\xfa':'u','\xfb':'u','\xfc':'u','\xdd':'Y','\xfd':'y','\xff':'y','\xc6':'Ae','\xe6':'ae','\xde':'Th','\xfe':'th','\xdf':'ss',// Latin Extended-A block.
'\u0100':'A','\u0102':'A','\u0104':'A','\u0101':'a','\u0103':'a','\u0105':'a','\u0106':'C','\u0108':'C','\u010a':'C','\u010c':'C','\u0107':'c','\u0109':'c','\u010b':'c','\u010d':'c','\u010e':'D','\u0110':'D','\u010f':'d','\u0111':'d','\u0112':'E','\u0114':'E','\u0116':'E','\u0118':'E','\u011a':'E','\u0113':'e','\u0115':'e','\u0117':'e','\u0119':'e','\u011b':'e','\u011c':'G','\u011e':'G','\u0120':'G','\u0122':'G','\u011d':'g','\u011f':'g','\u0121':'g','\u0123':'g','\u0124':'H','\u0126':'H','\u0125':'h','\u0127':'h','\u0128':'I','\u012a':'I','\u012c':'I','\u012e':'I','\u0130':'I','\u0129':'i','\u012b':'i','\u012d':'i','\u012f':'i','\u0131':'i','\u0134':'J','\u0135':'j','\u0136':'K','\u0137':'k','\u0138':'k','\u0139':'L','\u013b':'L','\u013d':'L','\u013f':'L','\u0141':'L','\u013a':'l','\u013c':'l','\u013e':'l','\u0140':'l','\u0142':'l','\u0143':'N','\u0145':'N','\u0147':'N','\u014a':'N','\u0144':'n','\u0146':'n','\u0148':'n','\u014b':'n','\u014c':'O','\u014e':'O','\u0150':'O','\u014d':'o','\u014f':'o','\u0151':'o','\u0154':'R','\u0156':'R','\u0158':'R','\u0155':'r','\u0157':'r','\u0159':'r','\u015a':'S','\u015c':'S','\u015e':'S','\u0160':'S','\u015b':'s','\u015d':'s','\u015f':'s','\u0161':'s','\u0162':'T','\u0164':'T','\u0166':'T','\u0163':'t','\u0165':'t','\u0167':'t','\u0168':'U','\u016a':'U','\u016c':'U','\u016e':'U','\u0170':'U','\u0172':'U','\u0169':'u','\u016b':'u','\u016d':'u','\u016f':'u','\u0171':'u','\u0173':'u','\u0174':'W','\u0175':'w','\u0176':'Y','\u0177':'y','\u0178':'Y','\u0179':'Z','\u017b':'Z','\u017d':'Z','\u017a':'z','\u017c':'z','\u017e':'z','\u0132':'IJ','\u0133':'ij','\u0152':'Oe','\u0153':'oe','\u0149':"'n",'\u017f':'s'};/** Used to map characters to HTML entities. */varhtmlEscapes={'&':'&','<':'<','>':'>','"':'"',"'":'''};/** Used to map HTML entities to characters. */varhtmlUnescapes={'&':'&','<':'<','>':'>','"':'"',''':"'"};/** Used to escape characters for inclusion in compiled string literals. */varstringEscapes={'\\':'\\',"'":"'",'\n':'n','\r':'r','\u2028':'u2028','\u2029':'u2029'};/** Built-in method references without a dependency on `root`. */varfreeParseFloat=parseFloat,freeParseInt=parseInt;/** Detect free variable `global` from Node.js. */varfreeGlobal=typeofcommonjsGlobal=='object'&&commonjsGlobal&&commonjsGlobal.Object===Object&&commonjsGlobal;/** Detect free variable `self`. */varfreeSelf=typeofself=='object'&&self&&self.Object===Object&&self;/** Used as a reference to the global object. */varroot=freeGlobal||freeSelf||Function('return this')();/** Detect free variable `exports`. */varfreeExports=exports&&!exports.nodeType&&exports;/** Detect free variable `module`. */varfreeModule=freeExports&&'object'=='object'&&module&&!module.nodeType&&module;/** Detect the popular CommonJS extension `module.exports`. */varmoduleExports=freeModule&&freeModule.exports===freeExports;/** Detect free variable `process` from Node.js. */varfreeProcess=moduleExports&&freeGlobal.process;/** Used to access faster Node.js helpers. */varnodeUtil=function(){try{// Use `util.types` for Node.js 10+.
vartypes=freeModule&&freeModule.require&&freeModule.require('util').types;if(types){returntypes;}// Legacy `process.binding('util')` for Node.js < 10.
*/function assignMergeValue(object,key,value){if(value!==undefined$1&&!eq(object[key],value)||value===undefined$1&&!(key in object)){baseAssignValue(object,key,value);}}/**
*/function assignValue(object,key,value){var objValue=object[key];if(!(hasOwnProperty.call(object,key)&&eq(objValue,value))||value===undefined$1&&!(key in object)){baseAssignValue(object,key,value);}}/**
*/function cloneDataView(dataView,isDeep){var buffer=isDeep?cloneArrayBuffer(dataView.buffer):dataView.buffer;return new dataView.constructor(buffer,dataView.byteOffset,dataView.byteLength);}/**
*/function cloneTypedArray(typedArray,isDeep){var buffer=isDeep?cloneArrayBuffer(typedArray.buffer):typedArray.buffer;return new typedArray.constructor(buffer,typedArray.byteOffset,typedArray.length);}/**
returneq(+object,+other);caseerrorTag:returnobject.name==other.name&&object.message==other.message;caseregexpTag:casestringTag:// Coerce regexes to strings and treat strings, primitives and objects,
// as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
// for more details.
returnobject==other+'';casemapTag:varconvert=mapToArray;casesetTag:varisPartial=bitmask&COMPARE_PARTIAL_FLAG;convert||(convert=setToArray);if(object.size!=other.size&&!isPartial){returnfalse;}// Assume cyclic values are equal.
varstacked=stack.get(object);if(stacked){returnstacked==other;}bitmask|=COMPARE_UNORDERED_FLAG;// Recursively compare objects (susceptible to call stack limits).
*/function equalObjects(object,other,bitmask,customizer,equalFunc,stack){var isPartial=bitmask&COMPARE_PARTIAL_FLAG,objProps=getAllKeys(object),objLength=objProps.length,othProps=getAllKeys(other),othLength=othProps.length;if(objLength!=othLength&&!isPartial){return false;}var index=objLength;while(index--){var key=objProps[index];if(!(isPartial?key in other:hasOwnProperty.call(other,key))){return false;}}//Checkthatcyclicvaluesareequal.
varobjStacked=stack.get(object);varothStacked=stack.get(other);if(objStacked&&othStacked){returnobjStacked==other&&othStacked==object;}varresult=true;stack.set(object,other);stack.set(other,object);varskipCtor=isPartial;while(++index<objLength){key=objProps[index];varobjValue=object[key],othValue=other[key];if(customizer){varcompared=isPartial?customizer(othValue,objValue,key,other,object,stack):customizer(objValue,othValue,key,object,other,stack);}// Recursively compare objects (susceptible to call stack limits).
if(!(compared===undefined$1?objValue===othValue||equalFunc(objValue,othValue,bitmask,customizer,stack):compared)){result=false;break;}skipCtor||(skipCtor=key=='constructor');}if(result&&!skipCtor){varobjCtor=object.constructor,othCtor=other.constructor;// Non `Object` object instances with different constructors are not equal.
varvalue=source[3];if(value){varpartials=data[3];data[3]=partials?composeArgs(partials,value,source[4]):value;data[4]=partials?replaceHolders(data[3],PLACEHOLDER):source[4];}// Compose partial right arguments.
value=source[5];if(value){partials=data[5];data[5]=partials?composeArgsRight(partials,value,source[6]):value;data[6]=partials?replaceHolders(data[5],PLACEHOLDER):source[6];}// Use source `argPos` if available.
value=source[7];if(value){data[7]=value;}// Use source `ary` if it's smaller.
if(srcBitmask&WRAP_ARY_FLAG){data[8]=data[8]==null?source[8]:nativeMin(data[8],source[8]);}// Use source `arity` if one is not provided.
if(data[9]==null){data[9]=source[9];}// Use source `func` and merge bitmasks.
lastInvokeTime=time;// Start the timer for the trailing edge.
timerId=setTimeout(timerExpired,wait);// Invoke the leading edge.
returnleading?invokeFunc(time):result;}functionremainingWait(time){vartimeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime,timeWaiting=wait-timeSinceLastCall;returnmaxing?nativeMin(timeWaiting,maxWait-timeSinceLastInvoke):timeWaiting;}functionshouldInvoke(time){vartimeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime;// Either this is the first call, activity has stopped and we're at the
// trailing edge, the system time has gone backwards and we're treating
// it as the trailing edge, or we've hit the `maxWait` limit.
returnlastCallTime===undefined$1||timeSinceLastCall>=wait||timeSinceLastCall<0||maxing&&timeSinceLastInvoke>=maxWait;}functiontimerExpired(){vartime=now();if(shouldInvoke(time)){returntrailingEdge(time);}// Restart the timer.
timerId=setTimeout(timerExpired,remainingWait(time));}functiontrailingEdge(time){timerId=undefined$1;// Only invoke if we have `lastArgs` which means `func` has been
// debounced at least once.
if(trailing&&lastArgs){returninvokeFunc(time);}lastArgs=lastThis=undefined$1;returnresult;}functioncancel(){if(timerId!==undefined$1){clearTimeout(timerId);}lastInvokeTime=0;lastArgs=lastCallTime=lastThis=timerId=undefined$1;}functionflush(){returntimerId===undefined$1?result:trailingEdge(now());}functiondebounced(){vartime=now(),isInvoking=shouldInvoke(time);lastArgs=arguments;lastThis=this;lastCallTime=time;if(isInvoking){if(timerId===undefined$1){returnleadingEdge(lastCallTime);}if(maxing){// Handle invocations in a tight loop.
*/var assign=createAssigner(function(object,source){if(isPrototype(source)||isArrayLike(source)){copyObject(source,keys(source),object);return;}for(var key in source){if(hasOwnProperty.call(source,key)){assignValue(object,key,source[key]);}}});/**
// and Laura Doktorova's doT.js (https://github.com/olado/doT).
varsettings=lodash.templateSettings;if(guard&&isIterateeCall(string,options,guard)){options=undefined$1;}string=toString(string);options=assignInWith({},options,settings,customDefaultsAssignIn);varimports=assignInWith({},options.imports,settings.imports,customDefaultsAssignIn),importsKeys=keys(imports),importsValues=baseValues(imports,importsKeys);varisEscaping,isEvaluating,index=0,interpolate=options.interpolate||reNoMatch,source="__p += '";// Compile the regexp to match each delimiter.
varreDelimiters=RegExp((options.escape||reNoMatch).source+'|'+interpolate.source+'|'+(interpolate===reInterpolate?reEsTemplate:reNoMatch).source+'|'+(options.evaluate||reNoMatch).source+'|$','g');// Use a sourceURL for easier debugging.
// The sourceURL gets injected into the source that's eval-ed, so be careful
// to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in
// and escape the comment, thus injecting code that gets evaled.
varsourceURL='//# sourceURL='+(hasOwnProperty.call(options,'sourceURL')?(options.sourceURL+'').replace(/\s/g,' '):'lodash.templateSources['+++templateCounter+']')+'\n';string.replace(reDelimiters,function(match,escapeValue,interpolateValue,esTemplateValue,evaluateValue,offset){interpolateValue||(interpolateValue=esTemplateValue);// Escape characters that can't be included in string literals.
source+=string.slice(index,offset).replace(reUnescapedString,escapeStringChar);// Replace delimiters with snippets.
if(escapeValue){isEscaping=true;source+="' +\n__e("+escapeValue+") +\n'";}if(evaluateValue){isEvaluating=true;source+="';\n"+evaluateValue+";\n__p += '";}if(interpolateValue){source+="' +\n((__t = ("+interpolateValue+")) == null ? '' : __t) +\n'";}index=offset+match.length;// The JS engine embedded in Adobe products needs `match` returned in
// order to produce the correct `offset` value.
returnmatch;});source+="';\n";// If `variable` is not specified wrap a with-statement around the generated
// code to add the data object to the top of the scope chain.
varvariable=hasOwnProperty.call(options,'variable')&&options.variable;if(!variable){source='with (obj) {\n'+source+'\n}\n';}// Throw an error if a forbidden character was found in `variable`, to prevent
// potential command injection attacks.
elseif(reForbiddenIdentifierChars.test(variable)){thrownewError(INVALID_TEMPL_VAR_ERROR_TEXT);}// Cleanup code by stripping empty strings.
source=(isEvaluating?source.replace(reEmptyStringLeading,''):source).replace(reEmptyStringMiddle,'$1').replace(reEmptyStringTrailing,'$1;');// Frame code as the function body.
source='function('+(variable||'obj')+') {\n'+(variable?'':'obj || (obj = {});\n')+"var __t, __p = ''"+(isEscaping?', __e = _.escape':'')+(isEvaluating?', __j = Array.prototype.join;\n'+"function print() { __p += __j.call(arguments, '') }\n":';\n')+source+'return __p\n}';varresult=attempt(function(){returnFunction(importsKeys,sourceURL+'return '+source).apply(undefined$1,importsValues);});// Provide the compiled function's source by its `toString` method or
// the `source` property as a convenience for inlining compiled templates.
lodash.entries=toPairs;lodash.entriesIn=toPairsIn;lodash.extend=assignIn;lodash.extendWith=assignInWith;// Add methods to `lodash.prototype`.
mixin(lodash,lodash);/*------------------------------------------------------------------------*/// Add methods that return unwrapped values in chain sequences.
arrayEach(['bind','bindKey','curry','curryRight','partial','partialRight'],function(methodName){lodash[methodName].placeholder=lodash;});// Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
arrayEach(['drop','take'],function(methodName,index){LazyWrapper.prototype[methodName]=function(n){n=n===undefined$1?1:nativeMax(toInteger(n),0);varresult=this.__filtered__&&!index?newLazyWrapper(this):this.clone();if(result.__filtered__){result.__takeCount__=nativeMin(n,result.__takeCount__);}else{result.__views__.push({'size':nativeMin(n,MAX_ARRAY_LENGTH),'type':methodName+(result.__dir__<0?'Right':'')});}returnresult;};LazyWrapper.prototype[methodName+'Right']=function(n){returnthis.reverse()[methodName](n).reverse();};});// Add `LazyWrapper` methods that accept an `iteratee` value.
arrayEach(['filter','map','takeWhile'],function(methodName,index){vartype=index+1,isFilter=type==LAZY_FILTER_FLAG||type==LAZY_WHILE_FLAG;LazyWrapper.prototype[methodName]=function(iteratee){varresult=this.clone();result.__iteratees__.push({'iteratee':getIteratee(iteratee,3),'type':type});result.__filtered__=result.__filtered__||isFilter;returnresult;};});// Add `LazyWrapper` methods for `_.head` and `_.last`.
arrayEach(['head','last'],function(methodName,index){vartakeName='take'+(index?'Right':'');LazyWrapper.prototype[methodName]=function(){returnthis[takeName](1).value()[0];};});// Add `LazyWrapper` methods for `_.initial` and `_.tail`.
arrayEach(['initial','tail'],function(methodName,index){vardropName='drop'+(index?'':'Right');LazyWrapper.prototype[methodName]=function(){returnthis.__filtered__?newLazyWrapper(this):this[dropName](1);};});LazyWrapper.prototype.compact=function(){returnthis.filter(identity);};LazyWrapper.prototype.find=function(predicate){returnthis.filter(predicate).head();};LazyWrapper.prototype.findLast=function(predicate){returnthis.reverse().find(predicate);};LazyWrapper.prototype.invokeMap=baseRest(function(path,args){if(typeofpath=='function'){returnnewLazyWrapper(this);}returnthis.map(function(value){returnbaseInvoke(value,path,args);});});LazyWrapper.prototype.reject=function(predicate){returnthis.filter(negate(getIteratee(predicate)));};LazyWrapper.prototype.slice=function(start,end){start=toInteger(start);varresult=this;if(result.__filtered__&&(start>0||end<0)){returnnewLazyWrapper(result);}if(start<0){result=result.takeRight(-start);}elseif(start){result=result.drop(start);}if(end!==undefined$1){end=toInteger(end);result=end<0?result.dropRight(-end):result.take(end-start);}returnresult;};LazyWrapper.prototype.takeRightWhile=function(predicate){returnthis.reverse().takeWhile(predicate).reverse();};LazyWrapper.prototype.toArray=function(){returnthis.take(MAX_ARRAY_LENGTH);};// Add `LazyWrapper` methods to `lodash.prototype`.
baseForOwn(LazyWrapper.prototype,function(func,methodName){varcheckIteratee=/^(?:filter|find|map|reject)|While$/.test(methodName),isTaker=/^(?:head|last)$/.test(methodName),lodashFunc=lodash[isTaker?'take'+(methodName=='last'?'Right':''):methodName],retUnwrapped=isTaker||/^find/.test(methodName);if(!lodashFunc){return;}lodash.prototype[methodName]=function(){varvalue=this.__wrapped__,args=isTaker?[1]:arguments,isLazy=valueinstanceofLazyWrapper,iteratee=args[0],useLazy=isLazy||isArray(value);varinterceptor=function(value){varresult=lodashFunc.apply(lodash,arrayPush([value],args));returnisTaker&&chainAll?result[0]:result;};if(useLazy&&checkIteratee&&typeofiteratee=='function'&&iteratee.length!=1){// Avoid lazy use if the iteratee has a "length" value other than `1`.
isLazy=useLazy=false;}varchainAll=this.__chain__,isHybrid=!!this.__actions__.length,isUnwrapped=retUnwrapped&&!chainAll,onlyLazy=isLazy&&!isHybrid;if(!retUnwrapped&&useLazy){value=onlyLazy?value:newLazyWrapper(this);varresult=func.apply(value,args);result.__actions__.push({'func':thru,'args':[interceptor],'thisArg':undefined$1});returnnewLodashWrapper(result,chainAll);}if(isUnwrapped&&onlyLazy){returnfunc.apply(this,args);}result=this.thru(interceptor);returnisUnwrapped?isTaker?result.value()[0]:result.value():result;};});// Add `Array` methods to `lodash.prototype`.
arrayEach(['pop','push','shift','sort','splice','unshift'],function(methodName){varfunc=arrayProto[methodName],chainName=/^(?:push|sort|unshift)$/.test(methodName)?'tap':'thru',retUnwrapped=/^(?:pop|shift)$/.test(methodName);lodash.prototype[methodName]=function(){varargs=arguments;if(retUnwrapped&&!this.__chain__){varvalue=this.value();returnfunc.apply(isArray(value)?value:[],args);}returnthis[chainName](function(value){returnfunc.apply(isArray(value)?value:[],args);});};});// Map minified method names to their real names.
baseForOwn(LazyWrapper.prototype,function(func,methodName){varlodashFunc=lodash[methodName];if(lodashFunc){varkey=lodashFunc.name+'';if(!hasOwnProperty.call(realNames,key)){realNames[key]=[];}realNames[key].push({'name':methodName,'func':lodashFunc});}});realNames[createHybrid(undefined$1,WRAP_BIND_KEY_FLAG).name]=[{'name':'wrapper','func':undefined$1}];// Add methods to `LazyWrapper`.
LazyWrapper.prototype.clone=lazyClone;LazyWrapper.prototype.reverse=lazyReverse;LazyWrapper.prototype.value=lazyValue;// Add chain sequence methods to the `lodash` wrapper.
Ok.prototype.unwrapOr=function(_v){returnthis.value;};Ok.prototype._unsafeUnwrap=function(){returnthis.value;};Ok.prototype._unsafeUnwrapErr=function(){thrownewError('Called `_unsafeUnwrapErr` on an Ok');};returnOk;}();varErr=/** @class */function(){functionErr(error){var_this=this;this.error=error;this.match=function(_ok,err){returnerr(_this.error);};}Err.prototype.isOk=function(){returnfalse;};Err.prototype.isErr=function(){return!this.isOk();};// eslint-disable-next-line @typescript-eslint/no-unused-vars
Err.prototype.asyncMap=function(_f){returnerrAsync(this.error);};Err.prototype.unwrapOr=function(v){returnv;};Err.prototype._unsafeUnwrap=function(){thrownewError('Called `_unsafeUnwrap` on an Err');};Err.prototype._unsafeUnwrapErr=function(){returnthis.error;};returnErr;}();/*!*****************************************************************************
(function(root,factory){if(module.exports){module.exports=factory();}else{root.nearley=factory();}})(commonjsGlobal,function(){functionRule(name,symbols,postprocess){this.id=++Rule.highestId;this.name=name;this.symbols=symbols;// a list of literal | regex class | nonterminal
this.postprocess=postprocess;returnthis;}Rule.highestId=0;Rule.prototype.toString=function(withCursorAt){varsymbolSequence=typeofwithCursorAt==="undefined"?this.symbols.map(getSymbolShortDisplay).join(' '):this.symbols.slice(0,withCursorAt).map(getSymbolShortDisplay).join(' ')+" ● "+this.symbols.slice(withCursorAt).map(getSymbolShortDisplay).join(' ');returnthis.name+" → "+symbolSequence;};// a State is a rule at a position from a given starting point in the input stream (reference)
functionState(rule,dot,reference,wantedBy){this.rule=rule;this.dot=dot;this.reference=reference;this.data=[];this.wantedBy=wantedBy;this.isComplete=this.dot===rule.symbols.length;}State.prototype.toString=function(){return"{"+this.rule.toString(this.dot)+"}, from: "+(this.reference||0);};State.prototype.nextState=function(child){varstate=newState(this.rule,this.dot+1,this.reference,this.wantedBy);state.left=this;state.right=child;if(state.isComplete){state.data=state.build();// Having right set here will prevent the right state and its children
// form being garbage collected
state.right=undefined;}returnstate;};State.prototype.build=function(){varchildren=[];varnode=this;do{children.push(node.right.data);node=node.left;}while(node.left);children.reverse();returnchildren;};State.prototype.finish=function(){if(this.rule.postprocess){this.data=this.rule.postprocess(this.data,this.reference,Parser.fail);}};functionColumn(grammar,index){this.grammar=grammar;this.index=index;this.states=[];this.wants={};// states indexed by the non-terminal they expect
this.scannable=[];// list of states that expect a token
this.completed={};// states that are nullable
}Column.prototype.process=function(nextColumn){varstates=this.states;varwants=this.wants;varcompleted=this.completed;for(varw=0;w<states.length;w++){// nb. we push() during iteration
if(wants[exp]){wants[exp].push(state);if(completed.hasOwnProperty(exp)){varnulls=completed[exp];for(vari=0;i<nulls.length;i++){varright=nulls[i];this.complete(state,right);}}}else{wants[exp]=[state];this.predict(exp);}}}};Column.prototype.predict=function(exp){varrules=this.grammar.byName[exp]||[];for(vari=0;i<rules.length;i++){varr=rules[i];varwantedBy=this.wants[exp];vars=newState(r,0,this.index,wantedBy);this.states.push(s);}};Column.prototype.complete=function(left,right){varcopy=left.nextState(right);this.states.push(copy);};functionGrammar(rules,start){this.rules=rules;this.start=start||this.rules[0].name;varbyName=this.byName={};this.rules.forEach(function(rule){if(!byName.hasOwnProperty(rule.name)){byName[rule.name]=[];}byName[rule.name].push(rule);});}// So we can allow passing (rules, start) directly to Parser for backwards compatibility
Grammar.fromCompiled=function(rules,start){varlexer=rules.Lexer;if(rules.ParserStart){start=rules.ParserStart;rules=rules.ParserRules;}varrules=rules.map(function(r){returnnewRule(r.name,r.symbols,r.postprocess);});varg=newGrammar(rules,start);g.lexer=lexer;// nb. storing lexer on Grammar is iffy, but unavoidable
returng;};functionStreamLexer(){this.reset("");}StreamLexer.prototype.reset=function(data,state){this.buffer=data;this.index=0;this.line=state?state.line:1;this.lastLineBreak=state?-state.col:0;};StreamLexer.prototype.next=function(){if(this.index<this.buffer.length){varch=this.buffer[this.index++];if(ch==='\n'){this.line+=1;this.lastLineBreak=this.index;}return{value:ch};}};StreamLexer.prototype.save=function(){return{line:this.line,col:this.index-this.lastLineBreak};};StreamLexer.prototype.formatError=function(token,message){// nb. this gets called after consuming the offending token,
// so the culprit is index-1
varbuffer=this.buffer;if(typeofbuffer==='string'){varlines=buffer.split("\n").slice(Math.max(0,this.line-5),this.line);varnextLineBreak=buffer.indexOf('\n',this.index);if(nextLineBreak===-1)nextLineBreak=buffer.length;varcol=this.index-this.lastLineBreak;varlastLineDigits=String(this.line).length;message+=" at line "+this.line+" col "+col+":\n\n";message+=lines.map(function(line,i){returnpad(this.line-lines.length+i+1,lastLineDigits)+" "+line;},this).join("\n");message+="\n"+pad("",lastLineDigits+col)+"^\n";returnmessage;}else{returnmessage+" at index "+(this.index-1);}functionpad(n,length){vars=String(n);returnArray(length-s.length+1).join(" ")+s;}};functionParser(rules,start,options){if(rulesinstanceofGrammar){vargrammar=rules;varoptions=start;}else{vargrammar=Grammar.fromCompiled(rules,start);}this.grammar=grammar;// Read options
this.lexer=this.options.lexer;this.lexerState=undefined;// Setup a table
varcolumn=newColumn(grammar,0);vartable=this.table=[column];// I could be expecting anything.
column.wants[grammar.start]=[];column.predict(grammar.start);// TODO what if start rule is nullable?
column.process();this.current=0;// token index
}// create a reserved token for indicating a parse fail
Parser.fail={};Parser.prototype.feed=function(chunk){varlexer=this.lexer;lexer.reset(chunk,this.lexerState);vartoken;while(true){try{token=lexer.next();if(!token){break;}}catch(e){// Create the next column so that the error reporter
// can display the correctly predicted states.
varnextColumn=newColumn(this.grammar,this.current+1);this.table.push(nextColumn);varerr=newError(this.reportLexerError(e));err.offset=this.current;err.token=e.token;throwerr;}// We add new states to table[current+1]
varcolumn=this.table[this.current];// GC unused states
if(!this.options.keepHistory){deletethis.table[this.current-1];}varn=this.current+1;varnextColumn=newColumn(this.grammar,n);this.table.push(nextColumn);// Advance all tokens that expect the symbol
varliteral=token.text!==undefined?token.text:token.value;varvalue=lexer.constructor===StreamLexer?token.value:token;varscannable=column.scannable;for(varw=scannable.length;w--;){varstate=scannable[w];varexpect=state.rule.symbols[state.dot];// Try to consume the token
// either regex or literal
if(expect.test?expect.test(value):expect.type?expect.type===token.type:expect.literal===literal){// Add it
varnext=state.nextState({data:value,token:token,isToken:true,reference:n-1});nextColumn.states.push(next);}}// Next, for each of the rules, we either
// (a) complete it, and try to see if the reference row expected that
// rule
// (b) predict the next nonterminal it expects by adding that
// nonterminal's start state
// To prevent duplication, we also keep track of rules we have already
// added
nextColumn.process();// If needed, throw an error:
if(nextColumn.states.length===0){// No states at all! This is not good.
varerr=newError(this.reportError(token));err.offset=this.current;err.token=token;throwerr;}// maybe save lexer state
if(this.options.keepHistory){column.lexerState=lexer.save();}this.current++;}if(column){this.lexerState=lexer.save();}// Incrementally keep track of results
this.results=this.finish();// Allow chaining, for whatever it's worth
returnthis;};Parser.prototype.reportLexerError=function(lexerError){vartokenDisplay,lexerMessage;// Planning to add a token property to moo's thrown error
// even on erroring tokens to be used in error display below
vartoken=lexerError.token;if(token){tokenDisplay="input "+JSON.stringify(token.text[0])+" (lexer error)";lexerMessage=this.lexer.formatError(token,"Syntax error");}else{tokenDisplay="input (lexer error)";lexerMessage=lexerError.message;}returnthis.reportErrorCommon(lexerMessage,tokenDisplay);};Parser.prototype.reportError=function(token){vartokenDisplay=(token.type?token.type+" token: ":"")+JSON.stringify(token.value!==undefined?token.value:token);varlexerMessage=this.lexer.formatError(token,"Syntax error");returnthis.reportErrorCommon(lexerMessage,tokenDisplay);};Parser.prototype.reportErrorCommon=function(lexerMessage,tokenDisplay){varlines=[];lines.push(lexerMessage);varlastColumnIndex=this.table.length-2;varlastColumn=this.table[lastColumnIndex];varexpectantStates=lastColumn.states.filter(function(state){varnextSymbol=state.rule.symbols[state.dot];returnnextSymbol&&typeofnextSymbol!=="string";});if(expectantStates.length===0){lines.push('Unexpected '+tokenDisplay+'. I did not expect any more input. Here is the state of my parse table:\n');this.displayStateStack(lastColumn.states,lines);}else{lines.push('Unexpected '+tokenDisplay+'. Instead, I was expecting to see one of the following:\n');// Display a "state stack" for each expectant state
// - which shows you how this state came to be, step by step.
// If there is more than one derivation, we only display the first one.
varstateStacks=expectantStates.map(function(state){returnthis.buildFirstStateStack(state,[])||[state];},this);// Display each state that is expecting a terminal symbol next.
stateStacks.forEach(function(stateStack){varstate=stateStack[0];varnextSymbol=state.rule.symbols[state.dot];varsymbolDisplay=this.getSymbolDisplay(nextSymbol);lines.push('A '+symbolDisplay+' based on:');this.displayStateStack(stateStack,lines);},this);}lines.push("");returnlines.join("\n");};Parser.prototype.displayStateStack=function(stateStack,lines){varlastDisplay;varsameDisplayCount=0;for(varj=0;j<stateStack.length;j++){varstate=stateStack[j];vardisplay=state.rule.toString(state.dot);if(display===lastDisplay){sameDisplayCount++;}else{if(sameDisplayCount>0){lines.push(' ^ '+sameDisplayCount+' more lines identical to this');}sameDisplayCount=0;lines.push(' '+display);}lastDisplay=display;}};Parser.prototype.getSymbolDisplay=function(symbol){returngetSymbolLongDisplay(symbol);};/*
// to eliminate this path from the results, because
// we don't know how to display it meaningfully
returnnull;}if(state.wantedBy.length===0){return[state];}varprevState=state.wantedBy[0];varchildVisited=[state].concat(visited);varchildResult=this.buildFirstStateStack(prevState,childVisited);if(childResult===null){returnnull;}return[state].concat(childResult);};Parser.prototype.save=function(){varcolumn=this.table[this.current];column.lexerState=this.lexerState;returncolumn;};Parser.prototype.restore=function(column){varindex=column.index;this.current=index;this.table[index]=column;this.table.splice(index+1);this.lexerState=column.lexerState;// Incrementally keep track of results
this.results=this.finish();};// nb. deprecated: use save/restore instead!
Parser.prototype.rewind=function(index){if(!this.options.keepHistory){thrownewError('set option `keepHistory` to enable rewinding');}// nb. recall column (table) indicies fall between token indicies.
// col 0 -- token 0 -- col 1
this.restore(this.table[index]);};Parser.prototype.finish=function(){// Return the possible parsings
varconsiderations=[];varstart=this.grammar.start;varcolumn=this.table[this.table.length-1];column.states.forEach(function(t){if(t.rule.name===start&&t.dot===t.rule.symbols.length&&t.reference===0&&t.data!==Parser.fail){considerations.push(t);}});returnconsiderations.map(function(c){returnc.data;});};functiongetSymbolLongDisplay(symbol){vartype=typeofsymbol;if(type==="string"){returnsymbol;}elseif(type==="object"){if(symbol.literal){returnJSON.stringify(symbol.literal);}elseif(symbolinstanceofRegExp){return'character matching '+symbol;}elseif(symbol.type){returnsymbol.type+' token';}elseif(symbol.test){return'token matching '+String(symbol.test);}else{thrownewError('Unknown symbol type: '+symbol);}}}functiongetSymbolShortDisplay(symbol){vartype=typeofsymbol;if(type==="string"){returnsymbol;}elseif(type==="object"){if(symbol.literal){returnJSON.stringify(symbol.literal);}elseif(symbolinstanceofRegExp){returnsymbol.toString();}elseif(symbol.type){return'%'+symbol.type;}elseif(symbol.test){return'<'+String(symbol.test)+'>';}else{thrownewError('Unknown symbol type: '+symbol);}}}return{Parser:Parser,Grammar:Grammar,Rule:Rule};});
/* eslint-disable no-unused-vars */vargetOwnPropertySymbols=Object.getOwnPropertySymbols;varhasOwnProperty=Object.prototype.hasOwnProperty;varpropIsEnumerable=Object.prototype.propertyIsEnumerable;functiontoObject(val){if(val===null||val===undefined){thrownewTypeError('Object.assign cannot be called with null or undefined');}returnObject(val);}functionshouldUseNative(){try{if(!Object.assign){returnfalse;}// Detect buggy property enumeration order in older V8 versions.
vartest3={};'abcdefghijklmnopqrst'.split('').forEach(function(letter){test3[letter]=letter;});if(Object.keys(Object.assign({},test3)).join('')!=='abcdefghijklmnopqrst'){returnfalse;}returntrue;}catch(err){// We don't expect any of the above to throw, but better to be safe.
varn=60103,p=60106;exports.Fragment=60107;exports.StrictMode=60108;exports.Profiler=60114;varq=60109,r=60110,t=60112;exports.Suspense=60113;varu=60115,v=60116;if("function"===typeofSymbol&&Symbol.for){varw=Symbol.for;n=w("react.element");p=w("react.portal");exports.Fragment=w("react.fragment");exports.StrictMode=w("react.strict_mode");exports.Profiler=w("react.profiler");q=w("react.provider");r=w("react.context");t=w("react.forward_ref");exports.Suspense=w("react.suspense");u=w("react.memo");v=w("react.lazy");}varx="function"===typeofSymbol&&Symbol.iterator;functiony(a){if(null===a||"object"!==typeofa)returnnull;a=x&&a[x]||a["@@iterator"];return"function"===typeofa?a:null;}functionz(a){for(varb="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";}varA={isMounted:function(){return!1;},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},B={};functionC(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A;}C.prototype.isReactComponent={};C.prototype.setState=function(a,b){if("object"!==typeofa&&"function"!==typeofa&&null!=a)throwError(z(85));this.updater.enqueueSetState(this,a,b,"setState");};C.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate");};functionD(){}D.prototype=C.prototype;functionE(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A;}varF=E.prototype=newD();F.constructor=E;objectAssign(F,C.prototype);F.isPureReactComponent=!0;varG={current:null},H=Object.prototype.hasOwnProperty,I={key:!0,ref:!0,__self:!0,__source:!0};functionJ(a,b,c){vare,d={},k=null,h=null;if(null!=b)for(einvoid0!==b.ref&&(h=b.ref),void0!==b.key&&(k=""+b.key),b)H.call(b,e)&&!I.hasOwnProperty(e)&&(d[e]=b[e]);varg=arguments.length-2;if(1===g)d.children=c;elseif(1<g){for(varf=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];d.children=f;}if(a&&a.defaultProps)for(eing=a.defaultProps,g)void0===d[e]&&(d[e]=g[e]);return{$$typeof:n,type:a,key:k,ref:h,props:d,_owner:G.current};}functionK(a,b){return{$$typeof:n,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner};}functionL(a){return"object"===typeofa&&null!==a&&a.$$typeof===n;}functionescape(a){varb={"=":"=0",":":"=2"};return"$"+a.replace(/[=:]/g,function(a){returnb[a];});}varM=/\/+/g;functionN(a,b){return"object"===typeofa&&null!==a&&null!=a.key?escape(""+a.key):b.toString(36);}functionO(a,b,c,e,d){vark=typeofa;if("undefined"===k||"boolean"===k)a=null;varh=!1;if(null===a)h=!0;elseswitch(k){case"string":case"number":h=!0;break;case"object":switch(a.$$typeof){casen:casep:h=!0;}}if(h)returnh=a,d=d(h),a=""===e?"."+N(h,0):e,Array.isArray(d)?(c="",null!=a&&(c=a.replace(M,"$&/")+"/"),O(d,b,c,"",function(a){returna;})):null!=d&&(L(d)&&(d=K(d,c+(!d.key||h&&h.key===d.key?"":(""+d.key).replace(M,"$&/")+"/")+a)),b.push(d)),1;h=0;e=""===e?".":e+":";if(Array.isArray(a))for(varg=0;g<a.length;g++){k=a[g];varf=e+N(k,g);h+=O(k,b,c,f,d);}elseif(f=y(a),"function"===typeoff)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=e+N(k,g++),h+=O(k,b,c,f,d);elseif("object"===k)throwb=""+a,Error(z(31,"[object Object]"===b?"object with keys {"+Object.keys(a).join(", ")+"}":b));returnh;}functionP(a,b,c){if(null==a)returna;vare=[],d=0;O(a,e,"","",function(a){returnb.call(c,a,d++);});returne;}functionQ(a){if(-1===a._status){varb=a._result;b=b();a._status=0;a._result=b;b.then(function(b){0===a._status&&(b=b.default,a._status=1,a._result=b);},function(b){0===a._status&&(a._status=2,a._result=b);});}if(1===a._status)returna._result;throwa._result;}varR={current:null};functionS(){vara=R.current;if(null===a)throwError(z(321));returna;}varT={ReactCurrentDispatcher:R,ReactCurrentBatchConfig:{transition:0},ReactCurrentOwner:G,IsSomeRendererActing:{current:!1},assign:objectAssign};exports.Children={map:P,forEach:function(a,b
ReactDebugCurrentFrame.getCurrentStack=null;ReactDebugCurrentFrame.getStackAddendum=function(){varstack='';// Add an extra top frame while an element is being validated
if(currentExtraStackFrame){stack+=currentExtraStackFrame;}// Delegate to the injected renderer-specific implementation
assign:_assign};{ReactSharedInternals.ReactDebugCurrentFrame=ReactDebugCurrentFrame;}// by calls to these methods by a Babel plugin.
//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.
functionwarn(format){{for(var_len=arguments.length,args=newArray(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key];}printWarning('warn',format,args);}}functionerror(format){{for(var_len2=arguments.length,args=newArray(_len2>1?_len2-1:0),_key2=1;_key2<_len2;_key2++){args[_key2-1]=arguments[_key2];}printWarning('error',format,args);}}functionprintWarning(level,format,args){// When changing this logic, you might want to also
// update consoleWithStackDev.www.js as well.
{varReactDebugCurrentFrame=ReactSharedInternals.ReactDebugCurrentFrame;varstack=ReactDebugCurrentFrame.getStackAddendum();if(stack!==''){format+='%s';args=args.concat([stack]);}varargsWithFormat=args.map(function(item){return''+item;});// Careful: RN currently depends on this prefix
argsWithFormat.unshift('Warning: '+format);// We intentionally don't use spread (or .apply) directly because it
Function.prototype.apply.call(console[level],console,argsWithFormat);}}vardidWarnStateUpdateForUnmountedComponent={};functionwarnNoop(publicInstance,callerName){{var_constructor=publicInstance.constructor;varcomponentName=_constructor&&(_constructor.displayName||_constructor.name)||'ReactClass';varwarningKey=componentName+"."+callerName;if(didWarnStateUpdateForUnmountedComponent[warningKey]){return;}error("Can't call %s on a component that is not yet mounted. "+'This is a no-op, but it might indicate a bug in your application. '+'Instead, assign to `this.state` directly or define a `state = {};` '+'class property with the desired state in the %s component.',callerName,componentName);didWarnStateUpdateForUnmountedComponent[warningKey]=true;}}/**
*/Component.prototype.setState=function(partialState,callback){if(!(typeof partialState==='object'||typeof partialState==='function'||partialState==null)){{throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");}}this.updater.enqueueSetState(this,partialState,callback,'setState');};/**
*/{var deprecatedAPIs={isMounted:['isMounted','Instead, make sure to clean up subscriptions and pending requests in '+'componentWillUnmount to prevent memory leaks.'],replaceState:['replaceState','Refactor your code to use setState instead (see '+'https://github.com/facebook/react/issues/3236).']};var defineDeprecationWarning=function(methodName,info){Object.defineProperty(Component.prototype,methodName,{get:function(){warn('%s(...) is deprecated in plain JavaScript React classes. %s',info[0],info[1]);return undefined;}});};for(var fnName in deprecatedAPIs){if(deprecatedAPIs.hasOwnProperty(fnName)){defineDeprecationWarning(fnName,deprecatedAPIs[fnName]);}}}function ComponentDummy(){}ComponentDummy.prototype=Component.prototype;/**
this.refs=emptyObject;this.updater=updater||ReactNoopUpdateQueue;}varpureComponentPrototype=PureComponent.prototype=newComponentDummy();pureComponentPrototype.constructor=PureComponent;// Avoid an extra prototype jump for these methods.
_assign(pureComponentPrototype,Component.prototype);pureComponentPrototype.isPureReactComponent=true;// an immutable object with a single mutable value
functioncreateRef(){varrefObject={current:null};{Object.seal(refObject);}returnrefObject;}functiongetWrappedName(outerType,innerType,wrapperName){varfunctionName=innerType.displayName||innerType.name||'';returnouterType.displayName||(functionName!==''?wrapperName+"("+functionName+")":wrapperName);}functiongetContextName(type){returntype.displayName||'Context';}functiongetComponentName(type){if(type==null){// Host root, text node or just invalid type.
returnnull;}{if(typeoftype.tag==='number'){error('Received an unexpected object in getComponentName(). '+'This is likely a bug in React. Please file an issue.');}}if(typeoftype==='function'){returntype.displayName||type.name||null;}if(typeoftype==='string'){returntype;}switch(type){caseexports.Fragment:return'Fragment';caseREACT_PORTAL_TYPE:return'Portal';caseexports.Profiler:return'Profiler';caseexports.StrictMode:return'StrictMode';caseexports.Suspense:return'Suspense';caseREACT_SUSPENSE_LIST_TYPE:return'SuspenseList';}if(typeoftype==='object'){switch(type.$$typeof){caseREACT_CONTEXT_TYPE:varcontext=type;returngetContextName(context)+'.Consumer';caseREACT_PROVIDER_TYPE:varprovider=type;returngetContextName(provider._context)+'.Provider';caseREACT_FORWARD_REF_TYPE:returngetWrappedName(type,type.render,'ForwardRef');caseREACT_MEMO_TYPE:returngetComponentName(type.type);caseREACT_BLOCK_TYPE:returngetComponentName(type._render);caseREACT_LAZY_TYPE:{varlazyComponent=type;varpayload=lazyComponent._payload;varinit=lazyComponent._init;try{returngetComponentName(init(payload));}catch(x){returnnull;}}}}returnnull;}varhasOwnProperty=Object.prototype.hasOwnProperty;varRESERVED_PROPS={key:true,ref:true,__self:true,__source:true};varspecialPropKeyWarningShown,specialPropRefWarningShown,didWarnAboutStringRefs;{didWarnAboutStringRefs={};}functionhasValidRef(config){{if(hasOwnProperty.call(config,'ref')){vargetter=Object.getOwnPropertyDescriptor(config,'ref').get;if(getter&&getter.isReactWarning){returnfalse;}}}returnconfig.ref!==undefined;}functionhasValidKey(config){{if(hasOwnProperty.call(config,'key')){vargetter=Object.getOwnPropertyDescriptor(config,'key').get;if(getter&&getter.isReactWarning){returnfalse;}}}returnconfig.key!==undefined;}functiondefineKeyPropWarningGetter(props,displayName){varwarnAboutAccessingKey=function(){{if(!specialPropKeyWarningShown){specialPropKeyWarningShown=true;error('%s: `key` is not a prop. Trying to access it will result '+'in `undefined` being returned. If you need to access the same '+'value within the child component, you should pass it as a different '+'prop. (https://reactjs.org/link/special-props)',displayName);}}};warnAboutAccessingKey.isReactWarning=true;Object.defineProperty(props,'key',{get:warnAboutAccessingKey,configurable:true});}functiondefineRefPropWarningGetter(props,displayName){varwarnAboutAccessingRef=function(){{if(!specialPropRefWarningShown){specialPropRefWarningShown=true;error('%s: `ref` is not a prop. Trying to access it will result '+'in `undefined` being returned. If you need to access the same '+'value within the child component, you should pass it as a different '+'prop. (https://reactjs.org/link/special-props)',displayName);}}};warnAboutAccessingRef.isReactWarning=true;Object.defineProperty(props,'ref',{get:warnAboutAccessingRef,configurable:true});}functionwarnIfStringRefCannotBeAutoConverted(config){{if(typeofconfig.ref==='string'&&ReactCurrentOwner.current&&config.__self&&ReactCurrentOwner.current.stateNode!==config.__self){varcomponentName=getComponentName(ReactCurrentOwner.current.type);if(!didWarnAboutStringRefs[componentName]){error('Component "%s" contains the string ref "%s". '+'Support for string refs will be removed in a future major release. '+'This case cannot be automatically converted to an arrow function. '+'We ask you to manually fix this case by using useRef() or createRef() instead. '+'Learn more about using refs safely here: '+'https://reactjs.org/link/strict-mode-string-ref',componentName,config.ref);didWarnAboutStringRefs[componentName]=true;}}}}/**
$$typeof:REACT_ELEMENT_TYPE,// Built-in properties that belong on the element
type:type,key:key,ref:ref,props:props,// Record the component responsible for creating this element.
_owner:owner};{// The validation flag is currently mutative. We put it on
// an external backing store so that we can freeze the whole object.
// This can be replaced with a WeakMap once they are implemented in
// commonly used development environments.
element._store={};// To make comparing ReactElements easier for testing purposes, we make
// the validation flag non-enumerable (where possible, which should
// include every environment we run tests in), so the test framework
// ignores it.
Object.defineProperty(element._store,'validated',{configurable:false,enumerable:false,writable:true,value:false});// self and source are DEV only properties.
Object.defineProperty(element,'_self',{configurable:false,enumerable:false,writable:false,value:self});// Two elements created in two different places should be considered
// equal for testing purposes and therefore we hide it from enumeration.
varprops={};varkey=null;varref=null;varself=null;varsource=null;if(config!=null){if(hasValidRef(config)){ref=config.ref;{warnIfStringRefCannotBeAutoConverted(config);}}if(hasValidKey(config)){key=''+config.key;}self=config.__self===undefined?null:config.__self;source=config.__source===undefined?null:config.__source;// Remaining properties are added to a new props object
for(propNameinconfig){if(hasOwnProperty.call(config,propName)&&!RESERVED_PROPS.hasOwnProperty(propName)){props[propName]=config[propName];}}}// Children can be more than one argument, and those are transferred onto
*/function cloneElement(element,config,children){if(!!(element===null||element===undefined)){{throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+element+".");}}var propName;//Originalpropsarecopied
varprops=_assign({},element.props);// Reserved names are extracted
varkey=element.key;varref=element.ref;// Self is preserved since the owner is preserved.
varself=element._self;// Source is preserved since cloneElement is unlikely to be targeted by a
// transpiler, and the original source is probably a better indicator of the
// true owner.
varsource=element._source;// Owner will be preserved, unless ref is overridden
varowner=element._owner;if(config!=null){if(hasValidRef(config)){// Silently steal the ref from the parent.
props[propName]=defaultProps[propName];}else{props[propName]=config[propName];}}}}// Children can be more than one argument, and those are transferred onto
returnescape(''+element.key);}// Implicit key determined by the index in the set
returnindex.toString(36);}functionmapIntoArray(children,array,escapedPrefix,nameSoFar,callback){vartype=typeofchildren;if(type==='undefined'||type==='boolean'){// All of the above are perceived as null.
children=null;}varinvokeCallback=false;if(children===null){invokeCallback=true;}else{switch(type){case'string':case'number':invokeCallback=true;break;case'object':switch(children.$$typeof){caseREACT_ELEMENT_TYPE:caseREACT_PORTAL_TYPE:invokeCallback=true;}}}if(invokeCallback){var_child=children;varmappedChild=callback(_child);// If it's the only child, treat the name as if it was wrapped in an array
// so that it's consistent if the number of children grows:
varchildKey=nameSoFar===''?SEPARATOR+getElementKey(_child,0):nameSoFar;if(Array.isArray(mappedChild)){varescapedChildKey='';if(childKey!=null){escapedChildKey=escapeUserProvidedKey(childKey)+'/';}mapIntoArray(mappedChild,array,escapedChildKey,'',function(c){returnc;});}elseif(mappedChild!=null){if(isValidElement(mappedChild)){mappedChild=cloneAndReplaceKey(mappedChild,// Keep both the (mapped) and old keys if they differ, just as
// traverseAllChildren used to do for objects as children
escapedPrefix+(// $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
mappedChild.key&&(!_child||_child.key!==mappedChild.key)?// $FlowFixMe Flow incorrectly thinks existing element's key can be a number
escapeUserProvidedKey(''+mappedChild.key)+'/':'')+childKey);}array.push(mappedChild);}return1;}varchild;varnextName;varsubtreeCount=0;// Count of children found in the current subtree.
varnextNamePrefix=nameSoFar===''?SEPARATOR:nameSoFar+SUBSEPARATOR;if(Array.isArray(children)){for(vari=0;i<children.length;i++){child=children[i];nextName=nextNamePrefix+getElementKey(child,i);subtreeCount+=mapIntoArray(child,array,escapedPrefix,nextName,callback);}}else{variteratorFn=getIteratorFn(children);if(typeofiteratorFn==='function'){variterableChildren=children;{// Warn about using Maps as children
if(iteratorFn===iterableChildren.entries){if(!didWarnAboutMaps){warn('Using Maps as children is not supported. '+'Use an array of keyed ReactElements instead.');}didWarnAboutMaps=true;}}variterator=iteratorFn.call(iterableChildren);varstep;varii=0;while(!(step=iterator.next()).done){child=step.value;nextName=nextNamePrefix+getElementKey(child,ii++);subtreeCount+=mapIntoArray(child,array,escapedPrefix,nextName,callback);}}elseif(type==='object'){varchildrenString=''+children;{{throwError("Objects are not valid as a React child (found: "+(childrenString==='[object Object]'?'object with keys {'+Object.keys(children).join(', ')+'}':childrenString)+"). If you meant to render a collection of children, use an array instead.");}}}}returnsubtreeCount;}/**
*/function onlyChild(children){if(!isValidElement(children)){{throw Error("React.Children.only expected to receive a single React element child.");}}return children;}function createContext(defaultValue,calculateChangedBits){if(calculateChangedBits===undefined){calculateChangedBits=null;}else {{if(calculateChangedBits!==null&&typeof calculateChangedBits!=='function'){error('createContext: Expected the optional second argument to be a '+'function. Instead received: %s',calculateChangedBits);}}}var context={$$typeof:REACT_CONTEXT_TYPE,_calculateChangedBits:calculateChangedBits,//Asaworkaroundtosupportmultipleconcurrentrenderers,wecategorize
// some renderers as primary and others as secondary. We only expect
// there to be two concurrent renderers at most: React Native (primary) and
// Fabric (secondary); React DOM (primary) and React ART (secondary).
// Secondary renderers store their context values on separate fields.
_currentValue:defaultValue,_currentValue2:defaultValue,// Used to track how many concurrent renderers this context currently
// supports within in a single renderer. Such as parallel server rendering.
_threadCount:0,// These are circular
Provider:null,Consumer:null};context.Provider={$$typeof:REACT_PROVIDER_TYPE,_context:context};varhasWarnedAboutUsingNestedContextConsumers=false;varhasWarnedAboutUsingConsumerProvider=false;varhasWarnedAboutDisplayNameOnConsumer=false;{// A separate object, but proxies back to the original context object for
// backwards compatibility. It has a different $$typeof, so we can properly
// warn for the incorrect usage of Context as a Consumer.
varConsumer={$$typeof:REACT_CONTEXT_TYPE,_context:context,_calculateChangedBits:context._calculateChangedBits};// $FlowFixMe: Flow complains about not setting a value, which is intentional here
Object.defineProperties(Consumer,{Provider:{get:function(){if(!hasWarnedAboutUsingConsumerProvider){hasWarnedAboutUsingConsumerProvider=true;error('Rendering <Context.Consumer.Provider> is not supported and will be removed in '+'a future major release. Did you mean to render <Context.Provider> instead?');}returncontext.Provider;},set:function(_Provider){context.Provider=_Provider;}},_currentValue:{get:function(){returncontext._currentValue;},set:function(_currentValue){context._currentValue=_currentValue;}},_currentValue2:{get:function(){returncontext._currentValue2;},set:function(_currentValue2){context._currentValue2=_currentValue2;}},_threadCount:{get:function(){returncontext._threadCount;},set:function(_threadCount){context._threadCount=_threadCount;}},Consumer:{get:function(){if(!hasWarnedAboutUsingNestedContextConsumers){hasWarnedAboutUsingNestedContextConsumers=true;error('Rendering <Context.Consumer.Consumer> is not supported and will be removed in '+'a future major release. Did you mean to render <Context.Consumer> instead?');}returncontext.Consumer;}},displayName:{get:function(){returncontext.displayName;},set:function(displayName){if(!hasWarnedAboutDisplayNameOnConsumer){warn('Setting `displayName` on Context.Consumer has no effect. '+"You should set it directly on the context with Context.displayName = '%s'.",displayName);hasWarnedAboutDisplayNameOnConsumer=true;}}}});// $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
context.Consumer=Consumer;}{context._currentRenderer=null;context._currentRenderer2=null;}returncontext;}varUninitialized=-1;varPending=0;varResolved=1;varRejected=2;functionlazyInitializer(payload){if(payload._status===Uninitialized){varctor=payload._result;varthenable=ctor();// Transition to the next state.
varpending=payload;pending._status=Pending;pending._result=thenable;thenable.then(function(moduleObject){if(payload._status===Pending){vardefaultExport=moduleObject.default;{if(defaultExport===undefined){error('lazy: Expected the result of a dynamic import() call. '+'Instead received: %s\n\nYour code should look like: \n '+// Break up imports to avoid accidentally parsing them as dependencies.
'const MyComponent = lazy(() => imp'+"ort('./MyComponent'))",moduleObject);}}// Transition to the next state.
varresolved=payload;resolved._status=Resolved;resolved._result=defaultExport;}},function(error){if(payload._status===Pending){// Transition to the next state.
varrejected=payload;rejected._status=Rejected;rejected._result=error;}});}if(payload._status===Resolved){returnpayload._result;}else{throwpayload._result;}}functionlazy(ctor){varpayload={// We use these fields to store the result.
_status:-1,_result:ctor};varlazyType={$$typeof:REACT_LAZY_TYPE,_payload:payload,_init:lazyInitializer};{// In production, this would just set it on the object.
vardefaultProps;varpropTypes;// $FlowFixMe
Object.defineProperties(lazyType,{defaultProps:{configurable:true,get:function(){returndefaultProps;},set:function(newDefaultProps){error('React.lazy(...): It is not supported to assign `defaultProps` to '+'a lazy component import. Either specify them where the component '+'is defined, or create a wrapping component around it.');defaultProps=newDefaultProps;// Match production behavior more closely:
// $FlowFixMe
Object.defineProperty(lazyType,'defaultProps',{enumerable:true});}},propTypes:{configurable:true,get:function(){returnpropTypes;},set:function(newPropTypes){error('React.lazy(...): It is not supported to assign `propTypes` to '+'a lazy component import. Either specify them where the component '+'is defined, or create a wrapping component around it.');propTypes=newPropTypes;// Match production behavior more closely:
// $FlowFixMe
Object.defineProperty(lazyType,'propTypes',{enumerable:true});}}});}returnlazyType;}functionforwardRef(render){{if(render!=null&&render.$$typeof===REACT_MEMO_TYPE){error('forwardRef requires a render function but received a `memo` '+'component. Instead of forwardRef(memo(...)), use '+'memo(forwardRef(...)).');}elseif(typeofrender!=='function'){error('forwardRef requires a render function but was given %s.',render===null?'null':typeofrender);}else{if(render.length!==0&&render.length!==2){error('forwardRef render functions accept exactly two parameters: props and ref. %s',render.length===1?'Did you forget to use the ref parameter?':'Any additional parameter will be undefined.');}}if(render!=null){if(render.defaultProps!=null||render.propTypes!=null){error('forwardRef render functions do not support propTypes or defaultProps. '+'Did you accidentally pass a React component?');}}}varelementType={$$typeof:REACT_FORWARD_REF_TYPE,render:render};{varownName;Object.defineProperty(elementType,'displayName',{enumerable:false,configurable:true,get:function(){returnownName;},set:function(name){ownName=name;if(render.displayName==null){render.displayName=name;}}});}returnelementType;}// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
functionisValidElementType(type){if(typeoftype==='string'||typeoftype==='function'){returntrue;}// Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
if(type===exports.Fragment||type===exports.Profiler||type===REACT_DEBUG_TRACING_MODE_TYPE||type===exports.StrictMode||type===exports.Suspense||type===REACT_SUSPENSE_LIST_TYPE||type===REACT_LEGACY_HIDDEN_TYPE||enableScopeAPI){returntrue;}if(typeoftype==='object'&&type!==null){if(type.$$typeof===REACT_LAZY_TYPE||type.$$typeof===REACT_MEMO_TYPE||type.$$typeof===REACT_PROVIDER_TYPE||type.$$typeof===REACT_CONTEXT_TYPE||type.$$typeof===REACT_FORWARD_REF_TYPE||type.$$typeof===REACT_FUNDAMENTAL_TYPE||type.$$typeof===REACT_BLOCK_TYPE||type[0]===REACT_SERVER_BLOCK_TYPE){returntrue;}}returnfalse;}functionmemo(type,compare){{if(!isValidElementType(type)){error('memo: The first argument must be a component. Instead '+'received: %s',type===null?'null':typeoftype);}}varelementType={$$typeof:REACT_MEMO_TYPE,type:type,compare:compare===undefined?null:compare};{varownName;Object.defineProperty(elementType,'displayName',{enumerable:false,configurable:true,get:function(){returnownName;},set:function(name){ownName=name;if(type.displayName==null){type.displayName=name;}}});}returnelementType;}functionresolveDispatcher(){vardispatcher=ReactCurrentDispatcher.current;if(!(dispatcher!==null)){{throwError("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");}}returndispatcher;}functionuseContext(Context,unstable_observedBits){vardispatcher=resolveDispatcher();{if(unstable_observedBits!==undefined){error('useContext() second argument is reserved for future '+'use in React. Passing it is not supported. '+'You passed: %s.%s',unstable_observedBits,typeofunstable_observedBits==='number'&&Array.isArray(arguments[2])?'\n\nDid you call array.map(useContext)? '+'Calling Hooks inside a loop is not supported. '+'Learn more at https://reactjs.org/link/rules-of-hooks':'');}// TODO: add a more generic warning for invalid values.
if(Context._context!==undefined){varrealContext=Context._context;// Don't deduplicate because this legitimately causes bugs
// and nobody should be using this in existing code.
if(realContext.Consumer===Context){error('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be '+'removed in a future major release. Did you mean to call useContext(Context) instead?');}elseif(realContext.Provider===Context){error('Calling useContext(Context.Provider) is not supported. '+'Did you mean to call useContext(Context) instead?');}}}returndispatcher.useContext(Context,unstable_observedBits);}functionuseState(initialState){vardispatcher=resolveDispatcher();returndispatcher.useState(initialState);}functionuseReducer(reducer,initialArg,init){vardispatcher=resolveDispatcher();returndispatcher.useReducer(reducer,initialArg,init);}functionuseRef(initialValue){vardispatcher=resolveDispatcher();returndispatcher.useRef(initialValue);}functionuseEffect(create,deps){vardispatcher=resolveDispatcher();returndispatcher.useEffect(create,deps);}functionuseLayoutEffect(create,deps){vardispatcher=resolveDispatcher();returndispatcher.useLayoutEffect(create,deps);}functionuseCallback(callback,deps){vardispatcher=resolveDispatcher();returndispatcher.useCallback(callback,deps);}functionuseMemo(create,deps){vardispatcher=resolveDispatcher();returndispatcher.useMemo(create,deps);}functionuseImperativeHandle(ref,create,deps){vardispatcher=resolveDispatcher();returndispatcher.useImperativeHandle(ref,create,deps);}functionuseDebugValue(value,formatterFn){{vardispatcher=resolveDispatcher();returndispatcher.useDebugValue(value,formatterFn);}}// Helpers to patch console.logs to avoid logging during side-effect free
// replaying on render function. This currently only patches the object
// lazily which won't cover if the log function was extracted eagerly.
Object.defineProperties(console,{log:_assign({},props,{value:prevLog}),info:_assign({},props,{value:prevInfo}),warn:_assign({},props,{value:prevWarn}),error:_assign({},props,{value:prevError}),group:_assign({},props,{value:prevGroup}),groupCollapsed:_assign({},props,{value:prevGroupCollapsed}),groupEnd:_assign({},props,{value:prevGroupEnd})});/* eslint-enable react-internal/no-production-logging */}if(disabledDepth<0){error('disabledDepth fell below zero. '+'This is a bug in React. Please file an issue.');}}}varReactCurrentDispatcher$1=ReactSharedInternals.ReactCurrentDispatcher;varprefix;functiondescribeBuiltInComponentFrame(name,source,ownerFn){{if(prefix===undefined){// Extract the VM specific prefix used by each line.
try{throwError();}catch(x){varmatch=x.stack.trim().match(/\n( *(at )?)/);prefix=match&&match[1]||'';}}// We use the prefix to ensure our stacks line up with native stack frames.
return'\n'+prefix+name;}}varreentry=false;varcomponentFrameCache;{varPossiblyWeakMap=typeofWeakMap==='function'?WeakMap:Map;componentFrameCache=newPossiblyWeakMap();}functiondescribeNativeComponentFrame(fn,construct){// If something asked for a stack inside a fake render, it should get ignored.
if(!fn||reentry){return'';}{varframe=componentFrameCache.get(fn);if(frame!==undefined){returnframe;}}varcontrol;reentry=true;varpreviousPrepareStackTrace=Error.prepareStackTrace;// $FlowFixMe It does accept undefined.
Error.prepareStackTrace=undefined;varpreviousDispatcher;{previousDispatcher=ReactCurrentDispatcher$1.current;// Set the dispatcher in DEV because this might be call in the render function
// for warnings.
ReactCurrentDispatcher$1.current=null;disableLogs();}try{// This should throw.
if(construct){// Something should be setting the props in the constructor.
varFake=function(){throwError();};// $FlowFixMe
Object.defineProperty(Fake.prototype,'props',{set:function(){// We use a throwing setter instead of frozen or non-writable props
// because that won't throw in a non-strict mode function.
throwError();}});if(typeofReflect==='object'&&Reflect.construct){// We construct a different control for this case to include any extra
// frames added by the construct call.
try{Reflect.construct(Fake,[]);}catch(x){control=x;}Reflect.construct(fn,[],Fake);}else{try{Fake.call();}catch(x){control=x;}fn.call(Fake.prototype);}}else{try{throwError();}catch(x){control=x;}fn();}}catch(sample){// This is inlined manually because closure doesn't do it for us.
if(sample&&control&&typeofsample.stack==='string'){// This extracts the first frame from the sample that isn't also in the control.
// Skipping one frame that we assume is the frame that calls the two.
varsampleLines=sample.stack.split('\n');varcontrolLines=control.stack.split('\n');vars=sampleLines.length-1;varc=controlLines.length-1;while(s>=1&&c>=0&&sampleLines[s]!==controlLines[c]){// We expect at least one stack frame to be shared.
// Typically this will be the root most one. However, stack frames may be
// cut off due to maximum stack limits. In this case, one maybe cut off
// earlier than the other. We assume that the sample is longer or the same
// and there for cut off earlier. So we should find the root most frame in
// the sample somewhere in the control.
c--;}for(;s>=1&&c>=0;s--,c--){// Next we find the first one that isn't the same which should be the
// frame that called our sample function and the control.
if(sampleLines[s]!==controlLines[c]){// In V8, the first line is describing the message but other VMs don't.
// If we're about to return the first line, and the control is also on the same
// line, that's a pretty good indicator that our sample threw at same line as
// the control. I.e. before we entered the sample frame. So we ignore this result.
// This can happen if you passed a class to function component, or non-function.
if(s!==1||c!==1){do{s--;c--;// We may still have similar intermediate frames from the construct call.
// The next one that isn't the same should be our match though.
if(c<0||sampleLines[s]!==controlLines[c]){// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
var_frame='\n'+sampleLines[s].replace(' at new ',' at ');{if(typeoffn==='function'){componentFrameCache.set(fn,_frame);}}// Return the line we found.
return_frame;}}while(s>=1&&c>=0);}break;}}}}finally{reentry=false;{ReactCurrentDispatcher$1.current=previousDispatcher;reenableLogs();}Error.prepareStackTrace=previousPrepareStackTrace;}// Fallback to just using the name if we couldn't make it throw.
varname=fn?fn.displayName||fn.name:'';varsyntheticFrame=name?describeBuiltInComponentFrame(name):'';{if(typeoffn==='function'){componentFrameCache.set(fn,syntheticFrame);}}returnsyntheticFrame;}functiondescribeFunctionComponentFrame(fn,source,ownerFn){{returndescribeNativeComponentFrame(fn,false);}}functionshouldConstruct(Component){varprototype=Component.prototype;return!!(prototype&&prototype.isReactComponent);}functiondescribeUnknownElementTypeFrameInDEV(type,source,ownerFn){if(type==null){return'';}if(typeoftype==='function'){{returndescribeNativeComponentFrame(type,shouldConstruct(type));}}if(typeoftype==='string'){returndescribeBuiltInComponentFrame(type);}switch(type){caseexports.Suspense:returndescribeBuiltInComponentFrame('Suspense');caseREACT_SUSPENSE_LIST_TYPE:returndescribeBuiltInComponentFrame('SuspenseList');}if(typeoftype==='object'){switch(type.$$typeof){caseREACT_FORWARD_REF_TYPE:returndescribeFunctionComponentFrame(type.render);caseREACT_MEMO_TYPE:// Memo may contain any component type so we recursively resolve it.
returndescribeUnknownElementTypeFrameInDEV(type.type,source,ownerFn);caseREACT_BLOCK_TYPE:returndescribeFunctionComponentFrame(type._render);caseREACT_LAZY_TYPE:{varlazyComponent=type;varpayload=lazyComponent._payload;varinit=lazyComponent._init;try{// Lazy may contain any component type so we recursively resolve it.
returndescribeUnknownElementTypeFrameInDEV(init(payload),source,ownerFn);}catch(x){}}}}return'';}varloggedTypeFailures={};varReactDebugCurrentFrame$1=ReactSharedInternals.ReactDebugCurrentFrame;functionsetCurrentlyValidatingElement(element){{if(element){varowner=element._owner;varstack=describeUnknownElementTypeFrameInDEV(element.type,element._source,owner?owner.type:null);ReactDebugCurrentFrame$1.setExtraStackFrame(stack);}else{ReactDebugCurrentFrame$1.setExtraStackFrame(null);}}}functioncheckPropTypes(typeSpecs,values,location,componentName,element){{// $FlowFixMe This is okay but Flow doesn't know it.
varhas=Function.call.bind(Object.prototype.hasOwnProperty);for(vartypeSpecNameintypeSpecs){if(has(typeSpecs,typeSpecName)){varerror$1=void0;// Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try{// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if(typeoftypeSpecs[typeSpecName]!=='function'){varerr=Error((componentName||'React class')+': '+location+' type `'+typeSpecName+'` is invalid; '+'it must be a function, usually from the `prop-types` package, but received `'+typeoftypeSpecs[typeSpecName]+'`.'+'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');err.name='Invariant Violation';throwerr;}error$1=typeSpecs[typeSpecName](values,typeSpecName,componentName,location,null,'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');}catch(ex){error$1=ex;}if(error$1&&!(error$1instanceofError)){setCurrentlyValidatingElement(element);error('%s: type specification of %s'+' `%s` is invalid; the type checker '+'function must return `null` or an `Error` but returned a %s. '+'You may have forgotten to pass an argument to the type checker '+'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and '+'shape all require an argument).',componentName||'React class',location,typeSpecName,typeoferror$1);setCurrentlyValidatingElement(null);}if(error$1instanceofError&&!(error$1.messageinloggedTypeFailures)){// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error$1.message]=true;setCurrentlyValidatingElement(element);error('Failed %s type: %s',location,error$1.message);setCurrentlyValidatingElement(null);}}}}}functionsetCurrentlyValidatingElement$1(element){{if(element){varowner=element._owner;varstack=describeUnknownElementTypeFrameInDEV(element.type,element._source,owner?owner.type:null);setExtraStackFrame(stack);}else{setExtraStackFrame(null);}}}varpropTypesMisspellWarningShown;{propTypesMisspellWarningShown=false;}functiongetDeclarationErrorAddendum(){if(ReactCurrentOwner.current){varname=getComponentName(ReactCurrentOwner.current.type);if(name){return'\n\nCheck the render method of `'+name+'`.';}}return'';}functiongetSourceInfoErrorAddendum(source){if(source!==undefined){varfileName=source.fileName.replace(/^.*[\\\/]/,'');varlineNumber=source.lineNumber;return'\n\nCheck your code at '+fileName+':'+lineNumber+'.';}return'';}functiongetSourceInfoErrorAddendumForProps(elementProps){if(elementProps!==null&&elementProps!==undefined){returngetSourceInfoErrorAddendum(elementProps.__source);}return'';}/**
// property, it may be the creator of the child that's responsible for
// assigning it a key.
varchildOwner='';if(element&&element._owner&&element._owner!==ReactCurrentOwner.current){// Give the component that originally created this child.
childOwner=" It was passed a child from "+getComponentName(element._owner.type)+".";}{setCurrentlyValidatingElement$1(element);error('Each child in a list should have a unique "key" prop.'+'%s%s See https://reactjs.org/link/warning-keys for more information.',currentComponentErrorInfo,childOwner);setCurrentlyValidatingElement$1(null);}}/**
if(node._store){node._store.validated=true;}}elseif(node){variteratorFn=getIteratorFn(node);if(typeofiteratorFn==='function'){// Entry iterators used to provide implicit keys,
// but now we print a separate warning for them later.
type.$$typeof===REACT_MEMO_TYPE)){propTypes=type.propTypes;}else{return;}if(propTypes){// Intentionally inside to avoid triggering lazy initializers:
varname=getComponentName(type);checkPropTypes(propTypes,element.props,'prop',name,element);}elseif(type.PropTypes!==undefined&&!propTypesMisspellWarningShown){propTypesMisspellWarningShown=true;// Intentionally inside to avoid triggering lazy initializers:
var_name=getComponentName(type);error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?',_name||'Unknown');}if(typeoftype.getDefaultProps==='function'&&!type.getDefaultProps.isReactClassApproved){error('getDefaultProps is only used on classic React.createClass '+'definitions. Use a static property named `defaultProps` instead.');}}}/**
*/function validateFragmentProps(fragment){{var keys=Object.keys(fragment.props);for(var i=0;i<keys.length;i++){var key=keys[i];if(key!=='children'&&key!=='key'){setCurrentlyValidatingElement$1(fragment);error('Invalid prop `%s` supplied to `React.Fragment`. '+'React.Fragment can only have `key` and `children` props.',key);setCurrentlyValidatingElement$1(null);break;}}if(fragment.ref!==null){setCurrentlyValidatingElement$1(fragment);error('Invalid attribute `ref` supplied to `React.Fragment`.');setCurrentlyValidatingElement$1(null);}}}function createElementWithValidation(type,props,children){var validType=isValidElementType(type);//Wewarninthiscasebutdon'tthrow.Weexpecttheelementcreationto
// succeed and there will likely be errors in render.
if(!validType){varinfo='';if(type===undefined||typeoftype==='object'&&type!==null&&Object.keys(type).length===0){info+=' You likely forgot to export your component from the file '+"it's defined in, or you might have mixed up default and named imports.";}varsourceInfo=getSourceInfoErrorAddendumForProps(props);if(sourceInfo){info+=sourceInfo;}else{info+=getDeclarationErrorAddendum();}vartypeString;if(type===null){typeString='null';}elseif(Array.isArray(type)){typeString='array';}elseif(type!==undefined&&type.$$typeof===REACT_ELEMENT_TYPE){typeString="<"+(getComponentName(type.type)||'Unknown')+" />";info=' Did you accidentally export a JSX literal instead of a component?';}else{typeString=typeoftype;}{error('React.createElement: type is invalid -- expected a string (for '+'built-in components) or a class/function (for composite '+'components) but got: %s.%s',typeString,info);}}varelement=createElement.apply(this,arguments);// The result can be nullish if a mock or a custom function is used.
// TODO: Drop this when these are no longer allowed as the type argument.
if(element==null){returnelement;}// Skip key warning if the type isn't valid since our key validation logic
// doesn't expect a non-string/function type and can throw confusing errors.
// We don't want exception behavior to differ between dev and prod.
// (Rendering will throw with a helpful message and as soon as the type is
// fixed, the key warnings will appear.)
if(validType){for(vari=2;i<arguments.length;i++){validateChildKeys(arguments[i],type);}}if(type===exports.Fragment){validateFragmentProps(element);}else{validatePropTypes(element);}returnelement;}vardidWarnAboutDeprecatedCreateFactory=false;functioncreateFactoryWithValidation(type){varvalidatedFactory=createElementWithValidation.bind(null,type);validatedFactory.type=type;{if(!didWarnAboutDeprecatedCreateFactory){didWarnAboutDeprecatedCreateFactory=true;warn('React.createFactory() is deprecated and will be removed in '+'a future major release. Consider using JSX '+'or use React.createElement() directly instead.');}// Legacy hook: remove it
Object.defineProperty(validatedFactory,'type',{enumerable:false,get:function(){warn('Factory.type is deprecated. Access the class directly '+'before passing it to createFactory.');Object.defineProperty(this,'type',{value:type});returntype;}});}returnvalidatedFactory;}functioncloneElementWithValidation(element,props,children){varnewElement=cloneElement.apply(this,arguments);for(vari=2;i<arguments.length;i++){validateChildKeys(arguments[i],newElement.type);}validatePropTypes(newElement);returnnewElement;}{try{varfrozenObject=Object.freeze({});/* eslint-disable no-new */newMap([[frozenObject,null]]);newSet([frozenObject]);/* eslint-enable no-new */}catch(e){}}varcreateElement$1=createElementWithValidation;varcloneElement$1=cloneElementWithValidation;varcreateFactory=createFactoryWithValidation;varChildren={map:mapChildren,forEach:forEachChildren,count:countChildren,toArray:toArray,only:onlyChild};exports.Children=Children;exports.Component=Component;exports.PureComponent=PureComponent;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ReactSharedInternals;exports.cloneElement=cloneElement$1;exports.createContext=createContext;exports.createElement=createElement$1;exports.createFactory=createFactory;exports.createRef=createRef;exports.forwardRef=forwardRef;exports.isValidElement=isValidElement;exports.lazy=lazy;exports.memo=memo;exports.useCallback=useCallback;exports.useContext=useContext;exports.useDebugValue=useDebugValue;exports.useEffect=useEffect;exports.useImperativeHandle=useImperativeHandle;exports.useLayoutEffect=useLayoutEffect;exports.useMemo=useMemo;exports.useReducer=useReducer;exports.useRef=useRef;exports.useState=useState;exports.version=ReactVersion;})();}
{(function(){// nor polyfill, then a plain number is used for performance.
varhasSymbol=typeofSymbol==='function'&&Symbol.for;varREACT_ELEMENT_TYPE=hasSymbol?Symbol.for('react.element'):0xeac7;varREACT_PORTAL_TYPE=hasSymbol?Symbol.for('react.portal'):0xeaca;varREACT_FRAGMENT_TYPE=hasSymbol?Symbol.for('react.fragment'):0xeacb;varREACT_STRICT_MODE_TYPE=hasSymbol?Symbol.for('react.strict_mode'):0xeacc;varREACT_PROFILER_TYPE=hasSymbol?Symbol.for('react.profiler'):0xead2;varREACT_PROVIDER_TYPE=hasSymbol?Symbol.for('react.provider'):0xeacd;varREACT_CONTEXT_TYPE=hasSymbol?Symbol.for('react.context'):0xeace;// TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
// (unstable) APIs that have been removed. Can we remove the symbols?
varREACT_ASYNC_MODE_TYPE=hasSymbol?Symbol.for('react.async_mode'):0xeacf;varREACT_CONCURRENT_MODE_TYPE=hasSymbol?Symbol.for('react.concurrent_mode'):0xeacf;varREACT_FORWARD_REF_TYPE=hasSymbol?Symbol.for('react.forward_ref'):0xead0;varREACT_SUSPENSE_TYPE=hasSymbol?Symbol.for('react.suspense'):0xead1;varREACT_SUSPENSE_LIST_TYPE=hasSymbol?Symbol.for('react.suspense_list'):0xead8;varREACT_MEMO_TYPE=hasSymbol?Symbol.for('react.memo'):0xead3;varREACT_LAZY_TYPE=hasSymbol?Symbol.for('react.lazy'):0xead4;varREACT_BLOCK_TYPE=hasSymbol?Symbol.for('react.block'):0xead9;varREACT_FUNDAMENTAL_TYPE=hasSymbol?Symbol.for('react.fundamental'):0xead5;varREACT_RESPONDER_TYPE=hasSymbol?Symbol.for('react.responder'):0xead6;varREACT_SCOPE_TYPE=hasSymbol?Symbol.for('react.scope'):0xead7;functionisValidElementType(type){returntypeoftype==='string'||typeoftype==='function'||// Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
type===REACT_FRAGMENT_TYPE||type===REACT_CONCURRENT_MODE_TYPE||type===REACT_PROFILER_TYPE||type===REACT_STRICT_MODE_TYPE||type===REACT_SUSPENSE_TYPE||type===REACT_SUSPENSE_LIST_TYPE||typeoftype==='object'&&type!==null&&(type.$$typeof===REACT_LAZY_TYPE||type.$$typeof===REACT_MEMO_TYPE||type.$$typeof===REACT_PROVIDER_TYPE||type.$$typeof===REACT_CONTEXT_TYPE||type.$$typeof===REACT_FORWARD_REF_TYPE||type.$$typeof===REACT_FUNDAMENTAL_TYPE||type.$$typeof===REACT_RESPONDER_TYPE||type.$$typeof===REACT_SCOPE_TYPE||type.$$typeof===REACT_BLOCK_TYPE);}functiontypeOf(object){if(typeofobject==='object'&&object!==null){var$$typeof=object.$$typeof;switch($$typeof){caseREACT_ELEMENT_TYPE:vartype=object.type;switch(type){caseREACT_ASYNC_MODE_TYPE:caseREACT_CONCURRENT_MODE_TYPE:caseREACT_FRAGMENT_TYPE:caseREACT_PROFILER_TYPE:caseREACT_STRICT_MODE_TYPE:caseREACT_SUSPENSE_TYPE:returntype;default:var$$typeofType=type&&type.$$typeof;switch($$typeofType){caseREACT_CONTEXT_TYPE:caseREACT_FORWARD_REF_TYPE:caseREACT_LAZY_TYPE:caseREACT_MEMO_TYPE:caseREACT_PROVIDER_TYPE:return$$typeofType;default:return$$typeof;}}caseREACT_PORTAL_TYPE:return$$typeof;}}returnundefined;}// AsyncMode is deprecated along with isAsyncMode
varAsyncMode=REACT_ASYNC_MODE_TYPE;varConcurrentMode=REACT_CONCURRENT_MODE_TYPE;varContextConsumer=REACT_CONTEXT_TYPE;varContextProvider=REACT_PROVIDER_TYPE;varElement=REACT_ELEMENT_TYPE;varForwardRef=REACT_FORWARD_REF_TYPE;varFragment=REACT_FRAGMENT_TYPE;varLazy=REACT_LAZY_TYPE;varMemo=REACT_MEMO_TYPE;varPortal=REACT_PORTAL_TYPE;varProfiler=REACT_PROFILER_TYPE;varStrictMode=REACT_STRICT_MODE_TYPE;varSuspense=REACT_SUSPENSE_TYPE;varhasWarnedAboutDeprecatedIsAsyncMode=false;// AsyncMode should be deprecated
functionisAsyncMode(object){{if(!hasWarnedAboutDeprecatedIsAsyncMode){hasWarnedAboutDeprecatedIsAsyncMode=true;// Using console['warn'] to evade Babel and ESLint
console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, '+'and will be removed in React 17+. Update your code to use '+'ReactIs.isConcurrentMode() instead. It has the exact same API.');}}returnisConcurrentMode(object)||typeOf(object)===REACT_ASYNC_MODE_TYPE;}functionisConcurrentMode(object){returntypeOf(object)===REACT_CONCURRENT_MODE_TYPE;}functionisContextConsumer(object){returntypeOf(object)===REACT_CONTEXT_TYPE;}functionisContextProvider(object){returntypeOf(object)===REACT_PROVIDER_TYPE;}functionisElement(object){returntypeofobject==='object'&&object!==null&&object.$$typeof===REACT_ELEMENT_TYPE;}functionisForwardRef(object){returntypeOf(object)===REACT_FORWARD_REF_TYPE;}functionisFragment(object){returntypeOf(object)===REACT_FRAGMENT_TYPE;}functionisLazy(object){returntypeOf(object)===REACT_LAZY_TYPE;}functionisMemo(object){returntypeOf(object)===REACT_MEMO_TYPE;}functionisPortal(object){returntypeOf(object)===REACT_PORTAL_TYPE;}functionisProfiler(object){returntypeOf(object)===REACT_PROFILER_TYPE;}functionisStrictMode(object){returntypeOf(object)===REACT_STRICT_MODE_TYPE;}functionisSuspense(object){returntypeOf(object)===REACT_SUSPENSE_TYPE;}exports.AsyncMode=AsyncMode;exports.ConcurrentMode=ConcurrentMode;exports.ContextConsumer=ContextConsumer;exports.ContextProvider=ContextProvider;exports.Element=Element;exports.ForwardRef=ForwardRef;exports.Fragment=Fragment;exports.Lazy=Lazy;exports.Memo=Memo;exports.Portal=Portal;exports.Profiler=Profiler;exports.StrictMode=StrictMode;exports.Suspense=Suspense;exports.isAsyncMode=isAsyncMode;exports.isConcurrentMode=isConcurrentMode;exports.isContextConsumer=isContextConsumer;exports.isContextProvider=isContextProvider;exports.isElement=isElement;exports.isForwardRef=isForwardRef;exports.isFragment=isFragment;exports.isLazy=isLazy;exports.isMemo=isMemo;exports.isPortal=isPortal;exports.isProfiler=isProfiler;exports.isStrictMode=isStrictMode;exports.isSuspense=isSuspense;exports.isValidElementType=isValidElementType;exports.typeOf=typeOf;})();}
varindex=memoize(function(prop){returnreactPropsRegex.test(prop)||prop.charCodeAt(0)===111/* o */&&prop.charCodeAt(1)===110/* n */&&prop.charCodeAt(2)<91;}/* Z+1 */);
functionv(){return(v=Object.assign||function(e){for(vart=1;t<arguments.length;t++){varn=arguments[t];for(varrinn)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r]);}returne;}).apply(this,arguments);}varg=function(e,t){for(varn=[e[0]],r=0,o=t.length;r<o;r+=1)n.push(t[r],e[r+1]);returnn;},S=function(t){returnnull!==t&&"object"==typeoft&&"[object Object]"===(t.toString?t.toString():Object.prototype.toString.call(t))&&!reactIs.typeOf(t);},w=Object.freeze([]),E=Object.freeze({});functionb(e){return"function"==typeofe;}function_(e){return"string"==typeofe&&e||e.displayName||e.name||"Component";}functionN(e){returne&&"string"==typeofe.styledComponentId;}varA="undefined"!=typeofprocess&&(process.env.REACT_APP_SC_ATTR||process.env.SC_ATTR)||"data-styled",I="undefined"!=typeofwindow&&"HTMLElement"inwindow,P=Boolean("boolean"==typeofSC_DISABLE_SPEEDY?SC_DISABLE_SPEEDY:"undefined"!=typeofprocess&&void0!==process.env.REACT_APP_SC_DISABLE_SPEEDY&&""!==process.env.REACT_APP_SC_DISABLE_SPEEDY?"false"!==process.env.REACT_APP_SC_DISABLE_SPEEDY&&process.env.REACT_APP_SC_DISABLE_SPEEDY:"undefined"!=typeofprocess&&void0!==process.env.SC_DISABLE_SPEEDY&&""!==process.env.SC_DISABLE_SPEEDY?"false"!==process.env.SC_DISABLE_SPEEDY&&process.env.SC_DISABLE_SPEEDY:"production"!==undefined),R={1:"Cannot create styled-component for component: %s.\n\n",2:"Can't collect styles once you've consumed a `ServerStyleSheet`'s styles! `ServerStyleSheet` is a one off instance for each server-side render cycle.\n\n- Are you trying to reuse it across renders?\n- Are you accidentally calling collectStyles twice?\n\n",3:"Streaming SSR is only supported in a Node.js environment; Please do not try to call this method in the browser.\n\n",4:"The `StyleSheetManager` expects a valid target or sheet prop!\n\n- Does this error occur on the client and is your target falsy?\n- Does this error occur on the server and is the sheet falsy?\n\n",5:"The clone method cannot be used on the client!\n\n- Are you running in a client-like environment on the server?\n- Are you trying to run SSR on the client?\n\n",6:"Trying to insert a new style tag, but the given Node is unmounted!\n\n- Are you using a custom target that isn't mounted?\n- Does your document not have a valid head element?\n- Have you accidentally removed a style tag manually?\n\n",7:'ThemeProvider: Please return an object from your "theme" prop function, e.g.\n\n```js\ntheme={() => ({})}\n```\n\n',8:'ThemeProvider: Please make your "theme" prop an object.\n\n',9:"Missing document `<head>`\n\n",10:"Cannot find a StyleSheet instance. Usually this happens if there are multiple copies of styled-components loaded at once. Check out this issue for how to troubleshoot and fix the common cases where this situation can happen: https://github.com/styled-components/styled-components/issues/1941#issuecomment-417862021\n\n",11:"_This error was replaced with a dev-time warning, it will be deleted for v4 final._ [createGlobalStyle] received children which will not be rendered. Please use the component without passing children elements.\n\n",12:"It seems you are interpolating a keyframe declaration (%s) into an untagged string. This was supported in styled-components v3, but is not longer supported in v4 as keyframes are now injected on-demand. Please wrap your string in the css\\`\\` helper which ensures the styles are injected correctly. See https://www.styled-components.com/docs/api#css\n\n",13:"%s is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.\n\n",14:'ThemeProvider: "theme" prop is required.\n\n',15:"Astylispluginhasbeensuppliedthatisnotnamed.Weneedanameforeachplugintobeabletopreventstylingcollisionsbetweendifferentstylisconfigurationswithinthesameapp.Beforeyoupassyourpluginto`<StyleSheetManager stylisPlugins={[]}>`,pleasemakesureeachpluginisuniquely-named,e.g.\n\n```js\nObject.defineProperty(importedPlugin, 'name', { value
*/function checkPropTypes(typeSpecs,values,location,componentName,getStack){{for(var typeSpecName in typeSpecs){if(has(typeSpecs,typeSpecName)){var error;//Proptypevalidationmaythrow.Incasetheydo,wedon'twantto
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try{// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if(typeoftypeSpecs[typeSpecName]!=='function'){varerr=Error((componentName||'React class')+': '+location+' type `'+typeSpecName+'` is invalid; '+'it must be a function, usually from the `prop-types` package, but received `'+typeoftypeSpecs[typeSpecName]+'`.');err.name='Invariant Violation';throwerr;}error=typeSpecs[typeSpecName](values,typeSpecName,componentName,location,null,ReactPropTypesSecret$1);}catch(ex){error=ex;}if(error&&!(errorinstanceofError)){printWarning((componentName||'React class')+': type specification of '+location+' `'+typeSpecName+'` is invalid; the type checker '+'function must return `null` or an `Error` but returned a '+typeoferror+'. '+'You may have forgotten to pass an argument to the type checker '+'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and '+'shape all require an argument).');}if(errorinstanceofError&&!(error.messageinloggedTypeFailures)){// Only monitor this failure once because there tends to be a lot of the
varhas$1=Function.call.bind(Object.prototype.hasOwnProperty);varprintWarning$1=function(){};{printWarning$1=function(text){varmessage='Warning: '+text;if(typeofconsole!=='undefined'){console.error(message);}try{// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
thrownewError(message);}catch(x){}};}functionemptyFunctionThatReturnsNull(){returnnull;}varfactoryWithTypeCheckers=function(isValidElement,throwOnDirectAccess){/* global Symbol */varITERATOR_SYMBOL=typeofSymbol==='function'&&Symbol.iterator;varFAUX_ITERATOR_SYMBOL='@@iterator';// Before Symbol spec.
PropTypeError.prototype=Error.prototype;functioncreateChainableTypeChecker(validate){{varmanualPropTypeCallCache={};varmanualPropTypeWarningCount=0;}functioncheckType(isRequired,props,propName,componentName,location,propFullName,secret){componentName=componentName||ANONYMOUS;propFullName=propFullName||propName;if(secret!==ReactPropTypesSecret_1){if(throwOnDirectAccess){// New behavior only for users of `prop-types` package
varerr=newError('Calling PropTypes validators directly is not supported by the `prop-types` package. '+'Use `PropTypes.checkPropTypes()` to call them. '+'Read more at http://fb.me/use-check-prop-types');err.name='Invariant Violation';throwerr;}elseif(typeofconsole!=='undefined'){// Old behavior for people using React.PropTypes
varcacheKey=componentName+':'+propName;if(!manualPropTypeCallCache[cacheKey]&&// Avoid spamming the console because they are often not actionable except for lib authors
manualPropTypeWarningCount<3){printWarning$1('You are manually calling a React.PropTypes validation '+'function for the `'+propFullName+'` prop on `'+componentName+'`. This is deprecated '+'and will throw in the standalone `prop-types` package. '+'You may be seeing this warning due to a third-party PropTypes '+'library. See https://fb.me/react-warning-dont-call-proptypes '+'for details.');manualPropTypeCallCache[cacheKey]=true;manualPropTypeWarningCount++;}}}if(props[propName]==null){if(isRequired){if(props[propName]===null){returnnewPropTypeError('The '+location+' `'+propFullName+'` is marked as required '+('in `'+componentName+'`, but its value is `null`.'));}returnnewPropTypeError('The '+location+' `'+propFullName+'` is marked as required in '+('`'+componentName+'`, but its value is `undefined`.'));}returnnull;}else{returnvalidate(props,propName,componentName,location,propFullName);}}varchainedCheckType=checkType.bind(null,false);chainedCheckType.isRequired=checkType.bind(null,true);returnchainedCheckType;}functioncreatePrimitiveTypeChecker(expectedType){functionvalidate(props,propName,componentName,location,propFullName,secret){varpropValue=props[propName];varpropType=getPropType(propValue);if(propType!==expectedType){// `propValue` being instance of, say, date/regexp, pass the 'object'
// check, but we can offer a more precise error message here rather than
// 'of type `object`'.
varpreciseType=getPreciseType(propValue);returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` of type '+('`'+preciseType+'` supplied to `'+componentName+'`, expected ')+('`'+expectedType+'`.'));}returnnull;}returncreateChainableTypeChecker(validate);}functioncreateAnyTypeChecker(){returncreateChainableTypeChecker(emptyFunctionThatReturnsNull);}functioncreateArrayOfTypeChecker(typeChecker){functionvalidate(props,propName,componentName,location,propFullName){if(typeoftypeChecker!=='function'){returnnewPropTypeError('Property `'+propFullName+'` of component `'+componentName+'` has invalid PropType notation inside arrayOf.');}varpropValue=props[propName];if(!Array.isArray(propValue)){varpropType=getPropType(propValue);returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` of type '+('`'+propType+'` supplied to `'+componentName+'`, expected an array.'));}for(vari=0;i<propValue.length;i++){varerror=typeChecker(propValue,i,componentName,location,propFullName+'['+i+']',ReactPropTypesSecret_1);if(errorinstanceofError){returnerror;}}returnnull;}returncreateChainableTypeChecker(validate);}functioncreateElementTypeChecker(){functionvalidate(props,propName,componentName,location,propFullName){varpropValue=props[propName];if(!isValidElement(propValue)){varpropType=getPropType(propValue);returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` of type '+('`'+propType+'` supplied to `'+componentName+'`, expected a single ReactElement.'));}returnnull;}returncreateChainableTypeChecker(validate);}functioncreateElementTypeTypeChecker(){functionvalidate(props,propName,componentName,location,propFullName){varpropValue=props[propName];if(!reactIs.isValidElementType(propValue)){varpropType=getPropType(propValue);returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` of type '+('`'+propType+'` supplied to `'+componentName+'`, expected a single ReactElement type.'));}returnnull;}returncreateChainableTypeChecker(validate);}functioncreateInstanceTypeChecker(expectedClass){functionvalidate(props,propName,componentName,location,propFullName){if(!(props[propName]instanceofexpectedClass)){varexpectedClassName=expectedClass.name||ANONYMOUS;varactualClassName=getClassName(props[propName]);returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` of type '+('`'+actualClassName+'` supplied to `'+componentName+'`, expected ')+('instance of `'+expectedClassName+'`.'));}returnnull;}returncreateChainableTypeChecker(validate);}functioncreateEnumTypeChecker(expectedValues){if(!Array.isArray(expectedValues)){{if(arguments.length>1){printWarning$1('Invalid arguments supplied to oneOf, expected an array, got '+arguments.length+' arguments. '+'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).');}else{printWarning$1('Invalid argument supplied to oneOf, expected an array.');}}returnemptyFunctionThatReturnsNull;}functionvalidate(props,propName,componentName,location,propFullName){varpropValue=props[propName];for(vari=0;i<expectedValues.length;i++){if(is(propValue,expectedValues[i])){returnnull;}}varvaluesString=JSON.stringify(expectedValues,functionreplacer(key,value){vartype=getPreciseType(value);if(type==='symbol'){returnString(value);}returnvalue;});returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` of value `'+String(propValue)+'` '+('supplied to `'+componentName+'`, expected one of '+valuesString+'.'));}returncreateChainableTypeChecker(validate);}functioncreateObjectOfTypeChecker(typeChecker){functionvalidate(props,propName,componentName,location,propFullName){if(typeoftypeChecker!=='function'){returnnewPropTypeError('Property `'+propFullName+'` of component `'+componentName+'` has invalid PropType notation inside objectOf.');}varpropValue=props[propName];varpropType=getPropType(propValue);if(propType!=='object'){returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` of type '+('`'+propType+'` supplied to `'+componentName+'`, expected an object.'));}for(varkeyinpropValue){if(has$1(propValue,key)){varerr
// props.
varallKeys=objectAssign({},props[propName],shapeTypes);for(varkeyinallKeys){varchecker=shapeTypes[key];if(!checker){returnnewPropTypeError('Invalid '+location+' `'+propFullName+'` key `'+key+'` supplied to `'+componentName+'`.'+'\nBad object: '+JSON.stringify(props[propName],null,' ')+'\nValid keys: '+JSON.stringify(Object.keys(shapeTypes),null,' '));}varerror=checker(propValue,key,componentName,location,propFullName+'.'+key,ReactPropTypesSecret_1);if(error){returnerror;}}returnnull;}returncreateChainableTypeChecker(validate);}functionisNode(propValue){switch(typeofpropValue){case'number':case'string':case'undefined':returntrue;case'boolean':return!propValue;case'object':if(Array.isArray(propValue)){returnpropValue.every(isNode);}if(propValue===null||isValidElement(propValue)){returntrue;}variteratorFn=getIteratorFn(propValue);if(iteratorFn){variterator=iteratorFn.call(propValue);varstep;if(iteratorFn!==propValue.entries){while(!(step=iterator.next()).done){if(!isNode(step.value)){returnfalse;}}}else{// Iterator will provide entry [k,v] tuples rather than values.
if(propValue['@@toStringTag']==='Symbol'){returntrue;}// Fallback for non-spec compliant Symbols which are polyfilled.
if(typeofSymbol==='function'&&propValueinstanceofSymbol){returntrue;}returnfalse;}// Equivalent of `typeof` but with special handling for array and regexp.
functiongetPropType(propValue){varpropType=typeofpropValue;if(Array.isArray(propValue)){return'array';}if(propValueinstanceofRegExp){// Old webkits (at least until Android 4.0) return 'function' rather than
// 'object' for typeof a RegExp. We'll normalize this here so that /bla/
// passes PropTypes.object.
return'object';}if(isSymbol(propType,propValue)){return'symbol';}returnpropType;}// This handles more types than `getPropType`. Only used for error messages.
// See `createPrimitiveTypeChecker`.
functiongetPreciseType(propValue){if(typeofpropValue==='undefined'||propValue===null){return''+propValue;}varpropType=getPropType(propValue);if(propType==='object'){if(propValueinstanceofDate){return'date';}elseif(propValueinstanceofRegExp){return'regexp';}}returnpropType;}// Returns a string that is postfixed to a warning about an invalid type.
// For example, "undefined" or "of type array"
functiongetPostfixForTypeWarning(value){vartype=getPreciseType(value);switch(type){case'array':case'object':return'an '+type;case'boolean':case'date':case'regexp':return'a '+type;default:returntype;}}// Returns class name of the object, if any.
// Since the DOM API does not support namespaces we need to manually search the returned list http://www.w3.org/TR/selectors-api/
Array.prototype.slice.call(container.querySelectorAll('svg')).filter(functionfilterChartistSvgObjects(svg){returnsvg.getAttributeNS(Chartist.namespaces.xmlns,'ct');}).forEach(functionremovePreviousElement(svg){container.removeChild(svg);});// Create svg object with width and height or use 100% as default
svg=newChartist.Svg('svg').attr({width:width,height:height}).addClass(className);svg._node.style.width=width;svg._node.style.height=height;// Add the DOM node to our container
output.normalized.series=Chartist.getDataArray({series:data.series||[]},reverse,multi);// If all elements of the normalized data array are arrays we're dealing with
// multi series data and we need to find the largest series if they are un-even
if(output.normalized.series.every(function(value){returnvalueinstanceofArray;})){// Getting the series with the the most elements
labelCount=Math.max.apply(null,output.normalized.series.map(function(series){returnseries.length;}));}else{// We're dealing with Pie data so we just take the normalized array length
labelCount=output.normalized.series.length;}output.normalized.labels=(data.labels||[]).slice();// Padding the labels to labelCount with empty strings
// to values. Check the tests in data core -> data normalization for a detailed specification of expected values
functionrecursiveConvert(value){if(Chartist.safeHasProperty(value,'value')){// We are dealing with value object notation so we need to recurse on value property
returnrecursiveConvert(value.value);}elseif(Chartist.safeHasProperty(value,'data')){// We are dealing with series object notation so we need to recurse on data property
returnrecursiveConvert(value.data);}elseif(valueinstanceofArray){// Data is of type array so we need to recurse on the series
returnvalue.map(recursiveConvert);}elseif(Chartist.isDataHoleValue(value)){// We're dealing with a hole in the data and therefore need to return undefined
// We're also returning undefined for multi value output
returnundefined;}else{// We need to prepare multi value output (x and y data)
if(multi){varmultiValue={};// Single series value arrays are assumed to specify the Y-Axis value
// If multi is a string then it's assumed that it specified which dimension should be filled as default
if(typeofmulti==='string'){multiValue[multi]=Chartist.getNumberOrUndefined(value);}else{multiValue.y=Chartist.getNumberOrUndefined(value);}multiValue.x=value.hasOwnProperty('x')?Chartist.getNumberOrUndefined(value.x):multiValue.x;multiValue.y=value.hasOwnProperty('y')?Chartist.getNumberOrUndefined(value.y):multiValue.y;returnmultiValue;}else{// We can return simple data
options=Chartist.extend({},options,dimension?options['axis'+dimension.toUpperCase()]:{});varhighLow={high:options.high===undefined?-Number.MAX_VALUE:+options.high,low:options.low===undefined?Number.MAX_VALUE:+options.low};varfindHigh=options.high===undefined;varfindLow=options.low===undefined;// Function to recursively walk through arrays and find highest and lowest number
functionrecursiveHighLow(data){if(data===undefined){returnundefined;}elseif(datainstanceofArray){for(vari=0;i<data.length;i++){recursiveHighLow(data[i]);}}else{varvalue=dimension?+data[dimension]:+data;if(findHigh&&value>highLow.high){highLow.high=value;}if(findLow&&value<highLow.low){highLow.low=value;}}}// Start to find highest and lowest number recursively
if(findHigh||findLow){recursiveHighLow(data);}// Overrides of high / low based on reference value, it will make sure that the invisible reference value is
// used to generate the chart. This is useful when the chart always needs to contain the position of the
// invisible reference value in the view i.e. for bipolar scales.
if(options.referenceValue||options.referenceValue===0){highLow.high=Math.max(options.referenceValue,highLow.high);highLow.low=Math.min(options.referenceValue,highLow.low);}// If high and low are the same because of misconfiguration or flat data (only the same value) we need
// to set the high or low to 0 depending on the polarity
if(highLow.high<=highLow.low){// If both values are 0 we set high to 1
if(highLow.low===0){highLow.high=1;}elseif(highLow.low<0){// If we have the same negative value for the bounds we set bounds.high to 0
highLow.high=0;}elseif(highLow.high>0){// If we have the same positive value for the bounds we set bounds.low to 0
highLow.low=0;}else{// If data array was empty, values are Number.MAX_VALUE and -Number.MAX_VALUE. Set bounds to prevent errors
*Getsavaluefromadimension`value.x`or`value.y`whilereturningvaluedirectlyifit's a valid numeric value. If the value is not numeric and it'sfalseythisfunctionwillreturn`defaultValue`.
// If we are already below the scaleMinSpace value we will scale up
varlength=Chartist.projectLength(axisLength,bounds.step,bounds);varscaleUp=length<scaleMinSpace;varsmallestFactor=onlyInteger?Chartist.rho(bounds.range):0;// First check if we should only use integer steps and if step 1 is still larger than scaleMinSpace so we can use 1
if(onlyInteger&&Chartist.projectLength(axisLength,1,bounds)>=scaleMinSpace){bounds.step=1;}elseif(onlyInteger&&smallestFactor<bounds.step&&Chartist.projectLength(axisLength,smallestFactor,bounds)>=scaleMinSpace){// If step 1 was too small, we can try the smallest factor of range
// If the smallest factor is smaller than the current bounds.step and the projected length of smallest factor
// is larger than the scaleMinSpace we should go for it.
bounds.step=smallestFactor;}else{// Trying to divide or multiply by 2 and find the best step value
while(true){if(scaleUp&&Chartist.projectLength(axisLength,bounds.step,bounds)<=scaleMinSpace){bounds.step*=2;}elseif(!scaleUp&&Chartist.projectLength(axisLength,bounds.step/2,bounds)>=scaleMinSpace){bounds.step/=2;if(onlyInteger&&bounds.step%1!==0){bounds.step*=2;break;}}else{break;}if(optimizationCounter++>1000){thrownewError('Exceeded maximum number of iterations while optimizing scale step!');}}}varEPSILON=2.221E-16;bounds.step=Math.max(bounds.step,EPSILON);functionsafeIncrement(value,increment){// If increment is too small use *= (1+EPSILON) as a simple nextafter
if(value===(value+=increment)){value*=1+(increment>0?EPSILON:-EPSILON);}returnvalue;}// Narrow min and max based on new step
varwidth=svg.width()||Chartist.quantity(options.width).value||0;varheight=svg.height()||Chartist.quantity(options.height).value||0;varnormalizedPadding=Chartist.normalizePadding(options.chartPadding,fallbackPadding);// If settings were to small to cope with offset (legacy) and padding, we'll adjust
*/Chartist.optionsProvider=function(options,responsiveOptions,eventEmitter){var baseOptions=Chartist.extend({},options),currentOptions,mediaQueryListeners=[],i;function updateCurrentOptions(mediaEvent){var previousOptions=currentOptions;currentOptions=Chartist.extend({},baseOptions);if(responsiveOptions){for(i=0;i<responsiveOptions.length;i++){var mql=window.matchMedia(responsiveOptions[i][0]);if(mql.matches){currentOptions=Chartist.extend(currentOptions,responsiveOptions[i][1]);}}}if(eventEmitter&&mediaEvent){eventEmitter.emit('optionsChanged',{previousOptions:previousOptions,currentOptions:currentOptions});}}function removeMediaQueryListeners(){mediaQueryListeners.forEach(function(mql){mql.removeListener(updateCurrentOptions);});}if(!window.matchMedia){throw 'window.matchMedia not found! Make sure you\'re using a polyfill.';}else if(responsiveOptions){for(i=0;i<responsiveOptions.length;i++){var mql=window.matchMedia(responsiveOptions[i][0]);mql.addListener(updateCurrentOptions);mediaQueryListeners.push(mql);}}//Executeinitiallywithoutaneventargumentsowegetthecorrectoptions
*// If fillHoles is true, undefined values are simply discarded without creating a new segment. Assuming other options are default, this returns single segment.
*fillHoles:false,
*// If increasingX is true, the coordinates in all segments have strictly increasing x-values.
if(!options.fillHoles){hole=true;}}else{if(options.increasingX&&i>=2&&pathCoordinates[i]<=pathCoordinates[i-2]){// X is not increasing, so we need to make sure we start a new segment
hole=true;}// If it's a valid value we need to check if we're coming out of a hole and create a new empty segment
if(hole){segments.push({pathCoordinates:[],valueData:[]});// As we have a valid value now, we are not in a "hole" anymore
hole=false;}// Add to the segment pathCoordinates and valueData
*Simplesmoothingcanbeusedinsteadof`Chartist.Smoothing.cardinal`ifyou'd like to get rid of the artifacts it produces sometimes. Simple smoothing produces less flowing lines but is accurate by hitting the points and it also doesn'tswingbeloworabovethegivendatapoint.
*/Chartist.Interpolation.cardinal=function(options){var defaultOptions={tension:1,fillHoles:false};options=Chartist.extend({},defaultOptions,options);var t=Math.min(1,Math.max(0,options.tension)),c=1-t;return function cardinal(pathCoordinates,valueData){//Firstwetrytosplitthecoordinatesintosegments
// This is necessary to treat "holes" in line charts
varsegments=Chartist.splitIntoSegments(pathCoordinates,valueData,{fillHoles:options.fillHoles});if(!segments.length){// If there were no segments return 'Chartist.Interpolation.none'
returnChartist.Interpolation.none()([]);}elseif(segments.length>1){// If the split resulted in more that one segment we need to interpolate each segment individually and join them
// afterwards together into a single path.
varpaths=[];// For each segment we will recurse the cardinal function
segments.forEach(function(segment){paths.push(cardinal(segment.pathCoordinates,segment.valueData));});// Join the segment path data into a single path and return
returnChartist.Svg.Path.join(paths);}else{// If there was only one segment we can proceed regularly by using pathCoordinates and valueData from the first
// segment
pathCoordinates=segments[0].pathCoordinates;valueData=segments[0].valueData;// If less than two points we need to fallback to no smoothing
*/Chartist.Interpolation.monotoneCubic=function(options){var defaultOptions={fillHoles:false};options=Chartist.extend({},defaultOptions,options);return function monotoneCubic(pathCoordinates,valueData){//Firstwetrytosplitthecoordinatesintosegments
// This is necessary to treat "holes" in line charts
varsegments=Chartist.splitIntoSegments(pathCoordinates,valueData,{fillHoles:options.fillHoles,increasingX:true});if(!segments.length){// If there were no segments return 'Chartist.Interpolation.none'
returnChartist.Interpolation.none()([]);}elseif(segments.length>1){// If the split resulted in more that one segment we need to interpolate each segment individually and join them
// afterwards together into a single path.
varpaths=[];// For each segment we will recurse the monotoneCubic fn function
segments.forEach(function(segment){paths.push(monotoneCubic(segment.pathCoordinates,segment.valueData));});// Join the segment path data into a single path and return
returnChartist.Svg.Path.join(paths);}else{// If there was only one segment we can proceed regularly by using pathCoordinates and valueData from the first
// segment
pathCoordinates=segments[0].pathCoordinates;valueData=segments[0].valueData;// If less than three points we need to fallback to no smoothing
if(pathCoordinates.length<=4){returnChartist.Interpolation.none()(pathCoordinates,valueData);}varxs=[],ys=[],i,n=pathCoordinates.length/2,ms=[],ds=[],dys=[],dxs=[],path;// Populate x and y coordinates into separate arrays, for readability
for(i=0;i<n;i++){xs[i]=pathCoordinates[i*2];ys[i]=pathCoordinates[i*2+1];}// Calculate deltas and derivative
for(i=0;i<n-1;i++){dys[i]=ys[i+1]-ys[i];dxs[i]=xs[i+1]-xs[i];ds[i]=dys[i]/dxs[i];}// Determine desired slope (m) at each point using Fritsch-Carlson method
ms[0]=ds[0];ms[n-1]=ds[n-2];for(i=1;i<n-1;i++){if(ds[i]===0||ds[i-1]===0||ds[i-1]>0!==ds[i]>0){ms[i]=0;}else{ms[i]=3*(dxs[i-1]+dxs[i])/((2*dxs[i]+dxs[i-1])/ds[i-1]+(dxs[i]+2*dxs[i-1])/ds[i]);if(!isFinite(ms[i])){ms[i]=0;}}}// Now build a path from the slopes
path=newChartist.Svg.Path().move(xs[0],ys[0],false,valueData[0]);for(i=0;i<n-1;i++){path.curve(// First control point
xs[i]+dxs[i]/3,ys[i]+ms[i]*dxs[i]/3,// Second control point
xs[i+1]-dxs[i]/3,ys[i+1]-ms[i+1]*dxs[i]/3,// End point
if(currData.value!==undefined){if(prevData===undefined){path.move(currX,currY,false,currData);}else{if(options.postpone){// If postponed we should draw the step line with the value of the previous value
path.line(currX,prevY,false,prevData);}else{// If not postponed we should draw the step line with the value of the current value
path.line(prevX,currY,false,currData);}// Line to the actual point (this should only be a Y-Axis movement
if(handlers[event]){// If handler is set we will look for a specific handler and only remove this
if(handler){handlers[event].splice(handlers[event].indexOf(handler),1);if(handlers[event].length===0){deletehandlers[event];}}else{// If no handler is specified we remove all handlers for this event
// To provide a fallback we will instantiate here and return the instance
instance=this===Chartist?Object.create(proto):this;fn.apply(instance,Array.prototype.slice.call(arguments,0));// If this constructor was not called with new we need to return the instance
// This will not harm when the constructor has been called with new as the returned value is ignored
returninstance;};constr.prototype=proto;constr.super=superProto;constr.extend=this.extend;returnconstr;}// Variable argument list clones args > 0 into args[0] and retruns modified args[0]
functioncloneDefinitions(){varargs=listToArray(arguments);vartarget=args[0];args.splice(1,args.length-1).forEach(function(source){Object.getOwnPropertyNames(source).forEach(function(propName){// If this property already exist in target we delete it first
deletetarget[propName];// Define the property with the descriptor from source
this.eventEmitter.emit('data',{type:'update',data:this.data});}if(options){this.options=Chartist.extend({},override?this.options:this.defaultOptions,options);// If chartist was not initialized yet, we just set the options and leave the rest to the initialization
// Otherwise we re-create the optionsProvider at this point
if(!this.initializeTimeoutId){this.optionsProvider.removeMediaQueryListeners();this.optionsProvider=Chartist.optionsProvider(this.options,this.responsiveOptions,this.eventEmitter);}}// Only re-created the chart if it has been initialized yet
if(!this.initializeTimeoutId){this.createChart(this.optionsProvider.getCurrentOptions());}// Return a reference to the chart object to chain up calls
window.addEventListener('resize',this.resizeListener);// Obtain current options based on matching media queries (if responsive options are given)
// This will also register a listener that is re-creating the chart based on media changes
this.optionsProvider=Chartist.optionsProvider(this.options,this.responsiveOptions,this.eventEmitter);// Register options change listener that will trigger a chart update
this.eventEmitter.addEventHandler('optionsChanged',function(){this.update();}.bind(this));// Before the first chart creation we need to register us with all plugins that are configured
// Initialize all relevant plugins with our chart object and the plugin options specified in the config
if(this.options.plugins){this.options.plugins.forEach(function(plugin){if(plugininstanceofArray){plugin[0](this,plugin[1]);}else{plugin(this);}}.bind(this));}// Event for data transformation that allows to manipulate the data before it gets rendered in the charts
this.eventEmitter.emit('data',{type:'initial',data:this.data});// Create the first chart
this.createChart(this.optionsProvider.getCurrentOptions());// As chart is initialized from the event loop now we can reset our timeout reference
// This is important if the chart gets initialized on the same element twice
if(this.container.__chartist__){this.container.__chartist__.detach();}this.container.__chartist__=this;}// Using event loop for first draw to make it possible to register event listeners in the same call stack where
// the chart was created.
this.initializeTimeoutId=setTimeout(initialize.bind(this),0);}// Creating the chart base class
Chartist.Base=Chartist.Class.extend({constructor:Base,optionsProvider:undefined,container:undefined,svg:undefined,eventEmitter:undefined,createChart:function(){thrownewError('Base chart type can\'t be instantiated!');},update:update,detach:detach,on:on,off:off,version:Chartist.version,supportsForeignObject:false});})(this||commonjsGlobal,Chartist);/**
if(nameinstanceofElement){this._node=name;}else{this._node=document.createElementNS(Chartist.namespaces.svg,name);// If this is an SVG element created then custom namespace
*ThismethodcreatesaforeignObject(seehttps://developer.mozilla.org/en-US/docs/Web/SVG/Element/foreignObject) that allows to embed HTML content into a SVG graphic. With the help of foreignObjects you can enable the usage of regular HTML elements inside of SVG where they are subject for SVG positioning and transformation but the Browser will use the HTML rendering capabilities for the containing DOM.
// TODO: Handle case where content is not a string nor a DOM Node
if(typeofcontent==='string'){varcontainer=document.createElement('div');container.innerHTML=content;content=container.firstChild;}// Adding namespace to content element
content.setAttribute('xmlns',Chartist.namespaces.xmlns);// Creating the foreignObject without required extension attribute (as described here
*TheanimatefunctionletsyouanimatethecurrentelementwithSMILanimations.Youcanaddanimationsformultipleattributesatthesametimebyusingananimationdefinitionobject.ThisobjectshouldcontainSMILanimationattributes.Pleaserefertohttp://www.w3.org/TR/SVG/animate.html for a detailed specification about the available animation attributes. Additionally an easing property can be passed in the animation definition object. This can be a string with a name of an easing function in `Chartist.Svg.Easing` or an array with four numbers specifying a cubic Bézier curve.
*ThedefaultbehaviorofSMILanimationswithoffsetusingthe`begin`attributeisthattheattributewillkeepit's original value until the animation starts. Mostly this behavior is not desired as you'dliketohaveyourelementattributesalreadyinitializedwiththeanimation`from`valueevenbeforetheanimationstarts.Alsoifyoudon't specify `fill="freeze"` on an animate element or if you delete the animation after it'sdone(whichisdoneinguidedmode)theattributewillswitchbacktotheinitialvalue.Thisbehaviorisalsonotdesiredwhenperformingsimpleone-timeanimations.Forone-timeanimationsyou'd want to trigger animations immediately instead of relative to the document begin time. That'swhyinguidedmodeChartist.Svgwillalsousethe`begin`propertytoscheduleatimeoutandmanuallystarttheanimationafterthetimeout.Ifyou'reusingmultipleSMILdefinitionobjectsforanattribute(inanarray),guidedmodewillbedisabledforthisattribute,evenifyouexplicitlyenabledit.
if(animationDefinition.easing){// If already an easing Bézier curve array we take it or we lookup a easing array in the Easing object
easing=animationDefinition.easinginstanceofArray?animationDefinition.easing:Chartist.Svg.Easing[animationDefinition.easing];deleteanimationDefinition.easing;}// If numeric dur or begin was provided we assume milli seconds
animationDefinition.begin=Chartist.ensureUnit(animationDefinition.begin,'ms');animationDefinition.dur=Chartist.ensureUnit(animationDefinition.dur,'ms');if(easing){animationDefinition.calcMode='spline';animationDefinition.keySplines=easing.join(' ');animationDefinition.keyTimes='0;1';}// Adding "fill: freeze" if we are in guided mode and set initial attribute values
if(guided){animationDefinition.fill='freeze';// Animated property on our element should already be set to the animation from value in guided mode
attributeProperties[attribute]=animationDefinition.from;this.attr(attributeProperties);// In guided mode we also set begin to indefinite so we can trigger the start manually and put the begin
// which needs to be in ms aside
timeout=Chartist.quantity(animationDefinition.begin||0).value;animationDefinition.begin='indefinite';}animate=this.elem('animate',Chartist.extend({attributeName:attribute},animationDefinition));if(guided){// If guided we take the value that was put aside in timeout and trigger the animation manually with a timeout
setTimeout(function(){// If beginElement fails we set the animated attribute to the end position and remove the animate element
// This happens if the SMIL ElementTimeControl interface is not supported or any other problems occured in
// the browser. (Currently FF 34 does not support animate elements in foreignObjects)
try{animate._node.beginElement();}catch(err){// Set animated attribute to current animated value
attributeProperties[attribute]=animationDefinition.to;this.attr(attributeProperties);// Remove the animate element as it's no longer required
animate.remove();}}.bind(this),timeout);}if(eventEmitter){animate._node.addEventListener('beginEvent',functionhandleBeginEvent(){eventEmitter.emit('animationBegin',{element:this,animate:animate._node,params:animationDefinition});}.bind(this));}animate._node.addEventListener('endEvent',functionhandleEndEvent(){if(eventEmitter){eventEmitter.emit('animationEnd',{element:this,animate:animate._node,params:animationDefinition});}if(guided){// Set animated attribute to current animated value
attributeProperties[attribute]=animationDefinition.to;this.attr(attributeProperties);// Remove the animate element as it's no longer required
animate.remove();}}.bind(this));}// If current attribute is an array of definition objects we create an animate for each and disable guided mode
varchunks=path.replace(/([A-Za-z])([0-9])/g,'$1 $2').replace(/([0-9])([A-Za-z])/g,'$1 $2').split(/[\s,]+/).reduce(function(result,element){if(element.match(/[A-Za-z]/)){result.push([]);}result[result.length-1].push(element);returnresult;},[]);// If this is a closed path we remove the Z at the end because this is determined by the close option
if(chunks[chunks.length-1][0].toUpperCase()==='Z'){chunks.pop();}// Using svgPathElementDescriptions to map raw path arrays into objects that contain the command and the parameters
// For example {command: 'M', x: '10', y: '10'}
varelements=chunks.map(function(chunk){varcommand=chunk.shift(),description=elementDescriptions[command.toLowerCase()];returnChartist.extend({command:command},description.reduce(function(result,paramName,index){result[paramName]=+chunk[index];returnresult;},{}));});// Preparing a splice call with the elements array as var arg params and insert the parsed elements at the current position
varspliceArgs=[this.pos,0];Array.prototype.push.apply(spliceArgs,elements);Array.prototype.splice.apply(this.pathElements,spliceArgs);// Increase the internal position by the element count
*SplitaSvg.Pathobjectbyaspecificcommandinthepathchain.Thepathchainwillbesplitandanarrayofnewlycreatedpathsobjectswillbereturned.Thisisusefulifyou'd like to split an SVG path by it'smovecommands,forexample,inordertoisolatechunksofdrawings.
// Calculate how much space we have available for the label
varlabelLength;if(projectedValues[index+1]){// If we still have one label ahead, we can calculate the distance to the next tick / label
labelLength=projectedValues[index+1]-projectedValue;}else{// If we don't have a label ahead and we have only two labels in total, we just take the remaining distance to
// on the whole axis length. We limit that to a minimum of 30 pixel, so that labels close to the border will
// still be visible inside of the chart padding.
labelLength=Math.max(this.axisLength-projectedValue,30);}// Skip grid lines and labels where interpolated label values are falsey (execpt for 0)
if(Chartist.isFalseyButZero(labelValues[index])&&labelValues[index]!==''){return;}// Transform to global coordinates using the chartRect
// We also need to set the label offset for the createLabel function
if(this.units.pos==='x'){projectedValue=this.chartRect.x1+projectedValue;labelOffset.x=chartOptions.axisX.labelOffset.x;// If the labels should be positioned in start position (top side for vertical axis) we need to set a
// different offset as for positioned with end (bottom)
if(chartOptions.axisX.position==='start'){labelOffset.y=this.chartRect.padding.top+chartOptions.axisX.labelOffset.y+(useForeignObject?5:20);}else{labelOffset.y=this.chartRect.y1+chartOptions.axisX.labelOffset.y+(useForeignObject?5:20);}}else{projectedValue=this.chartRect.y1-projectedValue;labelOffset.y=chartOptions.axisY.labelOffset.y-(useForeignObject?labelLength:0);// If the labels should be positioned in start position (left side for horizontal axis) we need to set a
// different offset as for positioned with end (right side)
if(chartOptions.axisY.position==='start'){labelOffset.x=useForeignObject?this.chartRect.padding.left+chartOptions.axisY.labelOffset.x:this.chartRect.x1-10;}else{labelOffset.x=this.chartRect.x2+chartOptions.axisY.labelOffset.x+10;}}if(axisOptions.showGrid){Chartist.createGrid(projectedValue,index,this,this.gridOffset,this.chartRect[this.counterUnits.len](),gridGroup,[chartOptions.classNames.grid,chartOptions.classNames[this.units.dir]],eventEmitter);}if(axisOptions.showLabel){Chartist.createLabel(projectedValue,labelLength,index,labelValues,this,axisOptions.offset,labelOffset,labelGroup,[chartOptions.classNames.label,chartOptions.classNames[this.units.dir],axisOptions.position==='start'?chartOptions.classNames[axisOptions.position]:chartOptions.classNames['end']],useForeignObject,eventEmitter);}}.bind(this));}Chartist.Axis=Chartist.Class.extend({constructor:Axis,createGridAndLabels:createGridAndLabels,projectValue:function(value,index,data){thrownewError('Base axis can\'t be instantiated!');}});Chartist.Axis.units=axisUnits;})(this||commonjsGlobal,Chartist);/**
*// If high is specified then the axis will display values explicitly up to this value and the computed maximum from the data is ignored
*high:100,
*// If low is specified then the axis will display values explicitly down to this value and the computed minimum from the data is ignored
*low:0,
*// This option will be used when finding the right scale division settings. The amount of ticks on the scale will be determined so that as many ticks as possible will be displayed, while not violating this minimum required space (in pixel).
*scaleMinSpace:20,
*// Can be set to true or false. If set to true, the scale will be generated with whole numbers only.
*onlyInteger:true,
*// The reference value can be used to make sure that this value will always be on the chart. This is especially useful on bipolar charts where the bipolar center always needs to be part of the chart.
*// If high is specified then the axis will display values explicitly up to this value and the computed maximum from the data is ignored
*high:100,
*// If low is specified then the axis will display values explicitly down to this value and the computed minimum from the data is ignored
*low:0,
*// If specified then the value range determined from minimum to maximum (or low and high) will be divided by this number and ticks will be generated at those division points. The default divisor is 1.
*divisor:4,
*// If ticks is explicitly set, then the axis will not compute the ticks with the divisor, but directly use the data in ticks to determine at what points on the axis a tick need to be generated.
*// Ticks to be used to distribute across the axis length. As this axis type relies on the index of the value rather than the value, arbitrary data that can be converted to a string can be used as ticks.
*ticks:['One','Two','Three'],
*// If set to true the full width will be used to distribute the values where the last value will be at the maximum of the axis length. If false the spaces between the ticks will be evenly distributed instead.
axisX:{// The offset of the labels to the chart area
offset:30,// Position where labels are placed. Can be set to `start` or `end` where `start` is equivalent to left or top on vertical axis and `end` is equivalent to right or bottom on horizontal axis.
position:'end',// Allows you to correct label positioning on this axis by positive or negative x and y offset.
labelOffset:{x:0,y:0},// If labels should be shown or not
showLabel:true,// If the axis grid should be drawn or not
showGrid:true,// Interpolation function that allows you to intercept the value from the axis label
labelInterpolationFnc:Chartist.noop,// Set the axis type to be used to project values on this axis. If not defined, Chartist.StepAxis will be used for the X-Axis, where the ticks option will be set to the labels in the data and the stretch option will be set to the global fullWidth option. This type can be changed to any axis constructor available (e.g. Chartist.FixedScaleAxis), where all axis options should be present here.
type:undefined},// Options for Y-Axis
axisY:{// The offset of the labels to the chart area
offset:40,// Position where labels are placed. Can be set to `start` or `end` where `start` is equivalent to left or top on vertical axis and `end` is equivalent to right or bottom on horizontal axis.
position:'start',// Allows you to correct label positioning on this axis by positive or negative x and y offset.
labelOffset:{x:0,y:0},// If labels should be shown or not
showLabel:true,// If the axis grid should be drawn or not
showGrid:true,// Interpolation function that allows you to intercept the value from the axis label
labelInterpolationFnc:Chartist.noop,// Set the axis type to be used to project values on this axis. If not defined, Chartist.AutoScaleAxis will be used for the Y-Axis, where the high and low options will be set to the global high and low options. This type can be changed to any axis constructor available (e.g. Chartist.FixedScaleAxis), where all axis options should be present here.
type:undefined,// This value specifies the minimum height in pixel of the scale steps
scaleMinSpace:20,// Use only integer values (whole numbers) for the scale steps
onlyInteger:false},// Specify a fixed width for the chart as a string (i.e. '100px' or '50%')
width:undefined,// Specify a fixed height for the chart as a string (i.e. '100px' or '50%')
height:undefined,// If the line should be drawn or not
showLine:true,// If dots should be drawn or not
showPoint:true,// If the line chart should draw an area
showArea:false,// The base for the area chart that will be used to close the area shape (is normally 0)
areaBase:0,// Specify if the lines should be smoothed. This value can be true or false where true will result in smoothing using the default smoothing interpolation function Chartist.Interpolation.cardinal and false results in Chartist.Interpolation.none. You can also choose other smoothing / interpolation functions available in the Chartist.Interpolation module, or write your own interpolation function. Check the examples for a brief description.
lineSmooth:true,// If the line chart should add a background fill to the .ct-grids group.
showGridBackground:false,// Overriding the natural low of the chart allows you to zoom in or limit the charts lowest displayed value
low:undefined,// Overriding the natural high of the chart allows you to zoom in or limit the charts highest displayed value
high:undefined,// Padding of the chart drawing area to the container element and labels as a number or padding object {top: 5, right: 5, bottom: 5, left: 5}
chartPadding:{top:15,right:15,bottom:5,left:10},// When set to true, the last grid line on the x-axis is not drawn and the chart elements will expand to the full available width of the chart. For the last label to be drawn correctly you might need to add chart padding or offset the last label with a draw event handler.
fullWidth:false,// If true the whole data is reversed including labels, the series order as well as the whole series data arrays.
reverseData:false,// Override the class names that get used to generate the SVG structure of the chart
this.svg=Chartist.createSvg(this.container,options.width,options.height,options.classNames.chart);// Create groups for labels, grid and series
vargridGroup=this.svg.elem('g').addClass(options.classNames.gridGroup);varseriesGroup=this.svg.elem('g');varlabelGroup=this.svg.elem('g').addClass(options.classNames.labelGroup);varchartRect=Chartist.createChartRect(this.svg,options,defaultOptions.padding);varaxisX,axisY;if(options.axisX.type===undefined){axisX=newChartist.StepAxis(Chartist.Axis.units.x,data.normalized.series,chartRect,Chartist.extend({},options.axisX,{ticks:data.normalized.labels,stretch:options.fullWidth}));}else{axisX=options.axisX.type.call(Chartist,Chartist.Axis.units.x,data.normalized.series,chartRect,options.axisX);}if(options.axisY.type===undefined){axisY=newChartist.AutoScaleAxis(Chartist.Axis.units.y,data.normalized.series,chartRect,Chartist.extend({},options.axisY,{high:Chartist.isNumeric(options.high)?options.high:options.axisY.high,low:Chartist.isNumeric(options.low)?options.low:options.axisY.low}));}else{axisY=options.axisY.type.call(Chartist,Chartist.Axis.units.y,data.normalized.series,chartRect,options.axisY);}axisX.createGridAndLabels(gridGroup,labelGroup,this.supportsForeignObject,options,this.eventEmitter);axisY.createGridAndLabels(gridGroup,labelGroup,this.supportsForeignObject,options,this.eventEmitter);if(options.showGridBackground){Chartist.createGridBackground(gridGroup,chartRect,options.classNames.gridBackground,this.eventEmitter);}// Draw the series
data.raw.series.forEach(function(series,seriesIndex){varseriesElement=seriesGroup.elem('g');// Write attributes to series group element. If series name or meta is undefined the attributes will not be written
seriesElement.attr({'ct:series-name':series.name,'ct:meta':Chartist.serialize(series.meta)});// Use series class from series data or if not set generate one
seriesElement.addClass([options.classNames.series,series.className||options.classNames.series+'-'+Chartist.alphaNumerate(seriesIndex)].join(' '));varpathCoordinates=[],pathData=[];data.normalized.series[seriesIndex].forEach(function(value,valueIndex){varp={x:chartRect.x1+axisX.projectValue(value,valueIndex,data.normalized.series[seriesIndex]),y:chartRect.y1-axisY.projectValue(value,valueIndex,data.normalized.series[seriesIndex])};pathCoordinates.push(p.x,p.y);pathData.push({value:value,valueIndex:valueIndex,meta:Chartist.getMetaData(series,valueIndex)});}.bind(this));varseriesOptions={lineSmooth:Chartist.getSeriesOption(series,options,'lineSmooth'),showPoint:Chartist.getSeriesOption(series,options,'showPoint'),showLine:Chartist.getSeriesOption(series,options,'showLine'),showArea:Chartist.getSeriesOption(series,options,'showArea'),areaBase:Chartist.getSeriesOption(series,options,'areaBase')};varsmoothing=typeofseriesOptions.lineSmooth==='function'?seriesOptions.lineSmooth:seriesOptions.lineSmooth?Chartist.Interpolation.monotoneCubic():Chartist.Interpolation.none();// Interpolating path where pathData will be used to annotate each path element so we can trace back the original
// index, value and meta data
varpath=smoothing(pathCoordinates,pathData);// If we should show points we need to create them now to avoid secondary loop
// Points are drawn from the pathElements returned by the interpolation function
// Small offset for Firefox to render squares correctly
if(seriesOptions.showPoint){path.pathElements.forEach(function(pathElement){varpoint=seriesElement.elem('line',{x1:pathElement.x,y1:pathElement.y,x2:pathElement.x+0.01,y2:pathElement.y},options.classNames.point).attr({'ct:value':[pathElement.data.value.x,pathElement.data.value.y].filter(Chartist.isNumeric).join(','),'ct:meta':Chartist.serialize(pathElement.data.meta)});this.eventEmitter.emit('draw',{type:'point',value:pathElement.data.value,index:pathElement.data.valueIndex,meta:pathElement.data.meta,series:series,seriesIndex:seriesIndex,axisX:axisX,axisY:axisY,group:seriesElement,element:point,x:pathElement.x,y:pathElement.y});}.bind(this));}if(seriesOptions.showLine){varline=seriesElement.elem('path',{d:path.stringify()},options.classNames.line,true);this.eventEmitter.emit('draw',{type:'line',values:data.normalized.series[seriesIndex],path:path.clone(),chartRect:chartRect,index:seriesIndex,series:series,seriesIndex:seriesIndex,seriesMeta:series.meta,axisX:axisX,axisY:axisY,group:seriesElement,element:line});}// Area currently only works with axes that support a range!
if(seriesOptions.showArea&&axisY.range){// If areaBase is outside the chart area (< min or > max) we need to set it respectively so that
// the area is not drawn outside the chart area.
varareaBase=Math.max(Math.min(seriesOptions.areaBase,axisY.range.max),axisY.range.min);// We project the areaBase value into screen coordinates
varareaBaseProjected=chartRect.y1-axisY.projectValue(areaBase);// In order to form the area we'll first split the path by move commands so we can chunk it up into segments
path.splitByCommand('M').filter(functiononlySolidSegments(pathSegment){// We filter only "solid" segments that contain more than one point. Otherwise there's no need for an area
returnpathSegment.pathElements.length>1;}).map(functionconvertToArea(solidPathSegments){// Receiving the filtered solid path segments we can now convert those segments into fill areas
varfirstElement=solidPathSegments.pathElements[0];varlastElement=solidPathSegments.pathElements[solidPathSegments.pathElements.length-1];// Cloning the solid path segment with closing option and removing the first move command from the clone
// We then insert a new move that should start at the area base and draw a straight line up or down
// at the end of the path we add an additional straight line to the projected area base value
// As the closing option is set our path will be automatically closed
returnsolidPathSegments.clone(true).position(0).remove(1).move(firstElement.x,areaBaseProjected).line(firstElement.x,firstElement.y).position(solidPathSegments.pathElements.length+1).line(lastElement.x,areaBaseProjected);}).forEach(functioncreateArea(areaPath){// For each of our newly created area paths, we'll now create path elements by stringifying our path objects
// and adding the created DOM elements to the correct series group
vararea=seriesElement.elem('path',{d:areaPath.stringify()},options.classNames.area,true);// Emit an event for each area that was drawn
*// A labels array that can contain any sort of values
*labels:['Mon','Tue','Wed','Thu','Fri'],
*// Our series array that contains series objects or in this case series data arrays
*series:[
*[5,2,4,2,0]
*]
*};
*
*// As options we currently only set a static size of 300x200 px
*varoptions={
*width:'300px',
*height:'200px'
*};
*
*// In the global name space Chartist we call the Line function to initialize a line chart. As a first parameter we pass in a selector where we would like to get our chart created. Second parameter is the actual data object and as a third parameter we pass in our options
*newChartist.Line('.ct-chart',data,options);
*
*@example
*// Use specific interpolation function with configuration from the Chartist.Interpolation module
*
*varchart=newChartist.Line('.ct-chart',{
*labels:[1,2,3,4,5],
*series:[
*[1,1,8,1,7]
*]
*},{
*lineSmooth:Chartist.Interpolation.cardinal({
*tension:0.2
*})
*});
*
*@example
*// Create a line chart with responsive options
*
*vardata={
*// A labels array that can contain any sort of values
*// Our series array that contains series objects or in this case series data arrays
*series:[
*[5,2,4,2,0]
*]
*};
*
*// In addition to the regular options we specify responsive option overrides that will override the default configutation based on the matching media queries.
*varresponsiveOptions=[
*['screen and (min-width: 641px) and (max-width: 1024px)',{
*showPoint:false,
*axisX:{
*labelInterpolationFnc:function(value){
*// Will return Mon, Tue, Wed etc. on medium screens
axisX:{// The offset of the chart drawing area to the border of the container
offset:30,// Position where labels are placed. Can be set to `start` or `end` where `start` is equivalent to left or top on vertical axis and `end` is equivalent to right or bottom on horizontal axis.
position:'end',// Allows you to correct label positioning on this axis by positive or negative x and y offset.
labelOffset:{x:0,y:0},// If labels should be shown or not
showLabel:true,// If the axis grid should be drawn or not
showGrid:true,// Interpolation function that allows you to intercept the value from the axis label
labelInterpolationFnc:Chartist.noop,// This value specifies the minimum width in pixel of the scale steps
scaleMinSpace:30,// Use only integer values (whole numbers) for the scale steps
onlyInteger:false},// Options for Y-Axis
axisY:{// The offset of the chart drawing area to the border of the container
offset:40,// Position where labels are placed. Can be set to `start` or `end` where `start` is equivalent to left or top on vertical axis and `end` is equivalent to right or bottom on horizontal axis.
position:'start',// Allows you to correct label positioning on this axis by positive or negative x and y offset.
labelOffset:{x:0,y:0},// If labels should be shown or not
showLabel:true,// If the axis grid should be drawn or not
showGrid:true,// Interpolation function that allows you to intercept the value from the axis label
labelInterpolationFnc:Chartist.noop,// This value specifies the minimum height in pixel of the scale steps
scaleMinSpace:20,// Use only integer values (whole numbers) for the scale steps
onlyInteger:false},// Specify a fixed width for the chart as a string (i.e. '100px' or '50%')
width:undefined,// Specify a fixed height for the chart as a string (i.e. '100px' or '50%')
height:undefined,// Overriding the natural high of the chart allows you to zoom in or limit the charts highest displayed value
high:undefined,// Overriding the natural low of the chart allows you to zoom in or limit the charts lowest displayed value
low:undefined,// Unless low/high are explicitly set, bar chart will be centered at zero by default. Set referenceValue to null to auto scale.
referenceValue:0,// Padding of the chart drawing area to the container element and labels as a number or padding object {top: 5, right: 5, bottom: 5, left: 5}
chartPadding:{top:15,right:15,bottom:5,left:10},// Specify the distance in pixel of bars in a group
seriesBarDistance:15,// If set to true this property will cause the series bars to be stacked. Check the `stackMode` option for further stacking options.
stackBars:false,// If set to 'overlap' this property will force the stacked bars to draw from the zero line.
// If set to 'accumulate' this property will form a total for each series point. This will also influence the y-axis and the overall bounds of the chart. In stacked mode the seriesBarDistance property will have no effect.
stackMode:'accumulate',// Inverts the axes of the bar chart in order to draw a horizontal bar chart. Be aware that you also need to invert your axis settings as the Y Axis will now display the labels and the X Axis the values.
horizontalBars:false,// If set to true then each bar will represent a series and the data array is expected to be a one dimensional array of data values rather than a series array of series. This is useful if the bar chart should represent a profile rather than some data over time.
distributeSeries:false,// If true the whole data is reversed including labels, the series order as well as the whole series data arrays.
reverseData:false,// If the bar chart should add a background fill to the .ct-grids group.
showGridBackground:false,// Override the class names that get used to generate the SVG structure of the chart
this.svg=Chartist.createSvg(this.container,options.width,options.height,options.classNames.chart+(options.horizontalBars?' '+options.classNames.horizontalBars:''));// Drawing groups in correct order
vargridGroup=this.svg.elem('g').addClass(options.classNames.gridGroup);varseriesGroup=this.svg.elem('g');varlabelGroup=this.svg.elem('g').addClass(options.classNames.labelGroup);if(options.stackBars&&data.normalized.series.length!==0){// If stacked bars we need to calculate the high low from stacked values from each series
varserialSums=Chartist.serialMap(data.normalized.series,functionserialSums(){returnArray.prototype.slice.call(arguments).map(function(value){returnvalue;}).reduce(function(prev,curr){return{x:prev.x+(curr&&curr.x)||0,y:prev.y+(curr&&curr.y)||0};},{x:0,y:0});});highLow=Chartist.getHighLow([serialSums],options,options.horizontalBars?'x':'y');}else{highLow=Chartist.getHighLow(data.normalized.series,options,options.horizontalBars?'x':'y');}// Overrides of high / low from settings
highLow.high=+options.high||(options.high===0?0:highLow.high);highLow.low=+options.low||(options.low===0?0:highLow.low);varchartRect=Chartist.createChartRect(this.svg,options,defaultOptions.padding);varvalueAxis,labelAxisTicks,labelAxis,axisX,axisY;// We need to set step count based on some options combinations
if(options.distributeSeries&&options.stackBars){// If distributed series are enabled and bars need to be stacked, we'll only have one bar and therefore should
// use only the first label for the step axis
labelAxisTicks=data.normalized.labels.slice(0,1);}else{// If distributed series are enabled but stacked bars aren't, we should use the series labels
// If we are drawing a regular bar chart with two dimensional series data, we just use the labels array
// as the bars are normalized
labelAxisTicks=data.normalized.labels;}// Set labelAxis and valueAxis based on the horizontalBars setting. This setting will flip the axes if necessary.
if(options.horizontalBars){if(options.axisX.type===undefined){valueAxis=axisX=newChartist.AutoScaleAxis(Chartist.Axis.units.x,data.normalized.series,chartRect,Chartist.extend({},options.axisX,{highLow:highLow,referenceValue:0}));}else{valueAxis=axisX=options.axisX.type.call(Chartist,Chartist.Axis.units.x,data.normalized.series,chartRect,Chartist.extend({},options.axisX,{highLow:highLow,referenceValue:0}));}if(options.axisY.type===undefined){labelAxis=axisY=newChartist.StepAxis(Chartist.Axis.units.y,data.normalized.series,chartRect,{ticks:labelAxisTicks});}else{labelAxis=axisY=options.axisY.type.call(Chartist,Chartist.Axis.units.y,data.normalized.series,chartRect,options.axisY);}}else{if(options.axisX.type===undefined){labelAxis=axisX=newChartist.StepAxis(Chartist.Axis.units.x,data.normalized.series,chartRect,{ticks:labelAxisTicks});}else{labelAxis=axisX=options.axisX.type.call(Chartist,Chartist.Axis.units.x,data.normalized.series,chartRect,options.axisX);}if(options.axisY.type===undefined){valueAxis=axisY=newChartist.AutoScaleAxis(Chartist.Axis.units.y,data.normalized.series,chartRect,Chartist.extend({},options.axisY,{highLow:highLow,referenceValue:0}));}else{valueAxis=axisY=options.axisY.type.call(Chartist,Chartist.Axis.units.y,data.normalized.series,chartRect,Chartist.extend({},options.axisY,{highLow:highLow,referenceValue:0}));}}// Projected 0 point
varzeroPoint=options.horizontalBars?chartRect.x1+valueAxis.projectValue(0):chartRect.y1-valueAxis.projectValue(0);// Used to track the screen coordinates of stacked bars
varstackedBarValues=[];labelAxis.createGridAndLabels(gridGroup,labelGroup,this.supportsForeignObject,options,this.eventEmitter);valueAxis.createGridAndLabels(gridGroup,labelGroup,this.supportsForeignObject,options,this.eventEmitter);if(options.showGridBackground){Chartist.createGridBackground(gridGroup,chartRect,options.classNames.gridBackground,this.eventEmitter);}// Draw the series
data.raw.series.forEach(function(series,seriesIndex){// Calculating bi-polar value of index for seriesOffset. For i = 0..4 biPol will be -1.5, -0.5, 0.5, 1.5 etc.
varbiPol=seriesIndex-(data.raw.series.length-1)/2;// Half of the period width between vertical grid lines used to position bars
varperiodHalfLength;// Current series SVG element
varseriesElement;// We need to set periodHalfLength based on some options combinations
if(options.distributeSeries&&!options.stackBars){// If distributed series are enabled but stacked bars aren't, we need to use the length of the normaizedData array
// which is the series count and divide by 2
periodHalfLength=labelAxis.axisLength/data.normalized.series.length/2;}elseif(options.distributeSeries&&options.stackBars){// If distributed series and stacked bars are enabled we'll only get one bar so we should just divide the axis
// length by 2
periodHalfLength=labelAxis.axisLength/2;}else{// On regular bar charts we should just use the series length
periodHalfLength=labelAxis.axisLength/data.normalized.series[seriesIndex].length/2;}// Adding the series group to the series element
seriesElement=seriesGroup.elem('g');// Write attributes to series group element. If series name or meta is undefined the attributes will not be written
seriesElement.attr({'ct:series-name':series.name,'ct:meta':Chartist.serialize(series.meta)});// Use series class from series data or if not set generate one
seriesElement.addClass([options.classNames.series,series.className||options.classNames.series+'-'+Chartist.alphaNumerate(seriesIndex)].join(' '));data.normalized.series[seriesIndex].forEach(function(value,valueIndex){varprojected,bar,previousStack,labelAxisValueIndex;// We need to set labelAxisValueIndex based on some options combinations
if(options.distributeSeries&&!options.stackBars){// If distributed series are enabled but stacked bars aren't, we can use the seriesIndex for later projection
// on the step axis for label positioning
labelAxisValueIndex=seriesIndex;}elseif(options.distributeSeries&&options.stackBars){// If distributed series and stacked bars are enabled, we will only get one bar and therefore always use
// 0 for projection on the label step axis
labelAxisValueIndex=0;}else{// On regular bar charts we just use the value index to project on the label step axis
labelAxisValueIndex=valueIndex;}// We need to transform coordinates differently based on the chart layout
if(options.horizontalBars){projected={x:chartRect.x1+valueAxis.projectValue(value&&value.x?value.x:0,valueIndex,data.normalized.series[seriesIndex]),y:chartRect.y1-labelAxis.projectValue(value&&value.y?value.y:0,labelAxisValueIndex,data.normalized.series[seriesIndex])};}else{projected={x:chartRect.x1+labelAxis.projectValue(value&&value.x?value.x:0,labelAxisValueIndex,data.normalized.series[seriesIndex]),y:chartRect.y1-valueAxis.projectValue(value&&value.y?value.y:0,valueIndex,data.normalized.series[seriesIndex])};}// If the label axis is a step based axis we will offset the bar into the middle of between two steps using
// the periodHalfLength value. Also we do arrange the different series so that they align up to each other using
// the seriesBarDistance. If we don't have a step axis, the bar positions can be chosen freely so we should not
// add any automated positioning.
if(labelAxisinstanceofChartist.StepAxis){// Offset to center bar between grid lines, but only if the step axis is not stretched
if(!labelAxis.options.stretch){projected[labelAxis.units.pos]+=periodHalfLength*(options.horizontalBars?-1:1);}// Using bi-polar offset for multiple series if no stacked bars or series distribution is used
projected[labelAxis.units.pos]+=options.stackBars||options.distributeSeries?0:biPol*options.seriesBarDistance*(options.horizontalBars?-1:1);}// Enter value in stacked bar values used to remember previous screen value for stacking up bars
previousStack=stackedBarValues[valueIndex]||zeroPoint;stackedBarValues[valueIndex]=previousStack-(zeroPoint-projected[labelAxis.counterUnits.pos]);// Skip if value is undefined
// If bars are stacked we use the stackedBarValues reference and otherwise base all bars off the zero line
// We want backwards compatibility, so the expected fallback without the 'stackMode' option
// to be the original behaviour (accumulate)
positions[labelAxis.counterUnits.pos+'1']=previousStack;positions[labelAxis.counterUnits.pos+'2']=stackedBarValues[valueIndex];}else{// Draw from the zero line normally
// This is also the same code for Stack mode: overlap
positions[labelAxis.counterUnits.pos+'1']=zeroPoint;positions[labelAxis.counterUnits.pos+'2']=projected[labelAxis.counterUnits.pos];}// Limit x and y so that they are within the chart rect
positions.x1=Math.min(Math.max(positions.x1,chartRect.x1),chartRect.x2);positions.x2=Math.min(Math.max(positions.x2,chartRect.x1),chartRect.x2);positions.y1=Math.min(Math.max(positions.y1,chartRect.y2),chartRect.y1);positions.y2=Math.min(Math.max(positions.y2,chartRect.y2),chartRect.y1);varmetaData=Chartist.getMetaData(series,valueIndex);// Create bar element
*// In the global name space Chartist we call the Bar function to initialize a bar chart. As a first parameter we pass in a selector where we would like to get our chart created and as a second parameter we pass our data object.
*newChartist.Bar('.ct-chart',data);
*
*@example
*// This example creates a bipolar grouped bar chart where the boundaries are limitted to -10 and 10
width:undefined,// Specify a fixed height for the chart as a string (i.e. '100px' or '50%')
height:undefined,// Padding of the chart drawing area to the container element and labels as a number or padding object {top: 5, right: 5, bottom: 5, left: 5}
chartPadding:5,// Override the class names that are used to generate the SVG structure of the chart
classNames:{chartPie:'ct-chart-pie',chartDonut:'ct-chart-donut',series:'ct-series',slicePie:'ct-slice-pie',sliceDonut:'ct-slice-donut',sliceDonutSolid:'ct-slice-donut-solid',label:'ct-label'},// The start angle of the pie chart in degrees where 0 points north. A higher value offsets the start angle clockwise.
startAngle:0,// An optional total you can specify. By specifying a total value, the sum of the values in the series must be this total in order to draw a full pie. You can use this parameter to draw only parts of a pie or gauge charts.
total:undefined,// If specified the donut CSS classes will be used and strokes will be drawn instead of pie slices.
donut:false,// If specified the donut segments will be drawn as shapes instead of strokes.
donutSolid:false,// Specify the donut stroke width, currently done in javascript for convenience. May move to CSS styles in the future.
// This option can be set as number or string to specify a relative width (i.e. 100 or '30%').
donutWidth:60,// If a label should be shown or not
showLabel:true,// Label position offset from the standard position which is half distance of the radius. This value can be either positive or negative. Positive values will position the label away from the center.
labelOffset:0,// This option can be set to 'inside', 'outside' or 'center'. Positioned with 'inside' the labels will be placed on half the distance of the radius to the border of the Pie by respecting the 'labelOffset'. The 'outside' option will place the labels at the border of the pie and 'center' will place the labels in the absolute center point of the chart. The 'center' option only makes sense in conjunction with the 'labelOffset' option.
labelPosition:'inside',// An interpolation function for the label value
labelInterpolationFnc:Chartist.noop,// Label direction can be 'neutral', 'explode' or 'implode'. The labels anchor will be positioned based on those settings as well as the fact if the labels are on the right or left side of the center of the chart. Usually explode is useful when labels are positioned far away from the center.
labelDirection:'neutral',// If true the whole data is reversed including labels, the series order as well as the whole series data arrays.
reverseData:false,// If true empty values will be ignored to avoid drawing unncessary slices and labels
this.svg=Chartist.createSvg(this.container,options.width,options.height,options.donut?options.classNames.chartDonut:options.classNames.chartPie);// Calculate charting rect
chartRect=Chartist.createChartRect(this.svg,options,defaultOptions.padding);// Get biggest circle radius possible within chartRect
radius=Math.min(chartRect.width()/2,chartRect.height()/2);// Calculate total of all series to get reference value or use total reference from optional options
totalDataSum=options.total||data.normalized.series.reduce(function(previousValue,currentValue){returnpreviousValue+currentValue;},0);vardonutWidth=Chartist.quantity(options.donutWidth);if(donutWidth.unit==='%'){donutWidth.value*=radius/100;}// If this is a donut chart we need to adjust our radius to enable strokes to be drawn inside
// Unfortunately this is not possible with the current SVG Spec
// See this proposal for more details: http://lists.w3.org/Archives/Public/www-svg/2003Oct/0000.html
radius-=options.donut&&!options.donutSolid?donutWidth.value/2:0;// If labelPosition is set to `outside` or a donut chart is drawn then the label position is at the radius,
// if regular pie chart it's half of the radius
if(options.labelPosition==='outside'||options.donut&&!options.donutSolid){labelRadius=radius;}elseif(options.labelPosition==='center'){// If labelPosition is center we start with 0 and will later wait for the labelOffset
labelRadius=0;}elseif(options.donutSolid){labelRadius=radius-donutWidth.value/2;}else{// Default option is 'inside' where we use half the radius so the label will be placed in the center of the pie
// slice
labelRadius=radius/2;}// Add the offset to the labelRadius where a negative offset means closed to the center of the chart
labelRadius+=options.labelOffset;// Calculate end angle based on total sum and current data value and offset with padding
varcenter={x:chartRect.x1+chartRect.width()/2,y:chartRect.y2+chartRect.height()/2};// Check if there is only one non-zero value in the series array.
varhasSingleValInSeries=data.raw.series.filter(function(val){returnval.hasOwnProperty('value')?val.value!==0:val!==0;}).length===1;// Creating the series groups
data.raw.series.forEach(function(series,index){seriesGroups[index]=this.svg.elem('g',null,null);}.bind(this));//if we need to show labels we create the label group now
if(options.showLabel){labelsGroup=this.svg.elem('g',null,null);}// Draw the series
// initialize series groups
data.raw.series.forEach(function(series,index){// If current value is zero and we are ignoring empty values then skip to next value
if(data.normalized.series[index]===0&&options.ignoreEmptyValues)return;// If the series is an object and contains a name or meta data we add a custom attribute
seriesGroups[index].attr({'ct:series-name':series.name});// Use series class from series data or if not set generate one
seriesGroups[index].addClass([options.classNames.series,series.className||options.classNames.series+'-'+Chartist.alphaNumerate(index)].join(' '));// If the whole dataset is 0 endAngle should be zero. Can't divide by 0.
varendAngle=totalDataSum>0?startAngle+data.normalized.series[index]/totalDataSum*360:0;// Use slight offset so there are no transparent hairline issues
varoverlappigStartAngle=Math.max(0,startAngle-(index===0||hasSingleValInSeries?0:0.2));// If we need to draw the arc for all 360 degrees we need to add a hack where we close the circle
// with Z and use 359.99 degrees
if(endAngle-overlappigStartAngle>=359.99){endAngle=overlappigStartAngle+359.99;}varstart=Chartist.polarToCartesian(center.x,center.y,radius,overlappigStartAngle),end=Chartist.polarToCartesian(center.x,center.y,radius,endAngle);varinnerStart,innerEnd,donutSolidRadius;// Create a new path element for the pie chart. If this isn't a donut chart we should close the path for a correct stroke
varpath=newChartist.Svg.Path(!options.donut||options.donutSolid).move(end.x,end.y).arc(radius,radius,0,endAngle-startAngle>180,0,start.x,start.y);// If regular pie chart (no donut) we add a line to the center of the circle for completing the pie
if(!options.donut){path.line(center.x,center.y);}elseif(options.donutSolid){donutSolidRadius=radius-donutWidth.value;innerStart=Chartist.polarToCartesian(center.x,center.y,donutSolidRadius,startAngle-(index===0||hasSingleValInSeries?0:0.2));innerEnd=Chartist.polarToCartesian(center.x,center.y,donutSolidRadius,endAngle);path.line(innerStart.x,innerStart.y);path.arc(donutSolidRadius,donutSolidRadius,0,endAngle-startAngle>180,1,innerEnd.x,innerEnd.y);}// Create the SVG path
// If this is a donut chart we add the donut class, otherwise just a regular slice
varpathClassName=options.classNames.slicePie;if(options.donut){pathClassName=options.classNames.sliceDonut;if(options.donutSolid){pathClassName=options.classNames.sliceDonutSolid;}}varpathElement=seriesGroups[index].elem('path',{d:path.stringify()},pathClassName);// Adding the pie series value to the path
pathElement.attr({'ct:value':data.normalized.series[index],'ct:meta':Chartist.serialize(series.meta)});// If this is a donut, we add the stroke-width as style attribute
if(options.donut&&!options.donutSolid){pathElement._node.style.strokeWidth=donutWidth.value+'px';}// Fire off draw event
this.eventEmitter.emit('draw',{type:'slice',value:data.normalized.series[index],totalDataSum:totalDataSum,index:index,meta:series.meta,series:series,group:seriesGroups[index],element:pathElement,path:path.clone(),center:center,radius:radius,startAngle:startAngle,endAngle:endAngle});// If we need to show labels we need to add the label for this slice now
if(options.showLabel){varlabelPosition;if(data.raw.series.length===1){// If we have only 1 series, we can position the label in the center of the pie
labelPosition={x:center.x,y:center.y};}else{// Position at the labelRadius distance from center and between start and end angle
labelPosition=Chartist.polarToCartesian(center.x,center.y,labelRadius,startAngle+(endAngle-startAngle)/2);}varrawValue;if(data.normalized.labels&&!Chartist.isFalseyButZero(data.normalized.labels[index])){rawValue=data.normalized.labels[index];}else{rawValue=data.normalized.series[index];}varinterpolatedValue=options.labelInterpolationFnc(rawValue,index);if(interpolatedValue||interpolatedValue===0){varlabelElement=labelsGroup.elem('text',{dx:labelPosition.x,dy:labelPosition.y,'text-anchor':determineAnchorPosition(center,labelPosition,options.labelDirection)},options.classNames.label).text(''+interpolatedValue);// Fire off draw event
this.eventEmitter.emit('draw',{type:'label',index:index,group:labelsGroup,element:labelElement,text:''+interpolatedValue,x:labelPosition.x,y:labelPosition.y});}}// Set next startAngle to current endAngle.
var_createClass=function(){functiondefineProperties(target,props){for(vari=0;i<props.length;i++){vardescriptor=props[i];descriptor.enumerable=descriptor.enumerable||false;descriptor.configurable=true;if("value"indescriptor)descriptor.writable=true;Object.defineProperty(target,descriptor.key,descriptor);}}returnfunction(Constructor,protoProps,staticProps){if(protoProps)defineProperties(Constructor.prototype,protoProps);if(staticProps)defineProperties(Constructor,staticProps);returnConstructor;};}();var_react2=_interopRequireDefault(react);var_propTypes2=_interopRequireDefault(propTypes);function_interopRequireDefault(obj){returnobj&&obj.__esModule?obj:{default:obj};}function_classCallCheck(instance,Constructor){if(!(instanceinstanceofConstructor)){thrownewTypeError("Cannot call a class as a function");}}function_possibleConstructorReturn(self,call){if(!self){thrownewReferenceError("this hasn't been initialised - super() hasn't been called");}returncall&&(typeofcall==="object"||typeofcall==="function")?call:self;}function_inherits(subClass,superClass){if(typeofsuperClass!=="function"&&superClass!==null){thrownewTypeError("Super expression must either be null or a function, not "+typeofsuperClass);}subClass.prototype=Object.create(superClass&&superClass.prototype,{constructor:{value:subClass,enumerable:false,writable:true,configurable:true}});if(superClass)Object.setPrototypeOf?Object.setPrototypeOf(subClass,superClass):subClass.__proto__=superClass;}varChartistGraph=function(_Component){_inherits(ChartistGraph,_Component);functionChartistGraph(){_classCallCheck(this,ChartistGraph);return_possibleConstructorReturn(this,(ChartistGraph.__proto__||Object.getPrototypeOf(ChartistGraph)).apply(this,arguments));}_createClass(ChartistGraph,[{key:'componentWillUnmount',value:functioncomponentWillUnmount(){if(this.chartist){try{this.chartist.detach();}catch(err){thrownewError('Internal chartist error',err);}}}},{key:'componentDidMount',value:functioncomponentDidMount(){this.updateChart(this.props);}},{key:'componentDidUpdate',value:functioncomponentDidUpdate(){this.updateChart(this.props);}},{key:'updateChart',value:functionupdateChart(config){varChartist=chartist;vartype=config.type,data=config.data;varoptions=config.options||{};varresponsiveOptions=config.responsiveOptions||[];varevent=void0;if(this.chartist){this.chartist.update(data,options,responsiveOptions);}else{this.chartist=newChartist[type](this.chart,data,options,responsiveOptions);if(config.listener){for(eventinconfig.listener){if(config.listener.hasOwnProperty(event)){this.chartist.on(event,config.listener[event]);}}}}returnthis.chartist;}},{key:'render',value:functionrender(){var_this2=this;var_props=this.props,className=_props.className,style=_props.style,children=_props.children,data=_props.data,type=_props.type;varchildrenWithProps=children&&react.Children.map(children,function(child){return(0,react.cloneElement)(child,{type:type,data:data});});return_react2.default.createElement('div',{className:'ct-chart '+(className||''),ref:functionref(_ref){return_this2.chart=_ref;},style:style},childrenWithProps);}}]);returnChartistGraph;}(react.Component);ChartistGraph.propTypes={type:_propTypes2.default.oneOf(['Line','Bar','Pie']).isRequired,data:_propTypes2.default.object.isRequired,className:_propTypes2.default.string,options:_propTypes2.default.object,responsiveOptions:_propTypes2.default.array,style:_propTypes2.default.object};var_default$1=ChartistGraph;
!function(e,t){t(exports,react);}(commonjsGlobal,function(e,t){functionn(e,t,n,o,r,i,u){try{varl=e[i](u),s=l.value;}catch(e){returnvoidn(e);}l.done?t(s):Promise.resolve(s).then(o,r);}functiono(e){returnfunction(){vart=this,o=arguments;returnnewPromise(function(r,i){varu=e.apply(t,o);functionl(e){n(u,r,i,l,s,"next",e);}functions(e){n(u,r,i,l,s,"throw",e);}l(void0);});};}functionr(){return(r=Object.assign||function(e){for(vart=1;t<arguments.length;t++){varn=arguments[t];for(varoinn)Object.prototype.hasOwnProperty.call(n,o)&&(e[o]=n[o]);}returne;}).apply(this,arguments);}functioni(e,t){if(null==e)return{};varn,o,r={},i=Object.keys(e);for(o=0;o<i.length;o++)n=i[o],t.indexOf(n)>=0||(r[n]=e[n]);returnr;}functionu(e){vart=function(e,t){if("object"!=typeofe||null===e)returne;varn=e[Symbol.toPrimitive];if(void0!==n){varo=n.call(e,t||"default");if("object"!=typeofo)returno;thrownewTypeError("@@toPrimitive must return a primitive value.");}return("string"===t?String:Number)(e);}(e,"string");return"symbol"==typeoft?t:String(t);}t=t&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t;varl={init:"init"},s=function(e){vart=e.value;returnvoid0===t?"":t;},a=function(){returnt.createElement(t.Fragment,null,"");},c={Cell:s,width:150,minWidth:0,maxWidth:Number.MAX_SAFE_INTEGER};functiond(){for(vare=arguments.length,t=newArray(e),n=0;n<e;n++)t[n]=arguments[n];returnt.reduce(function(e,t){varn=t.style,o=t.className;returne=r({},e,{},i(t,["style","className"])),n&&(e.style=e.style?r({},e.style||{},{},n||{}):n),o&&(e.className=e.className?e.className+" "+o:o),""===e.className&&deletee.className,e;},{});}varf=function(e,t){returnvoid0===t&&(t={}),function(n){returnvoid0===n&&(n={}),[].concat(e,[n]).reduce(function(e,o){returnfunctione(t,n,o){return"function"==typeofn?e({},n(t,o)):Array.isArray(n)?d.apply(void0,[t].concat(n)):d(t,n);}(e,o,r({},t,{userProps:n}));},{});};},p=function(e,t,n,o){returnvoid0===n&&(n={}),e.reduce(function(e,t){returnt(e,n);},t);},g=function(e,t,n){returnvoid0===n&&(n={}),e.forEach(function(e){e(t,n);});};functionv(e,t,n,o){e.findIndex(function(e){returne.pluginName===n;});t.forEach(function(t){e.findIndex(function(e){returne.pluginName===t;});});}functionm(e,t){return"function"==typeofe?e(t):e;}functionh(e){varn=t.useRef();returnn.current=e,t.useCallback(function(){returnn.current;},[]);}vary="undefined"!=typeofdocument?t.useLayoutEffect:t.useEffect;functionw(e,n){varo=t.useRef(!1);y(function(){o.current&&e(),o.current=!0;},n);}functionR(e,t,n){returnvoid0===n&&(n={}),function(o,i){void0===i&&(i={});varu="string"==typeofo?t[o]:o;if(void0===u)throwconsole.info(t),newError("Renderer Error ☝️");returnb(u,r({},e,{column:t},n,{},i));};}functionb(e,n){returnfunction(e){return"function"==typeofe&&(t=Object.getPrototypeOf(e)).prototype&&t.prototype.isReactComponent;vart;}(o=e)||"function"==typeofo||function(e){return"object"==typeofe&&"symbol"==typeofe.$$typeof&&["react.memo","react.forward_ref"].includes(e.$$typeof.description);}(o)?t.createElement(e,n):e;varo;}functionS(e,t,n){returnvoid0===n&&(n=0),e.map(function(e){returnx(e=r({},e,{parent:t,depth:n})),e.columns&&(e.columns=S(e.columns,e,n+1)),e;});}functionC(e){returnG(e,"columns");}functionx(e){vart=e.id,n=e.accessor,o=e.Header;if("string"==typeofn){t=t||n;varr=n.split(".");n=function(e){returnfunction(e,t,n){if(!t)returne;varo,r="function"==typeoft?t:JSON.stringify(t),i=E.get(r)||function(){vare=function(e){returnfunctione(t,n){void0===n&&(n=[]);if(Array.isArray(t))for(varo=0;o<t.length;o+=1)e(t[o],n);elsen.push(t);returnn;}(e).map(function(e){returnString(e).replace(".","_");}).join(".").replace(W,".").replace(O,"").split(".");}(t);returnE.set(r,e),e;}();try{o=i.reduce(function(e,t){returne[t];},e);}catch(e){}returnvoid0!==o?o:n;}(e,r);};}if(!t&&"string"==typeofo&&o&&(t=o),!t&&e.columns)throwconsole.error(e),newError('A column ID (or unique "Header" value) is required!');if(!t)throwconsole.error(e),newError("AcolumnID(or
(function(global,factory){factory(exports,react);})(commonjsGlobal,function(exports,React){React=React&&Object.prototype.hasOwnProperty.call(React,'default')?React['default']:React;functionasyncGeneratorStep(gen,resolve,reject,_next,_throw,key,arg){try{varinfo=gen[key](arg);varvalue=info.value;}catch(error){reject(error);return;}if(info.done){resolve(value);}else{Promise.resolve(value).then(_next,_throw);}}function_asyncToGenerator(fn){returnfunction(){varself=this,args=arguments;returnnewPromise(function(resolve,reject){vargen=fn.apply(self,args);function_next(value){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"next",value);}function_throw(err){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"throw",err);}_next(undefined);});};}function_extends(){_extends=Object.assign||function(target){for(vari=1;i<arguments.length;i++){varsource=arguments[i];for(varkeyinsource){if(Object.prototype.hasOwnProperty.call(source,key)){target[key]=source[key];}}}returntarget;};return_extends.apply(this,arguments);}function_objectWithoutPropertiesLoose(source,excluded){if(source==null)return{};vartarget={};varsourceKeys=Object.keys(source);varkey,i;for(i=0;i<sourceKeys.length;i++){key=sourceKeys[i];if(excluded.indexOf(key)>=0)continue;target[key]=source[key];}returntarget;}function_toPrimitive(input,hint){if(typeofinput!=="object"||input===null)returninput;varprim=input[Symbol.toPrimitive];if(prim!==undefined){varres=prim.call(input,hint||"default");if(typeofres!=="object")returnres;thrownewTypeError("@@toPrimitive must return a primitive value.");}return(hint==="string"?String:Number)(input);}function_toPropertyKey(arg){varkey=_toPrimitive(arg,"string");returntypeofkey==="symbol"?key:String(key);}varrenderErr='Renderer Error ☝️';varactions={init:'init'};vardefaultRenderer=functiondefaultRenderer(_ref){var_ref$value=_ref.value,value=_ref$value===void0?'':_ref$value;returnvalue;};varemptyRenderer=functionemptyRenderer(){returnReact.createElement(React.Fragment,null,"\xA0");};vardefaultColumn={Cell:defaultRenderer,width:150,minWidth:0,maxWidth:Number.MAX_SAFE_INTEGER};functionmergeProps(){for(var_len=arguments.length,propList=newArray(_len),_key=0;_key<_len;_key++){propList[_key]=arguments[_key];}returnpropList.reduce(function(props,next){varstyle=next.style,className=next.className,rest=_objectWithoutPropertiesLoose(next,["style","className"]);props=_extends({},props,{},rest);if(style){props.style=props.style?_extends({},props.style||{},{},style||{}):style;}if(className){props.className=props.className?props.className+' '+className:className;}if(props.className===''){deleteprops.className;}returnprops;},{});}functionhandlePropGetter(prevProps,userProps,meta){// Handle a lambda, pass it the previous props
if(typeofuserProps==='function'){returnhandlePropGetter({},userProps(prevProps,meta));}// Handle an array, merge each item as separate props
if(Array.isArray(userProps)){returnmergeProps.apply(void0,[prevProps].concat(userProps));}// Handle an object by default, merge the two objects
returnmergeProps(prevProps,userProps);}varmakePropGetter=functionmakePropGetter(hooks,meta){if(meta===void0){meta={};}returnfunction(userProps){if(userProps===void0){userProps={};}return[].concat(hooks,[userProps]).reduce(function(prev,next){returnhandlePropGetter(prev,next,_extends({},meta,{userProps:userProps}));},{});};};varreduceHooks=functionreduceHooks(hooks,initial,meta,allowUndefined){if(meta===void0){meta={};}returnhooks.reduce(function(prev,next){varnextValue=next(prev,meta);{if(!allowUndefined&&typeofnextValue==='undefined'){console.info(next);thrownewError('React Table: A reducer hook ☝️ just returned undefined! This is not allowed.');}}returnnextValue;},initial);};varloopHooks=functionloopHooks(hooks,context,meta){if(meta===void0){meta={};}returnhooks.forEach(function(hook){varnextValue=hook(context,meta);{if(typeofnextValue!=='undefined'){console.info(hook,nextValue);thrownewError('React Table: A loop-type hook ☝️ just returned a value! This is not allowed.');}}});};functionensurePluginOrder(plugins,befores,pluginName,afters){if(afters){thrownewError("Defining plugins in the \"after\" section of ensurePluginOrder is no longer supported (see plugin "+pluginName+")");}varpluginIndex=plugins.findIndex(function(plugin){returnplugin.pluginName===pluginName;});if(pluginIndex===-1){{thrownewError("The plugin \""+pluginName+"\" was not found in the plugin list!\nThis usually means you need to need to name your plugin hook by setting the 'pluginName' property of the hook function, eg:\n\n "+pluginName+".pluginName = '"+pluginName+"'\n");}}befores.forEach(function(before){varbeforeIndex=plugins.findIndex(function(plugin){returnplugin.pluginName===before;});if(beforeIndex>-1&&beforeIndex>pluginIndex){{thrownewError("React Table: The "+pluginName+" plugin hook must be placed after the "+before+" plugin hook!");}}});}functionfunctionalUpdate(updater,old){returntypeofupdater==='function'?updater(old):updater;}functionuseGetLatest(obj){varref=React.useRef();ref.current=obj;returnReact.useCallback(function(){returnref.current;},[]);}// SSR has issues with useLayoutEffect still, so use useEffect during SSR
},deps);}functionuseAsyncDebounce(defaultFn,defaultWait){if(defaultWait===void0){defaultWait=0;}vardebounceRef=React.useRef({});vargetDefaultFn=useGetLatest(defaultFn);vargetDefaultWait=useGetLatest(defaultWait);returnReact.useCallback(/*#__PURE__*/function(){var_ref2=_asyncToGenerator(/*#__PURE__*/regeneratorRuntime.mark(function_callee2(){var_len2,args,_key2,_args2=arguments;returnregeneratorRuntime.wrap(function_callee2$(_context2){while(1){switch(_context2.prev=_context2.next){case0:for(_len2=_args2.length,args=newArray(_len2),_key2=0;_key2<_len2;_key2++){args[_key2]=_args2[_key2];}if(!debounceRef.current.promise){debounceRef.current.promise=newPromise(function(resolve,reject){debounceRef.current.resolve=resolve;debounceRef.current.reject=reject;});}if(debounceRef.current.timeout){clearTimeout(debounceRef.current.timeout);}debounceRef.current.timeout=setTimeout(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/regeneratorRuntime.mark(function_callee(){returnregeneratorRuntime.wrap(function_callee$(_context){while(1){switch(_context.prev=_context.next){case0:deletedebounceRef.current.timeout;_context.prev=1;_context.t0=debounceRef.current;_context.next=5;returngetDefaultFn().apply(void0,args);case5:_context.t1=_context.sent;_context.t0.resolve.call(_context.t0,_context.t1);_context.next=12;break;case9:_context.prev=9;_context.t2=_context["catch"](1);debounceRef.current.reject(_context.t2);case12:_context.prev=12;deletedebounceRef.current.promise;return_context.finish(12);case15:case"end":return_context.stop();}}},_callee,null,[[1,9,12,15]]);})),getDefaultWait());return_context2.abrupt("return",debounceRef.current.promise);case5:case"end":return_context2.stop();}}},_callee2);}));returnfunction(){return_ref2.apply(this,arguments);};}(),[getDefaultFn,getDefaultWait]);}functionmakeRenderer(instance,column,meta){if(meta===void0){meta={};}returnfunction(type,userProps){if(userProps===void0){userProps={};}varComp=typeoftype==='string'?column[type]:type;if(typeofComp==='undefined'){console.info(column);thrownewError(renderErr);}returnflexRender(Comp,_extends({},instance,{column:column},meta,{},userProps));};}functionflexRender(Comp,props){returnisReactComponent(Comp)?React.createElement(Comp,props):Comp;}functionisReactComponent(component){returnisClassComponent(component)||typeofcomponent==='function'||isExoticComponent(component);}functionisClassComponent(component){returntypeofcomponent==='function'&&function(){varproto=Object.getPrototypeOf(component);returnproto.prototype&&proto.prototype.isReactComponent;}();}functionisExoticComponent(component){returntypeofcomponent==='object'&&typeofcomponent.$$typeof==='symbol'&&['react.memo','react.forward_ref'].includes(component.$$typeof.description);}functionlinkColumnStructure(columns,parent,depth){if(depth===void0){depth=0;}returncolumns.map(function(column){column=_extends({},column,{parent:parent,depth:depth});assignColumnAccessor(column);if(column.columns){column.columns=linkColumnStructure(column.columns,column,depth+1);}returncolumn;});}functionflattenColumns(columns){returnflattenBy(columns,'columns');}functionassignColumnAccessor(column){// First check for string accessor
varid=column.id,accessor=column.accessor,Header=column.Header;if(typeofaccessor==='string'){id=id||accessor;varaccessorPath=accessor.split('.');accessor=functionaccessor(row){returngetBy(row,accessorPath);};}if(!id&&typeofHeader==='string'&&Header){id=Header;}if(!id&&column.columns){console.error(column);thrownewError('A column ID (or unique "Header" value) is required!');}if(!id){console.error(column);thrownewError('A column ID (or string accessor) is required!');}Object.assign(column,{id:id,accessor:accessor});returncolumn;}functiondecorateColumn(column,userDefaultColumn){if(!userDefaultColumn){thrownewError();}Object.assign(column,_extends({// Make sure there is a fallback header, just in case
Header:emptyRenderer,Footer:emptyRenderer},defaultColumn,{},userDefaultColumn,{},column));Object.assign(column,{originalWidth:column.width});returncolumn;}// Build the header groups from the bottom up
functionmakeHeaderGroups(allColumns,defaultColumn,additionalHeaderProperties){if(additionalHeaderProperties===void0){additionalHeaderProperties=functionadditionalHeaderProperties(){return{};};}varheaderGroups=[];varscanColumns=allColumns;varuid=0;vargetUID=functiongetUID(){returnuid++;};var_loop=function_loop(){// The header group we are creating
varheaderGroup={headers:[]};// The parent columns we're going to scan next
varparentColumns=[];varhasParents=scanColumns.some(function(d){returnd.parent;});// Scan each column for parents
scanColumns.forEach(function(column){// What is the latest (last) parent column?
varlatestParentColumn=[].concat(parentColumns).reverse()[0];varnewParent;if(hasParents){// If the column has a parent, add it if necessary
if(column.parent){newParent=_extends({},column.parent,{originalId:column.parent.id,id:column.parent.id+"_"+getUID(),headers:[column]},additionalHeaderProperties(column));}else{// If other columns have parents, we'll need to add a place holder if necessary
varoriginalId=column.id+"_placeholder";newParent=decorateColumn(_extends({originalId:originalId,id:column.id+"_placeholder_"+getUID(),placeholderOf:column,headers:[column]},additionalHeaderProperties(column)),defaultColumn);}// If the resulting parent columns are the same, just add
// the column and increment the header span
if(latestParentColumn&&latestParentColumn.originalId===newParent.originalId){latestParentColumn.headers.push(column);}else{parentColumns.push(newParent);}}headerGroup.headers.push(column);});headerGroups.push(headerGroup);// Start scanning the parent columns
scanColumns=parentColumns;};while(scanColumns.length){_loop();}returnheaderGroups.reverse();}varpathObjCache=newMap();functiongetBy(obj,path,def){if(!path){returnobj;}varcacheKey=typeofpath==='function'?path:JSON.stringify(path);varpathObj=pathObjCache.get(cacheKey)||function(){varpathObj=makePathArray(path);pathObjCache.set(cacheKey,pathObj);returnpathObj;}();varval;try{val=pathObj.reduce(function(cursor,pathPart){returncursor[pathPart];},obj);}catch(e){// continue regardless of error
}returntypeofval!=='undefined'?val:def;}functiongetFirstDefined(){for(var_len=arguments.length,args=newArray(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}for(vari=0;i<args.length;i+=1){if(typeofargs[i]!=='undefined'){returnargs[i];}}}functionisFunction(a){if(typeofa==='function'){returna;}}functionflattenBy(arr,key){varflat=[];varrecurse=functionrecurse(arr){arr.forEach(function(d){if(!d[key]){flat.push(d);}else{recurse(d[key]);}});};recurse(arr);returnflat;}functionexpandRows(rows,_ref){varmanualExpandedKey=_ref.manualExpandedKey,expanded=_ref.expanded,_ref$expandSubRows=_ref.expandSubRows,expandSubRows=_ref$expandSubRows===void0?true:_ref$expandSubRows;varexpandedRows=[];varhandleRow=functionhandleRow(row,addToExpandedRows){if(addToExpandedRows===void0){addToExpandedRows=true;}row.isExpanded=row.original&&row.original[manualExpandedKey]||expanded[row.id];row.canExpand=row.subRows&&!!row.subRows.length;if(addToExpandedRows){expandedRows.push(row);}if(row.subRows&&row.subRows.length&&row.isExpanded){row.subRows.forEach(function(row){returnhandleRow(row,expandSubRows);});}};rows.forEach(function(row){returnhandleRow(row);});returnexpandedRows;}functiongetFilterMethod(filter,userFilterTypes,filterTypes){returnisFunction(filter)||userFilterTypes[filter]||filterTypes[filter]||filterTypes.text;}functionshouldAutoRemoveFilter(autoRemove,value,column){returnautoRemove?autoRemove(value,column):typeofvalue==='undefined';}functionunpreparedAccessWarning(){thrownewError('React-Table: You have not called prepareRow(row) one or more rows you are attempting to render.');}varpassiveSupported=null;functionpassiveEventSupported(){// memoize support to avoid adding multiple test events
varreOpenBracket=/\[/g;varreCloseBracket=/\]/g;functionmakePathArray(obj){returnflattenDeep(obj)// remove all periods in parts
.map(function(d){returnString(d).replace('.','_');})// join parts using period
.join('.')// replace brackets with periods
.replace(reOpenBracket,'.').replace(reCloseBracket,'')// split it back out on periods
.split('.');}functionflattenDeep(arr,newArr){if(newArr===void0){newArr=[];}if(!Array.isArray(arr)){newArr.push(arr);}else{for(vari=0;i<arr.length;i+=1){flattenDeep(arr[i],newArr);}}returnnewArr;}vardefaultGetTableProps=functiondefaultGetTableProps(props){return_extends({role:'table'},props);};vardefaultGetTableBodyProps=functiondefaultGetTableBodyProps(props){return_extends({role:'rowgroup'},props);};vardefaultGetHeaderProps=functiondefaultGetHeaderProps(props,_ref){varcolumn=_ref.column;return_extends({key:"header_"+column.id,colSpan:column.totalVisibleHeaderCount,role:'columnheader'},props);};vardefaultGetFooterProps=functiondefaultGetFooterProps(props,_ref2){varcolumn=_ref2.column;return_extends({key:"footer_"+column.id,colSpan:column.totalVisibleHeaderCount},props);};vardefaultGetHeaderGroupProps=functiondefaultGetHeaderGroupProps(props,_ref3){varindex=_ref3.index;return_extends({key:"headerGroup_"+index,role:'row'},props);};vardefaultGetFooterGroupProps=functiondefaultGetFooterGroupProps(props,_ref4){varindex=_ref4.index;return_extends({key:"footerGroup_"+index},props);};vardefaultGetRowProps=functiondefaultGetRowProps(props,_ref5){varrow=_ref5.row;return_extends({key:"row_"+row.id,role:'row'},props);};vardefaultGetCellProps=functiondefaultGetCellProps(props,_ref6){varcell=_ref6.cell;return_extends({key:"cell_"+cell.row.id+"_"+cell.column.id,role:'cell'},props);};functionmakeDefaultPluginHooks(){return{useOptions:[],stateReducers:[],useControlledState:[],columns:[],columnsDeps:[],allColumns:[],allColumnsDeps:[],accessValue:[],materializedColumns:[],materializedColumnsDeps:[],useInstanceAfterData:[],visibleColumns:[],visibleColumnsDeps:[],headerGroups:[],headerGroupsDeps:[],useInstanceBeforeDimensions:[],useInstance:[],prepareRow:[],getTableProps:[defaultGetTableProps],getTableBodyProps:[defaultGetTableBodyProps],getHeaderGroupProps:[defaultGetHeaderGroupProps],getFooterGroupProps:[defaultGetFooterGroupProps],getHeaderProps:[defaultGetHeaderProps],getFooterProps:[defaultGetFooterProps],getRowProps:[defaultGetRowProps],getCellProps:[defaultGetCellProps],useFinalInstance:[]};}actions.resetHiddenColumns='resetHiddenColumns';actions.toggleHideColumn='toggleHideColumn';actions.setHiddenColumns='setHiddenColumns';actions.toggleHideAllColumns='toggleHideAllColumns';varuseColumnVisibility=functionuseColumnVisibility(hooks){hooks.getToggleHiddenProps=[defaultGetToggleHiddenProps];hooks.getToggleHideAllColumnsProps=[defaultGetToggleHideAllColumnsProps];hooks.stateReducers.push(reducer);hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);hooks.headerGroupsDeps.push(function(deps,_ref){varinstance=_ref.instance;return[].concat(deps,[instance.state.hiddenColumns]);});hooks.useInstance.push(useInstance);};useColumnVisibility.pluginName='useColumnVisibility';vardefaultGetToggleHiddenProps=functiondefaultGetToggleHiddenProps(props,_ref2){varcolumn=_ref2.column;return[props,{onChange:functiononChange(e){column.toggleHidden(!e.target.checked);},style:{cursor:'pointer'},checked:column.isVisible,title:'Toggle Column Visible'}];};vardefaultGetToggleHideAllColumnsProps=functiondefaultGetToggleHideAllColumnsProps(props,_ref3){varinstance=_ref3.instance;return[props,{onChange:functiononChange(e){instance.toggleHideAllColumns(!e.target.checked);},style:{cursor:'pointer'},checked:!instance.allColumnsHidden&&!instance.state.hiddenColumns.length,title:'Toggle All Columns Hidden',indeterminate:!instance.allColumnsHidden&&instance.state.hiddenColumns.length}];};functionreducer(state,action,previousState,instance){if(action.type===actions.init){return_extends({hiddenColumns:[]},state);}if(action.type===actions.resetHiddenColumns){return_extends({},state,{hiddenColumns:instance.initialState.hiddenColumns||[]});}if(action.type===actions.toggleHideColumn){varshould=typeofaction.value!=='undefined'?action.value:!state.hiddenColumns.includes(action.columnId);varhiddenColumns=should?[].concat(state.hiddenColumns,[action.columnId]):state.hiddenColumns.filter(function(d){returnd!==
props=applyDefaults(props);// Add core plugins
plugins=[useColumnVisibility].concat(plugins);// Create the table instance
varinstanceRef=React.useRef({});// Create a getter for the instance (helps avoid a lot of potential memory leaks)
vargetInstance=useGetLatest(instanceRef.current);// Assign the props, plugins and hooks to the instance
Object.assign(getInstance(),_extends({},props,{plugins:plugins,hooks:makeDefaultPluginHooks()}));// Allow plugins to register hooks as early as possible
plugins.filter(Boolean).forEach(function(plugin){plugin(getInstance().hooks);});// Consume all hooks and make a getter for them
vargetHooks=useGetLatest(getInstance().hooks);getInstance().getHooks=getHooks;deletegetInstance().hooks;// Allow useOptions hooks to modify the options coming into the table
Object.assign(getInstance(),reduceHooks(getHooks().useOptions,applyDefaults(props)));var_getInstance=getInstance(),data=_getInstance.data,userColumns=_getInstance.columns,initialState=_getInstance.initialState,defaultColumn=_getInstance.defaultColumn,getSubRows=_getInstance.getSubRows,getRowId=_getInstance.getRowId,stateReducer=_getInstance.stateReducer,useControlledState=_getInstance.useControlledState;// Setup user reducer ref
vargetStateReducer=useGetLatest(stateReducer);// Build the reducer
if(!action.type){console.info({action:action});thrownewError('Unknown Action 👆');}// Reduce the state from all plugin reducers
return[].concat(getHooks().stateReducers,Array.isArray(getStateReducer())?getStateReducer():[getStateReducer()]).reduce(function(s,handler){returnhandler(s,action,state,getInstance())||s;},state);},[getHooks,getStateReducer,getInstance]);// Start the reducer
var_React$useReducer=React.useReducer(reducer,undefined,function(){returnreducer(initialState,{type:actions.init});}),reducerState=_React$useReducer[0],dispatch=_React$useReducer[1];// Allow the user to control the final state with hooks
varstate=reduceHooks([].concat(getHooks().useControlledState,[useControlledState]),reducerState,{instance:getInstance()});Object.assign(getInstance(),{state:state,dispatch:dispatch});// Decorate All the columns
varcolumns=React.useMemo(function(){returnlinkColumnStructure(reduceHooks(getHooks().columns,userColumns,{instance:getInstance()}));},[getHooks,getInstance,userColumns].concat(reduceHooks(getHooks().columnsDeps,[],{instance:getInstance()})));getInstance().columns=columns;// Get the flat list of all columns and allow hooks to decorate
// those columns (and trigger this memoization via deps)
varallColumns=React.useMemo(function(){returnreduceHooks(getHooks().allColumns,flattenColumns(columns),{instance:getInstance()}).map(assignColumnAccessor);},[columns,getHooks,getInstance].concat(reduceHooks(getHooks().allColumnsDeps,[],{instance:getInstance()})));getInstance().allColumns=allColumns;// Access the row model using initial columns
});loopHooks(getHooks().useInstanceAfterData,getInstance());// Get the flat list of all columns AFTER the rows
// have been access, and allow hooks to decorate
// those columns (and trigger this memoization via deps)
varvisibleColumns=React.useMemo(function(){returnreduceHooks(getHooks().visibleColumns,allColumns,{instance:getInstance()}).map(function(d){returndecorateColumn(d,defaultColumn);});},[getHooks,allColumns,getInstance,defaultColumn].concat(reduceHooks(getHooks().visibleColumnsDeps,[],{instance:getInstance()})));// Combine new visible columns with all columns
allColumns=React.useMemo(function(){varcolumns=[].concat(visibleColumns);allColumns.forEach(function(column){if(!columns.find(function(d){returnd.id===column.id;})){columns.push(column);}});returncolumns;},[allColumns,visibleColumns]);getInstance().allColumns=allColumns;{varduplicateColumns=allColumns.filter(function(column,i){returnallColumns.findIndex(function(d){returnd.id===column.id;})!==i;});if(duplicateColumns.length){console.info(allColumns);thrownewError("Duplicate columns were found with ids: \""+duplicateColumns.map(function(d){returnd.id;}).join(', ')+"\" in the columns array above");}}// Make the headerGroups
varheaderGroups=React.useMemo(function(){returnreduceHooks(getHooks().headerGroups,makeHeaderGroups(visibleColumns,defaultColumn),getInstance());},[getHooks,visibleColumns,defaultColumn,getInstance].concat(reduceHooks(getHooks().headerGroupsDeps,[],{instance:getInstance()})));getInstance().headerGroups=headerGroups;// Get the first level of headers
varheaders=React.useMemo(function(){returnheaderGroups.length?headerGroups[0].headers:[];},[headerGroups]);getInstance().headers=headers;// Provide a flat header list for utilities
getInstance().flatHeaders=headerGroups.reduce(function(all,headerGroup){return[].concat(all,headerGroup.headers);},[]);loopHooks(getHooks().useInstanceBeforeDimensions,getInstance());// Filter columns down to visible ones
[visibleColumns,visibleColumnsDep]);getInstance().visibleColumns=visibleColumns;// Header Visibility is needed by this point
var_calculateHeaderWidth=calculateHeaderWidths(headers),totalColumnsMinWidth=_calculateHeaderWidth[0],totalColumnsWidth=_calculateHeaderWidth[1],totalColumnsMaxWidth=_calculateHeaderWidth[2];getInstance().totalColumnsMinWidth=totalColumnsMinWidth;getInstance().totalColumnsWidth=totalColumnsWidth;getInstance().totalColumnsMaxWidth=totalColumnsMaxWidth;loopHooks(getHooks().useInstance,getInstance())// Each materialized header needs to be assigned a render function and other
// prop getter properties here.
;[].concat(getInstance().flatHeaders,getInstance().allColumns).forEach(function(column){// Give columns/headers rendering power
column.render=makeRenderer(getInstance(),column);// Give columns/headers a default getHeaderProps
column.getHeaderProps=makePropGetter(getHooks().getHeaderProps,{instance:getInstance(),column:column});// Give columns/headers a default getFooterProps
column.getFooterProps=makePropGetter(getHooks().getFooterProps,{instance:getInstance(),column:column});});getInstance().headerGroups=React.useMemo(function(){returnheaderGroups.filter(function(headerGroup,i){// Filter out any headers and headerGroups that don't have visible columns
headerGroup.headers=headerGroup.headers.filter(function(column){varrecurse=functionrecurse(headers){returnheaders.filter(function(column){if(column.headers){returnrecurse(column.headers);}returncolumn.isVisible;}).length;};if(column.headers){returnrecurse(column.headers);}returncolumn.isVisible;});// Give headerGroups getRowProps
if(headerGroup.headers.length){headerGroup.getHeaderGroupProps=makePropGetter(getHooks().getHeaderGroupProps,{instance:getInstance(),headerGroup:headerGroup,index:i});headerGroup.getFooterGroupProps=makePropGetter(getHooks().getFooterGroupProps,{instance:getInstance(),headerGroup:headerGroup,index:i});returntrue;}returnfalse;});},[headerGroups,getInstance,getHooks]);getInstance().footerGroups=[].concat(getInstance().headerGroups).reverse();// The prepareRow function is absolutely necessary and MUST be called on
// any rows the user wishes to be displayed.
getInstance().prepareRow=React.useCallback(function(row){row.getRowProps=makePropGetter(getHooks().getRowProps,{instance:getInstance(),row:row});// Build the visible cells for each row
row.allCells=allColumns.map(function(column){varvalue=row.values[column.id];varcell={column:column,row:row,value:value};// Give each cell a getCellProps base
cell.getCellProps=makePropGetter(getHooks().getCellProps,{instance:getInstance(),cell:cell});// Give each cell a renderer function (supports multiple renderers)
cell.render=makeRenderer(getInstance(),column,{row:row,cell:cell,value:value});returncell;});row.cells=visibleColumns.map(function(column){returnrow.allCells.find(function(cell){returncell.column.id===column.id;});});// need to apply any row specific hooks (useExpanded requires this)
loopHooks(getHooks().prepareRow,row,{instance:getInstance()});},[getHooks,getInstance,allColumns,visibleColumns]);getInstance().getTableProps=makePropGetter(getHooks().getTableProps,{instance:getInstance()});getInstance().getTableBodyProps=makePropGetter(getHooks().getTableBodyProps,{instance:getInstance()});loopHooks(getHooks().useFinalInstance,getInstance());returngetInstance();};functioncalculateHeaderWidths(headers,left){if(left===void0){left=0;}varsumTotalMinWidth=0;varsumTotalWidth=0;varsumTotalMaxWidth=0;varsumTotalFlexWidth=0;headers.forEach(function(header){varsubHeaders=header.headers;header.totalLeft=left;if(subHeaders&&subHeaders.length){var_calculateHeaderWidth2=calculateHeaderWidths(subHeaders,left),totalMinWidth=_calculateHeaderWidth2[0],totalWidth=_calculateHeaderWidth2[1],totalMaxWidth=_calculateHeaderWidth2[2],totalFlexWidth=_calculateHeaderWidth2[3];header.totalMinWidth=totalMinWidth;header.totalWidth=totalWidth;header.totalMaxWidth=totalMaxWidth;header.totalFlexWidth=totalFlexWidth;}else{header.totalMinWidth=header.minWidth;header.totalWidth=Math.min(Math.max(header.minWidth,header.width),header.maxWidth);header.totalMaxWidth=header.maxWidth;header.totalFlexWidth=header.canResize?header.totalWidth:0;}if(header.isVisible){left+=header.totalWidth;sumTotalMinWidth+=header.totalMinWidth;sumTotalWidth+=header.totalWidth;sumTotalMaxWidth+=header.totalMaxWidth;sumTotalFlexWidth+=header.totalFlexWidth;}});return[sumTotalMinWidth,sumTotalWidth,sumTotalMaxWidth,sumTotalFlexWidth];}functionaccessRowsForColumn(_ref){vardata=_ref.data,rows=_ref.rows,flatRows=_ref.flatRows,rowsById=_ref.rowsById,column=_ref.column,getRowId=_ref.getRowId,getSubRows=_ref.getSubRows,accessValueHooks=_ref.accessValueHooks,getInstance=_ref.getInstance;// Access the row's data column-by-column
// We do it this way so we can incrementally add materialized
// columns after the first pass and avoid excessive looping
varaccessRow=functionaccessRow(originalRow,rowIndex,depth,parent,parentRows){if(depth===void0){depth=0;}// Keep the original reference around
varoriginal=originalRow;varid=getRowId(originalRow,rowIndex,parent);varrow=rowsById[id];// If the row hasn't been created, let's make it
if(!row){row={id:id,original:original,index:rowIndex,depth:depth,cells:[{}]// This is a dummy cell
};// Override common array functions (and the dummy cell's getCellProps function)
// to show an error if it is accessed without calling prepareRow
row.cells.map=unpreparedAccessWarning;row.cells.filter=unpreparedAccessWarning;row.cells.forEach=unpreparedAccessWarning;row.cells[0].getCellProps=unpreparedAccessWarning;// Create the cells and values
row.values={};// Push this row into the parentRows array
parentRows.push(row);// Keep track of every row in a flat array
flatRows.push(row);// Also keep track of every row by its ID
rowsById[id]=row;// Get the original subrows
row.originalSubRows=getSubRows(originalRow,rowIndex);// Then recursively access them
if(row.originalSubRows){varsubRows=[];row.originalSubRows.forEach(function(d,i){returnaccessRow(d,i,depth+1,row,subRows);});// Keep the new subRows array on the row
row.subRows=subRows;}}elseif(row.subRows){// If the row exists, then it's already been accessed
// Keep recursing, but don't worry about passing the
// accumlator array (those rows already exist)
row.originalSubRows.forEach(function(d,i){returnaccessRow(d,i,depth+1,row);});}// If the column has an accessor, use it to get a value
if(column.accessor){row.values[column.id]=column.accessor(originalRow,rowIndex,row,parentRows,data);}// Allow plugins to manipulate the column value
row.values[column.id]=reduceHooks(accessValueHooks,row.values[column.id],{row:row,column:column,instance:getInstance()},true);};data.forEach(function(originalRow,rowIndex){returnaccessRow(originalRow,rowIndex,0,undefined,rows);});}actions.resetExpanded='resetExpanded';actions.toggleRowExpanded='toggleRowExpanded';actions.toggleAllRowsExpanded='toggleAllRowsExpanded';varuseExpanded=functionuseExpanded(hooks){hooks.getToggleAllRowsExpandedProps=[defaultGetToggleAllRowsExpandedProps];hooks.getToggleRowExpandedProps=[defaultGetToggleRowExpandedProps];hooks.stateReducers.push(reducer$1);hooks.useInstance.push(useInstance$1);hooks.prepareRow.push(prepareRow);};useExpanded.pluginName='useExpanded';vardefaultGetToggleAllRowsExpandedProps=functiondefaultGetToggleAllRowsExpandedProps(props,_ref){varinstance=_ref.instance;return[props,{onClick:functiononClick(e){instance.toggleAllRowsExpanded();},style:{cursor:'pointer'},title:'Toggle All Rows Expanded'}];};vardefaultGetToggleRowExpandedProps=functiondefaultGetToggleRowExpandedProps(props,_ref2){varrow=_ref2.row;return[props,{onClick:functiononClick(){row.toggleRowExpanded();},style:{cursor:'pointer'},title:'Toggle Row Expanded'}];};// Reducer
functionreducer$1(state,action,previousState,instance){if(action.type===actions.init){return_extends({expanded:{}},state);}if(action.type===actions.resetExpanded){return_extends({},state,{expanded:instance.initialState.expanded||{}});}if(action.type===actions.toggleAllRowsExpanded){varvalue=action.value;varisAllRowsExpanded=instance.isAllRowsExpanded,rowsById=instance.rowsById;varexpandAll=typeofvalue!=='undefined'?value:!isAllRowsExpanded;if(expandAll){varexpanded={};Object.keys(rowsById).forEach(function(rowId){expanded[rowId]=true;});return_extends({},state,{expanded:expanded});}return_extends({},state,{expanded:{}});}if(action.type===actions.toggleRowExpanded){varid=action.id,setExpanded=action.value;varexists=state.expanded[id];varshouldExist=typeofsetExpanded!=='undefined'?setExpanded:!exists;if(!exists&&shouldExist){var_extends2;return_extends({},state,{expanded:_extends({},state.expanded,(_extends2={},_extends2[id]=true,_extends2))});}elseif(exists&&!shouldExist){var_state$expanded=state.expanded,_=_state$expanded[id],rest=_objectWithoutPropertiesLoose(_state$expanded,[id].map(_toPropertyKey));return_extends({},state,{expanded:rest});}else{returnstate;}}}functionuseInstance$1(instance){vardata=instance.data,rows=instance.rows,rowsById=instance.rowsById,_instance$manualExpan=instance.manualExpandedKey,manualExpandedKey=_instance$manualExpan===void0?'expanded':_instance$manualExpan,_instance$paginateExp=instance.paginateExpandedRows,paginateExpandedRows=_instance$paginateExp===void0?true:_instance$paginateExp,_instance$expandSubRo=instance.expandSubRows,expandSubRows=_instance$expandSubRo===void0?true:_instance$expandSubRo,_instance$autoResetEx=instance.autoResetExpanded,autoResetExpanded=_instance$autoResetEx===void0?true:_instance$autoResetEx,getHooks=instance.getHooks,plugins=instance.plugins,expanded=instance.state.expanded,dispatch=instance.dispatch;ensurePluginOrder(plugins,['useSortBy','useGroupBy','usePivotColumns','useGlobalFilter'],'useExpanded');vargetAutoResetExpanded=useGetLatest(autoResetExpanded);varisAllRowsExpanded=Boolean(Object.keys(rowsById).length&&Object.keys(expanded).length);if(isAllRowsExpanded){if(Object.keys(rowsById).some(function(id){return!expanded[id];})){isAllRowsExpanded=false;}}// Bypass any effects from firing when this changes
returnrowValue==filterValue;});});};equals.autoRemove=function(val){returnval==null;};varbetween=functionbetween(rows,ids,filterValue){var_ref=filterValue||[],min=_ref[0],max=_ref[1];min=typeofmin==='number'?min:-Infinity;max=typeofmax==='number'?max:Infinity;if(min>max){vartemp=min;min=max;max=temp;}returnrows.filter(function(row){returnids.some(function(id){varrowValue=row.values[id];returnrowValue>=min&&rowValue<=max;});});};between.autoRemove=function(val){return!val||typeofval[0]!=='number'&&typeofval[1]!=='number';};varfilterTypes=/*#__PURE__*/Object.freeze({__proto__:null,text:text,exactText:exactText,exactTextCase:exactTextCase,includes:includes,includesAll:includesAll,includesSome:includesSome,includesValue:includesValue,exact:exact,equals:equals,between:between});actions.resetFilters='resetFilters';actions.setFilter='setFilter';actions.setAllFilters='setAllFilters';varuseFilters=functionuseFilters(hooks){hooks.stateReducers.push(reducer$2);hooks.useInstance.push(useInstance$2);};useFilters.pluginName='useFilters';functionreducer$2(state,action,previousState,instance){if(action.type===actions.init){return_extends({filters:[]},state);}if(action.type===actions.resetFilters){return_extends({},state,{filters:instance.initialState.filters||[]});}if(action.type===actions.setFilter){varcolumnId=action.columnId,filterValue=action.filterValue;varallColumns=instance.allColumns,userFilterTypes=instance.filterTypes;varcolumn=allColumns.find(function(d){returnd.id===columnId;});if(!column){thrownewError("React-Table: Could not find a column with id: "+columnId);}varfilterMethod=getFilterMethod(column.filter,userFilterTypes||{},filterTypes);varpreviousfilter=state.filters.find(function(d){returnd.id===columnId;});varnewFilter=functionalUpdate(filterValue,previousfilter&&previousfilter.value);//
if(shouldAutoRemoveFilter(filterMethod.autoRemove,newFilter,column)){return_extends({},state,{filters:state.filters.filter(function(d){returnd.id!==columnId;})});}if(previousfilter){return_extends({},state,{filters:state.filters.map(function(d){if(d.id===columnId){return{id:columnId,value:newFilter};}returnd;})});}return_extends({},state,{filters:[].concat(state.filters,[{id:columnId,value:newFilter}])});}if(action.type===actions.setAllFilters){varfilters=action.filters;var_allColumns=instance.allColumns,_userFilterTypes=instance.filterTypes;return_extends({},state,{// Filter out undefined values
filters:functionalUpdate(filters,state.filters).filter(function(filter){varcolumn=_allColumns.find(function(d){returnd.id===filter.id;});varfilterMethod=getFilterMethod(column.filter,_userFilterTypes||{},filterTypes);if(shouldAutoRemoveFilter(filterMethod.autoRemove,filter.value,column)){returnfalse;}returntrue;})});}}functionuseInstance$2(instance){vardata=instance.data,rows=instance.rows,flatRows=instance.flatRows,rowsById=instance.rowsById,allColumns=instance.allColumns,userFilterTypes=instance.filterTypes,manualFilters=instance.manualFilters,_instance$defaultCanF=instance.defaultCanFilter,defaultCanFilter=_instance$defaultCanF===void0?false:_instance$defaultCanF,disableFilters=instance.disableFilters,filters=instance.state.filters,dispatch=instance.dispatch,_instance$autoResetFi=instance.autoResetFilters,autoResetFilters=_instance$autoResetFi===void0?true:_instance$autoResetFi;varsetFilter=React.useCallback(function(columnId,filterValue){dispatch({type:actions.setFilter,columnId:columnId,filterValue:filterValue});},[dispatch]);varsetAllFilters=React.useCallback(function(filters){dispatch({type:actions.setAllFilters,filters:filters});},[dispatch]);allColumns.forEach(function(column){varid=column.id,accessor=column.accessor,columnDefaultCanFilter=column.defaultCanFilter,columnDisableFilters=column.disableFilters;// Determine if a column is filterable
column.canFilter=accessor?getFirstDefined(columnDisableFilters===true?false:undefined,disableFilters===true?false:undefined,true):getFirstDefined(columnDefaultCanFilter,defaultCanFilter,false);// Provide the column a way of updating the filter value
column.setFilter=function(val){returnsetFilter(column.id,val);};// Provide the current filter value to the column for
// convenience
varfound=filters.find(function(d){returnd.id===id;});column.filterValue=found&&found.value;});var_React$useMemo=React.useMemo(function(){if(manualFilters||!filters.length){return[rows,flatRows,rowsById];}varfilteredFlatRows=[];varfilteredRowsById={};// Filters top level and nested rows
varfilterRows=functionfilterRows(rows,depth){if(depth===void0){depth=0;}varfilteredRows=rows;filteredRows=filters.reduce(function(filteredSoFar,_ref){varcolumnId=_ref.id,filterValue=_ref.value;// Find the filters column
varcolumn=allColumns.find(function(d){returnd.id===columnId;});if(!column){returnfilteredSoFar;}if(depth===0){column.preFilteredRows=filteredSoFar;}varfilterMethod=getFilterMethod(column.filter,userFilterTypes||{},filterTypes);if(!filterMethod){console.warn("Could not find a valid 'column.filter' for column with the ID: "+column.id+".");returnfilteredSoFar;}// Pass the rows, id, filterValue and column to the filterMethod
// to get the filtered rows back
column.filteredRows=filterMethod(filteredSoFar,[columnId],filterValue);returncolumn.filteredRows;},rows);// Apply the filter to any subRows
// We technically could do this recursively in the above loop,
// but that would severely hinder the API for the user, since they
// would be required to do that recursion in some scenarios
filteredRows.forEach(function(row){filteredFlatRows.push(row);filteredRowsById[row.id]=row;if(!row.subRows){return;}row.subRows=row.subRows&&row.subRows.length>0?filterRows(row.subRows,depth+1):row.subRows;});returnfilteredRows;};return[filterRows(rows),filteredFlatRows,filteredRowsById];},[manualFilters,filters,rows,flatRows,rowsById,allColumns,userFilterTypes]),filteredRows=_React$useMemo[0],filteredFlatRows=_React$useMemo[1],filteredRowsById=_React$useMemo[2];React.useMemo(function(){// Now that each filtered column has it's partially filtered rows,
// lets assign the final filtered rows to all of the other columns
varnonFilteredColumns=allColumns.filter(function(column){return!filters.find(function(d){returnd.id===column.id;});});// This essentially enables faceted filter options to be built easily
if(shouldAutoRemoveFilter(filterMethod.autoRemove,newFilter)){varglobalFilter=state.globalFilter,stateWithoutGlobalFilter=_objectWithoutPropertiesLoose(state,["globalFilter"]);returnstateWithoutGlobalFilter;}return_extends({},state,{globalFilter:newFilter});}}functionuseInstance$3(instance){vardata=instance.data,rows=instance.rows,flatRows=instance.flatRows,rowsById=instance.rowsById,allColumns=instance.allColumns,userFilterTypes=instance.filterTypes,globalFilter=instance.globalFilter,manualGlobalFilter=instance.manualGlobalFilter,globalFilterValue=instance.state.globalFilter,dispatch=instance.dispatch,_instance$autoResetGl=instance.autoResetGlobalFilter,autoResetGlobalFilter=_instance$autoResetGl===void0?true:_instance$autoResetGl,disableGlobalFilter=instance.disableGlobalFilter;varsetGlobalFilter=React.useCallback(function(filterValue){dispatch({type:actions.setGlobalFilter,filterValue:filterValue});},[dispatch]);// TODO: Create a filter cache for incremental high speed multi-filtering
// This gets pretty complicated pretty fast, since you have to maintain a
// cache for each row group (top-level rows, and each row's recursive subrows)
// This would make multi-filtering a lot faster though. Too far?
var_React$useMemo=React.useMemo(function(){if(manualGlobalFilter||typeofglobalFilterValue==='undefined'){return[rows,flatRows,rowsById];}varfilteredFlatRows=[];varfilteredRowsById={};varfilterMethod=getFilterMethod(globalFilter,userFilterTypes||{},filterTypes);if(!filterMethod){console.warn("Could not find a valid 'globalFilter' option.");returnrows;}allColumns.forEach(function(column){varcolumnDisableGlobalFilter=column.disableGlobalFilter;column.canFilter=getFirstDefined(columnDisableGlobalFilter===true?false:undefined,disableGlobalFilter===true?false:undefined,true);});varfilterableColumns=allColumns.filter(function(c){returnc.canFilter===true;});// Filters top level and nested rows
varfilterRows=functionfilterRows(filteredRows){filteredRows=filterMethod(filteredRows,filterableColumns.map(function(d){returnd.id;}),globalFilterValue);filteredRows.forEach(function(row){filteredFlatRows.push(row);filteredRowsById[row.id]=row;row.subRows=row.subRows&&row.subRows.length?filterRows(row.subRows):row.subRows;});returnfilteredRows;};return[filterRows(rows),filteredFlatRows,filteredRowsById];},[manualGlobalFilter,globalFilterValue,globalFilter,userFilterTypes,allColumns,rows,flatRows,rowsById,disableGlobalFilter]),globalFilteredRows=_React$useMemo[0],globalFilteredFlatRows=_React$useMemo[1],globalFilteredRowsById=_React$useMemo[2];vargetAutoResetGlobalFilter=useGetLatest(autoResetGlobalFilter);useMountedLayoutEffect(function(){if(getAutoResetGlobalFilter()){dispatch({type:actions.resetGlobalFilter});}},[dispatch,manualGlobalFilter?null:data]);Object.assign(instance,{preGlobalFilteredRows:rows,preGlobalFilteredFlatRows:flatRows,preGlobalFilteredRowsById:rowsById,globalFilteredRows:globalFilteredRows,globalFilteredFlatRows:globalFilteredFlatRows,globalFilteredRowsById:globalFilteredRowsById,rows:globalFilteredRows,flatRows:globalFilteredFlatRows,rowsById:globalFilteredRowsById,setGlobalFilter:setGlobalFilter,disableGlobalFilter:disableGlobalFilter});}functionsum(values,aggregatedValues){// It's faster to just add the aggregations together instead of
functionreducer$4(state,action,previousState,instance){if(action.type===actions.init){return_extends({groupBy:[]},state);}if(action.type===actions.resetGroupBy){return_extends({},state,{groupBy:instance.initialState.groupBy||[]});}if(action.type===actions.setGroupBy){varvalue=action.value;return_extends({},state,{groupBy:value});}if(action.type===actions.toggleGroupBy){varcolumnId=action.columnId,setGroupBy=action.value;varresolvedGroupBy=typeofsetGroupBy!=='undefined'?setGroupBy:!state.groupBy.includes(columnId);if(resolvedGroupBy){return_extends({},state,{groupBy:[].concat(state.groupBy,[columnId])});}return_extends({},state,{groupBy:state.groupBy.filter(function(d){returnd!==columnId;})});}}functionvisibleColumns(columns,_ref3){vargroupBy=_ref3.instance.state.groupBy;// Sort grouped columns to the start of the column list
// before the headers are built
vargroupByColumns=groupBy.map(function(g){returncolumns.find(function(col){returncol.id===g;});}).filter(Boolean);varnonGroupByColumns=columns.filter(function(col){return!groupBy.includes(col.id);});columns=[].concat(groupByColumns,nonGroupByColumns);columns.forEach(function(column){column.isGrouped=groupBy.includes(column.id);column.groupedIndex=groupBy.indexOf(column.id);});returncolumns;}vardefaultUserAggregations={};functionuseInstance$4(instance){vardata=instance.data,rows=instance.rows,flatRows=instance.flatRows,rowsById=instance.rowsById,allColumns=instance.allColumns,flatHeaders=instance.flatHeaders,_instance$groupByFn=instance.groupByFn,groupByFn=_instance$groupByFn===void0?defaultGroupByFn:_instance$groupByFn,manualGroupBy=instance.manualGroupBy,_instance$aggregation=instance.aggregations,userAggregations=_instance$aggregation===void0?defaultUserAggregations:_instance$aggregation,plugins=instance.plugins,groupBy=instance.state.groupBy,dispatch=instance.dispatch,_instance$autoResetGr=instance.autoResetGroupBy,autoResetGroupBy=_instance$autoResetGr===void0?true:_instance$autoResetGr,disableGroupBy=instance.disableGroupBy,defaultCanGroupBy=instance.defaultCanGroupBy,getHooks=instance.getHooks;ensurePluginOrder(plugins,['useColumnOrder','useFilters'],'useGroupBy');vargetInstance=useGetLatest(instance);allColumns.forEach(function(column){varaccessor=column.accessor,defaultColumnGroupBy=column.defaultGroupBy,columnDisableGroupBy=column.disableGroupBy;column.canGroupBy=accessor?getFirstDefined(column.canGroupBy,columnDisableGroupBy===true?false:undefined,disableGroupBy===true?false:undefined,true):getFirstDefined(column.canGroupBy,defaultColumnGroupBy,defaultCanGroupBy,false);if(column.canGroupBy){column.toggleGroupBy=function(){returninstance.toggleGroupBy(column.id);};}column.Aggregated=column.Aggregated||column.Cell;});vartoggleGroupBy=React.useCallback(function(columnId,value){dispatch({type:actions.toggleGroupBy,columnId:columnId,value:value});},[dispatch]);varsetGroupBy=React.useCallback(function(value){dispatch({type:actions.setGroupBy,value:value});},[dispatch]);flatHeaders.forEach(function(header){header.getGroupByToggleProps=makePropGetter(getHooks().getGroupByToggleProps,{instance:getInstance(),header:header});});var_React$useMemo=React.useMemo(function(){if(manualGroupBy||!groupBy.length){return[rows,flatRows,rowsById,emptyArray,emptyObject,flatRows,rowsById];}// Ensure that the list of filtered columns exist
varexistingGroupBy=groupBy.filter(function(g){returnallColumns.find(function(col){returncol.id===g;});});// Find the columns that can or are aggregating
// Uses each column to aggregate rows into a single value
varaggregateRowsToValues=functionaggregateRowsToValues(leafRows,groupedRows,depth){varvalues={};allColumns.forEach(function(column){// Don't aggregate columns that are in the groupBy
if(existingGroupBy.includes(column.id)){values[column.id]=groupedRows[0]?groupedRows[0].values[column.id]:null;return;}// Aggregate the values
varaggregateFn=typeofcolumn.aggregate==='function'?column.aggregate:userAggregations[column.aggregate]||aggregations[column.aggregate];if(aggregateFn){// Get the columnValues to aggregate
vargroupedValues=groupedRows.map(function(row){returnrow.values[column.id];});// Get the columnValues to aggregate
varleafValues=leafRows.map(function(row){varcolumnValue=row.values[column.id];if(!depth&&column.aggregateValue){varaggregateValueFn=typeofcolumn.aggregateValue==='function'?column.aggregateValue:userAggregations[column.aggregateValue]||aggregations[column.aggregateValue];if(!aggregateValueFn){console.info({column:column});thrownewError("React Table: Invalid column.aggregateValue option for column listed above");}columnValue=aggregateValueFn(columnValue,row,column);}returncolumnValue;});values[column.id]=aggregateFn(leafValues,groupedValues);}elseif(column.aggregate){console.info({column:column});thrownewError("React Table: Invalid column.aggregate option for column listed above");}else{values[column.id]=null;}});returnvalues;};vargroupedFlatRows=[];vargroupedRowsById={};varonlyGroupedFlatRows=[];varonlyGroupedRowsById={};varnonGroupedFlatRows=[];varnonGroupedRowsById={};// Recursively group the data
vargroupUpRecursively=functiongroupUpRecursively(rows,depth,parentId){if(depth===void0){depth=0;}// This is the last level, just return the rows
if(depth===existingGroupBy.length){returnrows;}varcolumnId=existingGroupBy[depth];// Group the rows together for this level
varrowGroupsMap=groupByFn(rows,columnId);// Peform aggregations for each group
varaggregatedGroupedRows=Object.entries(rowGroupsMap).map(function(_ref4,index){vargroupByVal=_ref4[0],groupedRows=_ref4[1];varid=columnId+":"+groupByVal;id=parentId?parentId+">"+id:id;// First, Recurse to group sub rows before aggregation
varsubRows=groupUpRecursively(groupedRows,depth+1,id);// Flatten the leaf rows of the rows in this group
varleafRows=depth?flattenBy(groupedRows,'leafRows'):groupedRows;varvalues=aggregateRowsToValues(leafRows,groupedRows,depth);varrow={id:id,isGrouped:true,groupByID:columnId,groupByVal:groupByVal,values:values,subRows:subRows,leafRows:leafRows,depth:depth,index:index};subRows.forEach(function(subRow){groupedFlatRows.push(subRow);groupedRowsById[subRow.id]=subRow;if(subRow.isGrouped){onlyGroupedFlatRows.push(subRow);onlyGroupedRowsById[subRow.id]=subRow;}else{nonGroupedFlatRows.push(subRow);nonGroupedRowsById[subRow.id]=subRow;}});returnrow;});returnaggregatedGroupedRows;};vargroupedRows=groupUpRecursively(rows);groupedRows.forEach(function(subRow){groupedFlatRows.push(subRow);groupedRowsById[subRow.id]=subRow;if(subRow.isGrouped){onlyGroupedFlatRows.push(subRow);onlyGroupedRowsById[subRow.id]=subRow;}else{nonGroupedFlatRows.push(subRow);nonGroupedRowsById[subRow.id]=subRow;}});// Assign the new data
return[groupedRows,groupedFlatRows,groupedRowsById,onlyGroupedFlatRows,onlyGroupedRowsById,nonGroupedFlatRows,nonGroupedRowsById];},[manualGroupBy,groupBy,rows,flatRows,rowsById,allColumns,userAggregations,groupByFn]),groupedRows=_React$useMemo[0],groupedFlatRows=_React$useMemo[1],groupedRowsById=_React$useMemo[2],onlyGroupedFlatRows=_React$useMemo[3],onlyGroupedRowsById=_React$useMemo[4],nonGroupedFlatRows=_React$useMemo[5],nonGroupedRowsById=_React$useMemo[6];vargetAutoResetGroupBy=useGetLatest(autoResetGroupBy);useMountedLayoutEffect(function(){if(getAutoResetGroupBy()){dispatch({type:actions.resetGroupBy});}},[dispatch,manualGroupBy?null:data]);Object.assign(instance,{preGroupedRows:rows,preGroupedFlatRow:flatRows,preGroupedRowsById:rowsById,groupedRows:groupedRows,groupedFlatRows:groupedFlatRows,groupedRowsById:groupedRowsById,onlyGroupedFlatRows:onlyGroupedFlatRows,onlyGroupedRowsById:onlyGroupedRowsById,nonGroupedFlatRows:nonGroupedFlatRows,nonGroupedRowsById:nonGroupedRowsById,rows:groupedRows,flatRows:groupedFlatRows,rowsById:groupedRowsById,toggleGroupBy:toggleGroupBy,setGroupBy:setGroupBy});}functionprepareRow$1(row){row.allCells.forEach(function(cell){var_row$subRows;// Grouped cells are in the groupBy and the pivot cell for the row
cell.isGrouped=cell.column.isGrouped&&cell.column.id===row.groupByID;// Placeholder cells are any columns in the groupBy that are not grouped
cell.isPlaceholder=!cell.isGrouped&&cell.column.isGrouped;// Aggregated cells are not grouped, not repeated, but still have subRows
cell.isAggregated=!cell.isGrouped&&!cell.isPlaceholder&&((_row$subRows=row.subRows)==null?void0:_row$subRows.length);});}functiondefaultGroupByFn(rows,columnId){returnrows.reduce(function(prev,row,i){// TODO: Might want to implement a key serializer here so
// irregular column values can still be grouped if needed?
varresKey=""+row.values[columnId];prev[resKey]=Array.isArray(prev[resKey])?prev[resKey]:[];prev[resKey].push(row);returnprev;},{});}varreSplitAlphaNumeric=/([0-9]+)/gm;// Mixed sorting is slow, but very inclusive of many edge cases.
// It handles numbers, mixed alphanumeric combinations, and even
// null, undefined, and Infinity
varalphanumeric=functionalphanumeric(rowA,rowB,columnId){var_getRowValuesByColumn=getRowValuesByColumnID(rowA,rowB,columnId),a=_getRowValuesByColumn[0],b=_getRowValuesByColumn[1];// Force to strings (or "" for unsupported types)
a=toString(a);b=toString(b);// Split on number groups, but keep the delimiter
// Then remove falsey split values
a=a.split(reSplitAlphaNumeric).filter(Boolean);b=b.split(reSplitAlphaNumeric).filter(Boolean);// While
while(a.length&&b.length){varaa=a.shift();varbb=b.shift();varan=parseInt(aa,10);varbn=parseInt(bb,10);varcombo=[an,bn].sort();// Both are string
if(isNaN(combo[0])){if(aa>bb){return1;}if(bb>aa){return-1;}continue;}// One is a string, one is a number
if(isNaN(combo[1])){returnisNaN(an)?-1:1;}// Both are numbers
if(an>bn){return1;}if(bn>an){return-1;}}returna.length-b.length;};functiondatetime(rowA,rowB,columnId){var_getRowValuesByColumn2=getRowValuesByColumnID(rowA,rowB,columnId),a=_getRowValuesByColumn2[0],b=_getRowValuesByColumn2[1];a=a.getTime();b=b.getTime();returncompareBasic(a,b);}functionbasic(rowA,rowB,columnId){var_getRowValuesByColumn3=getRowValuesByColumnID(rowA,rowB,columnId),a=_getRowValuesByColumn3[0],b=_getRowValuesByColumn3[1];returncompareBasic(a,b);}functionstring(rowA,rowB,columnId){var_getRowValuesByColumn4=getRowValuesByColumnID(rowA,rowB,columnId),a=_getRowValuesByColumn4[0],b=_getRowValuesByColumn4[1];a=a.split('').filter(Boolean);b=b.split('').filter(Boolean);while(a.length&&b.length){varaa=a.shift();varbb=b.shift();varalower=aa.toLowerCase();varblower=bb.toLowerCase();// Case insensitive comparison until characters match
if(alower>blower){return1;}if(blower>alower){return-1;}// If lowercase characters are identical
functionreducer$5(state,action,previousState,instance){if(action.type===actions.init){return_extends({sortBy:[]},state);}if(action.type===actions.resetSortBy){return_extends({},state,{sortBy:instance.initialState.sortBy||[]});}if(action.type===actions.clearSortBy){varsortBy=state.sortBy;varnewSortBy=sortBy.filter(function(d){returnd.id!==action.columnId;});return_extends({},state,{sortBy:newSortBy});}if(action.type===actions.setSortBy){var_sortBy=action.sortBy;return_extends({},state,{sortBy:_sortBy});}if(action.type===actions.toggleSortBy){varcolumnId=action.columnId,desc=action.desc,multi=action.multi;varallColumns=instance.allColumns,disableMultiSort=instance.disableMultiSort,disableSortRemove=instance.disableSortRemove,disableMultiRemove=instance.disableMultiRemove,_instance$maxMultiSor=instance.maxMultiSortColCount,maxMultiSortColCount=_instance$maxMultiSor===void0?Number.MAX_SAFE_INTEGER:_instance$maxMultiSor;var_sortBy2=state.sortBy;// Find the column for this columnId
varcolumn=allColumns.find(function(d){returnd.id===columnId;});varsortDescFirst=column.sortDescFirst;// Find any existing sortBy for this column
varexistingSortBy=_sortBy2.find(function(d){returnd.id===columnId;});varexistingIndex=_sortBy2.findIndex(function(d){returnd.id===columnId;});varhasDescDefined=typeofdesc!=='undefined'&&desc!==null;var_newSortBy=[];// What should we do with this sort action?
varsortAction;if(!disableMultiSort&&multi){if(existingSortBy){sortAction='toggle';}else{sortAction='add';}}else{// Normal mode
if(existingIndex!==_sortBy2.length-1||_sortBy2.length!==1){sortAction='replace';}elseif(existingSortBy){sortAction='toggle';}else{sortAction='replace';}}// Handle toggle states that will remove the sortBy
if(sortAction==='toggle'&&// Must be toggling
!disableSortRemove&&// If disableSortRemove, disable in general
!hasDescDefined&&(// Must not be setting desc
multi?!disableMultiRemove:true)&&(// If multi, don't allow if disableMultiRemove
existingSortBy&&// Finally, detect if it should indeed be removed
existingSortBy.desc&&!sortDescFirst||!existingSortBy.desc&&sortDescFirst)){sortAction='remove';}if(sortAction==='replace'){_newSortBy=[{id:columnId,desc:hasDescDefined?desc:sortDescFirst}];}elseif(sortAction==='add'){_newSortBy=[].concat(_sortBy2,[{id:columnId,desc:hasDescDefined?desc:sortDescFirst}]);// Take latest n columns
_newSortBy.splice(0,_newSortBy.length-maxMultiSortColCount);}elseif(sortAction==='toggle'){// This flips (or sets) the
_newSortBy=_sortBy2.map(function(d){if(d.id===columnId){return_extends({},d,{desc:hasDescDefined?desc:!existingSortBy.desc});}returnd;});}elseif(sortAction==='remove'){_newSortBy=_sortBy2.filter(function(d){returnd.id!==columnId;});}return_extends({},state,{sortBy:_newSortBy});}}functionuseInstance$5(instance){vardata=instance.data,rows=instance.rows,flatRows=instance.flatRows,allColumns=instance.allColumns,_instance$orderByFn=instance.orderByFn,orderByFn=_instance$orderByFn===void0?defaultOrderByFn:_instance$orderByFn,userSortTypes=instance.sortTypes,manualSortBy=instance.manualSortBy,defaultCanSort=instance.defaultCanSort,disableSortBy=instance.disableSortBy,flatHeaders=instance.flatHeaders,sortBy=instance.state.sortBy,dispatch=instance.dispatch,plugins=instance.plugins,getHooks=instance.getHooks,_instance$autoResetSo=instance.autoResetSortBy,autoResetSortBy=_instance$autoResetSo===void0?true:_instance$autoResetSo;ensurePluginOrder(plugins,['useFilters','useGlobalFilter','useGroupBy','usePivotColumns'],'useSortBy');varsetSortBy=React.useCallback(function(sortBy){dispatch({type:actions.setSortBy,sortBy:sortBy});},[dispatch]);// Updates sorting based on a columnId, desc flag and multi flag
vartoggleSortBy=React.useCallback(function(columnId,desc,multi){dispatch({type:actions.toggleSortBy,columnId:columnId,desc:desc,multi:multi});},[dispatch]);// use reference to avoid memory leak in #1608
vargetInstance=useGetLatest(instance);// Add the getSortByToggleProps method to columns and headers
flatHeaders.forEach(function(column){varaccessor=column.accessor,defaultColumnCanSort=column.canSort,columnDisableSortBy=column.disableSortBy,id=column.id;varcanSort=accessor?getFirstDefined(columnDisableSortBy===true?false:undefined,disableSortBy===true?false:undefined,true):getFirstDefined(defaultCanSort,defaultColumnCanSort,false);column.canSort=canSort;if(column.canSort){column.toggleSortBy=function(desc,multi){returntoggleSortBy(column.id,desc,multi);};column.clearSortBy=function(){dispatch({type:actions.clearSortBy,columnId:column.id});};}column.getSortByToggleProps=makePropGetter(getHooks().getSortByToggleProps,{instance:getInstance(),column:column});varcolumnSort=sortBy.find(function(d){returnd.id===id;});column.isSorted=!!columnSort;column.sortedIndex=sortBy.findIndex(function(d){returnd.id===id;});column.isSortedDesc=column.isSorted?columnSort.desc:undefined;});var_React$useMemo=React.useMemo(function(){if(manualSortBy||!sortBy.length){return[rows,flatRows];}varsortedFlatRows=[];// Filter out sortBys that correspond to non existing columns
varavailableSortBy=sortBy.filter(function(sort){returnallColumns.find(function(col){returncol.id===sort.id;});});varsortData=functionsortData(rows){// Use the orderByFn to compose multiple sortBy's together.
// This will also perform a stable sorting using the row index
// if needed.
varsortedData=orderByFn(rows,availableSortBy.map(function(sort){// Support custom sorting methods for each column
varcolumn=allColumns.find(function(d){returnd.id===sort.id;});if(!column){thrownewError("React-Table: Could not find a column with id: "+sort.id+" while sorting");}varsortType=column.sortType;// Look up sortBy functions in this order:
// column function
// column string lookup on user sortType
// column string lookup on built-in sortType
// default function
// default string lookup on user sortType
// default string lookup on built-in sortType
varsortMethod=isFunction(sortType)||(userSortTypes||{})[sortType]||sortTypes[sortType];if(!sortMethod){thrownewError("React-Table: Could not find a valid sortType of '"+sortType+"' for column '"+sort.id+"'.");}// Return the correct sortFn.
// This function should always return in ascending order
returnfunction(a,b){returnsortMethod(a,b,sort.id,sort.desc);};}),// Map the directions
availableSortBy.map(function(sort){// Detect and use the sortInverted option
varcolumn=allColumns.find(function(d){returnd.id===sort.id;});if(column&&column.sortInverted){returnsort.desc;}return!sort.desc;}));// If there are sub-rows, sort them
actions.resetPage='resetPage';actions.gotoPage='gotoPage';actions.setPageSize='setPageSize';varusePagination=functionusePagination(hooks){hooks.stateReducers.push(reducer$6);hooks.useInstance.push(useInstance$6);};usePagination.pluginName=pluginName;functionreducer$6(state,action,previousState,instance){if(action.type===actions.init){return_extends({pageSize:10,pageIndex:0},state);}if(action.type===actions.resetPage){return_extends({},state,{pageIndex:instance.initialState.pageIndex||0});}if(action.type===actions.gotoPage){varpageCount=instance.pageCount,page=instance.page;varnewPageIndex=functionalUpdate(action.pageIndex,state.pageIndex);varcanNavigate=false;if(newPageIndex>state.pageIndex){// next page
functionreducer$7(state,action,previousState,instance){if(action.type===actions.init){return_extends({pivotColumns:defaultPivotColumns},state);}if(action.type===actions.resetPivot){return_extends({},state,{pivotColumns:instance.initialState.pivotColumns||defaultPivotColumns});}if(action.type===actions.togglePivot){varcolumnId=action.columnId,setPivot=action.value;varresolvedPivot=typeofsetPivot!=='undefined'?setPivot:!state.pivotColumns.includes(columnId);if(resolvedPivot){return_extends({},state,{pivotColumns:[].concat(state.pivotColumns,[columnId])});}return_extends({},state,{pivotColumns:state.pivotColumns.filter(function(d){returnd!==columnId;})});}}functionuseInstanceAfterData(instance){instance.allColumns.forEach(function(column){column.isPivotSource=instance.state.pivotColumns.includes(column.id);});}functionallColumns(columns,_ref2){varinstance=_ref2.instance;columns.forEach(function(column){column.isPivotSource=instance.state.pivotColumns.includes(column.id);column.uniqueValues=newSet();});returncolumns;}functionaccessValue(value,_ref3){varcolumn=_ref3.column;if(column.uniqueValues&&typeofvalue!=='undefined'){column.uniqueValues.add(value);}returnvalue;}functionmaterializedColumns(materialized,_ref4){varinstance=_ref4.instance;varallColumns=instance.allColumns,state=instance.state;if(!state.pivotColumns.length||!state.groupBy||!state.groupBy.length){returnmaterialized;}varpivotColumns=state.pivotColumns.map(function(id){returnallColumns.find(function(d){returnd.id===id;});}).filter(Boolean);varsourceColumns=allColumns.filter(function(d){return!d.isPivotSource&&!state.groupBy.includes(d.id)&&!state.pivotColumns.includes(d.id);});varbuildPivotColumns=functionbuildPivotColumns(depth,parent,pivotFilters){if(depth===void0){depth=0;}if(pivotFilters===void0){pivotFilters=[];}varpivotColumn=pivotColumns[depth];if(!pivotColumn){returnsourceColumns.map(function(sourceColumn){// TODO: We could offer support here for renesting pivoted
// columns inside copies of their header groups. For now,
// that seems like it would be (1) overkill on nesting, considering
// you already get nesting for every pivot level and (2)
// really hard. :)
return_extends({},sourceColumn,{canPivot:false,isPivoted:true,parent:parent,depth:depth,id:""+(parent?parent.id+"."+sourceColumn.id:sourceColumn.id),accessor:functionaccessor(originalRow,i,row){if(pivotFilters.every(function(filter){returnfilter(row);})){returnrow.values[sourceColumn.id];}}});});}varuniqueValues=Array.from(pivotColumn.uniqueValues).sort();returnuniqueValues.map(function(uniqueValue){varcolumnGroup=_extends({},pivotColumn,{Header:pivotColumn.PivotHeader||typeofpivotColumn.header==='string'?pivotColumn.Header+": "+uniqueValue:uniqueValue,isPivotGroup:true,parent:parent,depth:depth,id:parent?parent.id+"."+pivotColumn.id+"."+uniqueValue:pivotColumn.id+"."+uniqueValue,pivotValue:uniqueValue});columnGroup.columns=buildPivotColumns(depth+1,columnGroup,[].concat(pivotFilters,[function(row){returnrow.values[pivotColumn.id]===uniqueValue;}]));returncolumnGroup;});};varnewMaterialized=flattenColumns(buildPivotColumns());return[].concat(materialized,newMaterialized);}functionmaterializedColumnsDeps(deps,_ref5){var_ref5$instance$state=_ref5.instance.state,pivotColumns=_ref5$instance$state.pivotColumns,groupBy=_ref5$instance$state.groupBy;return[].concat(deps,[pivotColumns,groupBy]);}functionvisibleColumns$1(visibleColumns,_ref6){varstate=_ref6.instance.state;visibleColumns=visibleColumns.filter(function(d){return!d.isPivotSource;});if(state.pivotColumns.length&&state.groupBy&&state.groupBy.length){visibleColumns=visibleColumns.filter(function(column){returncolumn.isGrouped||column.isPivoted;});}returnvisibleColumns;}functionvisibleColumnsDeps(deps,_ref7){varinstance=_ref7.instance;return[].concat(deps,[instance.state.pivotColumns,instance.state.groupBy]);}functionuseInstance$7(instance){varcolumns=instance.columns,allColumns=instance.allColumns,flatHeaders=instance.flatHeaders,getHooks=instance.getHooks,plugins=instance.plugins,dispatch=instance.dispatch,_instance$autoResetPi=instance.autoResetPivot,autoResetPivot=_instance$autoResetPi===void0?true:_instance$autoResetPi,manaulPivot=instance.manaulPivot,disablePivot=instance.disablePivot,defaultCanPivot=instance.defaultCanPivot;ensurePluginOrder(plugins,['useGroupBy'],'usePivotColumns');vargetInstance=useGetLatest(instance);allColumns.forEach(function(column){varaccessor=column.accessor,defaultColumnPivot=column.defaultPivot,columnDisablePivot=column.disablePivot;column.canPivot=accessor?getFirstDefined(column.canPivot,columnDisablePivot===true?false:undefined,disablePivot===true?false:undefined,true):getFirstDefined(column.canPivot,defaultColumnPivot,defaultCanPivot,false);if(column.canPivot){column.togglePivot=function(){returninstance.togglePivot(column.id);};}column.Aggregated=column.Aggregated||column.Cell;});vartogglePivot=functiontogglePivot(columnId,value){dispatch({type:actions.togglePivot,columnId:columnId,value:value});};flatHeaders.forEach(function(header){header.getPivotToggleProps=makePropGetter(getHooks().getPivotToggleProps,{instance:getInstance(),header:header});});vargetAutoResetPivot=useGetLatest(autoResetPivot);useMountedLayoutEffect(function(){if(getAutoResetPivot()){dispatch({type:actions.resetPivot});}},[dispatch,manaulPivot?null:columns]);Object.assign(instance,{togglePivot:togglePivot});}functionprepareRow$2(row){row.allCells.forEach(function(cell){// Grouped cells are in the pivotColumns and the pivot cell for the row
actions.resetSelectedRows='resetSelectedRows';actions.toggleAllRowsSelected='toggleAllRowsSelected';actions.toggleRowSelected='toggleRowSelected';actions.toggleAllPageRowsSelected='toggleAllPageRowsSelected';varuseRowSelect=functionuseRowSelect(hooks){hooks.getToggleRowSelectedProps=[defaultGetToggleRowSelectedProps];hooks.getToggleAllRowsSelectedProps=[defaultGetToggleAllRowsSelectedProps];hooks.getToggleAllPageRowsSelectedProps=[defaultGetToggleAllPageRowsSelectedProps];hooks.stateReducers.push(reducer$8);hooks.useInstance.push(useInstance$8);hooks.prepareRow.push(prepareRow$3);};useRowSelect.pluginName=pluginName$1;vardefaultGetToggleRowSelectedProps=functiondefaultGetToggleRowSelectedProps(props,_ref){varinstance=_ref.instance,row=_ref.row;var_instance$manualRowSe=instance.manualRowSelectedKey,manualRowSelectedKey=_instance$manualRowSe===void0?'isSelected':_instance$manualRowSe;varchecked=false;if(row.original&&row.original[manualRowSelectedKey]){checked=true;}else{checked=row.isSelected;}return[props,{onChange:functiononChange(e){row.toggleRowSelected(e.target.checked);},style:{cursor:'pointer'},checked:checked,title:'Toggle Row Selected',indeterminate:row.isSomeSelected}];};vardefaultGetToggleAllRowsSelectedProps=functiondefaultGetToggleAllRowsSelectedProps(props,_ref2){varinstance=_ref2.instance;return[props,{onChange:functiononChange(e){instance.toggleAllRowsSelected(e.target.checked);},style:{cursor:'pointer'},checked:instance.isAllRowsSelected,title:'Toggle All Rows Selected',indeterminate:Boolean(!instance.isAllRowsSelected&&Object.keys(instance.state.selectedRowIds).length)}];};vardefaultGetToggleAllPageRowsSelectedProps=functiondefaultGetToggleAllPageRowsSelectedProps(props,_ref3){varinstance=_ref3.instance;return[props,{onChange:functiononChange(e){instance.toggleAllPageRowsSelected(e.target.checked);},style:{cursor:'pointer'},checked:instance.isAllPageRowsSelected,title:'Toggle All Current Page Rows Selected',indeterminate:Boolean(!instance.isAllPageRowsSelected&&instance.page.some(function(_ref4){varid=_ref4.id;returninstance.state.selectedRowIds[id];}))}];};// eslint-disable-next-line max-params
functionreducer$8(state,action,previousState,instance){if(action.type===actions.init){return_extends({selectedRowIds:{}},state);}if(action.type===actions.resetSelectedRows){return_extends({},state,{selectedRowIds:instance.initialState.selectedRowIds||{}});}if(action.type===actions.toggleAllRowsSelected){varsetSelected=action.value;varisAllRowsSelected=instance.isAllRowsSelected,rowsById=instance.rowsById,_instance$nonGroupedR=instance.nonGroupedRowsById,nonGroupedRowsById=_instance$nonGroupedR===void0?rowsById:_instance$nonGroupedR;varselectAll=typeofsetSelected!=='undefined'?setSelected:!isAllRowsSelected;// Only remove/add the rows that are visible on the screen
// Leave all the other rows that are selected alone.
if(!columnOrder||!columnOrder.length){returncolumns;}varcolumnOrderCopy=[].concat(columnOrder);// If there is an order, make a copy of the columns
varcolumnsCopy=[].concat(columns);// And make a new ordered array of the columns
varcolumnsInOrder=[];// Loop over the columns and place them in order into the new array
var_loop=function_loop(){vartargetColumnId=columnOrderCopy.shift();varfoundIndex=columnsCopy.findIndex(function(d){returnd.id===targetColumnId;});if(foundIndex>-1){columnsInOrder.push(columnsCopy.splice(foundIndex,1)[0]);}};while(columnsCopy.length&&columnOrderCopy.length){_loop();}// If there are any columns left, add them to the end
actions.columnStartResizing='columnStartResizing';actions.columnResizing='columnResizing';actions.columnDoneResizing='columnDoneResizing';actions.resetResize='resetResize';varuseResizeColumns=functionuseResizeColumns(hooks){hooks.getResizerProps=[defaultGetResizerProps];hooks.getHeaderProps.push({style:{position:'relative'}});hooks.stateReducers.push(reducer$b);hooks.useInstance.push(useInstance$b);hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions$1);};vardefaultGetResizerProps=functiondefaultGetResizerProps(props,_ref){varinstance=_ref.instance,header=_ref.header;vardispatch=instance.dispatch;varonResizeStart=functiononResizeStart(e,header){varisTouchEvent=false;if(e.type==='touchstart'){// lets not respond to multiple touches (e.g. 2 or 3 fingers)
*/function mergeOptions(obj1,obj2){var obj3={};var attrname;for(attrname in obj1){obj3[attrname]=obj1[attrname];}for(attrname in obj2){obj3[attrname]=obj2[attrname];}return obj3;}/**
*Markanyobjectwithanincrementingnumber
*usedforkeepingtrackofobjects
*
*@paramObjectobjAnyobjectorDOMElement
*@paramStringkey
*@returnObject
*/var stamp=function(){var keys={};return function stamp(obj){var key=arguments.length>1&&arguments[1]!==undefined?arguments[1]:"introjs-stamp";//eachgroupincrementsfrom0
keys[key]=keys[key]||0;// stamp only once per object
if(obj[key]===undefined){// increment key for each new object
varf$4=NASHORN_BUG?functionpropertyIsEnumerable(V){vardescriptor=getOwnPropertyDescriptor$1(this,V);return!!descriptor&&descriptor.enumerable;}:$propertyIsEnumerable;varobjectPropertyIsEnumerable={f:f$4};varcreatePropertyDescriptor=function(bitmap,value){return{enumerable:!(bitmap&1),configurable:!(bitmap&2),writable:!(bitmap&4),value:value};};varFunctionPrototype$2=Function.prototype;varbind$2=FunctionPrototype$2.bind;varcall$1=FunctionPrototype$2.call;varcallBind=bind$2&&bind$2.bind(call$1);varfunctionUncurryThis=bind$2?function(fn){returnfn&&callBind(call$1,fn);}:function(fn){returnfn&&function(){returncall$1.apply(fn,arguments);};};vartoString$1=functionUncurryThis({}.toString);varstringSlice$5=functionUncurryThis(''.slice);varclassofRaw=function(it){returnstringSlice$5(toString$1(it),8,-1);};varObject$4=global_1.Object;varsplit=functionUncurryThis(''.split);// fallback for non-array-like ES3 and non-enumerable old V8 strings
varindexedObject=fails(function(){// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
varrequireObjectCoercible=function(it){if(it==undefined)throwTypeError$c("Can't call method on "+it);returnit;};// toObject with fallback for non-array-like ES3 strings
varisCallable=function(argument){returntypeofargument=='function';};varisObject=function(it){returntypeofit=='object'?it!==null:isCallable(it);};varaFunction=function(argument){returnisCallable(argument)?argument:undefined;};vargetBuiltIn=function(namespace,method){returnarguments.length<2?aFunction(global_1[namespace]):global_1[namespace]&&global_1[namespace][method];};varobjectIsPrototypeOf=functionUncurryThis({}.isPrototypeOf);varengineUserAgent=getBuiltIn('navigator','userAgent')||'';varprocess=global_1.process;varDeno=global_1.Deno;varversions=process&&process.versions||Deno&&Deno.version;varv8=versions&&versions.v8;varmatch,version$1;if(v8){match=v8.split('.');// in old Chrome, versions of V8 isn't V8 = Chrome / 10
// but their correct versions are not interesting for us
version$1=match[0]>0&&match[0]<4?1:+(match[0]+match[1]);}// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
// so check `userAgent` even if `.v8` exists, but 0
if(!version$1&&engineUserAgent){match=engineUserAgent.match(/Edge\/(\d+)/);if(!match||match[1]>=74){match=engineUserAgent.match(/Chrome\/(\d+)/);if(match)version$1=+match[1];}}varengineV8Version=version$1;/* eslint-disable es/no-symbol -- required for testing */// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
varnativeSymbol=!!Object.getOwnPropertySymbols&&!fails(function(){varsymbol=Symbol();// Chrome 38 Symbol has incorrect toString conversion
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
return!String(symbol)||!(Object(symbol)instanceofSymbol)||// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
!Symbol.sham&&engineV8Version&&engineV8Version<41;});/* eslint-disable es/no-symbol -- required for testing */varuseSymbolAsUid=nativeSymbol&&!Symbol.sham&&typeofSymbol.iterator=='symbol';varObject$3=global_1.Object;varisSymbol=useSymbolAsUid?function(it){returntypeofit=='symbol';}:function(it){var$Symbol=getBuiltIn('Symbol');returnisCallable($Symbol)&&objectIsPrototypeOf($Symbol.prototype,Object$3(it));};varString$3=global_1.String;vartryToString=function(argument){try{returnString$3(argument);}catch(error){return'Object';}};varTypeError$b=global_1.TypeError;// `Assert: IsCallable(argument) is true`
varaCallable=function(argument){if(isCallable(argument))returnargument;throwTypeError$b(tryToString(argument)+' is not a function');};// `GetMethod` abstract operation
vartoPrimitive=function(input,pref){if(!isObject(input)||isSymbol(input))returninput;varexoticToPrim=getMethod(input,TO_PRIMITIVE);varresult;if(exoticToPrim){if(pref===undefined)pref='default';result=functionCall(exoticToPrim,input,pref);if(!isObject(result)||isSymbol(result))returnresult;throwTypeError$9("Can't convert object to primitive value");}if(pref===undefined)pref='number';returnordinaryToPrimitive(input,pref);};// `ToPropertyKey` abstract operation
// https://tc39.es/ecma262/#sec-topropertykey
vartoPropertyKey=function(argument){varkey=toPrimitive(argument,'string');returnisSymbol(key)?key:key+'';};vardocument$1=global_1.document;// typeof document.createElement is 'object' in old IE
varEXISTS$1=isObject(document$1)&&isObject(document$1.createElement);vardocumentCreateElement=function(it){returnEXISTS$1?document$1.createElement(it):{};};// Thank's IE8 for his funny defineProperty
varie8DomDefine=!descriptors&&!fails(function(){// eslint-disable-next-line es/no-object-defineproperty -- requied for testing
varf$3=descriptors?$getOwnPropertyDescriptor:functiongetOwnPropertyDescriptor(O,P){O=toIndexedObject(O);P=toPropertyKey(P);if(ie8DomDefine)try{return$getOwnPropertyDescriptor(O,P);}catch(error){/* empty */}if(hasOwnProperty_1(O,P))returncreatePropertyDescriptor(!functionCall(objectPropertyIsEnumerable.f,O,P),O[P]);};varobjectGetOwnPropertyDescriptor={f:f$3};varString$2=global_1.String;varTypeError$8=global_1.TypeError;// `Assert: Type(argument) is Object`
varanObject=function(argument){if(isObject(argument))returnargument;throwTypeError$8(String$2(argument)+' is not an object');};varTypeError$7=global_1.TypeError;// eslint-disable-next-line es/no-object-defineproperty -- safe
varf$2=descriptors?$defineProperty:functiondefineProperty(O,P,Attributes){anObject(O);P=toPropertyKey(P);anObject(Attributes);if(ie8DomDefine)try{return$defineProperty(O,P,Attributes);}catch(error){/* empty */}if('get'inAttributes||'set'inAttributes)throwTypeError$7('Accessors not supported');if('value'inAttributes)O[P]=Attributes.value;returnO;};varobjectDefineProperty={f:f$2};varcreateNonEnumerableProperty=descriptors?function(object,key,value){returnobjectDefineProperty.f(object,key,createPropertyDescriptor(1,value));}:function(object,key,value){object[key]=value;returnobject;};varfunctionToString=functionUncurryThis(Function.toString);// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
vargetDescriptor=descriptors&&Object.getOwnPropertyDescriptor;varEXISTS=hasOwnProperty_1(FunctionPrototype$1,'name');// additional protection from minified / mangled / dropped function names
varPROPER=EXISTS&&functionsomething(){/* empty */}.name==='something';varCONFIGURABLE=EXISTS&&(!descriptors||descriptors&&getDescriptor(FunctionPrototype$1,'name').configurable);varfunctionName={EXISTS:EXISTS,PROPER:PROPER,CONFIGURABLE:CONFIGURABLE};varredefine=createCommonjsModule(function(module){varCONFIGURABLE_FUNCTION_NAME=functionName.CONFIGURABLE;vargetInternalState=internalState.get;varenforceInternalState=internalState.enforce;varTEMPLATE=String(String).split('String');(module.exports=function(O,key,value,options){varunsafe=options?!!options.unsafe:false;varsimple=options?!!options.enumerable:false;varnoTargetGet=options?!!options.noTargetGet:false;varname=options&&options.name!==undefined?options.name:key;varstate;if(isCallable(value)){if(String(name).slice(0,7)==='Symbol('){name='['+String(name).replace(/^Symbol\(([^)]*)\)/,'$1')+']';}if(!hasOwnProperty_1(value,'name')||CONFIGURABLE_FUNCTION_NAME&&value.name!==name){createNonEnumerableProperty(value,'name',name);}state=enforceInternalState(value);if(!state.source){state.source=TEMPLATE.join(typeofname=='string'?name:'');}}if(O===global_1){if(simple)O[key]=value;elsesetGlobal(key,value);return;}elseif(!unsafe){deleteO[key];}elseif(!noTargetGet&&O[key]){simple=true;}if(simple)O[key]=value;elsecreateNonEnumerableProperty(O,key,value);// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
returnnumber!==number||number===0?0:(number>0?floor$2:ceil)(number);};varmax$3=Math.max;varmin$4=Math.min;// Helper for a popular repeating case of the spec:
// Let integer be ? ToInteger(index).
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
varf=Object.getOwnPropertySymbols;varobjectGetOwnPropertySymbols={f:f};varconcat$2=functionUncurryThis([].concat);// all object keys, includes non-enumerable and symbols
if(!FORCED&&targetProperty!==undefined){if(typeofsourceProperty==typeoftargetProperty)continue;copyConstructorProperties(sourceProperty,targetProperty);}// add a flag to not completely full polyfills
if(options.sham||targetProperty&&targetProperty.sham){createNonEnumerableProperty(sourceProperty,'sham',true);}// extend global
redefine(target,key,sourceProperty,options);}};varTO_STRING_TAG$1=wellKnownSymbol('toStringTag');vartest$1={};test$1[TO_STRING_TAG$1]='z';vartoStringTagSupport=String(test$1)==='[object z]';varTO_STRING_TAG=wellKnownSymbol('toStringTag');varObject$1=global_1.Object;// ES3 wrong here
varCORRECT_ARGUMENTS=classofRaw(function(){returnarguments;}())=='Arguments';// fallback for IE11 Script Access Denied error
vartryGet=function(it,key){try{returnit[key];}catch(error){/* empty */}};// getting tag from ES6+ `Object.prototype.toString`
varclassof=toStringTagSupport?classofRaw:function(it){varO,tag,result;returnit===undefined?'Undefined':it===null?'Null'// @@toStringTag case
:typeof(tag=tryGet(O=Object$1(it),TO_STRING_TAG))=='string'?tag// builtinTag case
:(result=classofRaw(O))=='Object'&&isCallable(O.callee)?'Arguments':result;};varString$1=global_1.String;vartoString_1=function(argument){if(classof(argument)==='Symbol')throwTypeError('Cannot convert a Symbol value to a string');returnString$1(argument);};// `RegExp.prototype.flags` getter implementation
varregexpFlags=function(){varthat=anObject(this);varresult='';if(that.global)result+='g';if(that.ignoreCase)result+='i';if(that.multiline)result+='m';if(that.dotAll)result+='s';if(that.unicode)result+='u';if(that.sticky)result+='y';returnresult;};// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
varobjectDefineProperties=descriptors?Object.defineProperties:functiondefineProperties(O,Properties){anObject(O);varprops=toIndexedObject(Properties);varkeys=objectKeys(Properties);varlength=keys.length;varindex=0;varkey;while(length>index)objectDefineProperty.f(O,key=keys[index++],props[key]);returnO;};varhtml=getBuiltIn('document','documentElement');/* global ActiveXObject -- old IE, WSH */varGT='>';varLT='<';varPROTOTYPE='prototype';varSCRIPT='script';varIE_PROTO=sharedKey('IE_PROTO');varEmptyConstructor=function(){/* empty */};varscriptTag=function(content){returnLT+SCRIPT+GT+content+LT+'/'+SCRIPT+GT;};// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
iframe.src=String(JS);iframeDocument=iframe.contentWindow.document;iframeDocument.open();iframeDocument.write(scriptTag('document.F=Object'));iframeDocument.close();returniframeDocument.F;};// Check for document.domain and active x support
// No need to use active x approach when document.domain is not set
// see https://github.com/es-shims/es5-shim/issues/150
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
// avoid IE GC bug
varactiveXDocument;varNullProtoObject=function(){try{activeXDocument=newActiveXObject('htmlfile');}catch(error){/* ignore */}NullProtoObject=typeofdocument!='undefined'?document.domain&&activeXDocument?NullProtoObjectViaActiveX(activeXDocument)// old IE
varobjectCreate=Object.create||functioncreate(O,Properties){varresult;if(O!==null){EmptyConstructor[PROTOTYPE]=anObject(O);result=newEmptyConstructor();EmptyConstructor[PROTOTYPE]=null;// add "__proto__" for Object.getPrototypeOf polyfill
result[IE_PROTO]=O;}elseresult=NullProtoObject();returnProperties===undefined?result:objectDefineProperties(result,Properties);};// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
var$RegExp$1=global_1.RegExp;varregexpUnsupportedDotAll=fails(function(){varre=$RegExp$1('.','s');return!(re.dotAll&&re.exec('\n')&&re.flags==='s');});// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
varNPCG_INCLUDED=/()??/.exec('')[1]!==undefined;varPATCH=UPDATES_LAST_INDEX_WRONG||NPCG_INCLUDED||UNSUPPORTED_Y$1||regexpUnsupportedDotAll||regexpUnsupportedNcg;if(PATCH){// eslint-disable-next-line max-statements -- TODO
patchedExec=functionexec(string){varre=this;varstate=getInternalState(re);varstr=toString_1(string);varraw=state.raw;varresult,reCopy,lastIndex,match,i,object,group;if(raw){raw.lastIndex=re.lastIndex;result=functionCall(patchedExec,raw,str);re.lastIndex=raw.lastIndex;returnresult;}vargroups=state.groups;varsticky=UNSUPPORTED_Y$1&&re.sticky;varflags=functionCall(regexpFlags,re);varsource=re.source;varcharsAdded=0;varstrCopy=str;if(sticky){flags=replace$1(flags,'y','');if(indexOf(flags,'g')===-1){flags+='g';}strCopy=stringSlice$4(str,re.lastIndex);// Support anchored sticky behavior.
if(re.lastIndex>0&&(!re.multiline||re.multiline&&charAt$3(str,re.lastIndex-1)!=='\n')){source='(?: '+source+')';strCopy=' '+strCopy;charsAdded++;}// ^(? + rx + ) is needed, in combination with some str slicing, to
varexecCalled=false;varre=/a/;if(KEY==='split'){// We can't use real regex here since it causes deoptimization
// and serious performance degradation in V8
// https://github.com/zloirock/core-js/issues/306
re={};// RegExp[@@split] doesn't call the regex's exec method, but first creates
// a new one. We need to return the patched regex when creating the new one.
re.constructor={};re.constructor[SPECIES$4]=function(){returnre;};re.flags='';re[SYMBOL]=/./[SYMBOL];}re.exec=function(){execCalled=true;returnnull;};re[SYMBOL]('');return!execCalled;});if(!DELEGATES_TO_SYMBOL||!DELEGATES_TO_EXEC||FORCED){varuncurriedNativeRegExpMethod=functionUncurryThis(/./[SYMBOL]);varmethods=exec(SYMBOL,''[KEY],function(nativeMethod,regexp,str,arg2,forceStringMethod){varuncurriedNativeMethod=functionUncurryThis(nativeMethod);var$exec=regexp.exec;if($exec===regexpExec||$exec===RegExpPrototype$1.exec){if(DELEGATES_TO_SYMBOL&&!forceStringMethod){// The native String method already delegates to @@method (this
// polyfilled function), leasing to infinite recursion.
// We avoid it by directly calling the native @@method method.
varregexpExecAbstract=function(R,S){varexec=R.exec;if(isCallable(exec)){varresult=functionCall(exec,R,S);if(result!==null)anObject(result);returnresult;}if(classofRaw(R)==='RegExp')returnfunctionCall(regexpExec,R,S);throwTypeError$5('RegExp#exec called on incompatible receiver');};// @@match logic
varisArray=Array.isArray||functionisArray(argument){returnclassofRaw(argument)=='Array';};varcreateProperty=function(object,key,value){varpropertyKey=toPropertyKey(key);if(propertyKeyinobject)objectDefineProperty.f(object,propertyKey,createPropertyDescriptor(0,value));elseobject[propertyKey]=value;};varnoop=function(){/* empty */};varempty=[];varconstruct=getBuiltIn('Reflect','construct');varconstructorRegExp=/^\s*(?:class|function)\b/;varexec$1=functionUncurryThis(constructorRegExp.exec);varINCORRECT_TO_STRING=!constructorRegExp.exec(noop);varisConstructorModern=function(argument){if(!isCallable(argument))returnfalse;try{construct(noop,empty,argument);returntrue;}catch(error){returnfalse;}};varisConstructorLegacy=function(argument){if(!isCallable(argument))returnfalse;switch(classof(argument)){case'AsyncFunction':case'GeneratorFunction':case'AsyncGeneratorFunction':returnfalse;// we can't check .prototype since constructors produced by .bind haven't it
varisConstructor=!construct||fails(function(){varcalled;returnisConstructorModern(isConstructorModern.call)||!isConstructorModern(Object)||!isConstructorModern(function(){called=true;})||called;})?isConstructorLegacy:isConstructorModern;varSPECIES$3=wellKnownSymbol('species');varArray$2=global_1.Array;// a part of `ArraySpeciesCreate` abstract operation
vararraySpeciesCreate=function(originalArray,length){returnnew(arraySpeciesConstructor(originalArray))(length===0?0:length);};varSPECIES$2=wellKnownSymbol('species');vararrayMethodHasSpeciesSupport=function(METHOD_NAME){// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
// https://github.com/zloirock/core-js/issues/677
returnengineV8Version>=51||!fails(function(){vararray=[];varconstructor=array.constructor={};constructor[SPECIES$2]=function(){return{foo:1};};returnarray[METHOD_NAME](Boolean).foo!==1;});};varIS_CONCAT_SPREADABLE=wellKnownSymbol('isConcatSpreadable');varMAX_SAFE_INTEGER$1=0x1FFFFFFFFFFFFF;varMAXIMUM_ALLOWED_INDEX_EXCEEDED='Maximum allowed index exceeded';varTypeError$4=global_1.TypeError;// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
if(!toStringTagSupport){redefine(Object.prototype,'toString',objectToString,{unsafe:true});}varPROPER_FUNCTION_NAME=functionName.PROPER;varTO_STRING='toString';varRegExpPrototype=RegExp.prototype;varn$ToString=RegExpPrototype[TO_STRING];vargetFlags=functionUncurryThis(regexpFlags);varNOT_GENERIC=fails(function(){returnn$ToString.call({source:'a',flags:'b'})!='/a/b';});// FF44- RegExp#toString has a wrong name
varisRegexp=function(it){varisRegExp;returnisObject(it)&&((isRegExp=it[MATCH$1])!==undefined?!!isRegExp:classofRaw(it)=='RegExp');};varTypeError$3=global_1.TypeError;// `Assert: IsConstructor(argument) is true`
varaConstructor=function(argument){if(isConstructor(argument))returnargument;throwTypeError$3(tryToString(argument)+' is not a constructor');};varSPECIES$1=wellKnownSymbol('species');// `SpeciesConstructor` abstract operation
varspeciesConstructor=function(O,defaultConstructor){varC=anObject(O).constructor;varS;returnC===undefined||(S=anObject(C)[SPECIES$1])==undefined?defaultConstructor:aConstructor(S);};vararraySlice=functionUncurryThis([].slice);varUNSUPPORTED_Y=regexpStickyHelpers.UNSUPPORTED_Y;varMAX_UINT32=0xFFFFFFFF;varmin$2=Math.min;var$push=[].push;varexec=functionUncurryThis(/./.exec);varpush$3=functionUncurryThis($push);varstringSlice$2=functionUncurryThis(''.slice);// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
// Weex JS has frozen built-in prototypes, so use try / catch wrapper
varSPLIT_WORKS_WITH_OVERWRITTEN_EXEC=!fails(function(){// eslint-disable-next-line regexp/no-empty-group -- required for testing
fixRegexpWellKnownSymbolLogic('split',function(SPLIT,nativeSplit,maybeCallNative){varinternalSplit;if('abbc'.split(/(b)*/)[1]=='c'||// eslint-disable-next-line regexp/no-empty-group -- required for testing
'test'.split(/(?:)/,-1).length!=4||'ab'.split(/(?:ab)*/).length!=2||'.'.split(/(.?)(.?)/).length!=4||// eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
'.'.split(/()()/).length>1||''.split(/.?/).length){// based on es5-shim implementation, need to rework it
internalSplit=function(separator,limit){varstring=toString_1(requireObjectCoercible(this));varlim=limit===undefined?MAX_UINT32:limit>>>0;if(lim===0)return[];if(separator===undefined)return[string];// If `separator` is not a regex, use native split
if(!isRegexp(separator)){returnfunctionCall(nativeSplit,string,separator,lim);}varoutput=[];varflags=(separator.ignoreCase?'i':'')+(separator.multiline?'m':'')+(separator.unicode?'u':'')+(separator.sticky?'y':'');varlastLastIndex=0;// Make `global` and avoid `lastIndex` issues by working with a copy
varseparatorCopy=newRegExp(separator.source,flags+'g');varmatch,lastIndex,lastLength;while(match=functionCall(regexpExec,separatorCopy,string)){lastIndex=separatorCopy.lastIndex;if(lastIndex>lastLastIndex){push$3(output,stringSlice$2(string,lastLastIndex,match.index));if(match.length>1&&match.index<string.length)functionApply($push,output,arraySlice(match,1));lastLength=match[0].length;lastLastIndex=lastIndex;if(output.length>=lim)break;}if(separatorCopy.lastIndex===match.index)separatorCopy.lastIndex++;// Avoid an infinite loop
// NOTE: This cannot be properly polyfilled in engines that don't support
// the 'y' flag.
function(string,limit){varrx=anObject(this);varS=toString_1(string);varres=maybeCallNative(internalSplit,rx,S,limit,internalSplit!==nativeSplit);if(res.done)returnres.value;varC=speciesConstructor(rx,RegExp);varunicodeMatching=rx.unicode;varflags=(rx.ignoreCase?'i':'')+(rx.multiline?'m':'')+(rx.unicode?'u':'')+(UNSUPPORTED_Y?'g':'y');// ^(? + rx + ) is needed, in combination with some S slicing, to
varpre=element.getAttribute("class")||"";if(!pre.match(className)){// check if element doesn't already have className
element.setAttribute("class","".concat(pre," ").concat(className));}}else{if(element.classList!==undefined){// check for modern classList property
varclasses=className.split(" ");forEach(classes,function(cls){element.classList.add(cls);});}elseif(!element.className.match(className)){// check if element doesn't already have className
// I have changed the scroll option and now it scrolls the window to
// the center of the target element or tooltip.
if(top<0||element.clientHeight>winHeight){window.scrollBy(0,rect.top-(winHeight/2-rect.height/2)-this._options.scrollPadding);// 30px padding from edge to look nice
//Scroll down
}else{window.scrollBy(0,rect.top-(winHeight/2-rect.height/2)+this._options.scrollPadding);// 30px padding from edge to look nice
varobjectAssign=!$assign||fails(function(){// should have correct order of operations (Edge bug)
if(descriptors&&$assign({b:1},$assign(defineProperty({},'a',{enumerable:true,get:function(){defineProperty(this,'b',{value:3,enumerable:false});}}),{b:2})).b!==1)returntrue;// should work with symbols and should have deterministic property order (V8 bug)
varn=+ch;if(n===0)returnmatch;if(n>m){varf=floor$1(n/10);if(f===0)returnmatch;if(f<=m)returncaptures[f-1]===undefined?charAt(ch,1):captures[f-1]+charAt(ch,1);returnmatch;}capture=captures[n-1];}returncapture===undefined?'':capture;});};varREPLACE=wellKnownSymbol('replace');varmax$2=Math.max;varmin$1=Math.min;varconcat=functionUncurryThis([].concat);varpush$2=functionUncurryThis([].push);varstringIndexOf$1=functionUncurryThis(''.indexOf);varstringSlice=functionUncurryThis(''.slice);varmaybeToString=function(it){returnit===undefined?it:String(it);};// IE <= 11 replaces $0 with the whole match, as if it was $&
function(string,replaceValue){varrx=anObject(this);varS=toString_1(string);if(typeofreplaceValue=='string'&&stringIndexOf$1(replaceValue,UNSAFE_SUBSTITUTE)===-1&&stringIndexOf$1(replaceValue,'$<')===-1){varres=maybeCallNative(nativeReplace,rx,S,replaceValue);if(res.done)returnres.value;}varfunctionalReplace=isCallable(replaceValue);if(!functionalReplace)replaceValue=toString_1(replaceValue);varglobal=rx.global;if(global){varfullUnicode=rx.unicode;rx.lastIndex=0;}varresults=[];while(true){varresult=regexpExecAbstract(rx,S);if(result===null)break;push$2(results,result);if(!global)break;varmatchStr=toString_1(result[0]);if(matchStr==='')rx.lastIndex=advanceStringIndex(S,toLength(rx.lastIndex),fullUnicode);}varaccumulatedResult='';varnextSourcePosition=0;for(vari=0;i<results.length;i++){result=results[i];varmatched=toString_1(result[0]);varposition=max$2(min$1(toIntegerOrInfinity(result.index),S.length),0);varcaptures=[];// NOTE: This is equivalent to
// captures = result.slice(1).map(maybeToString)
// but for some reason `nativeSlice.call(result, 1, result.length)` (called in
// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
if(!this._introItems[this._currentStep])return;varcurrentElement=this._introItems[this._currentStep];varelementPosition=getOffset(currentElement.element,this._targetElement);varwidthHeightPadding=this._options.helperElementPadding;// If the target element is fixed, the tooltip should be fixed as well.
// Otherwise, remove a fixed class that may be left over from the previous
// step.
if(isFixed(currentElement.element)){addClass(helperLayer,"introjs-fixedTooltip");}else{removeClass(helperLayer,"introjs-fixedTooltip");}if(currentElement.position==="floating"){widthHeightPadding=0;}//set new position to helper layer
if(ArrayPrototype[UNSCOPABLES]==undefined){objectDefineProperty.f(ArrayPrototype,UNSCOPABLES,{configurable:true,value:objectCreate(null)});}// add a key to Array.prototype[@@unscopables]
// fallback for not array-like ES3 strings and DOM objects
_export({target:'Array',proto:true,forced:!HAS_SPECIES_SUPPORT$2},{slice:functionslice(start,end){varO=toIndexedObject(this);varlength=lengthOfArrayLike(O);vark=toAbsoluteIndex(start,length);varfin=toAbsoluteIndex(end===undefined?length:end,length);// inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
if(winWidth-offsetLeft<tooltipWidth){removeEntry(possibleAlignments,"-left-aligned");}// valid middle must be at least half
// width away from both sides
if(offsetLeft<halfTooltipWidth||winWidth-offsetLeft<halfTooltipWidth){removeEntry(possibleAlignments,"-middle-aligned");}// valid right must be at least a tooltipWidth
// width away from left side
if(offsetLeft<tooltipWidth){removeEntry(possibleAlignments,"-right-aligned");}if(possibleAlignments.length){if(possibleAlignments.includes(desiredAlignment)){// the desired alignment is valid
calculatedAlignment=desiredAlignment;}else{// pick the first valid position, in order
calculatedAlignment=possibleAlignments[0];}}else{// if screen width is too small
varpossiblePositions=this._options.positionPrecedence.slice();varwindowSize=getWinSize();vartooltipHeight=getOffset(tooltipLayer).height+10;vartooltipWidth=getOffset(tooltipLayer).width+20;vartargetElementRect=targetElement.getBoundingClientRect();// If we check all the possible areas, and there are no valid places for the tooltip, the element
// must take up most of the screen real estate. Show the tooltip floating in the middle of the screen.
varcalculatedPosition="floating";/*
*autodetermineposition
*/ //Checkforspacebelow
if(targetElementRect.bottom+tooltipHeight>windowSize.height){removeEntry(possiblePositions,"bottom");}// Check for space above
if(targetElementRect.top-tooltipHeight<0){removeEntry(possiblePositions,"top");}// Check for space to the right
if(targetElementRect.right+tooltipWidth>windowSize.width){removeEntry(possiblePositions,"right");}// Check for space to the left
desiredTooltipPosition=desiredTooltipPosition.split("-")[0];}if(possiblePositions.length){if(possiblePositions.includes(desiredTooltipPosition)){// If the requested position is in the list, choose that
calculatedPosition=desiredTooltipPosition;}else{// Pick the first valid position, in order
calculatedPosition=possiblePositions[0];}}// only top and bottom positions have optional alignments
tooltipLayer.style.top=null;tooltipLayer.style.right=null;tooltipLayer.style.bottom=null;tooltipLayer.style.left=null;tooltipLayer.style.marginLeft=null;tooltipLayer.style.marginTop=null;arrowLayer.style.display="inherit";//prevent error when `this._currentStep` is undefined
if(!this._introItems[this._currentStep])return;//if we have a custom css class for each step
currentStepObj=this._introItems[this._currentStep];if(typeofcurrentStepObj.tooltipClass==="string"){tooltipCssClass=currentStepObj.tooltipClass;}else{tooltipCssClass=this._options.tooltipClass;}tooltipLayer.className=["introjs-tooltip",tooltipCssClass].filter(Boolean).join(" ");tooltipLayer.setAttribute("role","dialog");currentTooltipPosition=this._introItems[this._currentStep].position;// Floating is always valid, no point in calculating
if(currentTooltipPosition!=="floating"&&this._options.autoPosition){currentTooltipPosition=_determineAutoPosition.call(this,targetElement,tooltipLayer,currentTooltipPosition);}vartooltipLayerStyleLeft;targetOffset=getOffset(targetElement);tooltipOffset=getOffset(tooltipLayer);windowSize=getWinSize();addClass(tooltipLayer,"introjs-".concat(currentTooltipPosition));switch(currentTooltipPosition){case"top-right-aligned":arrowLayer.className="introjs-arrow bottom-right";vartooltipLayerStyleRight=0;checkLeft(targetOffset,tooltipLayerStyleRight,tooltipOffset,tooltipLayer);tooltipLayer.style.bottom="".concat(targetOffset.height+20,"px");break;case"top-middle-aligned":arrowLayer.className="introjs-arrow bottom-middle";vartooltipLayerStyleLeftRight=targetOffset.width/2-tooltipOffset.width/2;// a fix for middle aligned hints
if(hintMode){tooltipLayerStyleLeftRight+=5;}if(checkLeft(targetOffset,tooltipLayerStyleLeftRight,tooltipOffset,tooltipLayer)){tooltipLayer.style.right=null;checkRight(targetOffset,tooltipLayerStyleLeftRight,tooltipOffset,windowSize,tooltipLayer);}tooltipLayer.style.bottom="".concat(targetOffset.height+20,"px");break;case"top-left-aligned":// top-left-aligned is the same as the default top
case"top":arrowLayer.className="introjs-arrow bottom";tooltipLayerStyleLeft=hintMode?0:15;checkRight(targetOffset,tooltipLayerStyleLeft,tooltipOffset,windowSize,tooltipLayer);tooltipLayer.style.bottom="".concat(targetOffset.height+20,"px");break;case"right":tooltipLayer.style.left="".concat(targetOffset.width+20,"px");if(targetOffset.top+tooltipOffset.height>windowSize.height){// In this case, right would have fallen below the bottom of the screen.
// Modify so that the bottom of the tooltip connects with the target
arrowLayer.className="introjs-arrow left-bottom";tooltipLayer.style.top="-".concat(tooltipOffset.height-targetOffset.height-20,"px");}else{arrowLayer.className="introjs-arrow left";}break;case"left":if(!hintMode&&this._options.showStepNumbers===true){tooltipLayer.style.top="15px";}if(targetOffset.top+tooltipOffset.height>windowSize.height){// In this case, left would have fallen below the bottom of the screen.
// Modify so that the bottom of the tooltip connects with the target
tooltipLayer.style.top="-".concat(tooltipOffset.height-targetOffset.height-20,"px");arrowLayer.className="introjs-arrow right-bottom";}else{arrowLayer.className="introjs-arrow right";}tooltipLayer.style.right="".concat(targetOffset.width+20,"px");break;case"floating":arrowLayer.style.display="none";//we have to adjust the top and left of layer manually for intro items without element
tooltipLayer.style.left="50%";tooltipLayer.style.top="50%";tooltipLayer.style.marginLeft="-".concat(tooltipOffset.width/2,"px");tooltipLayer.style.marginTop="-".concat(tooltipOffset.height/2,"px");break;case"bottom-right-aligned":arrowLayer.className="introjs-arrow top-right";tooltipLayerStyleRight=0;checkLeft(targetOffset,tooltipLayerStyleRight,tooltipOffset,tooltipLayer);tooltipLayer.style.top="".concat(targetOffset.height+20,"px");break;case"bottom-middle-aligned":arrowLayer.className="introjs-arrow top-middle";tooltipLayerStyleLeftRight=targetOffset.width/2-tooltipOffset.width/2;// a fix for middle aligned hints
if(hintMode){tooltipLayerStyleLeftRight+=5;}if(checkLeft(targetOffset,tooltipLayerStyleLeftRight,tooltipOffset,tooltipLayer)){tooltipLayer.style.right=null;checkRight(targetOffset,tooltipLayerStyleLeftRight,tooltipOffset,windowSize,tooltipLayer);}tooltipLayer.style.top="".concat(targetOffset.height+20,"px");break;// case 'bottom-left-aligned':
// Bottom-left-aligned is the same as the default bottom
*/function _updateBullets(oldReferenceLayer,targetElement){if(this._options.showBullets){oldReferenceLayer.querySelector(".introjs-bullets li > a.active").className="";oldReferenceLayer.querySelector(".introjs-bullets li > a[data-stepnumber=\"".concat(targetElement.step,"\"]")).className="active";}}/**
if(typeoftargetElement.highlightClass==="string"){highlightClass+=" ".concat(targetElement.highlightClass);}//check for options highlight class
if(typeofthis._options.highlightClass==="string"){highlightClass+=" ".concat(this._options.highlightClass);}if(oldHelperLayer!==null&&oldReferenceLayer!==null){varoldHelperNumberLayer=oldReferenceLayer.querySelector(".introjs-helperNumberLayer");varoldtooltipLayer=oldReferenceLayer.querySelector(".introjs-tooltiptext");varoldTooltipTitleLayer=oldReferenceLayer.querySelector(".introjs-tooltip-title");varoldArrowLayer=oldReferenceLayer.querySelector(".introjs-arrow");varoldtooltipContainer=oldReferenceLayer.querySelector(".introjs-tooltip");skipTooltipButton=oldReferenceLayer.querySelector(".introjs-skipbutton");prevTooltipButton=oldReferenceLayer.querySelector(".introjs-prevbutton");nextTooltipButton=oldReferenceLayer.querySelector(".introjs-nextbutton");//update or reset the helper highlight class
oldHelperLayer.className=highlightClass;//hide the tooltip
oldtooltipContainer.style.opacity=0;oldtooltipContainer.style.display="none";// if the target element is within a scrollable element
scrollParentToElement.call(self,targetElement);// set new position to helper layer
setHelperLayerPosition.call(self,oldHelperLayer);setHelperLayerPosition.call(self,oldReferenceLayer);//remove old classes if the element still exist
removeShowElement();//we should wait until the CSS3 transition is competed (it's 0.3 sec) to prevent incorrect `height` and `width` calculation
if(self._lastShowElementTimer){window.clearTimeout(self._lastShowElementTimer);}self._lastShowElementTimer=window.setTimeout(function(){// set current step to the label
if(oldHelperNumberLayer!==null){oldHelperNumberLayer.innerHTML="".concat(targetElement.step," of ").concat(_this._introItems.length);}// set current tooltip text
oldtooltipLayer.innerHTML=targetElement.intro;// set current tooltip title
oldTooltipTitleLayer.innerHTML=targetElement.title;//set the tooltip position
oldtooltipContainer.style.display="block";placeTooltip.call(self,targetElement.element,oldtooltipContainer,oldArrowLayer);//change active bullet
_updateBullets.call(self,oldReferenceLayer,targetElement);_updateProgressBar.call(self,oldReferenceLayer);//show the tooltip
if(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null&&/introjs-donebutton/gi.test(nextTooltipButton.className)){// skip button is now "done" button
nextTooltipButton.focus();}elseif(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null){//still in the tour, focus on next
nextTooltipButton.focus();}// change the scroll of the window, if needed
scrollTo.call(self,targetElement.scrollTo,targetElement,oldtooltipLayer);},350);// end of old element if-else condition
}else{varhelperLayer=_createElement("div",{className:highlightClass});varreferenceLayer=_createElement("div",{className:"introjs-tooltipReferenceLayer"});vararrowLayer=_createElement("div",{className:"introjs-arrow"});vartooltipLayer=_createElement("div",{className:"introjs-tooltip"});vartooltipTextLayer=_createElement("div",{className:"introjs-tooltiptext"});vartooltipHeaderLayer=_createElement("div",{className:"introjs-tooltip-header"});vartooltipTitleLayer=_createElement("h1",{className:"introjs-tooltip-title"});varbuttonsLayer=_createElement("div");setStyle(helperLayer,{"box-shadow":"0 0 1px 2px rgba(33, 33, 33, 0.8), rgba(33, 33, 33, ".concat(self._options.overlayOpacity.toString(),") 0 0 0 5000px")});// target is within a scrollable element
scrollParentToElement.call(self,targetElement);//set new position to helper layer
setHelperLayerPosition.call(self,helperLayer);setHelperLayerPosition.call(self,referenceLayer);//add helper layer to target element
appendChild(this._targetElement,helperLayer,true);appendChild(this._targetElement,referenceLayer);tooltipTextLayer.innerHTML=targetElement.intro;tooltipTitleLayer.innerHTML=targetElement.title;buttonsLayer.className="introjs-tooltipbuttons";if(this._options.showButtons===false){buttonsLayer.style.display="none";}tooltipHeaderLayer.appendChild(tooltipTitleLayer);tooltipLayer.appendChild(tooltipHeaderLayer);tooltipLayer.appendChild(tooltipTextLayer);tooltipLayer.appendChild(_createBullets.call(this,targetElement));tooltipLayer.appendChild(_createProgressBar.call(this));// add helper layer number
varhelperNumberLayer=_createElement("div");if(this._options.showStepNumbers===true){helperNumberLayer.className="introjs-helperNumberLayer";helperNumberLayer.innerHTML="".concat(targetElement.step," of ").concat(this._introItems.length);tooltipLayer.appendChild(helperNumberLayer);}tooltipLayer.appendChild(arrowLayer);referenceLayer.appendChild(tooltipLayer);//next button
skipTooltipButton=_createElement("a",{className:"introjs-skipbutton"});setAnchorAsButton(skipTooltipButton);skipTooltipButton.innerHTML=this._options.skipLabel;skipTooltipButton.onclick=function(){if(self._introItems.length-1===self._currentStep&&typeofself._introCompleteCallback==="function"){self._introCompleteCallback.call(self,self._currentStep,"skip");}if(typeofself._introSkipCallback==="function"){self._introSkipCallback.call(self);}exitIntro.call(self,self._targetElement);};tooltipHeaderLayer.appendChild(skipTooltipButton);//in order to prevent displaying previous button always
if(this._introItems.length>1){buttonsLayer.appendChild(prevTooltipButton);}// we always need the next button because this
// button changes to "Done" in the last step of the tour
buttonsLayer.appendChild(nextTooltipButton);tooltipLayer.appendChild(buttonsLayer);//set proper position
placeTooltip.call(self,targetElement.element,tooltipLayer,arrowLayer);// change the scroll of the window, if needed
scrollTo.call(this,targetElement.scrollTo,targetElement,tooltipLayer);//end of new element if-else condition
if(targetElement.disableInteraction){_disableInteraction.call(self);}// when it's the first step of tour
if(this._currentStep===0&&this._introItems.length>1){if(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null){nextTooltipButton.className="".concat(this._options.buttonClass," introjs-nextbutton");nextTooltipButton.innerHTML=this._options.nextLabel;}if(this._options.hidePrev===true){if(typeofprevTooltipButton!=="undefined"&&prevTooltipButton!==null){prevTooltipButton.className="".concat(this._options.buttonClass," introjs-prevbutton introjs-hidden");}if(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null){addClass(nextTooltipButton,"introjs-fullbutton");}}else{if(typeofprevTooltipButton!=="undefined"&&prevTooltipButton!==null){prevTooltipButton.className="".concat(this._options.buttonClass," introjs-prevbutton introjs-disabled");}}}elseif(this._introItems.length-1===this._currentStep||this._introItems.length===1){// last step of tour
if(typeofprevTooltipButton!=="undefined"&&prevTooltipButton!==null){prevTooltipButton.className="".concat(this._options.buttonClass," introjs-prevbutton");}if(this._options.hideNext===true){if(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null){nextTooltipButton.className="".concat(this._options.buttonClass," introjs-nextbutton introjs-hidden");}if(typeofprevTooltipButton!=="undefined"&&prevTooltipButton!==null){addClass(prevTooltipButton,"introjs-fullbutton");}}else{if(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null){if(this._options.nextToDone===true){nextTooltipButton.innerHTML=this._options.doneLabel;addClass(nextTooltipButton,"".concat(this._options.buttonClass," introjs-nextbutton introjs-donebutton"));}else{nextTooltipButton.className="".concat(this._options.buttonClass," introjs-nextbutton introjs-disabled");}}}}else{// steps between start and end
if(typeofprevTooltipButton!=="undefined"&&prevTooltipButton!==null){prevTooltipButton.className="".concat(this._options.buttonClass," introjs-prevbutton");}if(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null){nextTooltipButton.className="".concat(this._options.buttonClass," introjs-nextbutton");nextTooltipButton.innerHTML=this._options.nextLabel;}}if(typeofprevTooltipButton!=="undefined"&&prevTooltipButton!==null){prevTooltipButton.setAttribute("role","button");}if(typeofnextTooltipButton!=="undefined"&&nextTooltipButton!==null){nextTooltipButton.setAttribute("role","button");}if(typeofskipTooltipButton!=="undefined"&&skipTooltipButton!==null){skipTooltipButton.setAttribute("role","button");}//Set focus on "next" button, so that hitting Enter always moves you onto the next step
vartarget=e.target||e.srcElement;if(target&&target.className.match("introjs-prevbutton")){//user hit enter while focusing on previous button
previousStep.call(this);}elseif(target&&target.className.match("introjs-skipbutton")){//user hit enter while focusing on skip button
if(this._introItems.length-1===this._currentStep&&typeofthis._introCompleteCallback==="function"){this._introCompleteCallback.call(this,this._currentStep,"skip");}exitIntro.call(this,this._targetElement);}elseif(target&&target.getAttribute("data-stepnumber")){// user hit enter while focusing on step bullet
target.click();}else{//default behavior for responding to enter
nextStep.call(this);}//prevent default behaviour on hitting Enter, to prevent steps being skipped in some browsers
if(document.querySelector(".introjs-hint[data-step=\"".concat(i,"\"]"))){return;}varhint=_createElement("a",{className:"introjs-hint"});setAnchorAsButton(hint);hint.onclick=getHintClick(i);if(!item.hintAnimation){addClass(hint,"introjs-hint-no-anim");}// hint's position should be fixed if the target element's position is fixed
if(isFixed(item.element)){addClass(hint,"introjs-fixedhint");}varhintDot=_createElement("div",{className:"introjs-hint-dot"});varhintPulse=_createElement("div",{className:"introjs-hint-pulse"});hint.appendChild(hintDot);hint.appendChild(hintPulse);hint.setAttribute("data-step",i);// we swap the hint element with target element
// because _setHelperLayerPosition uses `element` property
item.targetElement=item.element;item.element=hint;// align the hint position
alignHintPosition.call(_this4,item.hintPosition,hint,item.targetElement);hintsWrapper.appendChild(hint);});// adding the hints wrapper
document.body.appendChild(hintsWrapper);// call the callback function (if any)
if(typeofthis._hintClickCallback!=="undefined"){this._hintClickCallback.call(this,hintElement,item,stepId);}// remove all open tooltips
varremovedStep=removeHintTooltip.call(this);// to toggle the tooltip
if(parseInt(removedStep,10)===stepId){return;}vartooltipLayer=_createElement("div",{className:"introjs-tooltip"});vartooltipTextLayer=_createElement("div");vararrowLayer=_createElement("div");varreferenceLayer=_createElement("div");tooltipLayer.onclick=function(e){//IE9 & Other Browsers
if(e.stopPropagation){e.stopPropagation();}//IE8 and Lower
else{e.cancelBubble=true;}};tooltipTextLayer.className="introjs-tooltiptext";vartooltipWrapper=_createElement("p");tooltipWrapper.innerHTML=item.hint;tooltipTextLayer.appendChild(tooltipWrapper);if(this._options.hintShowButton){varcloseButton=_createElement("a");closeButton.className=this._options.buttonClass;closeButton.setAttribute("role","button");closeButton.innerHTML=this._options.hintButtonLabel;closeButton.onclick=hideHint.bind(this,stepId);tooltipTextLayer.appendChild(closeButton);}arrowLayer.className="introjs-arrow";tooltipLayer.appendChild(arrowLayer);tooltipLayer.appendChild(tooltipTextLayer);// set current step for _placeTooltip function
this._currentStep=hintElement.getAttribute("data-step");// align reference layer position
referenceLayer.className="introjs-tooltipReferenceLayer introjs-hintReference";referenceLayer.setAttribute("data-step",hintElement.getAttribute("data-step"));setHelperLayerPosition.call(this,referenceLayer);referenceLayer.appendChild(tooltipLayer);document.body.appendChild(referenceLayer);//set proper position
varFAILS_ON_NULL=fails(function(){test.sort(null);});// Old WebKit
varSTRICT_METHOD=arrayMethodIsStrict('sort');varSTABLE_SORT=!fails(function(){// feature detection can be too slow, so check engines versions
if(engineV8Version)returnengineV8Version<70;if(engineFfVersion&&engineFfVersion>3)return;if(engineIsIeOrEdge)returntrue;if(engineWebkitVersion)returnengineWebkitVersion<603;varresult='';varcode,chr,value,index;// generate an array with more 512 elements (Chakra and old V8 fails only in this case)
forEach(this._options.steps,function(step){varcurrentItem=cloneObject(step);//set the step
currentItem.step=introItems.length+1;currentItem.title=currentItem.title||"";//use querySelector function only when developer used CSS selector
if(typeofcurrentItem.element==="string"){//grab the element with given selector from the page
currentItem.element=document.querySelector(currentItem.element);}//intro without element
if(typeofcurrentItem.element==="undefined"||currentItem.element===null){varfloatingElementQuery=document.querySelector(".introjsFloatingElement");if(floatingElementQuery===null){floatingElementQuery=_createElement("div",{className:"introjsFloatingElement"});document.body.appendChild(floatingElementQuery);}currentItem.element=floatingElementQuery;currentItem.position="floating";}currentItem.position=currentItem.position||_this._options.tooltipPosition;currentItem.scrollTo=currentItem.scrollTo||_this._options.scrollTo;if(typeofcurrentItem.disableInteraction==="undefined"){currentItem.disableInteraction=_this._options.disableInteraction;}if(currentItem.element!==null){introItems.push(currentItem);}});}else{//use steps from data-* annotations
varelmsLength=allIntroSteps.length;vardisableInteraction;//if there's no element to intro
if(elmsLength<1){return[];}forEach(allIntroSteps,function(currentElement){// start intro for groups of elements
if(_this._options.group&¤tElement.getAttribute("data-intro-group")!==_this._options.group){return;}// skip hidden elements
if(currentElement.style.display==="none"){return;}varstep=parseInt(currentElement.getAttribute("data-step"),10);if(currentElement.hasAttribute("data-disable-interaction")){disableInteraction=!!currentElement.getAttribute("data-disable-interaction");}else{disableInteraction=_this._options.disableInteraction;}if(step>0){introItems[step-1]={element:currentElement,title:currentElement.getAttribute("data-title")||"",intro:currentElement.getAttribute("data-intro"),step:parseInt(currentElement.getAttribute("data-step"),10),tooltipClass:currentElement.getAttribute("data-tooltipclass"),highlightClass:currentElement.getAttribute("data-highlightclass"),position:currentElement.getAttribute("data-position")||_this._options.tooltipPosition,scrollTo:currentElement.getAttribute("data-scrollto")||_this._options.scrollTo,disableInteraction:disableInteraction};}});//next add intro items without data-step
//todo: we need a cleanup here, two loops are redundant
varnextStep=0;forEach(allIntroSteps,function(currentElement){// start intro for groups of elements
if(_this._options.group&¤tElement.getAttribute("data-intro-group")!==_this._options.group){return;}if(currentElement.getAttribute("data-step")===null){while(true){if(typeofintroItems[nextStep]==="undefined"){break;}else{nextStep++;}}if(currentElement.hasAttribute("data-disable-interaction")){disableInteraction=!!currentElement.getAttribute("data-disable-interaction");}else{disableInteraction=_this._options.disableInteraction;}introItems[nextStep]={element:currentElement,title:currentElement.getAttribute("data-title")||"",intro:currentElement.getAttribute("data-intro"),step:nextStep+1,tooltipClass:currentElement.getAttribute("data-tooltipclass"),highlightClass:currentElement.getAttribute("data-highlightclass"),position:currentElement.getAttribute("data-position")||_this._options.tooltipPosition,scrollTo:currentElement.getAttribute("data-scrollto")||_this._options.scrollTo,disableInteraction:disableInteraction};}});}//removing undefined/null elements
vartempIntroItems=[];for(varz=0;z<introItems.length;z++){if(introItems[z]){// copy non-falsy values to the end of the array
tempIntroItems.push(introItems[z]);}}introItems=tempIntroItems;//Ok, sort all items with given steps
// If this callback return `false`, it would halt the process
if(this._introBeforeExitCallback!==undefined){continueExit=this._introBeforeExitCallback.call(this);}// skip this check if `force` parameter is `true`
// otherwise, if `onbeforeexit` returned `false`, don't exit the intro
if(!force&&continueExit===false)return;// remove overlay layers from the page
varoverlayLayers=targetElement.querySelectorAll(".introjs-overlay");if(overlayLayers&&overlayLayers.length){forEach(overlayLayers,function(overlayLayer){returnremoveChild(overlayLayer);});}//remove all helper layers
vardisableInteractionLayer=targetElement.querySelector(".introjs-disableInteraction");removeChild(disableInteractionLayer);//remove intro floating element
instance=newIntroJs(targetElm);}elseif(typeoftargetElm==="string"){//select the target element with query selector
vartargetElement=document.querySelector(targetElm);if(targetElement){instance=newIntroJs(targetElement);}else{thrownewError("There is no element with given selector.");}}else{instance=newIntroJs(document.body);}// add instance to list of _instances
introJs.fn=IntroJs.prototype={clone:functionclone(){returnnewIntroJs(this);},setOption:functionsetOption(option,value){this._options[option]=value;returnthis;},setOptions:functionsetOptions(options){this._options=mergeOptions(this._options,options);returnthis;},start:functionstart(){introForElement.call(this,this._targetElement);returnthis;},goToStep:functiongoToStep$1(step){goToStep.call(this,step);returnthis;},addStep:functionaddStep(options){if(!this._options.steps){this._options.steps=[];}this._options.steps.push(options);returnthis;},addSteps:functionaddSteps(steps){if(!steps.length)return;for(varindex=0;index<steps.length;index++){this.addStep(steps[index]);}returnthis;},goToStepNumber:functiongoToStepNumber$1(step){goToStepNumber.call(this,step);returnthis;},nextStep:functionnextStep$1(){nextStep.call(this);returnthis;},previousStep:functionpreviousStep$1(){previousStep.call(this);returnthis;},currentStep:functioncurrentStep$1(){returncurrentStep.call(this);},exit:functionexit(force){exitIntro.call(this,this._targetElement,force);returnthis;},refresh:functionrefresh$1(refreshSteps){refresh.call(this,refreshSteps);returnthis;},onbeforechange:functiononbeforechange(providedCallback){if(typeofprovidedCallback==="function"){this._introBeforeChangeCallback=providedCallback;}else{thrownewError("Provided callback for onbeforechange was not a function");}returnthis;},onchange:functiononchange(providedCallback){if(typeofprovidedCallback==="function"){this._introChangeCallback=providedCallback;}else{thrownewError("Provided callback for onchange was not a function.");}returnthis;},onafterchange:functiononafterchange(providedCallback){if(typeofprovidedCallback==="function"){this._introAfterChangeCallback=providedCallback;}else{thrownewError("Provided callback for onafterchange was not a function");}returnthis;},oncomplete:functiononcomplete(providedCallback){if(typeofprovidedCallback==="function"){this._introCompleteCallback=providedCallback;}else{thrownewError("Provided callback for oncomplete was not a function.");}returnthis;},onhintsadded:functiononhintsadded(providedCallback){if(typeofprovidedCallback==="function"){this._hintsAddedCallback=providedCallback;}else{thrownewError("Provided callback for onhintsadded was not a function.");}returnthis;},onhintclick:functiononhintclick(providedCallback){if(typeofprovidedCallback==="function"){this._hintClickCallback=providedCallback;}else{thrownewError("Provided callback for onhintclick was not a function.");}returnthis;},onhintclose:functiononhintclose(providedCallback){if(typeofprovidedCallback==="function"){this._hintCloseCallback=providedCallback;}else{thrownewError("Provided callback for onhintclose was not a function.");}returnthis;},onstart:functiononstart(providedCallback){if(typeofprovidedCallback==="function"){this._introStartCallback=providedCallback;}else{thrownewError("Provided callback for onstart was not a function.");}returnthis;},onexit:functiononexit(providedCallback){if(typeofprovidedCallback==="function"){this._introExitCallback=providedCallback;}else{thrownewError("Provided callback for onexit was not a function.");}returnthis;},onskip:functiononskip(providedCallback){if(typeofprovidedCallback==="function"){this._introSkipCallback=providedCallback;}else{thrownewError("Provided callback for onskip was not a function.");}returnthis;},onbeforeexit:functiononbeforeexit(providedCallback){if(typeofprovidedCallback==="function"){this._introBeforeExitCallback=providedCallback;}else{thrownewError("Provided callback for onbeforeexit was not a function.");}returnthis;},addHints:functionaddHints(){populateHints.call(this,this._targetElement);returnthis;},hideHint:functionhideHint$1(stepId){hideHint.call(this,stepId);returnthis;},hideHints:functionhideHints$1(){hideHints.call(this);returnthis;},showHint:functionshowHint$1(stepId){showHint.call(this,stepId);returnthis;},showHints:functionshowHints$1(){showHints.call(this);returnthis;},removeHints:functionremoveHints$1
{(function(){varReact=react;var_assign=objectAssign;// Do not require this module directly! Use normal `invariant` calls with
// template literal strings. The messages will be replaced with error codes
// during build.
functionformatProdErrorMessage(code){varurl='https://reactjs.org/docs/error-decoder.html?invariant='+code;for(vari=1;i<arguments.length;i++){url+='&args[]='+encodeURIComponent(arguments[i]);}return"Minified React error #"+code+"; visit "+url+" for the full message or "+'use the non-minified dev environment for full errors and additional '+'helpful warnings.';}// TODO: this is special because it gets imported during build.
varReactVersion='17.0.2';varReactSharedInternals=React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;// by calls to these methods by a Babel plugin.
//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.
functionwarn(format){{for(var_len=arguments.length,args=newArray(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key];}printWarning('warn',format,args);}}functionerror(format){{for(var_len2=arguments.length,args=newArray(_len2>1?_len2-1:0),_key2=1;_key2<_len2;_key2++){args[_key2-1]=arguments[_key2];}printWarning('error',format,args);}}functionprintWarning(level,format,args){// When changing this logic, you might want to also
// update consoleWithStackDev.www.js as well.
{varReactDebugCurrentFrame=ReactSharedInternals.ReactDebugCurrentFrame;varstack=ReactDebugCurrentFrame.getStackAddendum();if(stack!==''){format+='%s';args=args.concat([stack]);}varargsWithFormat=args.map(function(item){return''+item;});// Careful: RN currently depends on this prefix
argsWithFormat.unshift('Warning: '+format);// We intentionally don't use spread (or .apply) directly because it
// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
varREACT_ELEMENT_TYPE=0xeac7;varREACT_PORTAL_TYPE=0xeaca;varREACT_FRAGMENT_TYPE=0xeacb;varREACT_STRICT_MODE_TYPE=0xeacc;varREACT_PROFILER_TYPE=0xead2;varREACT_PROVIDER_TYPE=0xeacd;varREACT_CONTEXT_TYPE=0xeace;varREACT_FORWARD_REF_TYPE=0xead0;varREACT_SUSPENSE_TYPE=0xead1;varREACT_SUSPENSE_LIST_TYPE=0xead8;varREACT_MEMO_TYPE=0xead3;varREACT_LAZY_TYPE=0xead4;varREACT_BLOCK_TYPE=0xead9;varREACT_SERVER_BLOCK_TYPE=0xeada;varREACT_FUNDAMENTAL_TYPE=0xead5;varREACT_SCOPE_TYPE=0xead7;varREACT_OPAQUE_ID_TYPE=0xeae0;varREACT_DEBUG_TRACING_MODE_TYPE=0xeae1;varREACT_OFFSCREEN_TYPE=0xeae2;varREACT_LEGACY_HIDDEN_TYPE=0xeae3;if(typeofSymbol==='function'&&Symbol.for){varsymbolFor=Symbol.for;REACT_ELEMENT_TYPE=symbolFor('react.element');REACT_PORTAL_TYPE=symbolFor('react.portal');REACT_FRAGMENT_TYPE=symbolFor('react.fragment');REACT_STRICT_MODE_TYPE=symbolFor('react.strict_mode');REACT_PROFILER_TYPE=symbolFor('react.profiler');REACT_PROVIDER_TYPE=symbolFor('react.provider');REACT_CONTEXT_TYPE=symbolFor('react.context');REACT_FORWARD_REF_TYPE=symbolFor('react.forward_ref');REACT_SUSPENSE_TYPE=symbolFor('react.suspense');REACT_SUSPENSE_LIST_TYPE=symbolFor('react.suspense_list');REACT_MEMO_TYPE=symbolFor('react.memo');REACT_LAZY_TYPE=symbolFor('react.lazy');REACT_BLOCK_TYPE=symbolFor('react.block');REACT_SERVER_BLOCK_TYPE=symbolFor('react.server.block');REACT_FUNDAMENTAL_TYPE=symbolFor('react.fundamental');REACT_SCOPE_TYPE=symbolFor('react.scope');REACT_OPAQUE_ID_TYPE=symbolFor('react.opaque.id');REACT_DEBUG_TRACING_MODE_TYPE=symbolFor('react.debug_trace_mode');REACT_OFFSCREEN_TYPE=symbolFor('react.offscreen');REACT_LEGACY_HIDDEN_TYPE=symbolFor('react.legacy_hidden');}functiongetWrappedName(outerType,innerType,wrapperName){varfunctionName=innerType.displayName||innerType.name||'';returnouterType.displayName||(functionName!==''?wrapperName+"("+functionName+")":wrapperName);}functiongetContextName(type){returntype.displayName||'Context';}functiongetComponentName(type){if(type==null){// Host root, text node or just invalid type.
returnnull;}{if(typeoftype.tag==='number'){error('Received an unexpected object in getComponentName(). '+'This is likely a bug in React. Please file an issue.');}}if(typeoftype==='function'){returntype.displayName||type.name||null;}if(typeoftype==='string'){returntype;}switch(type){caseREACT_FRAGMENT_TYPE:return'Fragment';caseREACT_PORTAL_TYPE:return'Portal';caseREACT_PROFILER_TYPE:return'Profiler';caseREACT_STRICT_MODE_TYPE:return'StrictMode';caseREACT_SUSPENSE_TYPE:return'Suspense';caseREACT_SUSPENSE_LIST_TYPE:return'SuspenseList';}if(typeoftype==='object'){switch(type.$$typeof){caseREACT_CONTEXT_TYPE:varcontext=type;returngetContextName(context)+'.Consumer';caseREACT_PROVIDER_TYPE:varprovider=type;returngetContextName(provider._context)+'.Provider';caseREACT_FORWARD_REF_TYPE:returngetWrappedName(type,type.render,'ForwardRef');caseREACT_MEMO_TYPE:returngetComponentName(type.type);caseREACT_BLOCK_TYPE:returngetComponentName(type._render);caseREACT_LAZY_TYPE:{varlazyComponent=type;varpayload=lazyComponent._payload;varinit=lazyComponent._init;try{returngetComponentName(init(payload));}catch(x){returnnull;}}}}returnnull;}// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
varenableSuspenseServerRenderer=false;// Helpers to patch console.logs to avoid logging during side-effect free
// replaying on render function. This currently only patches the object
// lazily which won't cover if the log function was extracted eagerly.
Object.defineProperties(console,{log:_assign({},props,{value:prevLog}),info:_assign({},props,{value:prevInfo}),warn:_assign({},props,{value:prevWarn}),error:_assign({},props,{value:prevError}),group:_assign({},props,{value:prevGroup}),groupCollapsed:_assign({},props,{value:prevGroupCollapsed}),groupEnd:_assign({},props,{value:prevGroupEnd})});/* eslint-enable react-internal/no-production-logging */}if(disabledDepth<0){error('disabledDepth fell below zero. '+'This is a bug in React. Please file an issue.');}}}varReactCurrentDispatcher=ReactSharedInternals.ReactCurrentDispatcher;varprefix;functiondescribeBuiltInComponentFrame(name,source,ownerFn){{if(prefix===undefined){// Extract the VM specific prefix used by each line.
try{throwError();}catch(x){varmatch=x.stack.trim().match(/\n( *(at )?)/);prefix=match&&match[1]||'';}}// We use the prefix to ensure our stacks line up with native stack frames.
return'\n'+prefix+name;}}varreentry=false;varcomponentFrameCache;{varPossiblyWeakMap=typeofWeakMap==='function'?WeakMap:Map;componentFrameCache=newPossiblyWeakMap();}functiondescribeNativeComponentFrame(fn,construct){// If something asked for a stack inside a fake render, it should get ignored.
if(!fn||reentry){return'';}{varframe=componentFrameCache.get(fn);if(frame!==undefined){returnframe;}}varcontrol;reentry=true;varpreviousPrepareStackTrace=Error.prepareStackTrace;// $FlowFixMe It does accept undefined.
Error.prepareStackTrace=undefined;varpreviousDispatcher;{previousDispatcher=ReactCurrentDispatcher.current;// Set the dispatcher in DEV because this might be call in the render function
// for warnings.
ReactCurrentDispatcher.current=null;disableLogs();}try{// This should throw.
if(construct){// Something should be setting the props in the constructor.
varFake=function(){throwError();};// $FlowFixMe
Object.defineProperty(Fake.prototype,'props',{set:function(){// We use a throwing setter instead of frozen or non-writable props
// because that won't throw in a non-strict mode function.
throwError();}});if(typeofReflect==='object'&&Reflect.construct){// We construct a different control for this case to include any extra
// frames added by the construct call.
try{Reflect.construct(Fake,[]);}catch(x){control=x;}Reflect.construct(fn,[],Fake);}else{try{Fake.call();}catch(x){control=x;}fn.call(Fake.prototype);}}else{try{throwError();}catch(x){control=x;}fn();}}catch(sample){// This is inlined manually because closure doesn't do it for us.
if(sample&&control&&typeofsample.stack==='string'){// This extracts the first frame from the sample that isn't also in the control.
// Skipping one frame that we assume is the frame that calls the two.
varsampleLines=sample.stack.split('\n');varcontrolLines=control.stack.split('\n');vars=sampleLines.length-1;varc=controlLines.length-1;while(s>=1&&c>=0&&sampleLines[s]!==controlLines[c]){// We expect at least one stack frame to be shared.
// Typically this will be the root most one. However, stack frames may be
// cut off due to maximum stack limits. In this case, one maybe cut off
// earlier than the other. We assume that the sample is longer or the same
// and there for cut off earlier. So we should find the root most frame in
// the sample somewhere in the control.
c--;}for(;s>=1&&c>=0;s--,c--){// Next we find the first one that isn't the same which should be the
// frame that called our sample function and the control.
if(sampleLines[s]!==controlLines[c]){// In V8, the first line is describing the message but other VMs don't.
// If we're about to return the first line, and the control is also on the same
// line, that's a pretty good indicator that our sample threw at same line as
// the control. I.e. before we entered the sample frame. So we ignore this result.
// This can happen if you passed a class to function component, or non-function.
if(s!==1||c!==1){do{s--;c--;// We may still have similar intermediate frames from the construct call.
// The next one that isn't the same should be our match though.
if(c<0||sampleLines[s]!==controlLines[c]){// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
var_frame='\n'+sampleLines[s].replace(' at new ',' at ');{if(typeoffn==='function'){componentFrameCache.set(fn,_frame);}}// Return the line we found.
return_frame;}}while(s>=1&&c>=0);}break;}}}}finally{reentry=false;{ReactCurrentDispatcher.current=previousDispatcher;reenableLogs();}Error.prepareStackTrace=previousPrepareStackTrace;}// Fallback to just using the name if we couldn't make it throw.
varname=fn?fn.displayName||fn.name:'';varsyntheticFrame=name?describeBuiltInComponentFrame(name):'';{if(typeoffn==='function'){componentFrameCache.set(fn,syntheticFrame);}}returnsyntheticFrame;}functiondescribeFunctionComponentFrame(fn,source,ownerFn){{returndescribeNativeComponentFrame(fn,false);}}functionshouldConstruct(Component){varprototype=Component.prototype;return!!(prototype&&prototype.isReactComponent);}functiondescribeUnknownElementTypeFrameInDEV(type,source,ownerFn){if(type==null){return'';}if(typeoftype==='function'){{returndescribeNativeComponentFrame(type,shouldConstruct(type));}}if(typeoftype==='string'){returndescribeBuiltInComponentFrame(type);}switch(type){caseREACT_SUSPENSE_TYPE:returndescribeBuiltInComponentFrame('Suspense');caseREACT_SUSPENSE_LIST_TYPE:returndescribeBuiltInComponentFrame('SuspenseList');}if(typeoftype==='object'){switch(type.$$typeof){caseREACT_FORWARD_REF_TYPE:returndescribeFunctionComponentFrame(type.render);caseREACT_MEMO_TYPE:// Memo may contain any component type so we recursively resolve it.
returndescribeUnknownElementTypeFrameInDEV(type.type,source,ownerFn);caseREACT_BLOCK_TYPE:returndescribeFunctionComponentFrame(type._render);caseREACT_LAZY_TYPE:{varlazyComponent=type;varpayload=lazyComponent._payload;varinit=lazyComponent._init;try{// Lazy may contain any component type so we recursively resolve it.
returndescribeUnknownElementTypeFrameInDEV(init(payload),source,ownerFn);}catch(x){}}}}return'';}varloggedTypeFailures={};varReactDebugCurrentFrame=ReactSharedInternals.ReactDebugCurrentFrame;functionsetCurrentlyValidatingElement(element){{if(element){varowner=element._owner;varstack=describeUnknownElementTypeFrameInDEV(element.type,element._source,owner?owner.type:null);ReactDebugCurrentFrame.setExtraStackFrame(stack);}else{ReactDebugCurrentFrame.setExtraStackFrame(null);}}}functioncheckPropTypes(typeSpecs,values,location,componentName,element){{// $FlowFixMe This is okay but Flow doesn't know it.
varhas=Function.call.bind(Object.prototype.hasOwnProperty);for(vartypeSpecNameintypeSpecs){if(has(typeSpecs,typeSpecName)){varerror$1=void0;// Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try{// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if(typeoftypeSpecs[typeSpecName]!=='function'){varerr=Error((componentName||'React class')+': '+location+' type `'+typeSpecName+'` is invalid; '+'it must be a function, usually from the `prop-types` package, but received `'+typeoftypeSpecs[typeSpecName]+'`.'+'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');err.name='Invariant Violation';throwerr;}error$1=typeSpecs[typeSpecName](values,typeSpecName,componentName,location,null,'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');}catch(ex){error$1=ex;}if(error$1&&!(error$1instanceofError)){setCurrentlyValidatingElement(element);error('%s: type specification of %s'+' `%s` is invalid; the type checker '+'function must return `null` or an `Error` but returned a %s. '+'You may have forgotten to pass an argument to the type checker '+'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and '+'shape all require an argument).',componentName||'React class',location,typeSpecName,typeoferror$1);setCurrentlyValidatingElement(null);}if(error$1instanceofError&&!(error$1.messageinloggedTypeFailures)){// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error$1.message]=true;setCurrentlyValidatingElement(element);error('Failed %s type: %s',location,error$1.message);setCurrentlyValidatingElement(null);}}}}}vardidWarnAboutInvalidateContextType;{didWarnAboutInvalidateContextType=newSet();}varemptyObject={};{Object.freeze(emptyObject);}functionmaskContext(type,context){varcontextTypes=type.contextTypes;if(!contextTypes){returnemptyObject;}varmaskedContext={};for(varcontextNameincontextTypes){maskedContext[contextName]=context[contextName];}returnmaskedContext;}functioncheckContextTypes(typeSpecs,values,location){{checkPropTypes(typeSpecs,values,location,'Component');}}functionvalidateContextBounds(context,threadID){// If we don't have enough slots in this context to store this threadID,
// fill it in without leaving any holes to ensure that the VM optimizes
// this as non-holey index properties.
// (Note: If `react` package is < 16.6, _threadCount is undefined.)
for(vari=context._threadCount|0;i<=threadID;i++){// We assume that this is the same as the defaultValue which might not be
// true if we're rendering inside a secondary renderer but they are
// secondary because these use cases are very rare.
context[i]=context._currentValue2;context._threadCount=i+1;}}functionprocessContext(type,context,threadID,isClass){if(isClass){varcontextType=type.contextType;{if('contextType'intype){varisValid=// Allow null for conditional declaration
contextType===null||contextType!==undefined&&contextType.$$typeof===REACT_CONTEXT_TYPE&&contextType._context===undefined;// Not a <Context.Consumer>
if(!isValid&&!didWarnAboutInvalidateContextType.has(type)){didWarnAboutInvalidateContextType.add(type);varaddendum='';if(contextType===undefined){addendum=' However, it is set to undefined. '+'This can be caused by a typo or by mixing up named and default imports. '+'This can also happen due to a circular dependency, so '+'try moving the createContext() call to a separate file.';}elseif(typeofcontextType!=='object'){addendum=' However, it is set to a '+typeofcontextType+'.';}elseif(contextType.$$typeof===REACT_PROVIDER_TYPE){addendum=' Did you accidentally pass the Context.Provider instead?';}elseif(contextType._context!==undefined){// <Context.Consumer>
addendum=' Did you accidentally pass the Context.Consumer instead?';}else{addendum=' However, it is set to an object with keys {'+Object.keys(contextType).join(', ')+'}.';}error('%s defines an invalid contextType. '+'contextType should point to the Context object returned by React.createContext().%s',getComponentName(type)||'Component',addendum);}}}if(typeofcontextType==='object'&&contextType!==null){validateContextBounds(contextType,threadID);returncontextType[threadID];}{varmaskedContext=maskContext(type,context);{if(type.contextTypes){checkContextTypes(type.contextTypes,maskedContext,'context');}}returnmaskedContext;}}else{{var_maskedContext=maskContext(type,context);{if(type.contextTypes){checkContextTypes(type.contextTypes,_maskedContext,'context');}}return_maskedContext;}}}varnextAvailableThreadIDs=newUint16Array(16);for(vari=0;i<15;i++){nextAvailableThreadIDs[i]=i+1;}nextAvailableThreadIDs[15]=0;functiongrowThreadCountAndReturnNextAvailable(){varoldArray=nextAvailableThreadIDs;varoldSize=oldArray.length;varnewSize=oldSize*2;if(!(newSize<=0x10000)){{throwError("Maximum number of concurrent React renderers exceeded. This can happen if you are not properly destroying the Readable provided by React. Ensure that you call .destroy() on it if you no longer want to read from it, and did not read to the end. If you use .pipe() this should be automatic.");}}varnewArray=newUint16Array(newSize);newArray.set(oldArray);nextAvailableThreadIDs=newArray;nextAvailableThreadIDs[0]=oldSize+1;for(var_i=oldSize;_i<newSize-1;_i++){nextAvailableThreadIDs[_i]=_i+1;}nextAvailableThreadIDs[newSize-1]=0;returnoldSize;}functionallocThreadID(){varnextID=nextAvailableThreadIDs[0];if(nextID===0){returngrowThreadCountAndReturnNextAvailable();}nextAvailableThreadIDs[0]=nextAvailableThreadIDs[nextID];returnnextID;}functionfreeThreadID(id){nextAvailableThreadIDs[id]=nextAvailableThreadIDs[0];nextAvailableThreadIDs[0]=id;}// A reserved attribute.
// It is handled by React separately and shouldn't be written to the DOM.
varRESERVED=0;// A simple string attribute.
// Attributes that aren't in the filter are presumed to have this type.
varSTRING=1;// A string attribute that accepts booleans in React. In HTML, these are called
// "enumerated" attributes with "true" and "false" as possible values.
// When true, it should be set to a "true" string.
// When false, it should be set to a "false" string.
varBOOLEANISH_STRING=2;// A real boolean attribute.
// When true, it should be present (set either to an empty string or its name).
// When false, it should be omitted.
varBOOLEAN=3;// An attribute that can be used as a flag as well as with a value.
// When true, it should be present (set either to an empty string or its name).
// When false, it should be omitted.
// For any other value, should be present with that value.
varOVERLOADED_BOOLEAN=4;// An attribute that must be numeric or parse as a numeric.
// When falsy, it should be removed.
varNUMERIC=5;// An attribute that must be positive numeric or parse as a positive numeric.
// When falsy, it should be removed.
varPOSITIVE_NUMERIC=6;/* eslint-disable max-len */varATTRIBUTE_NAME_START_CHAR=":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";/* eslint-enable max-len */varATTRIBUTE_NAME_CHAR=ATTRIBUTE_NAME_START_CHAR+"\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";varROOT_ATTRIBUTE_NAME='data-reactroot';varVALID_ATTRIBUTE_NAME_REGEX=newRegExp('^['+ATTRIBUTE_NAME_START_CHAR+']['+ATTRIBUTE_NAME_CHAR+']*$');varhasOwnProperty=Object.prototype.hasOwnProperty;varillegalAttributeNameCache={};varvalidatedAttributeNameCache={};functionisAttributeNameSafe(attributeName){if(hasOwnProperty.call(validatedAttributeNameCache,attributeName)){returntrue;}if(hasOwnProperty.call(illegalAttributeNameCache,attributeName)){returnfalse;}if(VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)){validatedAttributeNameCache[attributeName]=true;returntrue;}illegalAttributeNameCache[attributeName]=true;{error('Invalid attribute name: `%s`',attributeName);}returnfalse;}functionshouldIgnoreAttribute(name,propertyInfo,isCustomComponentTag){if(propertyInfo!==null){returnpropertyInfo.type===RESERVED;}if(isCustomComponentTag){returnfalse;}if(name.length>2&&(name[0]==='o'||name[0]==='O')&&(name[1]==='n'||name[1]==='N')){returntrue;}returnfalse;}functionshouldRemoveAttributeWithWarning(name,value,propertyInfo,isCustomComponentTag){if(propertyInfo!==null&&propertyInfo.type===RESERVED){returnfalse;}switch(typeofvalue){case'function':// $FlowIssue symbol is perfectly valid here
case'symbol':// eslint-disable-line
returntrue;case'boolean':{if(isCustomComponentTag){returnfalse;}if(propertyInfo!==null){return!propertyInfo.acceptsBooleans;}else{varprefix=name.toLowerCase().slice(0,5);returnprefix!=='data-'&&prefix!=='aria-';}}default:returnfalse;}}functionshouldRemoveAttribute(name,value,propertyInfo,isCustomComponentTag){if(value===null||typeofvalue==='undefined'){returntrue;}if(shouldRemoveAttributeWithWarning(name,value,propertyInfo,isCustomComponentTag)){returntrue;}if(isCustomComponentTag){returnfalse;}if(propertyInfo!==null){switch(propertyInfo.type){caseBOOLEAN:return!value;caseOVERLOADED_BOOLEAN:returnvalue===false;caseNUMERIC:returnisNaN(value);casePOSITIVE_NUMERIC:returnisNaN(value)||value<1;}}returnfalse;}functiongetPropertyInfo(name){returnproperties.hasOwnProperty(name)?properties[name]:null;}functionPropertyInfoRecord(name,type,mustUseProperty,attributeName,attributeNamespace,sanitizeURL,removeEmptyString){this.acceptsBooleans=type===BOOLEANISH_STRING||type===BOOLEAN||type===OVERLOADED_BOOLEAN;this.attributeName=attributeName;this.attributeNamespace=attributeNamespace;this.mustUseProperty=mustUseProperty;this.propertyName=name;this.type=type;this.sanitizeURL=sanitizeURL;this.removeEmptyString=removeEmptyString;}// When adding attributes to this list, be sure to also add them to
// the `possibleStandardNames` module to ensure casing and incorrect
// name warnings.
varproperties={};// These props are reserved by React. They shouldn't be written to the DOM.
varreservedProps=['children','dangerouslySetInnerHTML',// TODO: This prevents the assignment of defaultValue to regular
// elements (not just inputs). Now that ReactDOMInput assigns to the
false);});varCAMELIZE=/[\-\:]([a-z])/g;varcapitalize=function(token){returntoken[1].toUpperCase();};// This is a list of all SVG attributes that need special casing, namespacing,
// or boolean value assignment. Regular attributes that just accept strings
// and have the same names are omitted, just like in the HTML attribute filter.
// Some of these attributes can be hard to find. This list was created by
// scraping the MDN documentation.
['accent-height','alignment-baseline','arabic-form','baseline-shift','cap-height','clip-path','clip-rule','color-interpolation','color-interpolation-filters','color-profile','color-rendering','dominant-baseline','enable-background','fill-opacity','fill-rule','flood-color','flood-opacity','font-family','font-size','font-size-adjust','font-stretch','font-style','font-variant','font-weight','glyph-name','glyph-orientation-horizontal','glyph-orientation-vertical','horiz-adv-x','horiz-origin-x','image-rendering','letter-spacing','lighting-color','marker-end','marker-mid','marker-start','overline-position','overline-thickness','paint-order','panose-1','pointer-events','rendering-intent','shape-rendering','stop-color','stop-opacity','strikethrough-position','strikethrough-thickness','stroke-dasharray','stroke-dashoffset','stroke-linecap','stroke-linejoin','stroke-miterlimit','stroke-opacity','stroke-width','text-anchor','text-decoration','text-rendering','underline-position','underline-thickness','unicode-bidi','unicode-range','units-per-em','v-alphabetic','v-hanging','v-ideographic','v-mathematical','vector-effect','vert-adv-y','vert-origin-x','vert-origin-y','word-spacing','writing-mode','xmlns:xlink','x-height'// NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
/* eslint-disable max-len */varisJavaScriptProtocol=/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i;vardidWarn=false;functionsanitizeURL(url){{if(!didWarn&&isJavaScriptProtocol.test(url)){didWarn=true;error('A future version of React will block javascript: URLs as a security precaution. '+'Use event handlers instead if you can. If you need to generate unsafe HTML try '+'using dangerouslySetInnerHTML instead. React was passed %s.',JSON.stringify(url));}}}// code copied and modified from escape-html
escape=''';// modified from escape-html; used to be '''
break;case60:// <
escape='<';break;case62:// >
escape='>';break;default:continue;}if(lastIndex!==index){html+=str.substring(lastIndex,index);}lastIndex=index+1;html+=escape;}returnlastIndex!==index?html+str.substring(lastIndex,index):html;}// end code copied and modified from escape-html
;}varobjectIs=typeofObject.is==='function'?Object.is:is;varcurrentlyRenderingComponent=null;varfirstWorkInProgressHook=null;varworkInProgressHook=null;// Whether the work-in-progress hook is a re-rendered hook
varisReRender=false;// Whether an update was scheduled during the currently executing render pass.
vardidScheduleRenderPhaseUpdate=false;// Lazily created map of render-phase updates
varrenderPhaseUpdates=null;// Counter to prevent infinite loops.
varnumberOfReRenders=0;varRE_RENDER_LIMIT=25;varisInHookUserCodeInDev=false;// In DEV, this is the name of the currently executing primitive hook
varcurrentHookNameInDev;functionresolveCurrentlyRenderingComponent(){if(!(currentlyRenderingComponent!==null)){{throwError("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");}}{if(isInHookUserCodeInDev){error('Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. '+'You can only call Hooks at the top level of your React function. '+'For more information, see '+'https://reactjs.org/link/rules-of-hooks');}}returncurrentlyRenderingComponent;}functionareHookInputsEqual(nextDeps,prevDeps){if(prevDeps===null){{error('%s received a final argument during this render, but not during '+'the previous render. Even though the final argument is optional, '+'its type cannot change between renders.',currentHookNameInDev);}returnfalse;}{// Don't bother comparing lengths in prod because these arrays should be
// passed inline.
if(nextDeps.length!==prevDeps.length){error('The final argument passed to %s changed size between renders. The '+'order and size of this array must remain constant.\n\n'+'Previous: %s\n'+'Incoming: %s',currentHookNameInDev,"["+nextDeps.join(', ')+"]","["+prevDeps.join(', ')+"]");}}for(vari=0;i<prevDeps.length&&i<nextDeps.length;i++){if(objectIs(nextDeps[i],prevDeps[i])){continue;}returnfalse;}returntrue;}functioncreateHook(){if(numberOfReRenders>0){{{throwError("Rendered more hooks than during the previous render");}}}return{memoizedState:null,queue:null,next:null};}functioncreateWorkInProgressHook(){if(workInProgressHook===null){// This is the first hook in the list
if(firstWorkInProgressHook===null){isReRender=false;firstWorkInProgressHook=workInProgressHook=createHook();}else{// There's already a work-in-progress. Reuse it.
isReRender=true;workInProgressHook=firstWorkInProgressHook;}}else{if(workInProgressHook.next===null){isReRender=false;// Append to the end of the list
workInProgressHook=workInProgressHook.next=createHook();}else{// There's already a work-in-progress. Reuse it.
isReRender=true;workInProgressHook=workInProgressHook.next;}}returnworkInProgressHook;}functionprepareToUseHooks(componentIdentity){currentlyRenderingComponent=componentIdentity;{isInHookUserCodeInDev=false;}// The following should have already been reset
// didScheduleRenderPhaseUpdate = false;
// firstWorkInProgressHook = null;
// numberOfReRenders = 0;
// renderPhaseUpdates = null;
// workInProgressHook = null;
}functionfinishHooks(Component,props,children,refOrContext){// This must be called after every function component to prevent hooks from
// being used in classes.
while(didScheduleRenderPhaseUpdate){// Updates were scheduled during the render phase. They are stored in
// the `renderPhaseUpdates` map. Call the component again, reusing the
// work-in-progress hooks and applying the additional updates on top. Keep
// restarting until no more updates are scheduled.
didScheduleRenderPhaseUpdate=false;numberOfReRenders+=1;// Start over from the beginning of the list
workInProgressHook=null;children=Component(props,refOrContext);}resetHooksState();returnchildren;}// Reset the internal hooks state if an error occurs while rendering a component
functionresetHooksState(){{isInHookUserCodeInDev=false;}currentlyRenderingComponent=null;didScheduleRenderPhaseUpdate=false;firstWorkInProgressHook=null;numberOfReRenders=0;renderPhaseUpdates=null;workInProgressHook=null;}functionreadContext(context,observedBits){varthreadID=currentPartialRenderer.threadID;validateContextBounds(context,threadID);{if(isInHookUserCodeInDev){error('Context can only be read while React is rendering. '+'In classes, you can read it in the render method or getDerivedStateFromProps. '+'In function components, you can read it directly in the function body, but not '+'inside Hooks like useReducer() or useMemo().');}}returncontext[threadID];}functionuseContext(context,observedBits){{currentHookNameInDev='useContext';}resolveCurrentlyRenderingComponent();varthreadID=currentPartialRenderer.threadID;validateContextBounds(context,threadID);returncontext[threadID];}functionbasicStateReducer(state,action){// $FlowFixMe: Flow doesn't like mixed types
returntypeofaction==='function'?action(state):action;}functionuseState(initialState){{currentHookNameInDev='useState';}returnuseReducer(basicStateReducer,// useReducer has a special case to support lazy useState initializers
initialState);}functionuseReducer(reducer,initialArg,init){{if(reducer!==basicStateReducer){currentHookNameInDev='useReducer';}}currentlyRenderingComponent=resolveCurrentlyRenderingComponent();workInProgressHook=createWorkInProgressHook();if(isReRender){// This is a re-render. Apply the new render phase updates to the previous
// current hook.
varqueue=workInProgressHook.queue;vardispatch=queue.dispatch;if(renderPhaseUpdates!==null){// Render phase updates are stored in a map of queue -> linked list
varfirstRenderPhaseUpdate=renderPhaseUpdates.get(queue);if(firstRenderPhaseUpdate!==undefined){renderPhaseUpdates.delete(queue);varnewState=workInProgressHook.memoizedState;varupdate=firstRenderPhaseUpdate;do{// Process this render phase update. We don't have to check the
// priority because it will always be the same as the current
// render's.
varaction=update.action;{isInHookUserCodeInDev=true;}newState=reducer(newState,action);{isInHookUserCodeInDev=false;}update=update.next;}while(update!==null);workInProgressHook.memoizedState=newState;return[newState,dispatch];}}return[workInProgressHook.memoizedState,dispatch];}else{{isInHookUserCodeInDev=true;}varinitialState;if(reducer===basicStateReducer){// Special case for `useState`.
initialState=typeofinitialArg==='function'?initialArg():initialArg;}else{initialState=init!==undefined?init(initialArg):initialArg;}{isInHookUserCodeInDev=false;}workInProgressHook.memoizedState=initialState;var_queue=workInProgressHook.queue={last:null,dispatch:null};var_dispatch=_queue.dispatch=dispatchAction.bind(null,currentlyRenderingComponent,_queue);return[workInProgressHook.memoizedState,_dispatch];}}functionuseMemo(nextCreate,deps){currentlyRenderingComponent=resolveCurrentlyRenderingComponent();workInProgressHook=createWorkInProgressHook();varnextDeps=deps===undefined?null:deps;if(workInProgressHook!==null){varprevState=workInProgressHook.memoizedState;if(prevState!==null){if(nextDeps!==null){varprevDeps=prevState[1];if(areHookInputsEqual(nextDeps,prevDeps)){returnprevState[0];}}}}{isInHookUserCodeInDev=true;}varnextValue=nextCreate();{isInHookUserCodeInDev=false;}workInProgressHook.memoizedState=[nextValue,nextDeps];returnnextValue;}functionuseRef(initialValue){currentlyRenderingComponent=resolveCurrentlyRenderingComponent();workInProgressHook=createWorkInProgressHook();varpreviousRef=workInProgressHook.memoizedState;if(previousRef===null){varref={current:initialValue};{Object.seal(ref);}workInProgressHook.memoizedState=ref;returnref;}else{returnpreviousRef;}}functionuseLayoutEffect(create,inputs){{currentHookNameInDev='useLayoutEffect';error('useLayoutEffect does nothing on the server, because its effect cannot '+"be encoded into the server renderer's output format. This will lead "+'to a mismatch between the initial, non-hydrated UI and the intended '+'UI. To avoid this, useLayoutEffect should only be used in '+'components that render exclusively on the client. '+'See https://reactjs.org/link/uselayouteffect-ssr for common fixes.');}}functiondispatchAction(componentIdentity,queue,action){if(!(numberOfReRenders<RE_RENDER_LIMIT)){{throwError("Too many re-renders. React limits the number of renders to prevent an infinite loop.");}}if(componentIdentity===currentlyRenderingComponent){// This is a render phase update. Stash it in a lazily-created map of
// queue -> linked list of updates. After this render pass, we'll restart
// and apply the stashed updates on top of the work-in-progress hook.
didScheduleRenderPhaseUpdate=true;varupdate={action:action,next:null};if(renderPhaseUpdates===null){renderPhaseUpdates=newMap();}varfirstRenderPhaseUpdate=renderPhaseUpdates.get(queue);if(firstRenderPhaseUpdate===undefined){renderPhaseUpdates.set(queue,update);}else{// Append the update to the end of the list.
varlastRenderPhaseUpdate=firstRenderPhaseUpdate;while(lastRenderPhaseUpdate.next!==null){lastRenderPhaseUpdate=lastRenderPhaseUpdate.next;}lastRenderPhaseUpdate.next=update;}}}functionuseCallback(callback,deps){returnuseMemo(function(){returncallback;},deps);}// TODO Decide on how to implement this hook for server rendering.
// If a mutation occurs during render, consider triggering a Suspense boundary
// and falling back to client rendering.
functionuseMutableSource(source,getSnapshot,subscribe){resolveCurrentlyRenderingComponent();returngetSnapshot(source._source);}functionuseDeferredValue(value){resolveCurrentlyRenderingComponent();returnvalue;}functionuseTransition(){resolveCurrentlyRenderingComponent();varstartTransition=function(callback){callback();};return[startTransition,false];}functionuseOpaqueIdentifier(){return(currentPartialRenderer.identifierPrefix||'')+'R:'+(currentPartialRenderer.uniqueID++).toString(36);}functionnoop(){}varcurrentPartialRenderer=null;functionsetCurrentPartialRenderer(renderer){currentPartialRenderer=renderer;}varDispatcher={readContext:readContext,useContext:useContext,useMemo:useMemo,useReducer:useReducer,useRef:useRef,useState:useState,useLayoutEffect:useLayoutEffect,useCallback:useCallback,// useImperativeHandle is not run in the server environment
useImperativeHandle:noop,// Effects are not run in the server environment.
useEffect:noop,// Debugging effect
useDebugValue:noop,useDeferredValue:useDeferredValue,useTransition:useTransition,useOpaqueIdentifier:useOpaqueIdentifier,// Subscriptions are not setup in a server environment.
useMutableSource:useMutableSource};varHTML_NAMESPACE='http://www.w3.org/1999/xhtml';varMATH_NAMESPACE='http://www.w3.org/1998/Math/MathML';varSVG_NAMESPACE='http://www.w3.org/2000/svg';varNamespaces={html:HTML_NAMESPACE,mathml:MATH_NAMESPACE,svg:SVG_NAMESPACE};// Assumes there is no parent namespace.
functiongetIntrinsicNamespace(type){switch(type){case'svg':returnSVG_NAMESPACE;case'math':returnMATH_NAMESPACE;default:returnHTML_NAMESPACE;}}functiongetChildNamespace(parentNamespace,type){if(parentNamespace==null||parentNamespace===HTML_NAMESPACE){// No (or default) parent namespace: potential entry point.
returnHTML_NAMESPACE;}// By default, pass namespace below.
returnparentNamespace;}varhasReadOnlyValue={button:true,checkbox:true,image:true,hidden:true,radio:true,reset:true,submit:true};functioncheckControlledValueProps(tagName,props){{if(!(hasReadOnlyValue[props.type]||props.onChange||props.onInput||props.readOnly||props.disabled||props.value==null)){error('You provided a `value` prop to a form field without an '+'`onChange` handler. This will render a read-only field. If '+'the field should be mutable use `defaultValue`. Otherwise, '+'set either `onChange` or `readOnly`.');}if(!(props.onChange||props.readOnly||props.disabled||props.checked==null)){error('You provided a `checked` prop to a form field without an '+'`onChange` handler. This will render a read-only field. If '+'the field should be mutable use `defaultChecked`. Otherwise, '+'set either `onChange` or `readOnly`.');}}}// For HTML, certain tags should omit their close tag. We keep a list for
// those special-case tags.
varomittedCloseTags={area:true,base:true,br:true,col:true,embed:true,hr:true,img:true,input:true,keygen:true,link:true,meta:true,param:true,source:true,track:true,wbr:true// NOTE: menuitem's close tag should be omitted, but that causes problems.
};// `omittedCloseTags` except that `menuitem` should still have its closing tag.
varvoidElementTags=_assign({menuitem:true},omittedCloseTags);varHTML='__html';functionassertValidProps(tag,props){if(!props){return;}// Note the use of `==` which checks for null or undefined.
if(voidElementTags[tag]){if(!(props.children==null&&props.dangerouslySetInnerHTML==null)){{throwError(tag+" is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");}}}if(props.dangerouslySetInnerHTML!=null){if(!(props.children==null)){{throwError("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");}}if(!(typeofprops.dangerouslySetInnerHTML==='object'&&HTMLinprops.dangerouslySetInnerHTML)){{throwError("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");}}}{if(!props.suppressContentEditableWarning&&props.contentEditable&&props.children!=null){error('A component is `contentEditable` and contains `children` managed by '+'React. It is now your responsibility to guarantee that none of '+'those nodes are unexpectedly modified or duplicated. This is '+'probably not intentional.');}}if(!(props.style==null||typeofprops.style==='object')){{throwError("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");}}}/**
case'annotation-xml':case'color-profile':case'font-face':case'font-face-src':case'font-face-uri':case'font-face-format':case'font-face-name':case'missing-glyph':returnfalse;default:returntrue;}}varwarnValidStyle=function(){};{// 'msTransform' is correct, but the other prefixes should be capitalized
varbadVendoredStyleNamePattern=/^(?:webkit|moz|o)[A-Z]/;varmsPattern$1=/^-ms-/;varhyphenPattern=/-(.)/g;// style values shouldn't contain a semicolon
varbadStyleValueWithSemicolonPattern=/;\s*$/;varwarnedStyleNames={};varwarnedStyleValues={};varwarnedForNaNValue=false;varwarnedForInfinityValue=false;varcamelize=function(string){returnstring.replace(hyphenPattern,function(_,character){returncharacter.toUpperCase();});};varwarnHyphenatedStyleName=function(name){if(warnedStyleNames.hasOwnProperty(name)&&warnedStyleNames[name]){return;}warnedStyleNames[name]=true;error('Unsupported style property %s. Did you mean %s?',name,// As Andi Smith suggests
// (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
// is converted to lowercase `ms`.
camelize(name.replace(msPattern$1,'ms-')));};varwarnBadVendoredStyleName=function(name){if(warnedStyleNames.hasOwnProperty(name)&&warnedStyleNames[name]){return;}warnedStyleNames[name]=true;error('Unsupported vendor-prefixed style property %s. Did you mean %s?',name,name.charAt(0).toUpperCase()+name.slice(1));};varwarnStyleValueWithSemicolon=function(name,value){if(warnedStyleValues.hasOwnProperty(value)&&warnedStyleValues[value]){return;}warnedStyleValues[value]=true;error("Style property values shouldn't contain a semicolon. "+'Try "%s: %s" instead.',name,value.replace(badStyleValueWithSemicolonPattern,''));};varwarnStyleValueIsNaN=function(name,value){if(warnedForNaNValue){return;}warnedForNaNValue=true;error('`NaN` is an invalid value for the `%s` css style property.',name);};varwarnStyleValueIsInfinity=function(name,value){if(warnedForInfinityValue){return;}warnedForInfinityValue=true;error('`Infinity` is an invalid value for the `%s` css style property.',name);};warnValidStyle=function(name,value){if(name.indexOf('-')>-1){warnHyphenatedStyleName(name);}elseif(badVendoredStyleNamePattern.test(name)){warnBadVendoredStyleName(name);}elseif(badStyleValueWithSemicolonPattern.test(value)){warnStyleValueWithSemicolon(name,value);}if(typeofvalue==='number'){if(isNaN(value)){warnStyleValueIsNaN(name,value);}elseif(!isFinite(value)){warnStyleValueIsInfinity(name,value);}}};}varwarnValidStyle$1=warnValidStyle;varariaProperties={'aria-current':0,// state
'aria-autocomplete':0,'aria-checked':0,'aria-expanded':0,'aria-haspopup':0,'aria-level':0,'aria-modal':0,'aria-multiline':0,'aria-multiselectable':0,'aria-orientation':0,'aria-placeholder':0,'aria-pressed':0,'aria-readonly':0,'aria-required':0,'aria-selected':0,'aria-sort':0,'aria-valuemax':0,'aria-valuemin':0,'aria-valuenow':0,'aria-valuetext':0,// Live Region Attributes
'aria-activedescendant':0,'aria-colcount':0,'aria-colindex':0,'aria-colspan':0,'aria-controls':0,'aria-describedby':0,'aria-errormessage':0,'aria-flowto':0,'aria-labelledby':0,'aria-owns':0,'aria-posinset':0,'aria-rowcount':0,'aria-rowindex':0,'aria-rowspan':0,'aria-setsize':0};varwarnedProperties={};varrARIA=newRegExp('^(aria)-['+ATTRIBUTE_NAME_CHAR+']*$');varrARIACamel=newRegExp('^(aria)[A-Z]['+ATTRIBUTE_NAME_CHAR+']*$');varhasOwnProperty$1=Object.prototype.hasOwnProperty;functionvalidateProperty(tagName,name){{if(hasOwnProperty$1.call(warnedProperties,name)&&warnedProperties[name]){returntrue;}if(rARIACamel.test(name)){varariaName='aria-'+name.slice(4).toLowerCase();varcorrectName=ariaProperties.hasOwnProperty(ariaName)?ariaName:null;// If this is an aria-* attribute, but is not listed in the known DOM
// DOM properties, then it is an invalid aria-* attribute.
if(correctName==null){error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.',name);warnedProperties[name]=true;returntrue;}// aria-* attributes should be lowercase; suggest the lowercase version.
if(name!==correctName){error('Invalid ARIA attribute `%s`. Did you mean `%s`?',name,correctName);warnedProperties[name]=true;returntrue;}}if(rARIA.test(name)){varlowerCasedName=name.toLowerCase();varstandardName=ariaProperties.hasOwnProperty(lowerCasedName)?lowerCasedName:null;// If this is an aria-* attribute, but is not listed in the known DOM
// DOM properties, then it is an invalid aria-* attribute.
if(standardName==null){warnedProperties[name]=true;returnfalse;}// aria-* attributes should be lowercase; suggest the lowercase version.
if(name!==standardName){error('Unknown ARIA attribute `%s`. Did you mean `%s`?',name,standardName);warnedProperties[name]=true;returntrue;}}}returntrue;}functionwarnInvalidARIAProps(type,props){{varinvalidProps=[];for(varkeyinprops){varisValid=validateProperty(type,key);if(!isValid){invalidProps.push(key);}}varunknownPropString=invalidProps.map(function(prop){return'`'+prop+'`';}).join(', ');if(invalidProps.length===1){error('Invalid aria prop %s on <%s> tag. '+'For details, see https://reactjs.org/link/invalid-aria-props',unknownPropString,type);}elseif(invalidProps.length>1){error('Invalid aria props %s on <%s> tag. '+'For details, see https://reactjs.org/link/invalid-aria-props',unknownPropString,type);}}}functionvalidateProperties(type,props){if(isCustomComponent(type,props)){return;}warnInvalidARIAProps(type,props);}vardidWarnValueNull=false;functionvalidateProperties$1(type,props){{if(type!=='input'&&type!=='textarea'&&type!=='select'){return;}if(props!=null&&props.value===null&&!didWarnValueNull){didWarnValueNull=true;if(type==='select'&&props.multiple){error('`value` prop on `%s` should not be null. '+'Consider using an empty array when `multiple` is set to `true` '+'to clear the component or `undefined` for uncontrolled components.',type);}else{error('`value` prop on `%s` should not be null. '+'Consider using an empty string to clear the component or `undefined` '+'for uncontrolled components.',type);}}}}// When adding attributes to the HTML or SVG allowed attribute list, be sure to
// also add them to this module to ensure casing and incorrect name
if(eventRegistry!=null){varregistrationNameDependencies=eventRegistry.registrationNameDependencies,possibleRegistrationNames=eventRegistry.possibleRegistrationNames;if(registrationNameDependencies.hasOwnProperty(name)){returntrue;}varregistrationName=possibleRegistrationNames.hasOwnProperty(lowerCasedName)?possibleRegistrationNames[lowerCasedName]:null;if(registrationName!=null){error('Invalid event handler property `%s`. Did you mean `%s`?',name,registrationName);warnedProperties$1[name]=true;returntrue;}if(EVENT_NAME_REGEX.test(name)){error('Unknown event handler property `%s`. It will be ignored.',name);warnedProperties$1[name]=true;returntrue;}}elseif(EVENT_NAME_REGEX.test(name)){// If no event plugins have been injected, we are in a server environment.
// So we can't tell if the event name is correct for sure, but we can filter
// out known bad ones like `onclick`. We can't suggest a specific replacement though.
if(INVALID_EVENT_NAME_REGEX.test(name)){error('Invalid event handler property `%s`. '+'React events use the camelCase naming convention, for example `onClick`.',name);}warnedProperties$1[name]=true;returntrue;}// Let the ARIA attribute hook validate ARIA attributes
if(rARIA$1.test(name)||rARIACamel$1.test(name)){returntrue;}if(lowerCasedName==='innerhtml'){error('Directly setting property `innerHTML` is not permitted. '+'For more information, lookup documentation on `dangerouslySetInnerHTML`.');warnedProperties$1[name]=true;returntrue;}if(lowerCasedName==='aria'){error('The `aria` attribute is reserved for future use in React. '+'Pass individual `aria-` attributes instead.');warnedProperties$1[name]=true;returntrue;}if(lowerCasedName==='is'&&value!==null&&value!==undefined&&typeofvalue!=='string'){error('Received a `%s` for a string attribute `is`. If this is expected, cast '+'the value to a string.',typeofvalue);warnedProperties$1[name]=true;returntrue;}if(typeofvalue==='number'&&isNaN(value)){error('Received NaN for the `%s` attribute. If this is expected, cast '+'the value to a string.',name);warnedProperties$1[name]=true;returntrue;}varpropertyInfo=getPropertyInfo(name);varisReserved=propertyInfo!==null&&propertyInfo.type===RESERVED;// Known attributes should match the casing specified in the property config.
if(possibleStandardNames.hasOwnProperty(lowerCasedName)){varstandardName=possibleStandardNames[lowerCasedName];if(standardName!==name){error('Invalid DOM property `%s`. Did you mean `%s`?',name,standardName);warnedProperties$1[name]=true;returntrue;}}elseif(!isReserved&&name!==lowerCasedName){// Unknown attributes should have lowercase casing since that's how they
// will be cased anyway with server rendering.
error('React does not recognize the `%s` prop on a DOM element. If you '+'intentionally want it to appear in the DOM as a custom '+'attribute, spell it as lowercase `%s` instead. '+'If you accidentally passed it from a parent component, remove '+'it from the DOM element.',name,lowerCasedName);warnedProperties$1[name]=true;returntrue;}if(typeofvalue==='boolean'&&shouldRemoveAttributeWithWarning(name,value,propertyInfo,false)){if(value){error('Received `%s` for a non-boolean attribute `%s`.\n\n'+'If you want to write it to the DOM, pass a string instead: '+'%s="%s" or %s={value.toString()}.',value,name,name,value,name);}else{error('Received `%s` for a non-boolean attribute `%s`.\n\n'+'If you want to write it to the DOM, pass a string instead: '+'%s="%s" or %s={value.toString()}.\n\n'+'If you used to conditionally omit it with %s={condition && value}, '+'pass %s={condition ? value : undefined} instead.',value,name,name,value,name,name,name);}warnedProperties$1[name]=true;returntrue;}// Now that we've validated casing, do not validate
// data types for reserved props
if(isReserved){returntrue;}// Warn when a known attribute is a bad type
if(shouldRemoveAttributeWithWarning(name,value,propertyInfo,false)){warnedProperties$1[name]=true;returnfalse;}// Warn when passing the strings 'false' or 'true' into a boolean prop
if((value==='false'||value==='true')&&propertyInfo!==null&&propertyInfo.type===BOOLEAN){error('Received the string `%s` for the boolean attribute `%s`. '+'%s '+'Did you mean %s={%s}?',value,name,value==='false'?'The browser will interpret it as a truthy value.':'Although this works, it will not work as expected if you pass the string "false".',name,value);warnedProperties$1[name]=true;returntrue;}returntrue;};}varwarnUnknownProperties=function(type,props,eventRegistry){{varunknownProps=[];for(varkeyinprops){varisValid=validateProperty$1(type,key,props[key],eventRegistry);if(!isValid){unknownProps.push(key);}}varunknownPropString=unknownProps.map(function(prop){return'`'+prop+'`';}).join(', ');if(unknownProps.length===1){error('Invalid value for prop %s on <%s> tag. Either remove it from the element, '+'or pass a string or number value to keep it in the DOM. '+'For details, see https://reactjs.org/link/attribute-behavior ',unknownPropString,type);}elseif(unknownProps.length>1){error('Invalid values for props %s on <%s> tag. Either remove them from the element, '+'or pass a string or number value to keep them in the DOM. '+'For details, see https://reactjs.org/link/attribute-behavior ',unknownPropString,type);}}};functionvalidateProperties$2(type,props,eventRegistry){if(isCustomComponent(type,props)){return;}warnUnknownProperties(type,props,eventRegistry);}vartoArray=React.Children.toArray;// This is only used in DEV.
// Each entry is `this.stack` from a currently executing renderer instance.
// (There may be more than one because ReactDOMServer is reentrant).
// Each stack is an array of frames which may contain nested stacks of elements.
varcurrentDebugStacks=[];varReactCurrentDispatcher$1=ReactSharedInternals.ReactCurrentDispatcher;varReactDebugCurrentFrame$1;varprevGetCurrentStackImpl=null;vargetCurrentServerStackImpl=function(){return'';};vardescribeStackFrame=function(element){return'';};varvalidatePropertiesInDevelopment=function(type,props){};varpushCurrentDebugStack=function(stack){};varpushElementToDebugStack=function(element){};varpopCurrentDebugStack=function(){};varhasWarnedAboutUsingContextAsConsumer=false;{ReactDebugCurrentFrame$1=ReactSharedInternals.ReactDebugCurrentFrame;validatePropertiesInDevelopment=function(type,props){validateProperties(type,props);validateProperties$1(type,props);validateProperties$2(type,props,null);};describeStackFrame=function(element){returndescribeUnknownElementTypeFrameInDEV(element.type,element._source,null);};pushCurrentDebugStack=function(stack){currentDebugStacks.push(stack);if(currentDebugStacks.length===1){// We are entering a server renderer.
// Remember the previous (e.g. client) global stack implementation.
prevGetCurrentStackImpl=ReactDebugCurrentFrame$1.getCurrentStack;ReactDebugCurrentFrame$1.getCurrentStack=getCurrentServerStackImpl;}};pushElementToDebugStack=function(element){// For the innermost executing ReactDOMServer call,
varstack=currentDebugStacks[currentDebugStacks.length-1];// Take the innermost executing frame (e.g. <Foo>),
varframe=stack[stack.length-1];// and record that it has one more element associated with it.
frame.debugElementStack.push(element);// We only need this because we tail-optimize single-element
// children and directly handle them in an inner loop instead of
// creating separate frames for them.
};popCurrentDebugStack=function(){currentDebugStacks.pop();if(currentDebugStacks.length===0){// We are exiting the server renderer.
// Restore the previous (e.g. client) global stack implementation.
ReactDebugCurrentFrame$1.getCurrentStack=prevGetCurrentStackImpl;prevGetCurrentStackImpl=null;}};getCurrentServerStackImpl=function(){if(currentDebugStacks.length===0){// Nothing is currently rendering.
return'';}// ReactDOMServer is reentrant so there may be multiple calls at the same time.
// Take the frames from the innermost call which is the last in the array.
varframes=currentDebugStacks[currentDebugStacks.length-1];varstack='';// Go through every frame in the stack from the innermost one.
for(vari=frames.length-1;i>=0;i--){varframe=frames[i];// Every frame might have more than one debug element stack entry associated with it.
// This is because single-child nesting doesn't create materialized frames.
// Instead it would push them through `pushElementToDebugStack()`.
vardebugElementStack=frame.debugElementStack;for(varii=debugElementStack.length-1;ii>=0;ii--){stack+=describeStackFrame(debugElementStack[ii]);}}returnstack;};}vardidWarnDefaultInputValue=false;vardidWarnDefaultChecked=false;vardidWarnDefaultSelectValue=false;vardidWarnDefaultTextareaValue=false;vardidWarnInvalidOptionChildren=false;vardidWarnAboutNoopUpdateForComponent={};vardidWarnAboutBadClass={};vardidWarnAboutModulePatternComponent={};vardidWarnAboutDeprecatedWillMount={};vardidWarnAboutUndefinedDerivedState={};vardidWarnAboutUninitializedState={};varvaluePropNames=['value','defaultValue'];varnewlineEatingTags={listing:true,pre:true,textarea:true};// We accept any tag to be rendered but since this gets injected into arbitrary
// HTML, we want to make sure that it's a safe tag.
varvalidatedTagCache={};functionvalidateDangerousTag(tag){if(!validatedTagCache.hasOwnProperty(tag)){if(!VALID_TAG_REGEX.test(tag)){{throwError("Invalid tag: "+tag);}}validatedTagCache[tag]=true;}}varstyleNameCache={};varprocessStyleName=function(styleName){if(styleNameCache.hasOwnProperty(styleName)){returnstyleNameCache[styleName];}varresult=hyphenateStyleName(styleName);styleNameCache[styleName]=result;returnresult;};functioncreateMarkupForStyles(styles){varserialized='';vardelimiter='';for(varstyleNameinstyles){if(!styles.hasOwnProperty(styleName)){continue;}varisCustomProperty=styleName.indexOf('--')===0;varstyleValue=styles[styleName];{if(!isCustomProperty){warnValidStyle$1(styleName,styleValue);}}if(styleValue!=null){serialized+=delimiter+(isCustomProperty?styleName:processStyleName(styleName))+':';serialized+=dangerousStyleValue(styleName,styleValue,isCustomProperty);delimiter=';';}}returnserialized||null;}functionwarnNoop(publicInstance,callerName){{var_constructor=publicInstance.constructor;varcomponentName=_constructor&&getComponentName(_constructor)||'ReactClass';varwarningKey=componentName+'.'+callerName;if(didWarnAboutNoopUpdateForComponent[warningKey]){return;}error('%s(...): Can only update a mounting component. '+'This usually means you called %s() outside componentWillMount() on the server. '+'This is a no-op.\n\nPlease check the code for the %s component.',callerName,callerName,componentName);didWarnAboutNoopUpdateForComponent[warningKey]=true;}}functionshouldConstruct$1(Component){returnComponent.prototype&&Component.prototype.isReactComponent;}functiongetNonChildrenInnerMarkup(props){varinnerHTML=props.dangerouslySetInnerHTML;if(innerHTML!=null){if(innerHTML.__html!=null){returninnerHTML.__html;}}else{varcontent=props.children;if(typeofcontent==='string'||typeofcontent==='number'){returnescapeTextForBrowser(content);}}returnnull;}functionflattenTopLevelChildren(children){if(!React.isValidElement(children)){returntoArray(children);}varelement=children;if(element.type!==REACT_FRAGMENT_TYPE){return[element];}varfragmentChildren=element.props.children;if(!React.isValidElement(fragmentChildren)){returntoArray(fragmentChildren);}varfragmentChildElement=fragmentChildren;return[fragmentChildElement];}functionflattenOptionChildren(children){if(children===undefined||children===null){returnchildren;}varcontent='';// Flatten children and warn if they aren't strings or numbers;
// invalid types are ignored.
React.Children.forEach(children,function(child){if(child==null){return;}content+=child;{if(!didWarnInvalidOptionChildren&&typeofchild!=='string'&&typeofchild!=='number'){didWarnInvalidOptionChildren=true;error('Only strings and numbers are supported as <option> children.');}}});returncontent;}varhasOwnProperty$2=Object.prototype.hasOwnProperty;varSTYLE='style';varRESERVED_PROPS={children:null,dangerouslySetInnerHTML:null,suppressContentEditableWarning:null,suppressHydrationWarning:null};functioncreateOpenTagMarkup(tagVerbatim,tagLowercase,props,namespace,makeStaticMarkup,isRootElement){varret='<'+tagVerbatim;varisCustomComponent$1=isCustomComponent(tagLowercase,props);for(varpropKeyinprops){if(!hasOwnProperty$2.call(props,propKey)){continue;}varpropValue=props[propKey];if(propValue==null){continue;}if(propKey===STYLE){propValue=createMarkupForStyles(propValue);}varmarkup=null;if(isCustomComponent$1){if(!RESERVED_PROPS.hasOwnProperty(propKey)){markup=createMarkupForCustomAttribute(propKey,propValue);}}else{markup=createMarkupForProperty(propKey,propValue);}if(markup){ret+=' '+markup;}}// For static pages, no need to put React ID and checksum. Saves lots of
// bytes.
if(makeStaticMarkup){returnret;}if(isRootElement){ret+=' '+createMarkupForRoot();}returnret;}functionvalidateRenderResult(child,type){if(child===undefined){{{throwError((getComponentName(type)||'Component')+"(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.");}}}}functionresolve(child,context,threadID){while(React.isValidElement(child)){// Safe because we just checked it's an element.
varelement=child;varComponent=element.type;{pushElementToDebugStack(element);}if(typeofComponent!=='function'){break;}processChild(element,Component);}// Extra closure so queue and replace can be captured properly
functionprocessChild(element,Component){varisClass=shouldConstruct$1(Component);varpublicContext=processContext(Component,context,threadID,isClass);varqueue=[];varreplace=false;varupdater={isMounted:function(publicInstance){returnfalse;},enqueueForceUpdate:function(publicInstance){if(queue===null){warnNoop(publicInstance,'forceUpdate');returnnull;}},enqueueReplaceState:function(publicInstance,completeState){replace=true;queue=[completeState];},enqueueSetState:function(publicInstance,currentPartialState){if(queue===null){warnNoop(publicInstance,'setState');returnnull;}queue.push(currentPartialState);}};varinst;if(isClass){inst=newComponent(element.props,publicContext,updater);if(typeofComponent.getDerivedStateFromProps==='function'){{if(inst.state===null||inst.state===undefined){varcomponentName=getComponentName(Component)||'Unknown';if(!didWarnAboutUninitializedState[componentName]){error('`%s` uses `getDerivedStateFromProps` but its initial state is '+'%s. This is not recommended. Instead, define the initial state by '+'assigning an object to `this.state` in the constructor of `%s`. '+'This ensures that `getDerivedStateFromProps` arguments have a consistent shape.',componentName,inst.state===null?'null':'undefined',componentName);didWarnAboutUninitializedState[componentName]=true;}}}varpartialState=Component.getDerivedStateFromProps.call(null,element.props,inst.state);{if(partialState===undefined){var_componentName=getComponentName(Component)||'Unknown';if(!didWarnAboutUndefinedDerivedState[_componentName]){error('%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. '+'You have returned undefined.',_componentName);didWarnAboutUndefinedDerivedState[_componentName]=true;}}}if(partialState!=null){inst.state=_assign({},inst.state,partialState);}}}else{{if(Component.prototype&&typeofComponent.prototype.render==='function'){var_componentName2=getComponentName(Component)||'Unknown';if(!didWarnAboutBadClass[_componentName2]){error("The <%s /> component appears to have a render method, but doesn't extend React.Component. "+'This is likely to cause errors. Change %s to extend React.Component instead.',_componentName2,_componentName2);didWarnAboutBadClass[_componentName2]=true;}}}varcomponentIdentity={};prepareToUseHooks(componentIdentity);inst=Component(element.props,publicContext,updater);inst=finishHooks(Component,element.props,inst,publicContext);{// Support for module components is deprecated and is removed behind a flag.
// Whether or not it would crash later, we want to show a good message in DEV first.
if(inst!=null&&inst.render!=null){var_componentName3=getComponentName(Component)||'Unknown';if(!didWarnAboutModulePatternComponent[_componentName3]){error('The <%s /> component appears to be a function component that returns a class instance. '+'Change %s to a class that extends React.Component instead. '+"If you can't use a class try assigning the prototype on the function as a workaround. "+"`%s.prototype = React.Component.prototype`. Don't use an arrow function since it "+'cannot be called with `new` by React.',_componentName3,_componentName3,_componentName3);didWarnAboutModulePatternComponent[_componentName3]=true;}}}// If the flag is on, everything is assumed to be a function component.
// Otherwise, we also do the unfortunate dynamic checks.
if(inst==null||inst.render==null){child=inst;validateRenderResult(child,Component);return;}}inst.props=element.props;inst.context=publicContext;inst.updater=updater;varinitialState=inst.state;if(initialState===undefined){inst.state=initialState=null;}if(typeofinst.UNSAFE_componentWillMount==='function'||typeofinst.componentWillMount==='function'){if(typeofinst.componentWillMount==='function'){{if(inst.componentWillMount.__suppressDeprecationWarning!==true){var_componentName4=getComponentName(Component)||'Unknown';if(!didWarnAboutDeprecatedWillMount[_componentName4]){warn(// keep this warning in sync with ReactStrictModeWarning.js
'componentWillMount has been renamed, and is not recommended for use. '+'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n'+'* Move code from componentWillMount to componentDidMount (preferred in most cases) '+'or the constructor.\n'+'\nPlease update the following components: %s',_componentName4);didWarnAboutDeprecatedWillMount[_componentName4]=true;}}}// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for any component with the new gDSFP.
if(typeofComponent.getDerivedStateFromProps!=='function'){inst.componentWillMount();}}if(typeofinst.UNSAFE_componentWillMount==='function'&&typeofComponent.getDerivedStateFromProps!=='function'){// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for any component with the new gDSFP.
inst.UNSAFE_componentWillMount();}if(queue.length){varoldQueue=queue;varoldReplace=replace;queue=null;replace=false;if(oldReplace&&oldQueue.length===1){inst.state=oldQueue[0];}else{varnextState=oldReplace?oldQueue[0]:inst.state;vardontMutate=true;for(vari=oldReplace?1:0;i<oldQueue.length;i++){varpartial=oldQueue[i];var_partialState=typeofpartial==='function'?partial.call(inst,nextState,element.props,publicContext):partial;if(_partialState!=null){if(dontMutate){dontMutate=false;nextState=_assign({},nextState,_partialState);}else{_assign(nextState,_partialState);}}}inst.state=nextState;}}else{queue=null;}}child=inst.render();{if(child===undefined&&inst.render._isMockFunction){// This is probably bad practice. Consider warning here and
// deprecating this convenience.
child=null;}}validateRenderResult(child,Component);varchildContext;{if(typeofinst.getChildContext==='function'){var_childContextTypes=Component.childContextTypes;if(typeof_childContextTypes==='object'){childContext=inst.getChildContext();for(varcontextKeyinchildContext){if(!(contextKeyin_childContextTypes)){{throwError((getComponentName(Component)||'Unknown')+".getChildContext(): key \""+contextKey+"\" is not defined in childContextTypes.");}}}}else{{error('%s.getChildContext(): childContextTypes must be defined in order to '+'use getChildContext().',getComponentName(Component)||'Unknown');}}}if(childContext){context=_assign({},context,childContext);}}}return{child:child,context:context};}varReactDOMServerRenderer=/*#__PURE__*/function(){// TODO: type this more strictly:
// DEV-only
functionReactDOMServerRenderer(children,makeStaticMarkup,options){varflatChildren=flattenTopLevelChildren(children);vartopFrame={type:null,// Assume all trees start in the HTML namespace (not totally true, but
// this is what we did historically)
domNamespace:Namespaces.html,children:flatChildren,childIndex:0,context:emptyObject,footer:''};{topFrame.debugElementStack=[];}this.threadID=allocThreadID();this.stack=[topFrame];this.exhausted=false;this.currentSelectValue=null;this.previousWasTextNode=false;this.makeStaticMarkup=makeStaticMarkup;this.suspenseDepth=0;// Context (new API)
this.contextIndex=-1;this.contextStack=[];this.contextValueStack=[];// useOpaqueIdentifier ID
this.contextStack[index]=context;this.contextValueStack[index]=previousValue;{// Only used for push/pop mismatch warnings.
this.contextProviderStack[index]=provider;}// Mutate the current value.
context[threadID]=provider.props.value;};_proto.popProvider=functionpopProvider(provider){varindex=this.contextIndex;{if(index<0||provider!==this.contextProviderStack[index]){error('Unexpected pop.');}}varcontext=this.contextStack[index];varpreviousValue=this.contextValueStack[index];// "Hide" these null assignments from Flow by using `any`
// because conceptually they are deletions--as long as we
// promise to never access values beyond `this.contextIndex`.
this.contextStack[index]=null;this.contextValueStack[index]=null;{this.contextProviderStack[index]=null;}this.contextIndex--;// Restore to the previous value we stored as we were walking down.
// We've already verified that this context has been expanded to accommodate
// this thread id, so we don't need to do it again.
context[this.threadID]=previousValue;};_proto.clearProviders=functionclearProviders(){// Restore any remaining providers on the stack to previous values
for(varindex=this.contextIndex;index>=0;index--){varcontext=this.contextStack[index];varpreviousValue=this.contextValueStack[index];context[this.threadID]=previousValue;}};_proto.read=functionread(bytes){if(this.exhausted){returnnull;}varprevPartialRenderer=currentPartialRenderer;setCurrentPartialRenderer(this);varprevDispatcher=ReactCurrentDispatcher$1.current;ReactCurrentDispatcher$1.current=Dispatcher;try{// Markup generated within <Suspense> ends up buffered until we know
// nothing in that boundary suspended
varout=[''];varsuspended=false;while(out[0].length<bytes){if(this.stack.length===0){this.exhausted=true;freeThreadID(this.threadID);break;}varframe=this.stack[this.stack.length-1];if(suspended||frame.childIndex>=frame.children.length){varfooter=frame.footer;if(footer!==''){this.previousWasTextNode=false;}this.stack.pop();if(frame.type==='select'){this.currentSelectValue=null;}elseif(frame.type!=null&&frame.type.type!=null&&frame.type.type.$$typeof===REACT_PROVIDER_TYPE){varprovider=frame.type;this.popProvider(provider);}elseif(frame.type===REACT_SUSPENSE_TYPE){this.suspenseDepth--;varbuffered=out.pop();if(suspended){suspended=false;// If rendering was suspended at this boundary, render the fallbackFrame
varfallbackFrame=frame.fallbackFrame;if(!fallbackFrame){{throwError(true?"ReactDOMServer did not find an internal fallback frame for Suspense. This is a bug in React. Please file an issue.":formatProdErrorMessage(303));}}this.stack.push(fallbackFrame);out[this.suspenseDepth]+='<!--$!-->';// Skip flushing output since we're switching to the fallback
out[this.suspenseDepth]+=footer;continue;}varchild=frame.children[frame.childIndex++];varoutBuffer='';if(true){pushCurrentDebugStack(this.stack);// We're starting work on this frame, so reset its inner stack.
frame.debugElementStack.length=0;}try{outBuffer+=this.render(child,frame.context,frame.domNamespace);}catch(err){if(err!=null&&typeoferr.then==='function'){if(enableSuspenseServerRenderer);else{if(!false){{throwError(true?"ReactDOMServer does not yet support Suspense.":formatProdErrorMessage(294));}}}}else{throwerr;}}finally{if(true){popCurrentDebugStack();}}if(out.length<=this.suspenseDepth){out.push('');}out[this.suspenseDepth]+=outBuffer;}returnout[0];}finally{ReactCurrentDispatcher$1.current=prevDispatcher;setCurrentPartialRenderer(prevPartialRenderer);resetHooksState();}};_proto.render=functionrender(child,context,parentNamespace){if(typeofchild==='string'||typeofchild==='number'){vartext=''+child;if(text===''){return'';}if(this.makeStaticMarkup){returnescapeTextForBrowser(text);}if(this.previousWasTextNode){return'<!-- -->'+escapeTextForBrowser(text);}this.previousWasTextNode=true;returnescapeTextForBrowser(text);}else{varnextChild;var_resolve=resolve(child,context,this.threadID);nextChild=_resolve.child;context=_resolve.context;if(nextChild===null||nextChild===false){return'';}elseif(!React.isValidElement(nextChild)){if(nextChild!=null&&nextChild.$$typeof!=null){// Catch unexpected special types early.
var$$typeof=nextChild.$$typeof;if(!($$typeof!==REACT_PORTAL_TYPE)){{throwError("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");}}// Catch-all to prevent an infinite loop if React.Children.toArray() supports some new type.
{{throwError("Unknown element-like object type: "+$$typeof.toString()+". This is likely a bug in React. Please file an issue.");}}}varnextChildren=toArray(nextChild);varframe={type:null,domNamespace:parentNamespace,children:nextChildren,childIndex:0,context:context,footer:''};{frame.debugElementStack=[];}this.stack.push(frame);return'';}// Safe because we just checked it's an element.
varnextElement=nextChild;varelementType=nextElement.type;if(typeofelementType==='string'){returnthis.renderDOM(nextElement,context,parentNamespace);}switch(elementType){// TODO: LegacyHidden acts the same as a fragment. This only works
// because we currently assume that every instance of LegacyHidden is
// accompanied by a host component wrapper. In the hidden mode, the host
// component is given a `hidden` attribute, which ensures that the
// initial HTML is not visible. To support the use of LegacyHidden as a
// true fragment, without an extra DOM node, we would have to hide the
// initial HTML in some other way.
caseREACT_LEGACY_HIDDEN_TYPE:caseREACT_DEBUG_TRACING_MODE_TYPE:caseREACT_STRICT_MODE_TYPE:caseREACT_PROFILER_TYPE:caseREACT_SUSPENSE_LIST_TYPE:caseREACT_FRAGMENT_TYPE:{var_nextChildren=toArray(nextChild.props.children);var_frame={type:null,domNamespace:parentNamespace,children:_nextChildren,childIndex:0,context:context,footer:''};{_frame.debugElementStack=[];}this.stack.push(_frame);return'';}caseREACT_SUSPENSE_TYPE:{{{{throwError("ReactDOMServer does not yet support Suspense.");}}}}// eslint-disable-next-line-no-fallthrough
caseREACT_SCOPE_TYPE:{{{throwError("ReactDOMServer does not yet support scope components.");}}}}if(typeofelementType==='object'&&elementType!==null){switch(elementType.$$typeof){caseREACT_FORWARD_REF_TYPE:{varelement=nextChild;var_nextChildren5;varcomponentIdentity={};prepareToUseHooks(componentIdentity);_nextChildren5=elementType.render(element.props,element.ref);_nextChildren5=finishHooks(elementType.render,element.props,_nextChildren5,element.ref);_nextChildren5=toArray(_nextChildren5);var_frame5={type:null,domNamespace:parentNamespace,children:_nextChildren5,childIndex:0,context:context,footer:''};{_frame5.debugElementStack=[];}this.stack.push(_frame5);return'';}caseREACT_MEMO_TYPE:{var_element=nextChild;var_nextChildren6=[React.createElement(elementType.type,_assign({ref:_element.ref},_element.props))];var_frame6={type:null,domNamespace:parentNamespace,children:_nextChildren6,childIndex:0,context:context,footer:''};{_frame6.debugElementStack=[];}this.stack.push(_frame6);return'';}caseREACT_PROVIDER_TYPE:{varprovider=nextChild;varnextProps=provider.props;var_nextChildren7=toArray(nextProps.children);var_frame7={type:provider,domNamespace:parentNamespace,children:_nextChildren7,childIndex:0,context:context,footer:''};{_frame7.debugElementStack=[];}this.pushProvider(provider);this.stack.push(_frame7);return'';}caseREACT_CONTEXT_TYPE:{varreactContext=nextChild.type;// The logic below for Context differs depending on PROD or DEV mode. In
// DEV mode, we create a separate object for Context.Consumer that acts
// like a proxy to Context. This proxy object adds unnecessary code in PROD
// so we use the old behaviour (Context.Consumer references Context) to
// reduce size and overhead. The separate object references context via
// a property called "_context", which also gives us the ability to check
// in DEV mode if this property exists or not and warn if it does not.
{if(reactContext._context===undefined){// This may be because it's a Context (rather than a Consumer).
// Or it may be because it's older React where they're the same thing.
// We only want to warn if we're sure it's a new React.
if(reactContext!==reactContext.Consumer){if(!hasWarnedAboutUsingContextAsConsumer){hasWarnedAboutUsingContextAsConsumer=true;error('Rendering <Context> directly is not supported and will be removed in '+'a future major release. Did you mean to render <Context.Consumer> instead?');}}}else{reactContext=reactContext._context;}}var_nextProps=nextChild.props;varthreadID=this.threadID;validateContextBounds(reactContext,threadID);varnextValue=reactContext[threadID];var_nextChildren8=toArray(_nextProps.children(nextValue));var_frame8={type:nextChild,domNamespace:parentNamespace,children:_nextChildren8,childIndex:0,context:context,footer:''};{_frame8.debugElementStack=[];}this.stack.push(_frame8);return'';}// eslint-disable-next-line-no-fallthrough
caseREACT_FUNDAMENTAL_TYPE:{{{throwError("ReactDOMServer does not yet support the fundamental API.");}}}// eslint-disable-next-line-no-fallthrough
caseREACT_LAZY_TYPE:{var_element2=nextChild;varlazyComponent=nextChild.type;// Attempt to initialize lazy component regardless of whether the
// suspense server-side renderer is enabled so synchronously
// resolved constructors are supported.
varpayload=lazyComponent._payload;varinit=lazyComponent._init;varresult=init(payload);var_nextChildren10=[React.createElement(result,_assign({ref:_element2.ref},_element2.props))];var_frame10={type:null,domNamespace:parentNamespace,children:_nextChildren10,childIndex:0,context:context,footer:''};{_frame10.debugElementStack=[];}this.stack.push(_frame10);return'';}}}varinfo='';{varowner=nextElement._owner;if(elementType===undefined||typeofelementType==='object'&&elementType!==null&&Object.keys(elementType).length===0){info+=' You likely forgot to export your component from the file '+"it's defined in, or you might have mixed up default and "+'named imports.';}varownerName=owner?getComponentName(owner):null;if(ownerName){info+='\n\nCheck the render method of `'+ownerName+'`.';}}{{throwError("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+(elementType==null?elementType:typeofelementType)+"."+info);}}}};_proto.renderDOM=functionrenderDOM(element,context,parentNamespace){vartag=element.type.toLowerCase();varnamespace=parentNamespace;if(parentNamespace===Namespaces.html){namespace=getIntrinsicNamespace(tag);}{if(namespace===Namespaces.html){// Should this check be gated by parent namespace? Not sure we want to
// allow <SVG> or <mATH>.
if(tag!==element.type){error('<%s /> is using incorrect casing. '+'Use PascalCase for React components, '+'or lowercase for HTML elements.',element.type);}}}validateDangerousTag(tag);varprops=element.props;if(tag==='input'){{checkControlledValueProps('input',props);if(props.checked!==undefined&&props.defaultChecked!==undefined&&!didWarnDefaultChecked){error('%s contains an input of type %s with both checked and defaultChecked props. '+'Input elements must be either controlled or uncontrolled '+'(specify either the checked prop, or the defaultChecked prop, but not '+'both). Decide between using a controlled or uncontrolled input '+'element and remove one of these props. More info: '+'https://reactjs.org/link/controlled-components','A component',props.type);didWarnDefaultChecked=true;}if(props.value!==undefined&&props.defaultValue!==undefined&&!didWarnDefaultInputValue){error('%s contains an input of type %s with both value and defaultValue props. '+'Input elements must be either controlled or uncontrolled '+'(specify either the value prop, or the defaultValue prop, but not '+'both). Decide between using a controlled or uncontrolled input '+'element and remove one of these props. More info: '+'https://reactjs.org/link/controlled-components','A component',props.type);didWarnDefaultInputValue=true;}}props=_assign({type:undefined},props,{defaultChecked:undefined,defaultValue:undefined,value:props.value!=null?props.value:props.defaultValue,checked:props.checked!=null?props.checked:props.defaultChecked});}elseif(tag==='textarea'){{checkControlledValueProps('textarea',props);if(props.value!==undefined&&props.defaultValue!==undefined&&!didWarnDefaultTextareaValue){error('Textarea elements must be either controlled or uncontrolled '+'(specify either the value prop, or the defaultValue prop, but not '+'both). Decide between using a controlled or uncontrolled textarea '+'and remove one of these props. More info: '+'https://reactjs.org/link/controlled-components');didWarnDefaultTextareaValue=true;}}varinitialValue=props.value;if(initialValue==null){vardefaultValue=props.defaultValue;// TODO (yungsters): Remove support for children content in <textarea>.
vartextareaChildren=props.children;if(textareaChildren!=null){{error('Use the `defaultValue` or `value` props instead of setting '+'children on <textarea>.');}if(!(defaultValue==null)){{throwError("If you supply `defaultValue` on a <textarea>, do not pass children.");}}if(Array.isArray(textareaChildren)){if(!(textareaChildren.length<=1)){{throwError("<textarea> can only have at most one child.");}}textareaChildren=textareaChildren[0];}defaultValue=''+textareaChildren;}if(defaultValue==null){defaultValue='';}initialValue=defaultValue;}props=_assign({},props,{value:undefined,children:''+initialValue});}elseif(tag==='select'){{checkControlledValueProps('select',props);for(vari=0;i<valuePropNames.length;i++){varpropName=valuePropNames[i];if(props[propName]==null){continue;}varisArray=Array.isArray(props[propName]);if(props.multiple&&!isArray){error('The `%s` prop supplied to <select> must be an array if '+'`multiple` is true.',propName);}elseif(!props.multiple&&isArray){error('The `%s` prop supplied to <select> must be a scalar '+'value if `multiple` is false.',propName);}}if(props.value!==undefined&&props.defaultValue!==undefined&&!didWarnDefaultSelectValue){error('Select elements must be either controlled or uncontrolled '+'(specify either the value prop, or the defaultValue prop, but not '+'both). Decide between using a controlled or uncontrolled select '+'element and remove one of these props. More info: '+'https://reactjs.org/link/controlled-components');didWarnDefaultSelectValue=true;}}this.currentSelectValue=props.value!=null?props.value:props.defaultValue;props=_assign({},props,{value:undefined});}elseif(tag==='option'){varselected=null;varselectValue=this.currentSelectValue;varoptionChildren=flattenOptionChildren(props.children);if(selectValue!=null){varvalue;if(props.value!=null){value=props.value+'';}else{value=optionChildren;}selected=false;if(Array.isArray(selectValue)){// multiple
for(varj=0;j<selectValue.length;j++){if(''+selectValue[j]===value){selected=true;break;}}}else{selected=''+selectValue===value;}props=_assign({selected:undefined,children:undefined},props,{selected:selected,children:optionChildren});}}{validatePropertiesInDevelopment(tag,props);}assertValidProps(tag,props);varout=createOpenTagMarkup(element.type,tag,props,namespace,this.makeStaticMarkup,this.stack.length===1);varfooter='';if(omittedCloseTags.hasOwnProperty(tag)){out+='/>';}else{out+='>';footer='</'+element.type+'>';}varchildren;varinnerMarkup=getNonChildrenInnerMarkup(props);if(innerMarkup!=null){children=[];if(newlineEatingTags.hasOwnProperty(tag)&&innerMarkup.charAt(0)==='\n'){// text/html ignores the first character in these tags if it's a newline
// Prefer to break application/xml over text/html (for now) by adding
// a newline specifically to get eaten by the parser. (Alternately for
// textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
// \r is normalized out by HTMLTextAreaElement#value.)
Object.defineProperty(exports,"__esModule",{value:true});exports["default"]=void0;var_intro=_interopRequireDefault(intro);var_propTypes=_interopRequireDefault(propTypes);varintroJsPropTypes=_interopRequireWildcard(proptypes);varintroJsDefaultProps=_interopRequireWildcard(defaultProps);function_getRequireWildcardCache(){if(typeofWeakMap!=="function")returnnull;varcache=newWeakMap();_getRequireWildcardCache=function_getRequireWildcardCache(){returncache;};returncache;}function_interopRequireWildcard(obj){if(obj&&obj.__esModule){returnobj;}if(obj===null||_typeof(obj)!=="object"&&typeofobj!=="function"){return{"default":obj};}varcache=_getRequireWildcardCache();if(cache&&cache.has(obj)){returncache.get(obj);}varnewObj={};varhasPropertyDescriptor=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(varkeyinobj){if(Object.prototype.hasOwnProperty.call(obj,key)){vardesc=hasPropertyDescriptor?Object.getOwnPropertyDescriptor(obj,key):null;if(desc&&(desc.get||desc.set)){Object.defineProperty(newObj,key,desc);}else{newObj[key]=obj[key];}}}newObj["default"]=obj;if(cache){cache.set(obj,newObj);}returnnewObj;}function_interopRequireDefault(obj){returnobj&&obj.__esModule?obj:{"default":obj};}function_typeof(obj){"@babel/helpers - typeof";if(typeofSymbol==="function"&&typeofSymbol.iterator==="symbol"){_typeof=function_typeof(obj){returntypeofobj;};}else{_typeof=function_typeof(obj){returnobj&&typeofSymbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeofobj;};}return_typeof(obj);}functionownKeys(object,enumerableOnly){varkeys=Object.keys(object);if(Object.getOwnPropertySymbols){varsymbols=Object.getOwnPropertySymbols(object);if(enumerableOnly)symbols=symbols.filter(function(sym){returnObject.getOwnPropertyDescriptor(object,sym).enumerable;});keys.push.apply(keys,symbols);}returnkeys;}function_objectSpread(target){for(vari=1;i<arguments.length;i++){varsource=arguments[i]!=null?arguments[i]:{};if(i%2){ownKeys(Object(source),true).forEach(function(key){_defineProperty(target,key,source[key]);});}elseif(Object.getOwnPropertyDescriptors){Object.defineProperties(target,Object.getOwnPropertyDescriptors(source));}else{ownKeys(Object(source)).forEach(function(key){Object.defineProperty(target,key,Object.getOwnPropertyDescriptor(source,key));});}}returntarget;}function_classCallCheck(instance,Constructor){if(!(instanceinstanceofConstructor)){thrownewTypeError("Cannot call a class as a function");}}function_defineProperties(target,props){for(vari=0;i<props.length;i++){vardescriptor=props[i];descriptor.enumerable=descriptor.enumerable||false;descriptor.configurable=true;if("value"indescriptor)descriptor.writable=true;Object.defineProperty(target,descriptor.key,descriptor);}}function_createClass(Constructor,protoProps,staticProps){if(protoProps)_defineProperties(Constructor.prototype,protoProps);if(staticProps)_defineProperties(Constructor,staticProps);returnConstructor;}function_inherits(subClass,superClass){if(typeofsuperClass!=="function"&&superClass!==null){thrownewTypeError("Super expression must either be null or a function");}subClass.prototype=Object.create(superClass&&superClass.prototype,{constructor:{value:subClass,writable:true,configurable:true}});if(superClass)_setPrototypeOf(subClass,superClass);}function_setPrototypeOf(o,p){_setPrototypeOf=Object.setPrototypeOf||function_setPrototypeOf(o,p){o.__proto__=p;returno;};return_setPrototypeOf(o,p);}function_createSuper(Derived){varhasNativeReflectConstruct=_isNativeReflectConstruct();returnfunction(){varSuper=_getPrototypeOf(Derived),result;if(hasNativeReflectConstruct){varNewTarget=_getPrototypeOf(this).constructor;result=Reflect.construct(Super,arguments,NewTarget);}else{result=Super.apply(this,arguments);}return_possibleConstructorReturn(this,result);};}function_possibleConstructorReturn(self,call){if(call&&(_typeof(call)==="object"||typeofcall==="function")){returncall;}return_assertThisInitialized(self);}function_assertThisInitialized(self){if(self===void0){thrownew
Object.defineProperty(exports,"__esModule",{value:true});exports["default"]=void0;var_intro=_interopRequireDefault(intro);var_propTypes=_interopRequireDefault(propTypes);varintroJsPropTypes=_interopRequireWildcard(proptypes);varintroJsDefaultProps=_interopRequireWildcard(defaultProps);function_getRequireWildcardCache(){if(typeofWeakMap!=="function")returnnull;varcache=newWeakMap();_getRequireWildcardCache=function_getRequireWildcardCache(){returncache;};returncache;}function_interopRequireWildcard(obj){if(obj&&obj.__esModule){returnobj;}if(obj===null||_typeof(obj)!=="object"&&typeofobj!=="function"){return{"default":obj};}varcache=_getRequireWildcardCache();if(cache&&cache.has(obj)){returncache.get(obj);}varnewObj={};varhasPropertyDescriptor=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(varkeyinobj){if(Object.prototype.hasOwnProperty.call(obj,key)){vardesc=hasPropertyDescriptor?Object.getOwnPropertyDescriptor(obj,key):null;if(desc&&(desc.get||desc.set)){Object.defineProperty(newObj,key,desc);}else{newObj[key]=obj[key];}}}newObj["default"]=obj;if(cache){cache.set(obj,newObj);}returnnewObj;}function_interopRequireDefault(obj){returnobj&&obj.__esModule?obj:{"default":obj};}function_typeof(obj){"@babel/helpers - typeof";if(typeofSymbol==="function"&&typeofSymbol.iterator==="symbol"){_typeof=function_typeof(obj){returntypeofobj;};}else{_typeof=function_typeof(obj){returnobj&&typeofSymbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeofobj;};}return_typeof(obj);}functionownKeys(object,enumerableOnly){varkeys=Object.keys(object);if(Object.getOwnPropertySymbols){varsymbols=Object.getOwnPropertySymbols(object);if(enumerableOnly)symbols=symbols.filter(function(sym){returnObject.getOwnPropertyDescriptor(object,sym).enumerable;});keys.push.apply(keys,symbols);}returnkeys;}function_objectSpread(target){for(vari=1;i<arguments.length;i++){varsource=arguments[i]!=null?arguments[i]:{};if(i%2){ownKeys(Object(source),true).forEach(function(key){_defineProperty(target,key,source[key]);});}elseif(Object.getOwnPropertyDescriptors){Object.defineProperties(target,Object.getOwnPropertyDescriptors(source));}else{ownKeys(Object(source)).forEach(function(key){Object.defineProperty(target,key,Object.getOwnPropertyDescriptor(source,key));});}}returntarget;}function_classCallCheck(instance,Constructor){if(!(instanceinstanceofConstructor)){thrownewTypeError("Cannot call a class as a function");}}function_defineProperties(target,props){for(vari=0;i<props.length;i++){vardescriptor=props[i];descriptor.enumerable=descriptor.enumerable||false;descriptor.configurable=true;if("value"indescriptor)descriptor.writable=true;Object.defineProperty(target,descriptor.key,descriptor);}}function_createClass(Constructor,protoProps,staticProps){if(protoProps)_defineProperties(Constructor.prototype,protoProps);if(staticProps)_defineProperties(Constructor,staticProps);returnConstructor;}function_inherits(subClass,superClass){if(typeofsuperClass!=="function"&&superClass!==null){thrownewTypeError("Super expression must either be null or a function");}subClass.prototype=Object.create(superClass&&superClass.prototype,{constructor:{value:subClass,writable:true,configurable:true}});if(superClass)_setPrototypeOf(subClass,superClass);}function_setPrototypeOf(o,p){_setPrototypeOf=Object.setPrototypeOf||function_setPrototypeOf(o,p){o.__proto__=p;returno;};return_setPrototypeOf(o,p);}function_createSuper(Derived){varhasNativeReflectConstruct=_isNativeReflectConstruct();returnfunction(){varSuper=_getPrototypeOf(Derived),result;if(hasNativeReflectConstruct){varNewTarget=_getPrototypeOf(this).constructor;result=Reflect.construct(Super,arguments,NewTarget);}else{result=Super.apply(this,arguments);}return_possibleConstructorReturn(this,result);};}function_possibleConstructorReturn(self,call){if(call&&(_typeof(call)==="object"||typeofcall==="function")){returncall;}return_assertThisInitialized(self);}function_assertThisInitialized(self){if(self===void0){thrownew
varf,g,h,k;if("object"===typeofperformance&&"function"===typeofperformance.now){varl=performance;exports.unstable_now=function(){returnl.now();};}else{varp=Date,q=p.now();exports.unstable_now=function(){returnp.now()-q;};}if("undefined"===typeofwindow||"function"!==typeofMessageChannel){vart=null,u=null,w=function(){if(null!==t)try{vara=exports.unstable_now();t(!0,a);t=null;}catch(b){throwsetTimeout(w,0),b;}};f=function(a){null!==t?setTimeout(f,0,a):(t=a,setTimeout(w,0));};g=function(a,b){u=setTimeout(a,b);};h=function(){clearTimeout(u);};exports.unstable_shouldYield=function(){return!1;};k=exports.unstable_forceFrameRate=function(){};}else{varx=window.setTimeout,y=window.clearTimeout;if("undefined"!==typeofconsole){varz=window.cancelAnimationFrame;"function"!==typeofwindow.requestAnimationFrame&&console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");"function"!==typeofz&&console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");}varA=!1,B=null,C=-1,D=5,E=0;exports.unstable_shouldYield=function(){returnexports.unstable_now()>=E;};k=function(){};exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):D=0<a?Math.floor(1E3/a):5;};varF=newMessageChannel(),G=F.port2;F.port1.onmessage=function(){if(null!==B){vara=exports.unstable_now();E=a+D;try{B(!0,a)?G.postMessage(null):(A=!1,B=null);}catch(b){throwG.postMessage(null),b;}}elseA=!1;};f=function(a){B=a;A||(A=!0,G.postMessage(null));};g=function(a,b){C=x(function(){a(exports.unstable_now());},b);};h=function(){y(C);C=-1;};}functionH(a,b){varc=a.length;a.push(b);a:for(;;){vard=c-1>>>1,e=a[d];if(void0!==e&&0<I(e,b))a[d]=b,a[c]=e,c=d;elsebreaka;}}functionJ(a){a=a[0];returnvoid0===a?null:a;}functionK(a){varb=a[0];if(void0!==b){varc=a.pop();if(c!==b){a[0]=c;a:for(vard=0,e=a.length;d<e;){varm=2*(d+1)-1,n=a[m],v=m+1,r=a[v];if(void0!==n&&0>I(n,c))void0!==r&&0>I(r,n)?(a[d]=r,a[v]=c,d=v):(a[d]=n,a[m]=c,d=m);elseif(void0!==r&&0>I(r,c))a[d]=r,a[v]=c,d=v;elsebreaka;}}returnb;}returnnull;}functionI(a,b){varc=a.sortIndex-b.sortIndex;return0!==c?c:a.id-b.id;}varL=[],M=[],N=1,O=null,P=3,Q=!1,R=!1,S=!1;functionT(a){for(varb=J(M);null!==b;){if(null===b.callback)K(M);elseif(b.startTime<=a)K(M),b.sortIndex=b.expirationTime,H(L,b);elsebreak;b=J(M);}}functionU(a){S=!1;T(a);if(!R)if(null!==J(L))R=!0,f(V);else{varb=J(M);null!==b&&g(U,b.startTime-a);}}functionV(a,b){R=!1;S&&(S=!1,h());Q=!0;varc=P;try{T(b);for(O=J(L);null!==O&&(!(O.expirationTime>b)||a&&!exports.unstable_shouldYield());){vard=O.callback;if("function"===typeofd){O.callback=null;P=O.priorityLevel;vare=d(O.expirationTime<=b);b=exports.unstable_now();"function"===typeofe?O.callback=e:O===J(L)&&K(L);T(b);}elseK(L);O=J(L);}if(null!==O)varm=!0;else{varn=J(M);null!==n&&g(U,n.startTime-b);m=!1;}returnm;}finally{O=null,P=c,Q=!1;}}varW=k;exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null;};exports.unstable_continueExecution=function(){R||Q||(R=!0,f(V));};exports.unstable_getCurrentPriorityLevel=function(){returnP;};exports.unstable_getFirstCallbackNode=function(){returnJ(L);};exports.unstable_next=function(a){switch(P){case1:case2:case3:varb=3;break;default:b=P;}varc=P;P=b;try{returna();}finally{P=c;}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=W;exports.unstable_runWithPriority=function(a,b){switch(a){case1:case2:case3:case4:case5:break;default:a=3;}varc=P;P=a;try{returnb();}finally{P=c;}};exports.unstable_scheduleCallback=function(a,b,c){vard=exports.unstable_now();"object"===typ
{(function(){varenableSchedulerDebugging=false;varenableProfiling=false;varrequestHostCallback;varrequestHostTimeout;varcancelHostTimeout;varrequestPaint;varhasPerformanceNow=typeofperformance==='object'&&typeofperformance.now==='function';if(hasPerformanceNow){varlocalPerformance=performance;exports.unstable_now=function(){returnlocalPerformance.now();};}else{varlocalDate=Date;varinitialTime=localDate.now();exports.unstable_now=function(){returnlocalDate.now()-initialTime;};}if(// If Scheduler runs in a non-DOM environment, it falls back to a naive
// implementation using setTimeout.
typeofwindow==='undefined'||// Check if MessageChannel is supported, too.
typeofMessageChannel!=='function'){// If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
// fallback to a naive implementation.
var_callback=null;var_timeoutID=null;var_flushCallback=function(){if(_callback!==null){try{varcurrentTime=exports.unstable_now();varhasRemainingTime=true;_callback(hasRemainingTime,currentTime);_callback=null;}catch(e){setTimeout(_flushCallback,0);throwe;}}};requestHostCallback=function(cb){if(_callback!==null){// Protect against re-entrancy.
setTimeout(requestHostCallback,0,cb);}else{_callback=cb;setTimeout(_flushCallback,0);}};requestHostTimeout=function(cb,ms){_timeoutID=setTimeout(cb,ms);};cancelHostTimeout=function(){clearTimeout(_timeoutID);};exports.unstable_shouldYield=function(){returnfalse;};requestPaint=exports.unstable_forceFrameRate=function(){};}else{// Capture local references to native APIs, in case a polyfill overrides them.
var_setTimeout=window.setTimeout;var_clearTimeout=window.clearTimeout;if(typeofconsole!=='undefined'){// TODO: Scheduler no longer requires these methods to be polyfilled. But
// maybe we want to continue warning if they don't exist, to preserve the
// option to rely on it in the future?
varrequestAnimationFrame=window.requestAnimationFrame;varcancelAnimationFrame=window.cancelAnimationFrame;if(typeofrequestAnimationFrame!=='function'){// Using console['error'] to evade Babel and ESLint
console['error']("This browser doesn't support requestAnimationFrame. "+'Make sure that you load a '+'polyfill in older browsers. https://reactjs.org/link/react-polyfills');}if(typeofcancelAnimationFrame!=='function'){// Using console['error'] to evade Babel and ESLint
console['error']("This browser doesn't support cancelAnimationFrame. "+'Make sure that you load a '+'polyfill in older browsers. https://reactjs.org/link/react-polyfills');}}varisMessageLoopRunning=false;varscheduledHostCallback=null;vartaskTimeoutID=-1;// Scheduler periodically yields in case there is other work on the main
// thread, like user events. By default, it yields multiple times per frame.
// It does not attempt to align with frame boundaries, since most tasks don't
// need to be frame aligned; for those that do, use requestAnimationFrame.
varyieldInterval=5;vardeadline=0;// TODO: Make this configurable
{// `isInputPending` is not available. Since we have no way of knowing if
// there's pending input, always yield at the end of the frame.
exports.unstable_shouldYield=function(){returnexports.unstable_now()>=deadline;};// Since we yield every frame regardless, `requestPaint` has no effect.
requestPaint=function(){};}exports.unstable_forceFrameRate=function(fps){if(fps<0||fps>125){// Using console['error'] to evade Babel and ESLint
console['error']('forceFrameRate takes a positive int between 0 and 125, '+'forcing frame rates higher than 125 fps is not supported');return;}if(fps>0){yieldInterval=Math.floor(1000/fps);}else{// reset the framerate
yieldInterval=5;}};varperformWorkUntilDeadline=function(){if(scheduledHostCallback!==null){varcurrentTime=exports.unstable_now();// Yield after `yieldInterval` ms, regardless of where we are in the vsync
// cycle. This means there's always time remaining at the beginning of
// the message event.
deadline=currentTime+yieldInterval;varhasTimeRemaining=true;try{varhasMoreWork=scheduledHostCallback(hasTimeRemaining,currentTime);if(!hasMoreWork){isMessageLoopRunning=false;scheduledHostCallback=null;}else{// If there's more work, schedule the next message event at the end
// of the preceding one.
port.postMessage(null);}}catch(error){// If a scheduler task throws, exit the current browser task so the
// error can be observed.
port.postMessage(null);throwerror;}}else{isMessageLoopRunning=false;}// Yielding to the browser will give it a chance to paint, so we can
};varchannel=newMessageChannel();varport=channel.port2;channel.port1.onmessage=performWorkUntilDeadline;requestHostCallback=function(callback){scheduledHostCallback=callback;if(!isMessageLoopRunning){isMessageLoopRunning=true;port.postMessage(null);}};requestHostTimeout=function(callback,ms){taskTimeoutID=_setTimeout(function(){callback(exports.unstable_now());},ms);};cancelHostTimeout=function(){_clearTimeout(taskTimeoutID);taskTimeoutID=-1;};}functionpush(heap,node){varindex=heap.length;heap.push(node);siftUp(heap,node,index);}functionpeek(heap){varfirst=heap[0];returnfirst===undefined?null:first;}functionpop(heap){varfirst=heap[0];if(first!==undefined){varlast=heap.pop();if(last!==first){heap[0]=last;siftDown(heap,last,0);}returnfirst;}else{returnnull;}}functionsiftUp(heap,node,i){varindex=i;while(true){varparentIndex=index-1>>>1;varparent=heap[parentIndex];if(parent!==undefined&&compare(parent,node)>0){// The parent is larger. Swap positions.
heap[parentIndex]=node;heap[index]=parent;index=parentIndex;}else{// The parent is smaller. Exit.
return;}}}functionsiftDown(heap,node,i){varindex=i;varlength=heap.length;while(index<length){varleftIndex=(index+1)*2-1;varleft=heap[leftIndex];varrightIndex=leftIndex+1;varright=heap[rightIndex];// If the left or right node is smaller, swap with the smaller of those.
if(left!==undefined&&compare(left,node)<0){if(right!==undefined&&compare(right,left)<0){heap[index]=right;heap[rightIndex]=node;index=rightIndex;}else{heap[index]=left;heap[leftIndex]=node;index=leftIndex;}}elseif(right!==undefined&&compare(right,node)<0){heap[index]=right;heap[rightIndex]=node;index=rightIndex;}else{// Neither child is smaller. Exit.
return;}}}functioncompare(a,b){// Compare sort index first, then task id.
vardiff=a.sortIndex-b.sortIndex;returndiff!==0?diff:a.id-b.id;}// TODO: Use symbols?
varmaxSigned31BitInt=1073741823;// Times out immediately
varIMMEDIATE_PRIORITY_TIMEOUT=-1;// Eventually times out
varUSER_BLOCKING_PRIORITY_TIMEOUT=250;varNORMAL_PRIORITY_TIMEOUT=5000;varLOW_PRIORITY_TIMEOUT=10000;// Never times out
varIDLE_PRIORITY_TIMEOUT=maxSigned31BitInt;// Tasks are stored on a min heap
vartaskQueue=[];vartimerQueue=[];// Incrementing id counter. Used to maintain insertion order.
vartaskIdCounter=1;// Pausing the scheduler is useful for debugging.
varcurrentTask=null;varcurrentPriorityLevel=NormalPriority;// This is set while performing work, to prevent re-entrancy.
varisPerformingWork=false;varisHostCallbackScheduled=false;varisHostTimeoutScheduled=false;functionadvanceTimers(currentTime){// Check for tasks that are no longer delayed and add them to the queue.
vartimer=peek(timerQueue);while(timer!==null){if(timer.callback===null){// Timer was cancelled.
pop(timerQueue);}elseif(timer.startTime<=currentTime){// Timer fired. Transfer to the task queue.
pop(timerQueue);timer.sortIndex=timer.expirationTime;push(taskQueue,timer);}else{// Remaining timers are pending.
return;}timer=peek(timerQueue);}}functionhandleTimeout(currentTime){isHostTimeoutScheduled=false;advanceTimers(currentTime);if(!isHostCallbackScheduled){if(peek(taskQueue)!==null){isHostCallbackScheduled=true;requestHostCallback(flushWork);}else{varfirstTimer=peek(timerQueue);if(firstTimer!==null){requestHostTimeout(handleTimeout,firstTimer.startTime-currentTime);}}}}functionflushWork(hasTimeRemaining,initialTime){isHostCallbackScheduled=false;if(isHostTimeoutScheduled){// We scheduled a timeout but it's no longer needed. Cancel it.
isHostTimeoutScheduled=false;cancelHostTimeout();}isPerformingWork=true;varpreviousPriorityLevel=currentPriorityLevel;try{varcurrentTime;if(enableProfiling);else{// No catch in prod code path.
returnworkLoop(hasTimeRemaining,initialTime);}}finally{currentTask=null;currentPriorityLevel=previousPriorityLevel;isPerformingWork=false;}}functionworkLoop(hasTimeRemaining,initialTime){varcurrentTime=initialTime;advanceTimers(currentTime);currentTask=peek(taskQueue);while(currentTask!==null&&!enableSchedulerDebugging){if(currentTask.expirationTime>currentTime&&(!hasTimeRemaining||exports.unstable_shouldYield())){// This currentTask hasn't expired, and we've reached the deadline.
break;}varcallback=currentTask.callback;if(typeofcallback==='function'){currentTask.callback=null;currentPriorityLevel=currentTask.priorityLevel;vardidUserCallbackTimeout=currentTask.expirationTime<=currentTime;varcontinuationCallback=callback(didUserCallbackTimeout);currentTime=exports.unstable_now();if(typeofcontinuationCallback==='function'){currentTask.callback=continuationCallback;}else{if(currentTask===peek(taskQueue)){pop(taskQueue);}}advanceTimers(currentTime);}else{pop(taskQueue);}currentTask=peek(taskQueue);}// Return whether there's additional work
if(currentTask!==null){returntrue;}else{varfirstTimer=peek(timerQueue);if(firstTimer!==null){requestHostTimeout(handleTimeout,firstTimer.startTime-currentTime);}returnfalse;}}functionunstable_runWithPriority(priorityLevel,eventHandler){switch(priorityLevel){caseImmediatePriority:caseUserBlockingPriority:caseNormalPriority:caseLowPriority:caseIdlePriority:break;default:priorityLevel=NormalPriority;}varpreviousPriorityLevel=currentPriorityLevel;currentPriorityLevel=priorityLevel;try{returneventHandler();}finally{currentPriorityLevel=previousPriorityLevel;}}functionunstable_next(eventHandler){varpriorityLevel;switch(currentPriorityLevel){caseImmediatePriority:caseUserBlockingPriority:caseNormalPriority:// Shift down to normal priority
priorityLevel=NormalPriority;break;default:// Anything lower than normal priority should remain at the current level.
priorityLevel=currentPriorityLevel;break;}varpreviousPriorityLevel=currentPriorityLevel;currentPriorityLevel=priorityLevel;try{returneventHandler();}finally{currentPriorityLevel=previousPriorityLevel;}}functionunstable_wrapCallback(callback){varparentPriorityLevel=currentPriorityLevel;returnfunction(){// This is a fork of runWithPriority, inlined for performance.
varpreviousPriorityLevel=currentPriorityLevel;currentPriorityLevel=parentPriorityLevel;try{returncallback.apply(this,arguments);}finally{currentPriorityLevel=previousPriorityLevel;}};}functionunstable_scheduleCallback(priorityLevel,callback,options){varcurrentTime=exports.unstable_now();varstartTime;if(typeofoptions==='object'&&options!==null){vardelay=options.delay;if(typeofdelay==='number'&&delay>0){startTime=currentTime+delay;}else{startTime=currentTime;}}else{startTime=currentTime;}vartimeout;switch(priorityLevel){caseImmediatePriority:timeout=IMMEDIATE_PRIORITY_TIMEOUT;break;caseUserBlockingPriority:timeout=USER_BLOCKING_PRIORITY_TIMEOUT;break;caseIdlePriority:timeout=IDLE_PRIORITY_TIMEOUT;break;caseLowPriority:timeout=LOW_PRIORITY_TIMEOUT;break;caseNormalPriority:default:timeout=NORMAL_PRIORITY_TIMEOUT;break;}varexpirationTime=startTime+timeout;varnewTask={id:taskIdCounter++,callback:callback,priorityLevel:priorityLevel,startTime:startTime,expirationTime:expirationTime,sortIndex:-1};if(startTime>currentTime){// This is a delayed task.
newTask.sortIndex=startTime;push(timerQueue,newTask);if(peek(taskQueue)===null&&newTask===peek(timerQueue)){// All tasks are delayed, and this is the task with the earliest delay.
if(isHostTimeoutScheduled){// Cancel an existing timeout.
cancelHostTimeout();}else{isHostTimeoutScheduled=true;}// Schedule a timeout.
requestHostTimeout(handleTimeout,startTime-currentTime);}}else{newTask.sortIndex=expirationTime;push(taskQueue,newTask);// wait until the next time we yield.
if(!isHostCallbackScheduled&&!isPerformingWork){isHostCallbackScheduled=true;requestHostCallback(flushWork);}}returnnewTask;}functionunstable_pauseExecution(){}functionunstable_continueExecution(){if(!isHostCallbackScheduled&&!isPerformingWork){isHostCallbackScheduled=true;requestHostCallback(flushWork);}}functionunstable_getFirstCallbackNode(){returnpeek(taskQueue);}functionunstable_cancelCallback(task){// remove from the queue because you can't remove arbitrary nodes from an
{(function(){varDEFAULT_THREAD_ID=0;// Counters used to generate unique IDs.
varinteractionIDCounter=0;varthreadIDCounter=0;// Set of currently traced interactions.
// Interactions "stack"–
// Meaning that newly traced interactions are appended to the previously active set.
// When an interaction goes out of scope, the previous set (if any) is restored.
exports.__interactionsRef=null;// Listener(s) to notify when interactions begin and end.
exports.__subscriberRef=null;{exports.__interactionsRef={current:newSet()};exports.__subscriberRef={current:null};}functionunstable_clear(callback){varprevInteractions=exports.__interactionsRef.current;exports.__interactionsRef.current=newSet();try{returncallback();}finally{exports.__interactionsRef.current=prevInteractions;}}functionunstable_getCurrent(){{returnexports.__interactionsRef.current;}}functionunstable_getThreadID(){return++threadIDCounter;}functionunstable_trace(name,timestamp,callback){varthreadID=arguments.length>3&&arguments[3]!==undefined?arguments[3]:DEFAULT_THREAD_ID;varinteraction={__count:1,id:interactionIDCounter++,name:name,timestamp:timestamp};varprevInteractions=exports.__interactionsRef.current;// Traced interactions should stack/accumulate.
// To do that, clone the current interactions.
// The previous set will be restored upon completion.
varinteractions=newSet(prevInteractions);interactions.add(interaction);exports.__interactionsRef.current=interactions;varsubscriber=exports.__subscriberRef.current;varreturnValue;try{if(subscriber!==null){subscriber.onInteractionTraced(interaction);}}finally{try{if(subscriber!==null){subscriber.onWorkStarted(interactions,threadID);}}finally{try{returnValue=callback();}finally{exports.__interactionsRef.current=prevInteractions;try{if(subscriber!==null){subscriber.onWorkStopped(interactions,threadID);}}finally{interaction.__count--;// If no async work was scheduled for this interaction,
// Notify subscribers that it's completed.
if(subscriber!==null&&interaction.__count===0){subscriber.onInteractionScheduledWorkCompleted(interaction);}}}}}returnreturnValue;}functionunstable_wrap(callback){varthreadID=arguments.length>1&&arguments[1]!==undefined?arguments[1]:DEFAULT_THREAD_ID;varwrappedInteractions=exports.__interactionsRef.current;varsubscriber=exports.__subscriberRef.current;if(subscriber!==null){subscriber.onWorkScheduled(wrappedInteractions,threadID);}// Update the pending async work count for the current interactions.
// Update after calling subscribers in case of error.
wrappedInteractions.forEach(function(interaction){interaction.__count++;});varhasRun=false;functionwrapped(){varprevInteractions=exports.__interactionsRef.current;exports.__interactionsRef.current=wrappedInteractions;subscriber=exports.__subscriberRef.current;try{varreturnValue;try{if(subscriber!==null){subscriber.onWorkStarted(wrappedInteractions,threadID);}}finally{try{returnValue=callback.apply(undefined,arguments);}finally{exports.__interactionsRef.current=prevInteractions;if(subscriber!==null){subscriber.onWorkStopped(wrappedInteractions,threadID);}}}returnreturnValue;}finally{if(!hasRun){// We only expect a wrapped function to be executed once,
// But in the event that it's executed more than once–
// Only decrement the outstanding interaction counts once.
hasRun=true;// Update pending async counts for all wrapped interactions.
// If this was the last scheduled async work for any of them,
// Mark them as completed.
wrappedInteractions.forEach(function(interaction){interaction.__count--;if(subscriber!==null&&interaction.__count===0){subscriber.onInteractionScheduledWorkCompleted(interaction);}});}}}wrapped.cancel=functioncancel(){subscriber=exports.__subscriberRef.current;try{if(subscriber!==null){subscriber.onWorkCanceled(wrappedInteractions,threadID);}}finally{// Update pending async counts for all wrapped interactions.
// If this was the last scheduled async work for any of them,
{(function(){varReact=react;var_assign=objectAssign;varScheduler=scheduler;vartracing$1=tracing;varReactSharedInternals=React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;// by calls to these methods by a Babel plugin.
//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.
functionwarn(format){{for(var_len=arguments.length,args=newArray(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key];}printWarning('warn',format,args);}}functionerror(format){{for(var_len2=arguments.length,args=newArray(_len2>1?_len2-1:0),_key2=1;_key2<_len2;_key2++){args[_key2-1]=arguments[_key2];}printWarning('error',format,args);}}functionprintWarning(level,format,args){// When changing this logic, you might want to also
// update consoleWithStackDev.www.js as well.
{varReactDebugCurrentFrame=ReactSharedInternals.ReactDebugCurrentFrame;varstack=ReactDebugCurrentFrame.getStackAddendum();if(stack!==''){format+='%s';args=args.concat([stack]);}varargsWithFormat=args.map(function(item){return''+item;});// Careful: RN currently depends on this prefix
argsWithFormat.unshift('Warning: '+format);// We intentionally don't use spread (or .apply) directly because it
Function.prototype.apply.call(console[level],console,argsWithFormat);}}if(!React){{throwError("ReactDOM was loaded before React. Make sure you load the React package before loading ReactDOM.");}}varFunctionComponent=0;varClassComponent=1;varIndeterminateComponent=2;// Before we know whether it is function or class
varHostRoot=3;// Root of a host tree. Could be nested inside another node.
varHostPortal=4;// A subtree. Could be an entry point to a different renderer.
varHostComponent=5;varHostText=6;varFragment=7;varMode=8;varContextConsumer=9;varContextProvider=10;varForwardRef=11;varProfiler=12;varSuspenseComponent=13;varMemoComponent=14;varSimpleMemoComponent=15;varLazyComponent=16;varIncompleteClassComponent=17;varDehydratedFragment=18;varSuspenseListComponent=19;varFundamentalComponent=20;varScopeComponent=21;varBlock=22;varOffscreenComponent=23;varLegacyHiddenComponent=24;// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
varenableProfilerTimer=true;// Record durations for commit and passive effects phases.
functionregisterTwoPhaseEvent(registrationName,dependencies){registerDirectEvent(registrationName,dependencies);registerDirectEvent(registrationName+'Capture',dependencies);}functionregisterDirectEvent(registrationName,dependencies){{if(registrationNameDependencies[registrationName]){error('EventRegistry: More than one plugin attempted to publish the same '+'registration name, `%s`.',registrationName);}}registrationNameDependencies[registrationName]=dependencies;{varlowerCasedName=registrationName.toLowerCase();possibleRegistrationNames[lowerCasedName]=registrationName;if(registrationName==='onDoubleClick'){possibleRegistrationNames.ondblclick=registrationName;}}for(vari=0;i<dependencies.length;i++){allNativeEvents.add(dependencies[i]);}}varcanUseDOM=!!(typeofwindow!=='undefined'&&typeofwindow.document!=='undefined'&&typeofwindow.document.createElement!=='undefined');// A reserved attribute.
// It is handled by React separately and shouldn't be written to the DOM.
varRESERVED=0;// A simple string attribute.
// Attributes that aren't in the filter are presumed to have this type.
varSTRING=1;// A string attribute that accepts booleans in React. In HTML, these are called
// "enumerated" attributes with "true" and "false" as possible values.
// When true, it should be set to a "true" string.
// When false, it should be set to a "false" string.
varBOOLEANISH_STRING=2;// A real boolean attribute.
// When true, it should be present (set either to an empty string or its name).
// When false, it should be omitted.
varBOOLEAN=3;// An attribute that can be used as a flag as well as with a value.
// When true, it should be present (set either to an empty string or its name).
// When false, it should be omitted.
// For any other value, should be present with that value.
varOVERLOADED_BOOLEAN=4;// An attribute that must be numeric or parse as a numeric.
// When falsy, it should be removed.
varNUMERIC=5;// An attribute that must be positive numeric or parse as a positive numeric.
// When falsy, it should be removed.
varPOSITIVE_NUMERIC=6;/* eslint-disable max-len */varATTRIBUTE_NAME_START_CHAR=":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";/* eslint-enable max-len */varATTRIBUTE_NAME_CHAR=ATTRIBUTE_NAME_START_CHAR+"\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";varROOT_ATTRIBUTE_NAME='data-reactroot';varVALID_ATTRIBUTE_NAME_REGEX=newRegExp('^['+ATTRIBUTE_NAME_START_CHAR+']['+ATTRIBUTE_NAME_CHAR+']*$');varhasOwnProperty=Object.prototype.hasOwnProperty;varillegalAttributeNameCache={};varvalidatedAttributeNameCache={};functionisAttributeNameSafe(attributeName){if(hasOwnProperty.call(validatedAttributeNameCache,attributeName)){returntrue;}if(hasOwnProperty.call(illegalAttributeNameCache,attributeName)){returnfalse;}if(VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)){validatedAttributeNameCache[attributeName]=true;returntrue;}illegalAttributeNameCache[attributeName]=true;{error('Invalid attribute name: `%s`',attributeName);}returnfalse;}functionshouldIgnoreAttribute(name,propertyInfo,isCustomComponentTag){if(propertyInfo!==null){returnpropertyInfo.type===RESERVED;}if(isCustomComponentTag){returnfalse;}if(name.length>2&&(name[0]==='o'||name[0]==='O')&&(name[1]==='n'||name[1]==='N')){returntrue;}returnfalse;}functionshouldRemoveAttributeWithWarning(name,value,propertyInfo,isCustomComponentTag){if(propertyInfo!==null&&propertyInfo.type===RESERVED){returnfalse;}switch(typeofvalue){case'function':// $FlowIssue symbol is perfectly valid here
case'symbol':// eslint-disable-line
returntrue;case'boolean':{if(isCustomComponentTag){returnfalse;}if(propertyInfo!==null){return!propertyInfo.acceptsBooleans;}else{varprefix=name.toLowerCase().slice(0,5);returnprefix!=='data-'&&prefix!=='aria-';}}default:returnfalse;}}functionshouldRemoveAttribute(name,value,propertyInfo,isCustomComponentTag){if(value===null||typeofvalue==='undefined'){returntrue;}if(shouldRemoveAttributeWithWarning(name,value,propertyInfo,isCustomComponentTag)){returntrue;}if(isCustomComponentTag){returnfalse;}if(propertyInfo!==null){switch(propertyInfo.type){caseBOOLEAN:return!value;caseOVERLOADED_BOOLEAN:returnvalue===false;caseNUMERIC:returnisNaN(value);casePOSITIVE_NUMERIC:returnisNaN(value)||value<1;}}returnfalse;}functiongetPropertyInfo(name){returnproperties.hasOwnProperty(name)?properties[name]:null;}functionPropertyInfoRecord(name,type,mustUseProperty,attributeName,attributeNamespace,sanitizeURL,removeEmptyString){this.acceptsBooleans=type===BOOLEANISH_STRING||type===BOOLEAN||type===OVERLOADED_BOOLEAN;this.attributeName=attributeName;this.attributeNamespace=attributeNamespace;this.mustUseProperty=mustUseProperty;this.propertyName=name;this.type=type;this.sanitizeURL=sanitizeURL;this.removeEmptyString=removeEmptyString;}// When adding attributes to this list, be sure to also add them to
// the `possibleStandardNames` module to ensure casing and incorrect
// name warnings.
varproperties={};// These props are reserved by React. They shouldn't be written to the DOM.
varreservedProps=['children','dangerouslySetInnerHTML',// TODO: This prevents the assignment of defaultValue to regular
// elements (not just inputs). Now that ReactDOMInput assigns to the
false);});varCAMELIZE=/[\-\:]([a-z])/g;varcapitalize=function(token){returntoken[1].toUpperCase();};// This is a list of all SVG attributes that need special casing, namespacing,
// or boolean value assignment. Regular attributes that just accept strings
// and have the same names are omitted, just like in the HTML attribute filter.
// Some of these attributes can be hard to find. This list was created by
// scraping the MDN documentation.
['accent-height','alignment-baseline','arabic-form','baseline-shift','cap-height','clip-path','clip-rule','color-interpolation','color-interpolation-filters','color-profile','color-rendering','dominant-baseline','enable-background','fill-opacity','fill-rule','flood-color','flood-opacity','font-family','font-size','font-size-adjust','font-stretch','font-style','font-variant','font-weight','glyph-name','glyph-orientation-horizontal','glyph-orientation-vertical','horiz-adv-x','horiz-origin-x','image-rendering','letter-spacing','lighting-color','marker-end','marker-mid','marker-start','overline-position','overline-thickness','paint-order','panose-1','pointer-events','rendering-intent','shape-rendering','stop-color','stop-opacity','strikethrough-position','strikethrough-thickness','stroke-dasharray','stroke-dashoffset','stroke-linecap','stroke-linejoin','stroke-miterlimit','stroke-opacity','stroke-width','text-anchor','text-decoration','text-rendering','underline-position','underline-thickness','unicode-bidi','unicode-range','units-per-em','v-alphabetic','v-hanging','v-ideographic','v-mathematical','vector-effect','vert-adv-y','vert-origin-x','vert-origin-y','word-spacing','writing-mode','xmlns:xlink','x-height'// NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
/* eslint-disable max-len */varisJavaScriptProtocol=/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i;vardidWarn=false;functionsanitizeURL(url){{if(!didWarn&&isJavaScriptProtocol.test(url)){didWarn=true;error('A future version of React will block javascript: URLs as a security precaution. '+'Use event handlers instead if you can. If you need to generate unsafe HTML try '+'using dangerouslySetInnerHTML instead. React was passed %s.',JSON.stringify(url));}}}/**
// the hydration is successful of a javascript: URL, we
// still want to warn on the client.
sanitizeURL(''+expected);}varattributeName=propertyInfo.attributeName;varstringValue=null;if(propertyInfo.type===OVERLOADED_BOOLEAN){if(node.hasAttribute(attributeName)){varvalue=node.getAttribute(attributeName);if(value===''){returntrue;}if(shouldRemoveAttribute(name,expected,propertyInfo,false)){returnvalue;}if(value===''+expected){returnexpected;}returnvalue;}}elseif(node.hasAttribute(attributeName)){if(shouldRemoveAttribute(name,expected,propertyInfo,false)){// We had an attribute but shouldn't have had one, so read it
// for the error message.
returnnode.getAttribute(attributeName);}if(propertyInfo.type===BOOLEAN){// If this was a boolean, it doesn't matter what the value is
// the fact that we have it is the same as the expected.
returnexpected;}// Even if this property uses a namespace we use getAttribute
// because we assume its namespaced name is the same as our config.
// To use getAttributeNS we need the local name which we don't have
if(isCustomComponentTag||propertyInfo===null){if(isAttributeNameSafe(name)){var_attributeName=name;if(value===null){node.removeAttribute(_attributeName);}else{node.setAttribute(_attributeName,''+value);}}return;}varmustUseProperty=propertyInfo.mustUseProperty;if(mustUseProperty){varpropertyName=propertyInfo.propertyName;if(value===null){vartype=propertyInfo.type;node[propertyName]=type===BOOLEAN?false:'';}else{// Contrary to `setAttribute`, object properties are properly
// `toString`ed by IE8/9.
node[propertyName]=value;}return;}// The rest are treated as attributes with special cases.
varattributeName=propertyInfo.attributeName,attributeNamespace=propertyInfo.attributeNamespace;if(value===null){node.removeAttribute(attributeName);}else{var_type=propertyInfo.type;varattributeValue;if(_type===BOOLEAN||_type===OVERLOADED_BOOLEAN&&value===true){// If attribute type is boolean, we know for sure it won't be an execution sink
// and we won't require Trusted Type here.
attributeValue='';}else{// `setAttribute` with objects becomes only `[object]` in IE8/9,
// ('' + value) makes it output the correct toString()-value.
// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
varREACT_ELEMENT_TYPE=0xeac7;varREACT_PORTAL_TYPE=0xeaca;varREACT_FRAGMENT_TYPE=0xeacb;varREACT_STRICT_MODE_TYPE=0xeacc;varREACT_PROFILER_TYPE=0xead2;varREACT_PROVIDER_TYPE=0xeacd;varREACT_CONTEXT_TYPE=0xeace;varREACT_FORWARD_REF_TYPE=0xead0;varREACT_SUSPENSE_TYPE=0xead1;varREACT_SUSPENSE_LIST_TYPE=0xead8;varREACT_MEMO_TYPE=0xead3;varREACT_LAZY_TYPE=0xead4;varREACT_BLOCK_TYPE=0xead9;varREACT_SERVER_BLOCK_TYPE=0xeada;varREACT_FUNDAMENTAL_TYPE=0xead5;varREACT_SCOPE_TYPE=0xead7;varREACT_OPAQUE_ID_TYPE=0xeae0;varREACT_DEBUG_TRACING_MODE_TYPE=0xeae1;varREACT_OFFSCREEN_TYPE=0xeae2;varREACT_LEGACY_HIDDEN_TYPE=0xeae3;if(typeofSymbol==='function'&&Symbol.for){varsymbolFor=Symbol.for;REACT_ELEMENT_TYPE=symbolFor('react.element');REACT_PORTAL_TYPE=symbolFor('react.portal');REACT_FRAGMENT_TYPE=symbolFor('react.fragment');REACT_STRICT_MODE_TYPE=symbolFor('react.strict_mode');REACT_PROFILER_TYPE=symbolFor('react.profiler');REACT_PROVIDER_TYPE=symbolFor('react.provider');REACT_CONTEXT_TYPE=symbolFor('react.context');REACT_FORWARD_REF_TYPE=symbolFor('react.forward_ref');REACT_SUSPENSE_TYPE=symbolFor('react.suspense');REACT_SUSPENSE_LIST_TYPE=symbolFor('react.suspense_list');REACT_MEMO_TYPE=symbolFor('react.memo');REACT_LAZY_TYPE=symbolFor('react.lazy');REACT_BLOCK_TYPE=symbolFor('react.block');REACT_SERVER_BLOCK_TYPE=symbolFor('react.server.block');REACT_FUNDAMENTAL_TYPE=symbolFor('react.fundamental');REACT_SCOPE_TYPE=symbolFor('react.scope');REACT_OPAQUE_ID_TYPE=symbolFor('react.opaque.id');REACT_DEBUG_TRACING_MODE_TYPE=symbolFor('react.debug_trace_mode');REACT_OFFSCREEN_TYPE=symbolFor('react.offscreen');REACT_LEGACY_HIDDEN_TYPE=symbolFor('react.legacy_hidden');}varMAYBE_ITERATOR_SYMBOL=typeofSymbol==='function'&&Symbol.iterator;varFAUX_ITERATOR_SYMBOL='@@iterator';functiongetIteratorFn(maybeIterable){if(maybeIterable===null||typeofmaybeIterable!=='object'){returnnull;}varmaybeIterator=MAYBE_ITERATOR_SYMBOL&&maybeIterable[MAYBE_ITERATOR_SYMBOL]||maybeIterable[FAUX_ITERATOR_SYMBOL];if(typeofmaybeIterator==='function'){returnmaybeIterator;}returnnull;}// Helpers to patch console.logs to avoid logging during side-effect free
// replaying on render function. This currently only patches the object
// lazily which won't cover if the log function was extracted eagerly.
Object.defineProperties(console,{log:_assign({},props,{value:prevLog}),info:_assign({},props,{value:prevInfo}),warn:_assign({},props,{value:prevWarn}),error:_assign({},props,{value:prevError}),group:_assign({},props,{value:prevGroup}),groupCollapsed:_assign({},props,{value:prevGroupCollapsed}),groupEnd:_assign({},props,{value:prevGroupEnd})});/* eslint-enable react-internal/no-production-logging */}if(disabledDepth<0){error('disabledDepth fell below zero. '+'This is a bug in React. Please file an issue.');}}}varReactCurrentDispatcher=ReactSharedInternals.ReactCurrentDispatcher;varprefix;functiondescribeBuiltInComponentFrame(name,source,ownerFn){{if(prefix===undefined){// Extract the VM specific prefix used by each line.
try{throwError();}catch(x){varmatch=x.stack.trim().match(/\n( *(at )?)/);prefix=match&&match[1]||'';}}// We use the prefix to ensure our stacks line up with native stack frames.
return'\n'+prefix+name;}}varreentry=false;varcomponentFrameCache;{varPossiblyWeakMap=typeofWeakMap==='function'?WeakMap:Map;componentFrameCache=newPossiblyWeakMap();}functiondescribeNativeComponentFrame(fn,construct){// If something asked for a stack inside a fake render, it should get ignored.
if(!fn||reentry){return'';}{varframe=componentFrameCache.get(fn);if(frame!==undefined){returnframe;}}varcontrol;reentry=true;varpreviousPrepareStackTrace=Error.prepareStackTrace;// $FlowFixMe It does accept undefined.
Error.prepareStackTrace=undefined;varpreviousDispatcher;{previousDispatcher=ReactCurrentDispatcher.current;// Set the dispatcher in DEV because this might be call in the render function
// for warnings.
ReactCurrentDispatcher.current=null;disableLogs();}try{// This should throw.
if(construct){// Something should be setting the props in the constructor.
varFake=function(){throwError();};// $FlowFixMe
Object.defineProperty(Fake.prototype,'props',{set:function(){// We use a throwing setter instead of frozen or non-writable props
// because that won't throw in a non-strict mode function.
throwError();}});if(typeofReflect==='object'&&Reflect.construct){// We construct a different control for this case to include any extra
// frames added by the construct call.
try{Reflect.construct(Fake,[]);}catch(x){control=x;}Reflect.construct(fn,[],Fake);}else{try{Fake.call();}catch(x){control=x;}fn.call(Fake.prototype);}}else{try{throwError();}catch(x){control=x;}fn();}}catch(sample){// This is inlined manually because closure doesn't do it for us.
if(sample&&control&&typeofsample.stack==='string'){// This extracts the first frame from the sample that isn't also in the control.
// Skipping one frame that we assume is the frame that calls the two.
varsampleLines=sample.stack.split('\n');varcontrolLines=control.stack.split('\n');vars=sampleLines.length-1;varc=controlLines.length-1;while(s>=1&&c>=0&&sampleLines[s]!==controlLines[c]){// We expect at least one stack frame to be shared.
// Typically this will be the root most one. However, stack frames may be
// cut off due to maximum stack limits. In this case, one maybe cut off
// earlier than the other. We assume that the sample is longer or the same
// and there for cut off earlier. So we should find the root most frame in
// the sample somewhere in the control.
c--;}for(;s>=1&&c>=0;s--,c--){// Next we find the first one that isn't the same which should be the
// frame that called our sample function and the control.
if(sampleLines[s]!==controlLines[c]){// In V8, the first line is describing the message but other VMs don't.
// If we're about to return the first line, and the control is also on the same
// line, that's a pretty good indicator that our sample threw at same line as
// the control. I.e. before we entered the sample frame. So we ignore this result.
// This can happen if you passed a class to function component, or non-function.
if(s!==1||c!==1){do{s--;c--;// We may still have similar intermediate frames from the construct call.
// The next one that isn't the same should be our match though.
if(c<0||sampleLines[s]!==controlLines[c]){// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
var_frame='\n'+sampleLines[s].replace(' at new ',' at ');{if(typeoffn==='function'){componentFrameCache.set(fn,_frame);}}// Return the line we found.
return_frame;}}while(s>=1&&c>=0);}break;}}}}finally{reentry=false;{ReactCurrentDispatcher.current=previousDispatcher;reenableLogs();}Error.prepareStackTrace=previousPrepareStackTrace;}// Fallback to just using the name if we couldn't make it throw.
varname=fn?fn.displayName||fn.name:'';varsyntheticFrame=name?describeBuiltInComponentFrame(name):'';{if(typeoffn==='function'){componentFrameCache.set(fn,syntheticFrame);}}returnsyntheticFrame;}functiondescribeClassComponentFrame(ctor,source,ownerFn){{returndescribeNativeComponentFrame(ctor,true);}}functiondescribeFunctionComponentFrame(fn,source,ownerFn){{returndescribeNativeComponentFrame(fn,false);}}functionshouldConstruct(Component){varprototype=Component.prototype;return!!(prototype&&prototype.isReactComponent);}functiondescribeUnknownElementTypeFrameInDEV(type,source,ownerFn){if(type==null){return'';}if(typeoftype==='function'){{returndescribeNativeComponentFrame(type,shouldConstruct(type));}}if(typeoftype==='string'){returndescribeBuiltInComponentFrame(type);}switch(type){caseREACT_SUSPENSE_TYPE:returndescribeBuiltInComponentFrame('Suspense');caseREACT_SUSPENSE_LIST_TYPE:returndescribeBuiltInComponentFrame('SuspenseList');}if(typeoftype==='object'){switch(type.$$typeof){caseREACT_FORWARD_REF_TYPE:returndescribeFunctionComponentFrame(type.render);caseREACT_MEMO_TYPE:// Memo may contain any component type so we recursively resolve it.
returndescribeUnknownElementTypeFrameInDEV(type.type,source,ownerFn);caseREACT_BLOCK_TYPE:returndescribeFunctionComponentFrame(type._render);caseREACT_LAZY_TYPE:{varlazyComponent=type;varpayload=lazyComponent._payload;varinit=lazyComponent._init;try{// Lazy may contain any component type so we recursively resolve it.
returndescribeUnknownElementTypeFrameInDEV(init(payload),source,ownerFn);}catch(x){}}}}return'';}functiondescribeFiber(fiber){varowner=fiber._debugOwner?fiber._debugOwner.type:null;varsource=fiber._debugSource;switch(fiber.tag){caseHostComponent:returndescribeBuiltInComponentFrame(fiber.type);caseLazyComponent:returndescribeBuiltInComponentFrame('Lazy');caseSuspenseComponent:returndescribeBuiltInComponentFrame('Suspense');caseSuspenseListComponent:returndescribeBuiltInComponentFrame('SuspenseList');caseFunctionComponent:caseIndeterminateComponent:caseSimpleMemoComponent:returndescribeFunctionComponentFrame(fiber.type);caseForwardRef:returndescribeFunctionComponentFrame(fiber.type.render);caseBlock:returndescribeFunctionComponentFrame(fiber.type._render);caseClassComponent:returndescribeClassComponentFrame(fiber.type);default:return'';}}functiongetStackByFiberInDevAndProd(workInProgress){try{varinfo='';varnode=workInProgress;do{info+=describeFiber(node);node=node.return;}while(node);returninfo;}catch(x){return'\nError generating stack: '+x.message+'\n'+x.stack;}}functiongetWrappedName(outerType,innerType,wrapperName){varfunctionName=innerType.displayName||innerType.name||'';returnouterType.displayName||(functionName!==''?wrapperName+"("+functionName+")":wrapperName);}functiongetContextName(type){returntype.displayName||'Context';}functiongetComponentName(type){if(type==null){// Host root, text node or just invalid type.
returnnull;}{if(typeoftype.tag==='number'){error('Received an unexpected object in getComponentName(). '+'This is likely a bug in React. Please file an issue.');}}if(typeoftype==='function'){returntype.displayName||type.name||null;}if(typeoftype==='string'){returntype;}switch(type){caseREACT_FRAGMENT_TYPE:return'Fragment';caseREACT_PORTAL_TYPE:return'Portal';caseREACT_PROFILER_TYPE:return'Profiler';caseREACT_STRICT_MODE_TYPE:return'StrictMode';caseREACT_SUSPENSE_TYPE:return'Suspense';caseREACT_SUSPENSE_LIST_TYPE:return'SuspenseList';}if(typeoftype==='object'){switch(type.$$typeof){caseREACT_CONTEXT_TYPE:varcontext=type;returngetContextName(context)+'.Consumer';caseREACT_PROVIDER_TYPE:varprovider=type;returngetContextName(provider._context)+'.Provider';caseREACT_FORWARD_REF_TYPE:returngetWrappedName(type,type.render,'ForwardRef');caseREACT_MEMO_TYPE:returngetComponentName(type.type);caseREACT_BLOCK_TYPE:returngetComponentName(type._render);caseREACT_LAZY_TYPE:{varlazyComponent=type;varpayload=lazyComponent._payload;varinit=lazyComponent._init;try{returngetComponentName(init(payload));}catch(x){returnnull;}}}}returnnull;}varReactDebugCurrentFrame=ReactSharedInternals.ReactDebugCurrentFrame;varcurrent=null;varisRendering=false;functiongetCurrentFiberOwnerNameInDevOrNull(){{if(current===null){returnnull;}varowner=current._debugOwner;if(owner!==null&&typeofowner!=='undefined'){returngetComponentName(owner.type);}}returnnull;}functiongetCurrentFiberStackInDev(){{if(current===null){return'';}// Safe because if current fiber exists, we are reconciling,
// and it is guaranteed to be the work-in-progress version.
returngetStackByFiberInDevAndProd(current);}}functionresetCurrentFiber(){{ReactDebugCurrentFrame.getCurrentStack=null;current=null;isRendering=false;}}functionsetCurrentFiber(fiber){{ReactDebugCurrentFrame.getCurrentStack=getCurrentFiberStackInDev;current=fiber;isRendering=false;}}functionsetIsRendering(rendering){{isRendering=rendering;}}functiongetIsRendering(){{returnisRendering;}}// Flow does not allow string concatenation of most non-string types. To work
// around this limitation, we use an opaque type that can only be obtained by
// passing the value through getToStringValue first.
functiontoString(value){return''+value;}functiongetToStringValue(value){switch(typeofvalue){case'boolean':case'number':case'object':case'string':case'undefined':returnvalue;default:// function, symbol are assigned as empty strings
return'';}}varhasReadOnlyValue={button:true,checkbox:true,image:true,hidden:true,radio:true,reset:true,submit:true};functioncheckControlledValueProps(tagName,props){{if(!(hasReadOnlyValue[props.type]||props.onChange||props.onInput||props.readOnly||props.disabled||props.value==null)){error('You provided a `value` prop to a form field without an '+'`onChange` handler. This will render a read-only field. If '+'the field should be mutable use `defaultValue`. Otherwise, '+'set either `onChange` or `readOnly`.');}if(!(props.onChange||props.readOnly||props.disabled||props.checked==null)){error('You provided a `checked` prop to a form field without an '+'`onChange` handler. This will render a read-only field. If '+'the field should be mutable use `defaultChecked`. Otherwise, '+'set either `onChange` or `readOnly`.');}}}functionisCheckable(elem){vartype=elem.type;varnodeName=elem.nodeName;returnnodeName&&nodeName.toLowerCase()==='input'&&(type==='checkbox'||type==='radio');}functiongetTracker(node){returnnode._valueTracker;}functiondetachTracker(node){node._valueTracker=null;}functiongetValueFromNode(node){varvalue='';if(!node){returnvalue;}if(isCheckable(node)){value=node.checked?'true':'false';}else{value=node.value;}returnvalue;}functiontrackValueOnNode(node){varvalueField=isCheckable(node)?'checked':'value';vardescriptor=Object.getOwnPropertyDescriptor(node.constructor.prototype,valueField);varcurrentValue=''+node[valueField];// if someone has already defined a value or Safari, then bail
// and don't track value will cause over reporting of changes,
// but it's better then a hard failure
// (needed for certain tests that spyOn input values and Safari)
if(node.hasOwnProperty(valueField)||typeofdescriptor==='undefined'||typeofdescriptor.get!=='function'||typeofdescriptor.set!=='function'){return;}varget=descriptor.get,set=descriptor.set;Object.defineProperty(node,valueField,{configurable:true,get:function(){returnget.call(this);},set:function(value){currentValue=''+value;set.call(this,value);}});// We could've passed this the first time
// but it triggers a bug in IE11 and Edge 14/15.
// Calling defineProperty() again should be equivalent.
// https://github.com/facebook/react/issues/11768
Object.defineProperty(node,valueField,{enumerable:descriptor.enumerable});vartracker={getValue:function(){returncurrentValue;},setValue:function(value){currentValue=''+value;},stopTracking:function(){detachTracker(node);deletenode[valueField];}};returntracker;}functiontrack(node){if(getTracker(node)){return;}// TODO: Once it's just Fiber we can move this to node._wrapperState
node._valueTracker=trackValueOnNode(node);}functionupdateValueIfChanged(node){if(!node){returnfalse;}vartracker=getTracker(node);// if there is no tracker at this point it's unlikely
*/function getHostProps(element,props){var node=element;var checked=props.checked;var hostProps=_assign({},props,{defaultChecked:undefined,defaultValue:undefined,value:undefined,checked:checked!=null?checked:node._wrapperState.initialChecked});return hostProps;}function initWrapperState(element,props){{checkControlledValueProps('input',props);if(props.checked!==undefined&&props.defaultChecked!==undefined&&!didWarnCheckedDefaultChecked){error('%s contains an input of type %s with both checked and defaultChecked props. '+'Input elements must be either controlled or uncontrolled '+'(specify either the checked prop, or the defaultChecked prop, but not '+'both). Decide between using a controlled or uncontrolled input '+'element and remove one of these props. More info: '+'https://reactjs.org/link/controlled-components',getCurrentFiberOwnerNameInDevOrNull()||'Acomponent',props.type);didWarnCheckedDefaultChecked=true;}if(props.value!==undefined&&props.defaultValue!==undefined&&!didWarnValueDefaultValue){error('%scontainsaninputoftype%swithbothvalueanddefaultValueprops.'+'Inputelementsmustbeeithercontrolledoruncontrolled'+'(specifyeitherthevalueprop,orthedefaultValueprop,butnot'+'both).Decidebetweenusingacontrolledoruncontrolledinput'+'elementandremoveoneoftheseprops.Moreinfo:'+'https://reactjs.org/link/controlled-components',getCurrentFiberOwnerNameInDevOrNull()||'A component',props.type);didWarnValueDefaultValue=true;}}var node=element;var defaultValue=props.defaultValue==null?'':props.defaultValue;node._wrapperState={initialChecked:props.checked!=null?props.checked:props.defaultChecked,initialValue:getToStringValue(props.value!=null?props.value:defaultValue),controlled:isControlled(props)};}function updateChecked(element,props){var node=element;var checked=props.checked;if(checked!=null){setValueForProperty(node,'checked',checked,false);}}function updateWrapper(element,props){var node=element;{var controlled=isControlled(props);if(!node._wrapperState.controlled&&controlled&&!didWarnUncontrolledToControlled){error('A component is changing an uncontrolled input to be controlled. '+'This is likely caused by the value changing from undefined to '+'a defined value, which should not happen. '+'Decide between using a controlled or uncontrolled input '+'element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components');didWarnUncontrolledToControlled=true;}if(node._wrapperState.controlled&&!controlled&&!didWarnControlledToUncontrolled){error('A component is changing a controlled input to be uncontrolled. '+'This is likely caused by the value changing from a defined to '+'undefined, which should not happen. '+'Decide between using a controlled or uncontrolled input '+'element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components');didWarnControlledToUncontrolled=true;}}updateChecked(element,props);var value=getToStringValue(props.value);var type=props.type;if(value!=null){if(type==='number'){if(value===0&&node.value===''||// We explicitly want to coerce to number here if possible.
// eslint-disable-next-line
node.value!=value){node.value=toString(value);}}elseif(node.value!==toString(value)){node.value=toString(value);}}elseif(type==='submit'||type==='reset'){// Submit/reset inputs need the attribute removed completely to avoid
// blank-text buttons.
node.removeAttribute('value');return;}{// When syncing the value attribute, the value comes from a cascade of
// properties:
// 1. The value React property
// 2. The defaultValue React property
// 3. Otherwise there should be no change
if(props.hasOwnProperty('value')){setDefaultValue(node,props.type,value);}elseif(props.hasOwnProperty('defaultValue')){setDefaultValue(node,props.type,getToStringValue(props.defaultValue));}}{// When syncing the checked attribute, it only changes when it needs
// to be removed, such as transitioning from a checkbox into a text input
if(props.checked==null&&props.defaultChecked!=null){node.defaultChecked=!!props.defaultChecked;}}}functionpostMountWrapper(element,props,isHydrating){varnode=element;// Do not assign value if it is already set. This prevents user text input
// from being lost during SSR hydration.
if(props.hasOwnProperty('value')||props.hasOwnProperty('defaultValue')){vartype=props.type;varisButton=type==='submit'||type==='reset';// Avoid setting value attribute on submit/reset inputs as it overrides the
// default value provided by the browser. See: #12872
if(isButton&&(props.value===undefined||props.value===null)){return;}varinitialValue=toString(node._wrapperState.initialValue);// Do not assign value if it is already set. This prevents user text input
// from being lost during SSR hydration.
if(!isHydrating){{// When syncing the value attribute, the value property should use
// the wrapperState._initialValue property. This uses:
//
// 1. The value React property when present
// 2. The defaultValue React property when present
// 3. An empty string
if(initialValue!==node.value){node.value=initialValue;}}}{// Otherwise, the value attribute is synchronized to the property,
// so we assign defaultValue to the same thing as the value property
// assignment step above.
node.defaultValue=initialValue;}}// Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
// this is needed to work around a chrome bug where setting defaultChecked
// will sometimes influence the value of checked (even after detachment).
// We need to temporarily unset name to avoid disrupting radio button groups.
varname=node.name;if(name!==''){node.name='';}{// When syncing the checked attribute, both the checked property and
// attribute are assigned at the same time using defaultChecked. This uses:
//
// 1. The checked React property when present
// 2. The defaultChecked React property when present
// 3. Otherwise, false
node.defaultChecked=!node.defaultChecked;node.defaultChecked=!!node._wrapperState.initialChecked;}if(name!==''){node.name=name;}}functionrestoreControlledState(element,props){varnode=element;updateWrapper(node,props);updateNamedCousins(node,props);}functionupdateNamedCousins(rootNode,props){varname=props.name;if(props.type==='radio'&&name!=null){varqueryRoot=rootNode;while(queryRoot.parentNode){queryRoot=queryRoot.parentNode;}// If `rootNode.form` was non-null, then we could try `form.elements`,
// but that sometimes behaves strangely in IE8. We could also try using
// `form.getElementsByName`, but that will only return direct children
// and won't include inputs that use the HTML5 `form=` attribute. Since
// the input might not even be in a form. It might not even be in the
// document. Let's just use the local `querySelectorAll` to ensure we don't
// miss anything.
vargroup=queryRoot.querySelectorAll('input[name='+JSON.stringify(''+name)+'][type="radio"]');for(vari=0;i<group.length;i++){varotherNode=group[i];if(otherNode===rootNode||otherNode.form!==rootNode.form){continue;}// This will throw if radio buttons rendered by different copies of React
// and the same name are rendered into the same form (same as #1939).
// That's probably okay; we don't support it just as we don't support
// mixing React radio buttons with non-React ones.
varotherProps=getFiberCurrentPropsFromNode(otherNode);if(!otherProps){{throwError("ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.");}}// We need update the tracked value on the named cousin since the value
// was changed but the input saw no event or value set
updateValueIfChanged(otherNode);// If this is a controlled radio button group, forcing the input that
// was previously checked to update will cause it to be come re-checked
// as appropriate.
updateWrapper(otherNode,otherProps);}}}// In Chrome, assigning defaultValue to certain input types triggers input validation.
// For number inputs, the display value loses trailing decimal points. For email inputs,
// Chrome raises "The specified value <x> is not a valid email address".
//
// Here we check to see if the defaultValue has actually changed, avoiding these problems
// when the user is inputting text
//
// https://github.com/facebook/react/issues/7253
functionsetDefaultValue(node,type,value){if(// Focused number inputs synchronize on blur. See ChangeEventPlugin.js
type!=='number'||getActiveElement(node.ownerDocument)!==node){if(value==null){node.defaultValue=toString(node._wrapperState.initialValue);}elseif(node.defaultValue!==toString(value)){node.defaultValue=toString(value);}}}vardidWarnSelectedSetOnOption=false;vardidWarnInvalidChild=false;functionflattenChildren(children){varcontent='';// Flatten children. We'll warn if they are invalid
// during validateProps() which runs for hydration too.
// Note that this would throw on non-element objects.
// Elements are stringified (which is normally irrelevant
// but matters for <fbt>).
React.Children.forEach(children,function(child){if(child==null){return;}content+=child;// Note: we don't warn about invalid children here.
// Warn about invalid children here so that client and hydration are consistent.
// TODO: this seems like it could cause a DEV-only throw for hydration
// if children contains a non-element object. We should try to avoid that.
if(typeofprops.children==='object'&&props.children!==null){React.Children.forEach(props.children,function(child){if(child==null){return;}if(typeofchild==='string'||typeofchild==='number'){return;}if(typeofchild.type!=='string'){return;}if(!didWarnInvalidChild){didWarnInvalidChild=true;error('Only strings and numbers are supported as <option> children.');}});}// TODO: Remove support for `selected` in <option>.
if(props.selected!=null&&!didWarnSelectedSetOnOption){error('Use the `defaultValue` or `value` props on <select> instead of '+'setting `selected` on <option>.');didWarnSelectedSetOnOption=true;}}}functionpostMountWrapper$1(element,props){// value="" should make a value attribute (#6219)
if(props.value!=null){element.setAttribute('value',toString(getToStringValue(props.value)));}}functiongetHostProps$1(element,props){varhostProps=_assign({children:undefined},props);varcontent=flattenChildren(props.children);if(content){hostProps.children=content;}returnhostProps;}vardidWarnValueDefaultValue$1;{didWarnValueDefaultValue$1=false;}functiongetDeclarationErrorAddendum(){varownerName=getCurrentFiberOwnerNameInDevOrNull();if(ownerName){return'\n\nCheck the render method of `'+ownerName+'`.';}return'';}varvaluePropNames=['value','defaultValue'];/**
*Validationfunctionfor`value`and`defaultValue`.
*/function checkSelectPropTypes(props){{checkControlledValueProps('select',props);for(var i=0;i<valuePropNames.length;i++){var propName=valuePropNames[i];if(props[propName]==null){continue;}var isArray=Array.isArray(props[propName]);if(props.multiple&&!isArray){error('The `%s` prop supplied to <select> must be an array if '+'`multiple` is true.%s',propName,getDeclarationErrorAddendum());}else if(!props.multiple&&isArray){error('The `%s` prop supplied to <select> must be a scalar '+'value if `multiple` is false.%s',propName,getDeclarationErrorAddendum());}}}}function updateOptions(node,multiple,propValue,setDefaultSelected){var options=node.options;if(multiple){var selectedValues=propValue;var selectedValue={};for(var i=0;i<selectedValues.length;i++){//Prefixtoavoidchaoswithspecialkeys.
selectedValue['$'+selectedValues[i]]=true;}for(var_i=0;_i<options.length;_i++){varselected=selectedValue.hasOwnProperty('$'+options[_i].value);if(options[_i].selected!==selected){options[_i].selected=selected;}if(selected&&setDefaultSelected){options[_i].defaultSelected=true;}}}else{// Do not set `select.value` as exact behavior isn't consistent across all
*/function getHostProps$2(element,props){return _assign({},props,{value:undefined});}function initWrapperState$1(element,props){var node=element;{checkSelectPropTypes(props);}node._wrapperState={wasMultiple:!!props.multiple};{if(props.value!==undefined&&props.defaultValue!==undefined&&!didWarnValueDefaultValue$1){error('Select elements must be either controlled or uncontrolled '+'(specify either the value prop, or the defaultValue prop, but not '+'both). Decide between using a controlled or uncontrolled select '+'element and remove one of these props. More info: '+'https://reactjs.org/link/controlled-components');didWarnValueDefaultValue$1=true;}}}functionpostMountWrapper$2(element,props){varnode=element;node.multiple=!!props.multiple;varvalue=props.value;if(value!=null){updateOptions(node,!!props.multiple,value,false);}elseif(props.defaultValue!=null){updateOptions(node,!!props.multiple,props.defaultValue,true);}}functionpostUpdateWrapper(element,props){varnode=element;varwasMultiple=node._wrapperState.wasMultiple;node._wrapperState.wasMultiple=!!props.multiple;varvalue=props.value;if(value!=null){updateOptions(node,!!props.multiple,value,false);}elseif(wasMultiple!==!!props.multiple){// For simplicity, reapply `defaultValue` if `multiple` is toggled.
if(props.defaultValue!=null){updateOptions(node,!!props.multiple,props.defaultValue,true);}else{// Revert the select back to its default unselected state.
*/function getHostProps$3(element,props){var node=element;if(!(props.dangerouslySetInnerHTML==null)){{throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");}}//Alwayssetchildrentothesamething.InIE9,theselectionrangewill
// get reset if `textContent` is mutated. We could add a check in setTextContent
// to only set the value if/when the value differs from the node value (which would
// completely solve this IE9 bug), but Sebastian+Sophie seemed to like this
// solution. The value can be a boolean or object so that's why it's forced
// to be a string.
varhostProps=_assign({},props,{value:undefined,defaultValue:undefined,children:toString(node._wrapperState.initialValue)});returnhostProps;}functioninitWrapperState$2(element,props){varnode=element;{checkControlledValueProps('textarea',props);if(props.value!==undefined&&props.defaultValue!==undefined&&!didWarnValDefaultVal){error('%s contains a textarea with both value and defaultValue props. '+'Textarea elements must be either controlled or uncontrolled '+'(specify either the value prop, or the defaultValue prop, but not '+'both). Decide between using a controlled or uncontrolled textarea '+'and remove one of these props. More info: '+'https://reactjs.org/link/controlled-components',getCurrentFiberOwnerNameInDevOrNull()||'A component');didWarnValDefaultVal=true;}}varinitialValue=props.value;// Only bother fetching default value if we're going to use it
if(initialValue==null){varchildren=props.children,defaultValue=props.defaultValue;if(children!=null){{error('Use the `defaultValue` or `value` props instead of setting '+'children on <textarea>.');}{if(!(defaultValue==null)){{throwError("If you supply `defaultValue` on a <textarea>, do not pass children.");}}if(Array.isArray(children)){if(!(children.length<=1)){{throwError("<textarea> can only have at most one child.");}}children=children[0];}defaultValue=children;}}if(defaultValue==null){defaultValue='';}initialValue=defaultValue;}node._wrapperState={initialValue:getToStringValue(initialValue)};}functionupdateWrapper$1(element,props){varnode=element;varvalue=getToStringValue(props.value);vardefaultValue=getToStringValue(props.defaultValue);if(value!=null){// Cast `value` to a string to ensure the value is set correctly. While
// browsers typically do this as necessary, jsdom doesn't.
varnewValue=toString(value);// To avoid side effects (such as losing text selection), only set value if changed
if(newValue!==node.value){node.value=newValue;}if(props.defaultValue==null&&node.defaultValue!==newValue){node.defaultValue=newValue;}}if(defaultValue!=null){node.defaultValue=toString(defaultValue);}}functionpostMountWrapper$3(element,props){varnode=element;// This is in postMount because we need access to the DOM node, which is not
// available until after the component has mounted.
vartextContent=node.textContent;// Only set node.value if textContent is equal to the expected
// initial value. In IE10/IE11 there is a bug where the placeholder attribute
if(textContent===node._wrapperState.initialValue){if(textContent!==''&&textContent!==null){node.value=textContent;}}}functionrestoreControlledState$2(element,props){// DOM component is still mounted; update
updateWrapper$1(element,props);}varHTML_NAMESPACE='http://www.w3.org/1999/xhtml';varMATH_NAMESPACE='http://www.w3.org/1998/Math/MathML';varSVG_NAMESPACE='http://www.w3.org/2000/svg';varNamespaces={html:HTML_NAMESPACE,mathml:MATH_NAMESPACE,svg:SVG_NAMESPACE};// Assumes there is no parent namespace.
functiongetIntrinsicNamespace(type){switch(type){case'svg':returnSVG_NAMESPACE;case'math':returnMATH_NAMESPACE;default:returnHTML_NAMESPACE;}}functiongetChildNamespace(parentNamespace,type){if(parentNamespace==null||parentNamespace===HTML_NAMESPACE){// No (or default) parent namespace: potential entry point.
varbadVendoredStyleNamePattern=/^(?:webkit|moz|o)[A-Z]/;varmsPattern$1=/^-ms-/;varhyphenPattern=/-(.)/g;// style values shouldn't contain a semicolon
varbadStyleValueWithSemicolonPattern=/;\s*$/;varwarnedStyleNames={};varwarnedStyleValues={};varwarnedForNaNValue=false;varwarnedForInfinityValue=false;varcamelize=function(string){returnstring.replace(hyphenPattern,function(_,character){returncharacter.toUpperCase();});};varwarnHyphenatedStyleName=function(name){if(warnedStyleNames.hasOwnProperty(name)&&warnedStyleNames[name]){return;}warnedStyleNames[name]=true;error('Unsupported style property %s. Did you mean %s?',name,// As Andi Smith suggests
// (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
// is converted to lowercase `ms`.
camelize(name.replace(msPattern$1,'ms-')));};varwarnBadVendoredStyleName=function(name){if(warnedStyleNames.hasOwnProperty(name)&&warnedStyleNames[name]){return;}warnedStyleNames[name]=true;error('Unsupported vendor-prefixed style property %s. Did you mean %s?',name,name.charAt(0).toUpperCase()+name.slice(1));};varwarnStyleValueWithSemicolon=function(name,value){if(warnedStyleValues.hasOwnProperty(value)&&warnedStyleValues[value]){return;}warnedStyleValues[value]=true;error("Style property values shouldn't contain a semicolon. "+'Try "%s: %s" instead.',name,value.replace(badStyleValueWithSemicolonPattern,''));};varwarnStyleValueIsNaN=function(name,value){if(warnedForNaNValue){return;}warnedForNaNValue=true;error('`NaN` is an invalid value for the `%s` css style property.',name);};varwarnStyleValueIsInfinity=function(name,value){if(warnedForInfinityValue){return;}warnedForInfinityValue=true;error('`Infinity` is an invalid value for the `%s` css style property.',name);};warnValidStyle=function(name,value){if(name.indexOf('-')>-1){warnHyphenatedStyleName(name);}elseif(badVendoredStyleNamePattern.test(name)){warnBadVendoredStyleName(name);}elseif(badStyleValueWithSemicolonPattern.test(value)){warnStyleValueWithSemicolon(name,value);}if(typeofvalue==='number'){if(isNaN(value)){warnStyleValueIsNaN(name,value);}elseif(!isFinite(value)){warnStyleValueIsInfinity(name,value);}}};}varwarnValidStyle$1=warnValidStyle;/**
*/function validateShorthandPropertyCollisionInDev(styleUpdates,nextStyles){{if(!nextStyles){return;}var expandedUpdates=expandShorthandMap(styleUpdates);var expandedStyles=expandShorthandMap(nextStyles);var warnedAbout={};for(var key in expandedUpdates){var originalKey=expandedUpdates[key];var correctOriginalKey=expandedStyles[key];if(correctOriginalKey&&originalKey!==correctOriginalKey){var warningKey=originalKey+','+correctOriginalKey;if(warnedAbout[warningKey]){continue;}warnedAbout[warningKey]=true;error('%s a style property during rerender (%s) when a '+'conflicting property is set (%s) can lead to styling bugs. To '+"avoid this, don't mix shorthand and non-shorthand properties "+'for the same value; instead, replace the shorthand with '+'separate values.',isValueEmpty(styleUpdates[originalKey])?'Removing':'Updating',originalKey,correctOriginalKey);}}}}//ForHTML,certaintagsshouldomittheirclosetag.Wekeepalistfor
// those special-case tags.
varomittedCloseTags={area:true,base:true,br:true,col:true,embed:true,hr:true,img:true,input:true,keygen:true,link:true,meta:true,param:true,source:true,track:true,wbr:true// NOTE: menuitem's close tag should be omitted, but that causes problems.
};// `omittedCloseTags` except that `menuitem` should still have its closing tag.
varvoidElementTags=_assign({menuitem:true},omittedCloseTags);varHTML='__html';functionassertValidProps(tag,props){if(!props){return;}// Note the use of `==` which checks for null or undefined.
if(voidElementTags[tag]){if(!(props.children==null&&props.dangerouslySetInnerHTML==null)){{throwError(tag+" is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");}}}if(props.dangerouslySetInnerHTML!=null){if(!(props.children==null)){{throwError("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");}}if(!(typeofprops.dangerouslySetInnerHTML==='object'&&HTMLinprops.dangerouslySetInnerHTML)){{throwError("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");}}}{if(!props.suppressContentEditableWarning&&props.contentEditable&&props.children!=null){error('A component is `contentEditable` and contains `children` managed by '+'React. It is now your responsibility to guarantee that none of '+'those nodes are unexpectedly modified or duplicated. This is '+'probably not intentional.');}}if(!(props.style==null||typeofprops.style==='object')){{throwError("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");}}}functionisCustomComponent(tagName,props){if(tagName.indexOf('-')===-1){returntypeofprops.is==='string';}switch(tagName){// These are reserved SVG and MathML elements.
// We don't mind this list too much because we expect it to never grow.
// The alternative is to track the namespace in a few places which is convoluted.
case'annotation-xml':case'color-profile':case'font-face':case'font-face-src':case'font-face-uri':case'font-face-format':case'font-face-name':case'missing-glyph':returnfalse;default:returntrue;}}// When adding attributes to the HTML or SVG allowed attribute list, be sure to
// also add them to this module to ensure casing and incorrect name
'aria-autocomplete':0,'aria-checked':0,'aria-expanded':0,'aria-haspopup':0,'aria-level':0,'aria-modal':0,'aria-multiline':0,'aria-multiselectable':0,'aria-orientation':0,'aria-placeholder':0,'aria-pressed':0,'aria-readonly':0,'aria-required':0,'aria-selected':0,'aria-sort':0,'aria-valuemax':0,'aria-valuemin':0,'aria-valuenow':0,'aria-valuetext':0,// Live Region Attributes
'aria-activedescendant':0,'aria-colcount':0,'aria-colindex':0,'aria-colspan':0,'aria-controls':0,'aria-describedby':0,'aria-errormessage':0,'aria-flowto':0,'aria-labelledby':0,'aria-owns':0,'aria-posinset':0,'aria-rowcount':0,'aria-rowindex':0,'aria-rowspan':0,'aria-setsize':0};varwarnedProperties={};varrARIA=newRegExp('^(aria)-['+ATTRIBUTE_NAME_CHAR+']*$');varrARIACamel=newRegExp('^(aria)[A-Z]['+ATTRIBUTE_NAME_CHAR+']*$');varhasOwnProperty$1=Object.prototype.hasOwnProperty;functionvalidateProperty(tagName,name){{if(hasOwnProperty$1.call(warnedProperties,name)&&warnedProperties[name]){returntrue;}if(rARIACamel.test(name)){varariaName='aria-'+name.slice(4).toLowerCase();varcorrectName=ariaProperties.hasOwnProperty(ariaName)?ariaName:null;// If this is an aria-* attribute, but is not listed in the known DOM
// DOM properties, then it is an invalid aria-* attribute.
if(correctName==null){error('Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.',name);warnedProperties[name]=true;returntrue;}// aria-* attributes should be lowercase; suggest the lowercase version.
if(name!==correctName){error('Invalid ARIA attribute `%s`. Did you mean `%s`?',name,correctName);warnedProperties[name]=true;returntrue;}}if(rARIA.test(name)){varlowerCasedName=name.toLowerCase();varstandardName=ariaProperties.hasOwnProperty(lowerCasedName)?lowerCasedName:null;// If this is an aria-* attribute, but is not listed in the known DOM
// DOM properties, then it is an invalid aria-* attribute.
if(standardName==null){warnedProperties[name]=true;returnfalse;}// aria-* attributes should be lowercase; suggest the lowercase version.
if(name!==standardName){error('Unknown ARIA attribute `%s`. Did you mean `%s`?',name,standardName);warnedProperties[name]=true;returntrue;}}}returntrue;}functionwarnInvalidARIAProps(type,props){{varinvalidProps=[];for(varkeyinprops){varisValid=validateProperty(type,key);if(!isValid){invalidProps.push(key);}}varunknownPropString=invalidProps.map(function(prop){return'`'+prop+'`';}).join(', ');if(invalidProps.length===1){error('Invalid aria prop %s on <%s> tag. '+'For details, see https://reactjs.org/link/invalid-aria-props',unknownPropString,type);}elseif(invalidProps.length>1){error('Invalid aria props %s on <%s> tag. '+'For details, see https://reactjs.org/link/invalid-aria-props',unknownPropString,type);}}}functionvalidateProperties(type,props){if(isCustomComponent(type,props)){return;}warnInvalidARIAProps(type,props);}vardidWarnValueNull=false;functionvalidateProperties$1(type,props){{if(type!=='input'&&type!=='textarea'&&type!=='select'){return;}if(props!=null&&props.value===null&&!didWarnValueNull){didWarnValueNull=true;if(type==='select'&&props.multiple){error('`value` prop on `%s` should not be null. '+'Consider using an empty array when `multiple` is set to `true` '+'to clear the component or `undefined` for uncontrolled components.',type);}else{error('`value` prop on `%s` should not be null. '+'Consider using an empty string to clear the component or `undefined` '+'for uncontrolled components.',type);}}}}varvalidateProperty$1=function(){};{varwarnedProperties$1={};var_hasOwnProperty=Object.prototype.hasOwnProperty;varEVENT_NAME_REGEX=/^on./;varINVALID_EVENT_NAME_REGEX=/^on[^A-Z]/;varrARIA$1=newRegExp('^(aria)-['+ATTRIBUTE_NAME_CHAR+']*$');varrARIACamel$1=newRegExp('^(aria)[A-Z]['+ATTRIBUTE_NAME_CHAR+']*$');validateProperty$1=function(tagName,name,value,eventRegistry){if(_hasOwnProperty.call(warnedProperties$1,name)&&warnedProperties$1[name]){returntrue;}varlowerCasedName=name.toLowerCase();if(lowerCasedName==='onfocusin'||lowerCasedName==='onfocusout'){error('React uses onFocus and onBlur instead of onFocusIn and onFocusOut. '+'All React events are normalized to bubble, so onFocusIn and onFocusOut '+'are not needed/supported by React.');warnedProperties$1[name]=true;returntrue;}// We can't rely on the event system being injected on the server.
if(eventRegistry!=null){varregistrationNameDependencies=eventRegistry.registrationNameDependencies,possibleRegistrationNames=eventRegistry.possibleRegistrationNames;if(registrationNameDependencies.hasOwnProperty(name)){returntrue;}varregistrationName=possibleRegistrationNames.hasOwnProperty(lowerCasedName)?possibleRegistrationNames[lowerCasedName]:null;if(registrationName!=null){error('Invalid event handler property `%s`. Did you mean `%s`?',name,registrationName);warnedProperties$1[name]=true;returntrue;}if(EVENT_NAME_REGEX.test(name)){error('Unknown event handler property `%s`. It will be ignored.',name);warnedProperties$1[name]=true;returntrue;}}elseif(EVENT_NAME_REGEX.test(name)){// If no event plugins have been injected, we are in a server environment.
// So we can't tell if the event name is correct for sure, but we can filter
// out known bad ones like `onclick`. We can't suggest a specific replacement though.
if(INVALID_EVENT_NAME_REGEX.test(name)){error('Invalid event handler property `%s`. '+'React events use the camelCase naming convention, for example `onClick`.',name);}warnedProperties$1[name]=true;returntrue;}// Let the ARIA attribute hook validate ARIA attributes
if(rARIA$1.test(name)||rARIACamel$1.test(name)){returntrue;}if(lowerCasedName==='innerhtml'){error('Directly setting property `innerHTML` is not permitted. '+'For more information, lookup documentation on `dangerouslySetInnerHTML`.');warnedProperties$1[name]=true;returntrue;}if(lowerCasedName==='aria'){error('The `aria` attribute is reserved for future use in React. '+'Pass individual `aria-` attributes instead.');warnedProperties$1[name]=true;returntrue;}if(lowerCasedName==='is'&&value!==null&&value!==undefined&&typeofvalue!=='string'){error('Received a `%s` for a string attribute `is`. If this is expected, cast '+'the value to a string.',typeofvalue);warnedProperties$1[name]=true;returntrue;}if(typeofvalue==='number'&&isNaN(value)){error('Received NaN for the `%s` attribute. If this is expected, cast '+'the value to a string.',name);warnedProperties$1[name]=true;returntrue;}varpropertyInfo=getPropertyInfo(name);varisReserved=propertyInfo!==null&&propertyInfo.type===RESERVED;// Known attributes should match the casing specified in the property config.
if(possibleStandardNames.hasOwnProperty(lowerCasedName)){varstandardName=possibleStandardNames[lowerCasedName];if(standardName!==name){error('Invalid DOM property `%s`. Did you mean `%s`?',name,standardName);warnedProperties$1[name]=true;returntrue;}}elseif(!isReserved&&name!==lowerCasedName){// Unknown attributes should have lowercase casing since that's how they
// will be cased anyway with server rendering.
error('React does not recognize the `%s` prop on a DOM element. If you '+'intentionally want it to appear in the DOM as a custom '+'attribute, spell it as lowercase `%s` instead. '+'If you accidentally passed it from a parent component, remove '+'it from the DOM element.',name,lowerCasedName);warnedProperties$1[name]=true;returntrue;}if(typeofvalue==='boolean'&&shouldRemoveAttributeWithWarning(name,value,propertyInfo,false)){if(value){error('Received `%s` for a non-boolean attribute `%s`.\n\n'+'If you want to write it to the DOM, pass a string instead: '+'%s="%s" or %s={value.toString()}.',value,name,name,value,name);}else{error('Received `%s` for a non-boolean attribute `%s`.\n\n'+'If you want to write it to the DOM, pass a string instead: '+'%s="%s" or %s={value.toString()}.\n\n'+'If you used to conditionally omit it with %s={condition && value}, '+'pass %s={condition ? value : undefined} instead.',value,name,name,value,name,name,name);}warnedProperties$1[name]=true;returntrue;}// Now that we've validated casing, do not validate
// data types for reserved props
if(isReserved){returntrue;}// Warn when a known attribute is a bad type
if(shouldRemoveAttributeWithWarning(name,value,propertyInfo,false)){warnedProperties$1[name]=true;returnfalse;}// Warn when passing the strings 'false' or 'true' into a boolean prop
if((value==='false'||value==='true')&&propertyInfo!==null&&propertyInfo.type===BOOLEAN){error('Received the string `%s` for the boolean attribute `%s`. '+'%s '+'Did you mean %s={%s}?',value,name,value==='false'?'The browser will interpret it as a truthy value.':'Although this works, it will not work as expected if you pass the string "false".',name,value);warnedProperties$1[name]=true;returntrue;}returntrue;};}varwarnUnknownProperties=function(type,props,eventRegistry){{varunknownProps=[];for(varkeyinprops){varisValid=validateProperty$1(type,key,props[key],eventRegistry);if(!isValid){unknownProps.push(key);}}varunknownPropString=unknownProps.map(function(prop){return'`'+prop+'`';}).join(', ');if(unknownProps.length===1){error('Invalid value for prop %s on <%s> tag. Either remove it from the element, '+'or pass a string or number value to keep it in the DOM. '+'For details, see https://reactjs.org/link/attribute-behavior ',unknownPropString,type);}elseif(unknownProps.length>1){error('Invalid values for props %s on <%s> tag. Either remove them from the element, '+'or pass a string or number value to keep them in the DOM. '+'For details, see https://reactjs.org/link/attribute-behavior ',unknownPropString,type);}}};functionvalidateProperties$2(type,props,eventRegistry){if(isCustomComponent(type,props)){return;}warnUnknownProperties(type,props,eventRegistry);}varIS_EVENT_HANDLE_NON_MANAGED_NODE=1;varIS_NON_DELEGATED=1<<1;varIS_CAPTURE_PHASE=1<<2;varIS_REPLAYED=1<<4;// set to LEGACY_FB_SUPPORT. LEGACY_FB_SUPPORT only gets set when
// we call willDeferLaterForLegacyFBSupport, thus not bailing out
// will result in endless cycles like an infinite loop.
// We also don't want to defer during event replaying.
returntarget.nodeType===TEXT_NODE?target.parentNode:target;}varrestoreImpl=null;varrestoreTarget=null;varrestoreQueue=null;functionrestoreStateOfTarget(target){// We perform this translation at the end of the event loop so that we
return;}if(!(typeofrestoreImpl==='function')){{throwError("setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue.");}}varstateNode=internalInstance.stateNode;// Guard against Fiber being unmounted.
if(stateNode){var_props=getFiberCurrentPropsFromNode(stateNode);restoreImpl(internalInstance.stateNode,internalInstance.type,_props);}}functionsetRestoreImplementation(impl){restoreImpl=impl;}functionenqueueStateRestore(target){if(restoreTarget){if(restoreQueue){restoreQueue.push(target);}else{restoreQueue=[target];}}else{restoreTarget=target;}}functionneedsStateRestore(){returnrestoreTarget!==null||restoreQueue!==null;}functionrestoreStateIfNeeded(){if(!restoreTarget){return;}vartarget=restoreTarget;varqueuedTargets=restoreQueue;restoreTarget=null;restoreQueue=null;restoreStateOfTarget(target);if(queuedTargets){for(vari=0;i<queuedTargets.length;i++){restoreStateOfTarget(queuedTargets[i]);}}}// the renderer. Such as when we're dispatching events or if third party
// libraries need to call batchedUpdates. Eventually, this API will go away when
// everything is batched by default. We'll then have a similar API to opt-out of
// scheduled work and instead do synchronous work.
// Defaults
varbatchedUpdatesImpl=function(fn,bookkeeping){returnfn(bookkeeping);};vardiscreteUpdatesImpl=function(fn,a,b,c,d){returnfn(a,b,c,d);};varflushDiscreteUpdatesImpl=function(){};varbatchedEventUpdatesImpl=batchedUpdatesImpl;varisInsideEventHandler=false;varisBatchingEventUpdates=false;functionfinishEventHandler(){// Here we wait until all updates have propagated, which is important
// when using controlled components within layers:
// https://github.com/facebook/react/issues/1698
// Then we restore state of any controlled component.
varcontrolledComponentsHavePendingUpdates=needsStateRestore();if(controlledComponentsHavePendingUpdates){// If a controlled event was fired, we may need to restore the state of
// the DOM node back to the controlled value. This is necessary when React
// bails out of the update without touching the DOM.
flushDiscreteUpdatesImpl();restoreStateIfNeeded();}}functionbatchedUpdates(fn,bookkeeping){if(isInsideEventHandler){// If we are currently inside another batch, we need to wait until it
// fully completes before restoring state.
returnfn(bookkeeping);}isInsideEventHandler=true;try{returnbatchedUpdatesImpl(fn,bookkeeping);}finally{isInsideEventHandler=false;finishEventHandler();}}functionbatchedEventUpdates(fn,a,b){if(isBatchingEventUpdates){// If we are currently inside another batch, we need to wait until it
returnnull;}varprops=getFiberCurrentPropsFromNode(stateNode);if(props===null){// Work in progress.
returnnull;}varlistener=props[registrationName];if(shouldPreventMouseEvent(registrationName,inst.type,props)){returnnull;}if(!(!listener||typeoflistener==='function')){{throwError("Expected `"+registrationName+"` listener to be a function, instead got a value of `"+typeoflistener+"` type.");}}returnlistener;}varpassiveBrowserEventsSupported=false;// Check if browser support events with passive listeners
if(canUseDOM){try{varoptions={};// $FlowFixMe: Ignore Flow complaining about needing a value
Object.defineProperty(options,'passive',{get:function(){passiveBrowserEventsSupported=true;}});window.addEventListener('test',options,options);window.removeEventListener('test',options,options);}catch(e){passiveBrowserEventsSupported=false;}}functioninvokeGuardedCallbackProd(name,func,context,a,b,c,d,e,f){varfuncArgs=Array.prototype.slice.call(arguments,3);try{func.apply(context,funcArgs);}catch(error){this.onError(error);}}varinvokeGuardedCallbackImpl=invokeGuardedCallbackProd;{// In DEV mode, we swap out invokeGuardedCallback for a special version
// that plays more nicely with the browser's DevTools. The idea is to preserve
// "Pause on exceptions" behavior. Because React wraps all user-provided
// functions in invokeGuardedCallback, and the production version of
// invokeGuardedCallback uses a try-catch, all user exceptions are treated
// like caught exceptions, and the DevTools won't pause unless the developer
// takes the extra step of enabling pause on caught exceptions. This is
// unintuitive, though, because even though React has caught the error, from
// the developer's perspective, the error is uncaught.
//
// To preserve the expected "Pause on exceptions" behavior, we don't use a
// try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake
// DOM node, and call the user-provided callback from inside an event handler
// for that fake event. If the callback throws, the error is "captured" using
// a global event handler. But because the error happens in a different
// event loop context, it does not interrupt the normal program flow.
// Effectively, this gives us try-catch behavior without actually using
// try-catch. Neat!
// Check that the browser supports the APIs we need to implement our special
// DEV version of invokeGuardedCallback
if(typeofwindow!=='undefined'&&typeofwindow.dispatchEvent==='function'&&typeofdocument!=='undefined'&&typeofdocument.createEvent==='function'){varfakeNode=document.createElement('react');invokeGuardedCallbackImpl=functioninvokeGuardedCallbackDev(name,func,context,a,b,c,d,e,f){// If document doesn't exist we know for sure we will crash in this method
// when we call document.createEvent(). However this can cause confusing
// So we preemptively throw with a better message instead.
if(!(typeofdocument!=='undefined')){{throwError("The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous.");}}varevt=document.createEvent('Event');vardidCall=false;// Keeps track of whether the user-provided callback threw an error. We
// set this to true at the beginning, then set it to false right after
// calling the function. If the function errors, `didError` will never be
// set to false. This strategy works even if the browser is flaky and
// fails to call our global error handler, because it doesn't rely on
// the error event at all.
vardidError=true;// Keeps track of the value of window.event so that we can reset it
// during the callback to let user code access window.event in the
// browsers that support it.
varwindowEvent=window.event;// Keeps track of the descriptor of window.event to restore it after event
varwindowEventDescriptor=Object.getOwnPropertyDescriptor(window,'event');functionrestoreAfterDispatch(){// We immediately remove the callback from event listeners so that
// nested `invokeGuardedCallback` calls do not clash. Otherwise, a
// nested call would trigger the fake event handlers of any call higher
// in the stack.
fakeNode.removeEventListener(evtType,callCallback,false);// We check for window.hasOwnProperty('event') to prevent the
// window.event assignment in both IE <= 10 as they throw an error
// "Member not found" in strict mode, and in Firefox which does not
// support window.event.
if(typeofwindow.event!=='undefined'&&window.hasOwnProperty('event')){window.event=windowEvent;}}// Create an event handler for our fake event. We will synchronously
// dispatch our fake event using `dispatchEvent`. Inside the handler, we
// call the user-provided callback.
varfuncArgs=Array.prototype.slice.call(arguments,3);functioncallCallback(){didCall=true;restoreAfterDispatch();func.apply(context,funcArgs);didError=false;}// Create a global error event handler. We use this to capture the value
// that was thrown. It's possible that this error handler will fire more
// than once; for example, if non-React code also calls `dispatchEvent`
// and a handler for that event throws. We should be resilient to most of
// those cases. Even if our error event handler fires more than once, the
// last error event is always used. If the callback actually does error,
// we know that the last error event is the correct one, because it's not
// possible for anything else to have happened in between our callback
// erroring and the code that follows the `dispatchEvent` call below. If
// the callback doesn't error, but the error event was fired, we know to
// ignore it because `didError` will be false, as described above.
varerror;// Use this to track whether the error event is ever called.
vardidSetError=false;varisCrossOriginError=false;functionhandleWindowError(event){error=event.error;didSetError=true;if(error===null&&event.colno===0&&event.lineno===0){isCrossOriginError=true;}if(event.defaultPrevented){// Some other error handler has prevented default.
// Browsers silence the error report if this happens.
// We'll remember this to later decide whether to log it or not.
window.addEventListener('error',handleWindowError);fakeNode.addEventListener(evtType,callCallback,false);// Synchronously dispatch our fake event. If the user-provided function
// errors, it will trigger our global error handler.
evt.initEvent(evtType,false,false);fakeNode.dispatchEvent(evt);if(windowEventDescriptor){Object.defineProperty(window,'event',windowEventDescriptor);}if(didCall&&didError){if(!didSetError){// The callback errored, but the error event never fired.
error=newError('An error was thrown inside one of your components, but React '+"doesn't know what it was. This is likely due to browser "+'flakiness. React does its best to preserve the "Pause on '+'exceptions" behavior of the DevTools, which requires some '+"DEV-mode only tricks. It's possible that these don't work in "+'your browser. Try triggering the error in production mode, '+'or switching to a modern browser. If you suspect that this is '+'actually an issue with React, please file an issue.');}elseif(isCrossOriginError){error=newError("A cross-origin error was thrown. React doesn't have access to "+'the actual error object in development. '+'See https://reactjs.org/link/crossorigin-error for more information.');}this.onError(error);}// Remove our event listeners
window.removeEventListener('error',handleWindowError);if(!didCall){// Something went really wrong, and our event was not dispatched.
// https://github.com/facebook/react/issues/16734
// https://github.com/facebook/react/issues/16585
// Fall back to the production implementation.
restoreAfterDispatch();returninvokeGuardedCallbackProd.apply(this,arguments);}};}}varinvokeGuardedCallbackImpl$1=invokeGuardedCallbackImpl;varhasError=false;varcaughtError=null;// Used by event system to capture/rethrow the first error.
*/function rethrowCaughtError(){if(hasRethrowError){var error=rethrowError;hasRethrowError=false;rethrowError=null;throw error;}}function hasCaughtError(){return hasError;}function clearCaughtError(){if(hasError){var error=caughtError;hasError=false;caughtError=null;return error;}else {{{throw Error("clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.");}}}}/**
*/function get(key){return key._reactInternals;}function has(key){return key._reactInternals!==undefined;}function set(key,value){key._reactInternals=value;}//Don't change these two values. They'reusedbyReactDevTools.
varNoFlags=/* */0;varPerformedWork=/* */1;// You can change the rest (and add more).
varPlacement=/* */2;varUpdate=/* */4;varPlacementAndUpdate=/* */6;varDeletion=/* */8;varContentReset=/* */16;varCallback=/* */32;varDidCapture=/* */64;varRef=/* */128;varSnapshot=/* */256;varPassive=/* */512;// TODO (effects) Remove this bit once the new reconciler is synced to the old.
varLifecycleEffectMask=/* */932;// Union of all host effects
varHostEffectMask=/* */2047;// These are not really side effects, but we still reuse this field.
varIncomplete=/* */2048;varShouldCapture=/* */4096;varForceUpdateForLegacySuspense=/* */16384;// Static tags describe aspects of a fiber that are not specific to a render,
varReactCurrentOwner=ReactSharedInternals.ReactCurrentOwner;functiongetNearestMountedFiber(fiber){varnode=fiber;varnearestMounted=fiber;if(!fiber.alternate){// If there is no alternate, this might be a new tree that isn't inserted
// yet. If it is, then it will have a pending insertion effect on it.
varnextNode=node;do{node=nextNode;if((node.flags&(Placement|Hydrating))!==NoFlags){// This is an insertion or in-progress hydration. The nearest possible
// mounted fiber is the parent but we need to continue to figure out
// if that one is still mounted.
nearestMounted=node.return;}nextNode=node.return;}while(nextNode);}else{while(node.return){node=node.return;}}if(node.tag===HostRoot){// TODO: Check if this was a nested HostRoot when used with
// renderContainerIntoSubtree.
returnnearestMounted;}// If we didn't hit the root, that means that we're in an disconnected tree
// that has been unmounted.
returnnull;}functiongetSuspenseInstanceFromFiber(fiber){if(fiber.tag===SuspenseComponent){varsuspenseState=fiber.memoizedState;if(suspenseState===null){varcurrent=fiber.alternate;if(current!==null){suspenseState=current.memoizedState;}}if(suspenseState!==null){returnsuspenseState.dehydrated;}}returnnull;}functiongetContainerFromFiber(fiber){returnfiber.tag===HostRoot?fiber.stateNode.containerInfo:null;}functionisFiberMounted(fiber){returngetNearestMountedFiber(fiber)===fiber;}functionisMounted(component){{varowner=ReactCurrentOwner.current;if(owner!==null&&owner.tag===ClassComponent){varownerFiber=owner;varinstance=ownerFiber.stateNode;if(!instance._warnedAboutRefsInRender){error('%s is accessing isMounted inside its render() function. '+'render() should be a pure function of props and state. It should '+'never access something that requires stale data from the previous '+'render, such as refs. Move this logic to componentDidMount and '+'componentDidUpdate instead.',getComponentName(ownerFiber.type)||'A component');}instance._warnedAboutRefsInRender=true;}}varfiber=get(component);if(!fiber){returnfalse;}returngetNearestMountedFiber(fiber)===fiber;}functionassertIsMounted(fiber){if(!(getNearestMountedFiber(fiber)===fiber)){{throwError("Unable to find node on an unmounted component.");}}}functionfindCurrentFiberUsingSlowPath(fiber){varalternate=fiber.alternate;if(!alternate){// If there is no alternate, then we only need to check if it is mounted.
varnearestMounted=getNearestMountedFiber(fiber);if(!(nearestMounted!==null)){{throwError("Unable to find node on an unmounted component.");}}if(nearestMounted!==fiber){returnnull;}returnfiber;}// If we have two possible branches, we'll walk backwards up to the root
// to see what path the root points to. On the way we may hit one of the
// special cases and we'll deal with them.
vara=fiber;varb=alternate;while(true){varparentA=a.return;if(parentA===null){// We're at the root.
break;}varparentB=parentA.alternate;if(parentB===null){// There is no alternate. This is an unusual case. Currently, it only
// happens when a Suspense component is hidden. An extra fragment fiber
// is inserted in between the Suspense fiber and its children. Skip
// over this extra fragment fiber and proceed to the next parent.
varnextParent=parentA.return;if(nextParent!==null){a=b=nextParent;continue;}// If there's no parent, we're at the root.
break;}// If both copies of the parent fiber point to the same child, we can
// assume that the child is current. This happens when we bailout on low
// priority: the bailed out fiber's child reuses the current child.
if(parentA.child===parentB.child){varchild=parentA.child;while(child){if(child===a){// We've determined that A is the current branch.
assertIsMounted(parentA);returnfiber;}if(child===b){// We've determined that B is the current branch.
assertIsMounted(parentA);returnalternate;}child=child.sibling;}// We should never have an alternate for any mounting node. So the only
// way this could possibly happen is if this was unmounted, if at all.
{{throwError("Unable to find node on an unmounted component.");}}}if(a.return!==b.return){// The return pointer of A and the return pointer of B point to different
// fibers. We assume that return pointers never criss-cross, so A must
// belong to the child set of A.return, and B must belong to the child
// set of B.return.
a=parentA;b=parentB;}else{// The return pointers point to the same fiber. We'll have to use the
// default, slow path: scan the child sets of each parent alternate to see
// which child belongs to which set.
//
// Search parent A's child set
vardidFindChild=false;var_child=parentA.child;while(_child){if(_child===a){didFindChild=true;a=parentA;b=parentB;break;}if(_child===b){didFindChild=true;b=parentA;a=parentB;break;}_child=_child.sibling;}if(!didFindChild){// Search parent B's child set
_child=parentB.child;while(_child){if(_child===a){didFindChild=true;a=parentB;b=parentA;break;}if(_child===b){didFindChild=true;b=parentB;a=parentA;break;}_child=_child.sibling;}if(!didFindChild){{throwError("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.");}}}}if(!(a.alternate===b)){{throwError("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");}}}// If the root is not a host container, we're in a disconnected tree. I.e.
// unmounted.
if(!(a.tag===HostRoot)){{throwError("Unable to find node on an unmounted component.");}}if(a.stateNode.current===a){// We've determined that A is the current branch.
returnfiber;}// Otherwise B has to be current branch.
returnalternate;}functionfindCurrentHostFiber(parent){varcurrentParent=findCurrentFiberUsingSlowPath(parent);if(!currentParent){returnnull;}// Next we'll drill down this component to find the first HostComponent/Text.
varnode=currentParent;while(true){if(node.tag===HostComponent||node.tag===HostText){returnnode;}elseif(node.child){node.child.return=node;node=node.child;continue;}if(node===currentParent){returnnull;}while(!node.sibling){if(!node.return||node.return===currentParent){returnnull;}node=node.return;}node.sibling.return=node.return;node=node.sibling;}// Flow needs the return null here, but ESLint complains about it.
// eslint-disable-next-line no-unreachable
returnnull;}functionfindCurrentHostFiberWithNoPortals(parent){varcurrentParent=findCurrentFiberUsingSlowPath(parent);if(!currentParent){returnnull;}// Next we'll drill down this component to find the first HostComponent/Text.
varnode=currentParent;while(true){if(node.tag===HostComponent||node.tag===HostText||enableFundamentalAPI){returnnode;}elseif(node.child&&node.tag!==HostPortal){node.child.return=node;node=node.child;continue;}if(node===currentParent){returnnull;}while(!node.sibling){if(!node.return||node.return===currentParent){returnnull;}node=node.return;}node.sibling.return=node.return;node=node.sibling;}// Flow needs the return null here, but ESLint complains about it.
// eslint-disable-next-line no-unreachable
returnnull;}functiondoesFiberContain(parentFiber,childFiber){varnode=childFiber;varparentFiberAlternate=parentFiber.alternate;while(node!==null){if(node===parentFiber||node===parentFiberAlternate){returntrue;}node=node.return;}returnfalse;}varattemptUserBlockingHydration;functionsetAttemptUserBlockingHydration(fn){attemptUserBlockingHydration=fn;}varattemptContinuousHydration;functionsetAttemptContinuousHydration(fn){attemptContinuousHydration=fn;}varattemptHydrationAtCurrentPriority;functionsetAttemptHydrationAtCurrentPriority(fn){attemptHydrationAtCurrentPriority=fn;}varattemptHydrationAtPriority;functionsetAttemptHydrationAtPriority(fn){attemptHydrationAtPriority=fn;}// TODO: Upgrade this definition once we're on a newer version of Flow that
varhasScheduledReplayAttempt=false;// The queue of discrete events to be replayed.
varqueuedDiscreteEvents=[];// Indicates if any continuous event targets are non-null for early bailout.
// if the last target was dehydrated.
varqueuedFocus=null;varqueuedDrag=null;varqueuedMouse=null;// For pointer events there can be one latest event per pointerId.
varqueuedPointers=newMap();varqueuedPointerCaptures=newMap();// We could consider replaying selectionchange and touchmoves too.
'copy','cut','paste','click','change','contextmenu','reset','submit'];functionisReplayableDiscreteEvent(eventType){returndiscreteReplayableEvents.indexOf(eventType)>-1;}functioncreateQueuedReplayableEvent(blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent){return{blockedOn:blockedOn,domEventName:domEventName,eventSystemFlags:eventSystemFlags|IS_REPLAYED,nativeEvent:nativeEvent,targetContainers:[targetContainer]};}functionqueueDiscreteEvent(blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent){varqueuedEvent=createQueuedReplayableEvent(blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent);queuedDiscreteEvents.push(queuedEvent);}// Resets the replaying for this type of continuous event to no event.
functionclearIfContinuousEvent(domEventName,nativeEvent){switch(domEventName){case'focusin':case'focusout':queuedFocus=null;break;case'dragenter':case'dragleave':queuedDrag=null;break;case'mouseover':case'mouseout':queuedMouse=null;break;case'pointerover':case'pointerout':{varpointerId=nativeEvent.pointerId;queuedPointers.delete(pointerId);break;}case'gotpointercapture':case'lostpointercapture':{var_pointerId=nativeEvent.pointerId;queuedPointerCaptures.delete(_pointerId);break;}}}functionaccumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent,blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent){if(existingQueuedEvent===null||existingQueuedEvent.nativeEvent!==nativeEvent){varqueuedEvent=createQueuedReplayableEvent(blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent);if(blockedOn!==null){var_fiber2=getInstanceFromNode(blockedOn);if(_fiber2!==null){// Attempt to increase the priority of this target.
attemptContinuousHydration(_fiber2);}}returnqueuedEvent;}// If we have already queued this exact event, then it's because
// the different event systems have different DOM event listeners.
// We can accumulate the flags, and the targetContainers, and
// store a single event to be replayed.
existingQueuedEvent.eventSystemFlags|=eventSystemFlags;vartargetContainers=existingQueuedEvent.targetContainers;if(targetContainer!==null&&targetContainers.indexOf(targetContainer)===-1){targetContainers.push(targetContainer);}returnexistingQueuedEvent;}functionqueueIfContinuousEvent(blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent){// These set relatedTarget to null because the replayed event will be treated as if we
// moved from outside the window (no target) onto the target once it hydrates.
// Instead of mutating we could clone the event.
switch(domEventName){case'focusin':{varfocusEvent=nativeEvent;queuedFocus=accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus,blockedOn,domEventName,eventSystemFlags,targetContainer,focusEvent);returntrue;}case'dragenter':{vardragEvent=nativeEvent;queuedDrag=accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag,blockedOn,domEventName,eventSystemFlags,targetContainer,dragEvent);returntrue;}case'mouseover':{varmouseEvent=nativeEvent;queuedMouse=accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse,blockedOn,domEventName,eventSystemFlags,targetContainer,mouseEvent);returntrue;}case'pointerover':{varpointerEvent=nativeEvent;varpointerId=pointerEvent.pointerId;queuedPointers.set(pointerId,accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId)||null,blockedOn,domEventName,eventSystemFlags,targetContainer,pointerEvent));returntrue;}case'gotpointercapture':{var_pointerEvent=nativeEvent;var_pointerId2=_pointerEvent.pointerId;queuedPointerCaptures.set(_pointerId2,accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(_pointerId2)||null,blockedOn,domEventName,eventSystemFlags,targetContainer,_pointerEvent));returntrue;}}returnfalse;}// Check if this target is unblocked. Returns true if it's unblocked.
functionattemptExplicitHydrationTarget(queuedTarget){// TODO: This function shares a lot of logic with attemptToDispatchEvent.
// Try to unify them. It's a bit tricky since it would require two return
// values.
vartargetInst=getClosestInstanceFromNode(queuedTarget.target);if(targetInst!==null){varnearestMounted=getNearestMountedFiber(targetInst);if(nearestMounted!==null){vartag=nearestMounted.tag;if(tag===SuspenseComponent){varinstance=getSuspenseInstanceFromFiber(nearestMounted);if(instance!==null){// We're blocked on hydrating this boundary.
// Increase its priority.
queuedTarget.blockedOn=instance;attemptHydrationAtPriority(queuedTarget.lanePriority,function(){Scheduler.unstable_runWithPriority(queuedTarget.priority,function(){attemptHydrationAtCurrentPriority(nearestMounted);});});return;}}elseif(tag===HostRoot){varroot=nearestMounted.stateNode;if(root.hydrate){queuedTarget.blockedOn=getContainerFromFiber(nearestMounted);// We don't currently have a way to increase the priority of
// a root other than sync.
return;}}}}queuedTarget.blockedOn=null;}functionattemptReplayContinuousQueuedEvent(queuedEvent){if(queuedEvent.blockedOn!==null){returnfalse;}vartargetContainers=queuedEvent.targetContainers;while(targetContainers.length>0){vartargetContainer=targetContainers[0];varnextBlockedOn=attemptToDispatchEvent(queuedEvent.domEventName,queuedEvent.eventSystemFlags,targetContainer,queuedEvent.nativeEvent);if(nextBlockedOn!==null){// We're still blocked. Try again later.
var_fiber3=getInstanceFromNode(nextBlockedOn);if(_fiber3!==null){attemptContinuousHydration(_fiber3);}queuedEvent.blockedOn=nextBlockedOn;returnfalse;}// This target container was successfully dispatched. Try the next.
targetContainers.shift();}returntrue;}functionattemptReplayContinuousQueuedEventInMap(queuedEvent,key,map){if(attemptReplayContinuousQueuedEvent(queuedEvent)){map.delete(key);}}functionreplayUnblockedEvents(){hasScheduledReplayAttempt=false;// First replay discrete events.
while(queuedDiscreteEvents.length>0){varnextDiscreteEvent=queuedDiscreteEvents[0];if(nextDiscreteEvent.blockedOn!==null){// We're still blocked.
// Increase the priority of this boundary to unblock
// the next discrete event.
var_fiber4=getInstanceFromNode(nextDiscreteEvent.blockedOn);if(_fiber4!==null){attemptUserBlockingHydration(_fiber4);}break;}vartargetContainers=nextDiscreteEvent.targetContainers;while(targetContainers.length>0){vartargetContainer=targetContainers[0];varnextBlockedOn=attemptToDispatchEvent(nextDiscreteEvent.domEventName,nextDiscreteEvent.eventSystemFlags,targetContainer,nextDiscreteEvent.nativeEvent);if(nextBlockedOn!==null){// We're still blocked. Try again later.
nextDiscreteEvent.blockedOn=nextBlockedOn;break;}// This target container was successfully dispatched. Try the next.
targetContainers.shift();}if(nextDiscreteEvent.blockedOn===null){// We've successfully replayed the first event. Let's try the next one.
queuedDiscreteEvents.shift();}}// Next replay any continuous events.
if(queuedFocus!==null&&attemptReplayContinuousQueuedEvent(queuedFocus)){queuedFocus=null;}if(queuedDrag!==null&&attemptReplayContinuousQueuedEvent(queuedDrag)){queuedDrag=null;}if(queuedMouse!==null&&attemptReplayContinuousQueuedEvent(queuedMouse)){queuedMouse=null;}queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);}functionscheduleCallbackIfUnblocked(queuedEvent,unblocked){if(queuedEvent.blockedOn===unblocked){queuedEvent.blockedOn=null;if(!hasScheduledReplayAttempt){hasScheduledReplayAttempt=true;// Schedule a callback to attempt replaying as many events as are
// now unblocked. This first might not actually be unblocked yet.
// We could check it early to avoid scheduling an unnecessary callback.
Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority,replayUnblockedEvents);}}}functionretryIfBlockedOn(unblocked){// Mark anything that was blocked on this as no longer blocked
// and eligible for a replay.
if(queuedDiscreteEvents.length>0){scheduleCallbackIfUnblocked(queuedDiscreteEvents[0],unblocked);// This is a exponential search for each boundary that commits. I think it's
// worth it because we expect very few discrete events to queue up and once
// we are actually fully unblocked it will be fast to replay them.
for(vari=1;i<queuedDiscreteEvents.length;i++){varqueuedEvent=queuedDiscreteEvents[i];if(queuedEvent.blockedOn===unblocked){queuedEvent.blockedOn=null;}}}if(queuedFocus!==null){scheduleCallbackIfUnblocked(queuedFocus,unblocked);}if(queuedDrag!==null){scheduleCallbackIfUnblocked(queuedDrag,unblocked);}if(queuedMouse!==null){scheduleCallbackIfUnblocked(queuedMouse,unblocked);}varunblock=function(queuedEvent){returnscheduleCallbackIfUnblocked(queuedEvent,unblocked);};queuedPointers.forEach(unblock);queuedPointerCaptures.forEach(unblock);for(var_i=0;_i<queuedExplicitHydrationTargets.length;_i++){varqueuedTarget=queuedExplicitHydrationTargets[_i];if(queuedTarget.blockedOn===unblocked){queuedTarget.blockedOn=null;}}while(queuedExplicitHydrationTargets.length>0){varnextExplicitTarget=queuedExplicitHydrationTargets[0];if(nextExplicitTarget.blockedOn!==null){// We're still blocked.
// the un-prefixed "animation" and "transition" properties are defined on the
// style object but the events that fire will still be prefixed, so we need
// to check if the un-prefixed events are usable, and if not remove them from the map.
if(!('AnimationEvent'inwindow)){deletevendorPrefixes.animationend.animation;deletevendorPrefixes.animationiteration.animation;deletevendorPrefixes.animationstart.animation;}// Same as above
// through in twos. The events are in pairs of two to save code
// and improve init perf of processing this array, as it will
// result in far fewer object allocations and property accesses
// if we only use three arrays to process all the categories of
// instead of tuples.
for(vari=0;i<eventTypes.length;i+=2){vartopEvent=eventTypes[i];varevent=eventTypes[i+1];varcapitalizedEvent=event[0].toUpperCase()+event.slice(1);varreactName='on'+capitalizedEvent;eventPriorities.set(topEvent,priority);topLevelEventsToReactNames.set(topEvent,reactName);registerTwoPhaseEvent(reactName,[topEvent]);}}functionsetEventPriorities(eventTypes,priority){for(vari=0;i<eventTypes.length;i++){eventPriorities.set(eventTypes[i],priority);}}functiongetEventPriorityForPluginSystem(domEventName){varpriority=eventPriorities.get(domEventName);// Default to a ContinuousEvent. Note: we might
// want to warn if we can't detect the priority
// for the event.
returnpriority===undefined?ContinuousEvent:priority;}functionregisterSimpleEvents(){registerSimplePluginEventsAndSetTheirPriorities(discreteEventPairsForSimpleEventPlugin,DiscreteEvent);registerSimplePluginEventsAndSetTheirPriorities(userBlockingPairsForSimpleEventPlugin,UserBlockingEvent);registerSimplePluginEventsAndSetTheirPriorities(continuousPairsForSimpleEventPlugin,ContinuousEvent);setEventPriorities(otherDiscreteEvents,DiscreteEvent);}varScheduler_now=Scheduler.unstable_now;{// Provide explicit error message when production+profiling bundle of e.g.
// react-dom is used with production (non-profiling) bundle of
// scheduler/tracing
if(!(tracing$1.__interactionsRef!=null&&tracing$1.__interactionsRef.current!=null)){{throwError("It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at https://reactjs.org/link/profiling");}}}// ascending numbers so we can compare them like numbers. They start at 90 to
// avoid clashing with Scheduler's priorities.
varImmediatePriority=99;varUserBlockingPriority=98;varNormalPriority=97;varLowPriority=96;varIdlePriority=95;// NoPriority is the absence of priority. Also React-only.
varNoPriority=90;varinitialTimeMs=Scheduler_now();// If the initial timestamp is reasonably small, use Scheduler's `now` directly.
// Used by getHighestPriorityLanes and getNextLanes:
varreturn_highestLanePriority=DefaultLanePriority;functiongetHighestPriorityLanes(lanes){if((SyncLane&lanes)!==NoLanes){return_highestLanePriority=SyncLanePriority;returnSyncLane;}if((SyncBatchedLane&lanes)!==NoLanes){return_highestLanePriority=SyncBatchedLanePriority;returnSyncBatchedLane;}if((InputDiscreteHydrationLane&lanes)!==NoLanes){return_highestLanePriority=InputDiscreteHydrationLanePriority;returnInputDiscreteHydrationLane;}varinputDiscreteLanes=InputDiscreteLanes&lanes;if(inputDiscreteLanes!==NoLanes){return_highestLanePriority=InputDiscreteLanePriority;returninputDiscreteLanes;}if((lanes&InputContinuousHydrationLane)!==NoLanes){return_highestLanePriority=InputContinuousHydrationLanePriority;returnInputContinuousHydrationLane;}varinputContinuousLanes=InputContinuousLanes&lanes;if(inputContinuousLanes!==NoLanes){return_highestLanePriority=InputContinuousLanePriority;returninputContinuousLanes;}if((lanes&DefaultHydrationLane)!==NoLanes){return_highestLanePriority=DefaultHydrationLanePriority;returnDefaultHydrationLane;}vardefaultLanes=DefaultLanes&lanes;if(defaultLanes!==NoLanes){return_highestLanePriority=DefaultLanePriority;returndefaultLanes;}if((lanes&TransitionHydrationLane)!==NoLanes){return_highestLanePriority=TransitionHydrationPriority;returnTransitionHydrationLane;}vartransitionLanes=TransitionLanes&lanes;if(transitionLanes!==NoLanes){return_highestLanePriority=TransitionPriority;returntransitionLanes;}varretryLanes=RetryLanes&lanes;if(retryLanes!==NoLanes){return_highestLanePriority=RetryLanePriority;returnretryLanes;}if(lanes&SelectiveHydrationLane){return_highestLanePriority=SelectiveHydrationLanePriority;returnSelectiveHydrationLane;}if((lanes&IdleHydrationLane)!==NoLanes){return_highestLanePriority=IdleHydrationLanePriority;returnIdleHydrationLane;}varidleLanes=IdleLanes&lanes;if(idleLanes!==NoLanes){return_highestLanePriority=IdleLanePriority;returnidleLanes;}if((OffscreenLane&lanes)!==NoLanes){return_highestLanePriority=OffscreenLanePriority;returnOffscreenLane;}{error('Should have found matching lanes. This is a bug in React.');}// This shouldn't be reachable, but as a fallback, return the entire bitmask.
return_highestLanePriority=DefaultLanePriority;returnlanes;}functionschedulerPriorityToLanePriority(schedulerPriorityLevel){switch(schedulerPriorityLevel){caseImmediatePriority:returnSyncLanePriority;caseUserBlockingPriority:returnInputContinuousLanePriority;caseNormalPriority:caseLowPriority:// TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
returnDefaultLanePriority;caseIdlePriority:returnIdleLanePriority;default:returnNoLanePriority;}}functionlanePriorityToSchedulerPriority(lanePriority){switch(lanePriority){caseSyncLanePriority:caseSyncBatchedLanePriority:returnImmediatePriority;caseInputDiscreteHydrationLanePriority:caseInputDiscreteLanePriority:caseInputContinuousHydrationLanePriority:caseInputContinuousLanePriority:returnUserBlockingPriority;caseDefaultHydrationLanePriority:caseDefaultLanePriority:caseTransitionHydrationPriority:caseTransitionPriority:caseSelectiveHydrationLanePriority:caseRetryLanePriority:returnNormalPriority;caseIdleHydrationLanePriority:caseIdleLanePriority:caseOffscreenLanePriority:returnIdlePriority;caseNoLanePriority:returnNoPriority;default:{{throwError("Invalid update priority: "+lanePriority+". This is a bug in React.");}}}}functiongetNextLanes(root,wipLanes){// Early bailout if there's no pending work left.
varpendingLanes=root.pendingLanes;if(pendingLanes===NoLanes){return_highestLanePriority=NoLanePriority;returnNoLanes;}varnextLanes=NoLanes;varnextLanePriority=NoLanePriority;varexpiredLanes=root.expiredLanes;varsuspendedLanes=root.suspendedLanes;varpingedLanes=root.pingedLanes;// Check if any work has expired.
if(expiredLanes!==NoLanes){nextLanes=expiredLanes;nextLanePriority=return_highestLanePriority=SyncLanePriority;}else{// Do not work on any idle work until all the non-idle work has finished,
// even if the work is suspended.
varnonIdlePendingLanes=pendingLanes&NonIdleLanes;if(nonIdlePendingLanes!==NoLanes){varnonIdleUnblockedLanes=nonIdlePendingLanes&~suspendedLanes;if(nonIdleUnblockedLanes!==NoLanes){nextLanes=getHighestPriorityLanes(nonIdleUnblockedLanes);nextLanePriority=return_highestLanePriority;}else{varnonIdlePingedLanes=nonIdlePendingLanes&pingedLanes;if(nonIdlePingedLanes!==NoLanes){nextLanes=getHighestPriorityLanes(nonIdlePingedLanes);nextLanePriority=return_highestLanePriority;}}}else{// The only remaining work is Idle.
varunblockedLanes=pendingLanes&~suspendedLanes;if(unblockedLanes!==NoLanes){nextLanes=getHighestPriorityLanes(unblockedLanes);nextLanePriority=return_highestLanePriority;}else{if(pingedLanes!==NoLanes){nextLanes=getHighestPriorityLanes(pingedLanes);nextLanePriority=return_highestLanePriority;}}}}if(nextLanes===NoLanes){// This should only be reachable if we're suspended
// TODO: Consider warning in this path if a fallback timer is not scheduled.
returnNoLanes;}// If there are higher priority lanes, we'll include them even if they
// are suspended.
nextLanes=pendingLanes&getEqualOrHigherPriorityLanes(nextLanes);// If we're already in the middle of a render, switching lanes will interrupt
// it and we'll lose our progress. We should only do this if the new lanes are
// higher priority.
if(wipLanes!==NoLanes&&wipLanes!==nextLanes&&// If we already suspended with a delay, then interrupting is fine. Don't
// bother waiting until the root is complete.
(wipLanes&suspendedLanes)===NoLanes){getHighestPriorityLanes(wipLanes);varwipLanePriority=return_highestLanePriority;if(nextLanePriority<=wipLanePriority){returnwipLanes;}else{return_highestLanePriority=nextLanePriority;}}// Check for entangled lanes and add them to the batch.
//
// A lane is said to be entangled with another when it's not allowed to render
// in a batch that does not also include the other lane. Typically we do this
// when multiple updates have the same source, and we only want to respond to
// the most recent event from that source.
//
// Note that we apply entanglements *after* checking for partial work above.
// This means that if a lane is entangled during an interleaved event while
// it's already rendering, we won't interrupt it. This is intentional, since
// entanglement is usually "best effort": we'll try our best to render the
// lanes in the same batch, but it's not worth throwing out partially
// completed work in order to do it.
//
// For those exceptions where entanglement is semantically important, like
// useMutableSource, we should ensure that there is no partial work at the
// time we apply the entanglement.
varentangledLanes=root.entangledLanes;if(entangledLanes!==NoLanes){varentanglements=root.entanglements;varlanes=nextLanes&entangledLanes;while(lanes>0){varindex=pickArbitraryLaneIndex(lanes);varlane=1<<index;nextLanes|=entanglements[index];lanes&=~lane;}}returnnextLanes;}functiongetMostRecentEventTime(root,lanes){vareventTimes=root.eventTimes;varmostRecentEventTime=NoTimestamp;while(lanes>0){varindex=pickArbitraryLaneIndex(lanes);varlane=1<<index;vareventTime=eventTimes[index];if(eventTime>mostRecentEventTime){mostRecentEventTime=eventTime;}lanes&=~lane;}returnmostRecentEventTime;}functioncomputeExpirationTime(lane,currentTime){// TODO: Expiration heuristic is constant per lane, so could use a map.
getHighestPriorityLanes(lane);varpriority=return_highestLanePriority;if(priority>=InputContinuousLanePriority){// User interactions should expire slightly more quickly.
//
// NOTE: This is set to the corresponding constant as in Scheduler.js. When
// we made it larger, a product metric in www regressed, suggesting there's
// a user interaction that's being starved by a series of synchronous
// updates. If that theory is correct, the proper solution is to fix the
// starvation. However, this scenario supports the idea that expiration
// times are an important safeguard when starvation does happen.
//
// Also note that, in the case of user input specifically, this will soon no
// longer be an issue because we plan to make user input synchronous by
// default (until you enter `startTransition`, of course.)
//
// If weren't planning to make these updates synchronous soon anyway, I
// would probably make this number a configurable parameter.
returncurrentTime+250;}elseif(priority>=TransitionPriority){returncurrentTime+5000;}else{// Anything idle priority or lower should never expire.
returnNoTimestamp;}}functionmarkStarvedLanesAsExpired(root,currentTime){// TODO: This gets called every time we yield. We can optimize by storing
// the earliest expiration time on the root. Then use that to quickly bail out
// of this function.
varpendingLanes=root.pendingLanes;varsuspendedLanes=root.suspendedLanes;varpingedLanes=root.pingedLanes;varexpirationTimes=root.expirationTimes;// Iterate through the pending lanes and check if we've reached their
// expiration time. If so, we'll assume the update is being starved and mark
// it as expired to force it to finish.
varlanes=pendingLanes;while(lanes>0){varindex=pickArbitraryLaneIndex(lanes);varlane=1<<index;varexpirationTime=expirationTimes[index];if(expirationTime===NoTimestamp){// Found a pending lane with no expiration time. If it's not suspended, or
// if it's pinged, assume it's CPU-bound. Compute a new expiration time
// using the current time.
if((lane&suspendedLanes)===NoLanes||(lane&pingedLanes)!==NoLanes){// Assumes timestamps are monotonically increasing.
expirationTimes[index]=computeExpirationTime(lane,currentTime);}}elseif(expirationTime<=currentTime){// This lane expired
root.expiredLanes|=lane;}lanes&=~lane;}}// This returns the highest priority pending lanes regardless of whether they
functiongetLanesToRetrySynchronouslyOnError(root){vareverythingButOffscreen=root.pendingLanes&~OffscreenLane;if(everythingButOffscreen!==NoLanes){returneverythingButOffscreen;}if(everythingButOffscreen&OffscreenLane){returnOffscreenLane;}returnNoLanes;}functionreturnNextLanesPriority(){returnreturn_highestLanePriority;}functionincludesNonIdleWork(lanes){return(lanes&NonIdleLanes)!==NoLanes;}functionincludesOnlyRetries(lanes){return(lanes&RetryLanes)===lanes;}functionincludesOnlyTransitions(lanes){return(lanes&TransitionLanes)===lanes;}// To ensure consistency across multiple updates in the same event, this should
// be a pure function, so that it always returns the same lane for given inputs.
functionfindUpdateLane(lanePriority,wipLanes){switch(lanePriority){caseNoLanePriority:break;caseSyncLanePriority:returnSyncLane;caseSyncBatchedLanePriority:returnSyncBatchedLane;caseInputDiscreteLanePriority:{var_lane=pickArbitraryLane(InputDiscreteLanes&~wipLanes);if(_lane===NoLane){// Shift to the next priority level
returnfindUpdateLane(InputContinuousLanePriority,wipLanes);}return_lane;}caseInputContinuousLanePriority:{var_lane2=pickArbitraryLane(InputContinuousLanes&~wipLanes);if(_lane2===NoLane){// Shift to the next priority level
returnfindUpdateLane(DefaultLanePriority,wipLanes);}return_lane2;}caseDefaultLanePriority:{var_lane3=pickArbitraryLane(DefaultLanes&~wipLanes);if(_lane3===NoLane){// If all the default lanes are already being worked on, look for a
// lane in the transition range.
_lane3=pickArbitraryLane(TransitionLanes&~wipLanes);if(_lane3===NoLane){// All the transition lanes are taken, too. This should be very
// rare, but as a last resort, pick a default lane. This will have
// the effect of interrupting the current work-in-progress render.
_lane3=pickArbitraryLane(DefaultLanes);}}return_lane3;}caseTransitionPriority:// Should be handled by findTransitionLane instead
caseRetryLanePriority:// Should be handled by findRetryLane instead
break;caseIdleLanePriority:varlane=pickArbitraryLane(IdleLanes&~wipLanes);if(lane===NoLane){lane=pickArbitraryLane(IdleLanes);}returnlane;}{{throwError("Invalid update priority: "+lanePriority+". This is a bug in React.");}}}// To ensure consistency across multiple updates in the same event, this should
// be pure function, so that it always returns the same lane for given inputs.
functionfindTransitionLane(wipLanes,pendingLanes){// First look for lanes that are completely unclaimed, i.e. have no
// pending work.
varlane=pickArbitraryLane(TransitionLanes&~pendingLanes);if(lane===NoLane){// If all lanes have pending work, look for a lane that isn't currently
// being worked on.
lane=pickArbitraryLane(TransitionLanes&~wipLanes);if(lane===NoLane){// If everything is being worked on, pick any lane. This has the
// effect of interrupting the current work-in-progress.
lane=pickArbitraryLane(TransitionLanes);}}returnlane;}// To ensure consistency across multiple updates in the same event, this should
// be pure function, so that it always returns the same lane for given inputs.
functionfindRetryLane(wipLanes){// This is a fork of `findUpdateLane` designed specifically for Suspense
// "retries" — a special update that attempts to flip a Suspense boundary
// from its placeholder state to its primary/resolved state.
varlane=pickArbitraryLane(RetryLanes&~wipLanes);if(lane===NoLane){lane=pickArbitraryLane(RetryLanes);}returnlane;}functiongetHighestPriorityLane(lanes){returnlanes&-lanes;}functiongetLowestPriorityLane(lanes){// This finds the most significant non-zero bit.
varindex=31-clz32(lanes);returnindex<0?NoLanes:1<<index;}functiongetEqualOrHigherPriorityLanes(lanes){return(getLowestPriorityLane(lanes)<<1)-1;}functionpickArbitraryLane(lanes){// This wrapper function gets inlined. Only exists so to communicate that it
// doesn't matter which bit is selected; you can pick any bit without
// affecting the algorithms where its used. Here I'm using
// getHighestPriorityLane because it requires the fewest operations.
returngetHighestPriorityLane(lanes);}functionpickArbitraryLaneIndex(lanes){return31-clz32(lanes);}functionlaneToIndex(lane){returnpickArbitraryLaneIndex(lane);}functionincludesSomeLane(a,b){return(a&b)!==NoLanes;}functionisSubsetOfLanes(set,subset){return(set&subset)===subset;}functionmergeLanes(a,b){returna|b;}functionremoveLanes(set,subset){returnset&~subset;}// Seems redundant, but it changes the type from a single lane (used for
// updates) to a group of lanes (used for flushing work).
functionlaneToLanes(lane){returnlane;}functionhigherPriorityLane(a,b){// This works because the bit ranges decrease in priority as you go left.
returna!==NoLane&&a<b?a:b;}functioncreateLaneMap(initial){// Intentionally pushing one by one.
varlaneMap=[];for(vari=0;i<TotalLanes;i++){laneMap.push(initial);}returnlaneMap;}functionmarkRootUpdated(root,updateLane,eventTime){root.pendingLanes|=updateLane;// TODO: Theoretically, any update to any lane can unblock any other lane. But
// it's not practical to try every single possible combination. We need a
// heuristic to decide which lanes to attempt to render, and in which batches.
// For now, we use the same heuristic as in the old ExpirationTimes model:
// retry any lane at equal or lower priority, but don't try updates at higher
// priority without also including the lower priority updates. This works well
// when considering updates across different priority levels, but isn't
// sufficient for updates within the same priority, since we want to treat
// those updates as parallel.
// Unsuspend any update at equal or lower priority.
varhigherPriorityLanes=updateLane-1;// Turns 0b1000 into 0b0111
root.suspendedLanes&=higherPriorityLanes;root.pingedLanes&=higherPriorityLanes;vareventTimes=root.eventTimes;varindex=laneToIndex(updateLane);// We can always overwrite an existing timestamp because we prefer the most
// recent event, and we assume time is monotonically increasing.
eventTimes[index]=eventTime;}functionmarkRootSuspended(root,suspendedLanes){root.suspendedLanes|=suspendedLanes;root.pingedLanes&=~suspendedLanes;// The suspended lanes are no longer CPU-bound. Clear their expiration times.
varexpirationTimes=root.expirationTimes;varlanes=suspendedLanes;while(lanes>0){varindex=pickArbitraryLaneIndex(lanes);varlane=1<<index;expirationTimes[index]=NoTimestamp;lanes&=~lane;}}functionmarkRootPinged(root,pingedLanes,eventTime){root.pingedLanes|=root.suspendedLanes&pingedLanes;}functionmarkDiscreteUpdatesExpired(root){root.expiredLanes|=InputDiscreteLanes&root.pendingLanes;}functionhasDiscreteLanes(lanes){return(lanes&InputDiscreteLanes)!==NoLanes;}functionmarkRootMutableRead(root,updateLane){root.mutableReadLanes|=updateLane&root.pendingLanes;}functionmarkRootFinished(root,remainingLanes){varnoLongerPendingLanes=root.pendingLanes&~remainingLanes;root.pendingLanes=remainingLanes;// Let's try everything again
root.suspendedLanes=0;root.pingedLanes=0;root.expiredLanes&=remainingLanes;root.mutableReadLanes&=remainingLanes;root.entangledLanes&=remainingLanes;varentanglements=root.entanglements;vareventTimes=root.eventTimes;varexpirationTimes=root.expirationTimes;// Clear the lanes that no longer have pending work
varlanes=noLongerPendingLanes;while(lanes>0){varindex=pickArbitraryLaneIndex(lanes);varlane=1<<index;entanglements[index]=NoLanes;eventTimes[index]=NoTimestamp;expirationTimes[index]=NoTimestamp;lanes&=~lane;}}functionmarkRootEntangled(root,entangledLanes){root.entangledLanes|=entangledLanes;varentanglements=root.entanglements;varlanes=entangledLanes;while(lanes>0){varindex=pickArbitraryLaneIndex(lanes);varlane=1<<index;entanglements[index]|=entangledLanes;lanes&=~lane;}}varclz32=Math.clz32?Math.clz32:clz32Fallback;// Count leading zeros. Only used on lanes, so assume input is an integer.
varlog=Math.log;varLN2=Math.LN2;functionclz32Fallback(lanes){if(lanes===0){return32;}return31-(log(lanes)/LN2|0)|0;}// Intentionally not named imports because Rollup would use dynamic dispatch for
varUserBlockingPriority$1=Scheduler.unstable_UserBlockingPriority,runWithPriority=Scheduler.unstable_runWithPriority;// TODO: can we stop exporting these?
var_enabled=true;// This is exported in FB builds for use by legacy FB layer infra.
// We'd like to remove this but it's not clear if this is safe.
functionsetEnabled(enabled){_enabled=!!enabled;}functionisEnabled(){return_enabled;}functioncreateEventListenerWrapperWithPriority(targetContainer,domEventName,eventSystemFlags){vareventPriority=getEventPriorityForPluginSystem(domEventName);varlistenerWrapper;switch(eventPriority){caseDiscreteEvent:listenerWrapper=dispatchDiscreteEvent;break;caseUserBlockingEvent:listenerWrapper=dispatchUserBlockingUpdate;break;caseContinuousEvent:default:listenerWrapper=dispatchEvent;break;}returnlistenerWrapper.bind(null,domEventName,eventSystemFlags,targetContainer);}functiondispatchDiscreteEvent(domEventName,eventSystemFlags,container,nativeEvent){{flushDiscreteUpdatesIfNeeded(nativeEvent.timeStamp);}discreteUpdates(dispatchEvent,domEventName,eventSystemFlags,container,nativeEvent);}functiondispatchUserBlockingUpdate(domEventName,eventSystemFlags,container,nativeEvent){{runWithPriority(UserBlockingPriority$1,dispatchEvent.bind(null,domEventName,eventSystemFlags,container,nativeEvent));}}functiondispatchEvent(domEventName,eventSystemFlags,targetContainer,nativeEvent){if(!_enabled){return;}varallowReplay=true;{// TODO: replaying capture phase events is currently broken
// because we used to do it during top-level native bubble handlers
// but now we use different bubble and capture handlers.
// In eager mode, we attach capture listeners early, so we need
// to filter them out until we fix the logic to handle them correctly.
// This could've been outside the flag but I put it inside to reduce risk.
allowReplay=(eventSystemFlags&IS_CAPTURE_PHASE)===0;}if(allowReplay&&hasQueuedDiscreteEvents()&&isReplayableDiscreteEvent(domEventName)){// If we already have a queue of discrete events, and this is another discrete
// event, then we can't dispatch it regardless of its target, since they
// need to dispatch in order.
queueDiscreteEvent(null,// Flags that we're not actually blocked on anything as far as we know.
domEventName,eventSystemFlags,targetContainer,nativeEvent);return;}varblockedOn=attemptToDispatchEvent(domEventName,eventSystemFlags,targetContainer,nativeEvent);if(blockedOn===null){// We successfully dispatched this event.
if(allowReplay){clearIfContinuousEvent(domEventName,nativeEvent);}return;}if(allowReplay){if(isReplayableDiscreteEvent(domEventName)){// This this to be replayed later once the target is available.
queueDiscreteEvent(blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent);return;}if(queueIfContinuousEvent(blockedOn,domEventName,eventSystemFlags,targetContainer,nativeEvent)){return;}// We need to clear only if we didn't queue because
// queueing is accummulative.
clearIfContinuousEvent(domEventName,nativeEvent);}// This is not replayable so we'll invoke it but without a target,
// in case the event system needs to trace it.
dispatchEventForPluginEventSystem(domEventName,eventSystemFlags,nativeEvent,null,targetContainer);}// Attempt dispatching an event. Returns a SuspenseInstance or Container if it's blocked.
functionattemptToDispatchEvent(domEventName,eventSystemFlags,targetContainer,nativeEvent){// TODO: Warn if _enabled is false.
varnativeEventTarget=getEventTarget(nativeEvent);vartargetInst=getClosestInstanceFromNode(nativeEventTarget);if(targetInst!==null){varnearestMounted=getNearestMountedFiber(targetInst);if(nearestMounted===null){// This tree has been unmounted already. Dispatch without a target.
targetInst=null;}else{vartag=nearestMounted.tag;if(tag===SuspenseComponent){varinstance=getSuspenseInstanceFromFiber(nearestMounted);if(instance!==null){// Queue the event to be replayed later. Abort dispatching since we
// don't want this event dispatched twice through the event system.
// TODO: If this is the first discrete event in the queue. Schedule an increased
// priority for this boundary.
returninstance;}// This shouldn't happen, something went wrong but to avoid blocking
// the whole system, dispatch the event without a target.
// TODO: Warn.
targetInst=null;}elseif(tag===HostRoot){varroot=nearestMounted.stateNode;if(root.hydrate){// If this happens during a replay something went wrong and it might block
// the whole system.
returngetContainerFromFiber(nearestMounted);}targetInst=null;}elseif(nearestMounted!==targetInst){// If we get an event (ex: img onload) before committing that
// component's mount, ignore it for now (that is, treat it as if it was an
// event on a non-React tree). We might also consider queueing events and
// dispatching them after the mount.
targetInst=null;}}}dispatchEventForPluginEventSystem(domEventName,eventSystemFlags,nativeEvent,targetInst,targetContainer);// We're not blocked on anything.
if(charCode===0&&keyCode===13){charCode=13;}}else{// IE8 does not implement `charCode`, but `keyCode` has the correct value.
charCode=keyCode;}// IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
// report Enter as charCode 10 when ctrl is pressed.
if(charCode===10){charCode=13;}// Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
// Must not discard the (non-)printable Enter-key.
if(charCode>=32||charCode===13){returncharCode;}return0;}functionfunctionThatReturnsTrue(){returntrue;}functionfunctionThatReturnsFalse(){returnfalse;}// This is intentionally a factory so that we have different returned constructors.
// If we had a single constructor, it would be megamorphic and engines would deopt.
}elseif(typeofevent.returnValue!=='unknown'){event.returnValue=false;}this.isDefaultPrevented=functionThatReturnsTrue;},stopPropagation:function(){varevent=this.nativeEvent;if(!event){return;}if(event.stopPropagation){event.stopPropagation();// $FlowFixMe - flow is not aware of `unknown` in IE
}elseif(typeofevent.cancelBubble!=='unknown'){// The ChangeEventPlugin registers a "propertychange" event for
// IE. This event does not support bubbling or cancelling, and
// any references to cancelBubble throw "Member not found". A
// typeof check of "unknown" circumvents this issue (and is also
// implementations of a working draft specification.
// FireFox implements `key` but returns `MozPrintableKey` for all
// printable characters (normalized to `Unidentified`), ignore it.
varkey=normalizeKey[nativeEvent.key]||nativeEvent.key;if(key!=='Unidentified'){returnkey;}}// Browser does not implement `key`, polyfill as much of it as we can.
if(nativeEvent.type==='keypress'){varcharCode=getEventCharCode(nativeEvent);// The enter-key is technically both printable and non-printable and can
// thus be captured by `keypress`, no other non-printable key should.
returncharCode===13?'Enter':String.fromCharCode(charCode);}if(nativeEvent.type==='keydown'||nativeEvent.type==='keyup'){// While user keyboard layout determines the actual meaning of each
// `keyCode` value, almost all function keys have a universal value.
charCode:function(event){// `charCode` is the result of a KeyPress event and represents the value of
// the actual printable character.
// KeyPress is deprecated, but its replacement is not yet final and not
// implemented in any major browser. Only KeyPress has charCode.
if(event.type==='keypress'){returngetEventCharCode(event);}return0;},keyCode:function(event){// `keyCode` is the result of a KeyDown/Up event and represents the value of
// physical keyboard key.
// The actual meaning of the value depends on the users' keyboard layout
// which cannot be detected. Assuming that it is a US keyboard layout
// provides a surprisingly accurate mapping for US and European users.
// Due to this, it is left to the user to implement at this time.
if(event.type==='keydown'||event.type==='keyup'){returnevent.keyCode;}return0;},which:function(event){// `which` is an alias for either `keyCode` or `charCode` depending on the
'wheelDeltaX'inevent?-event.wheelDeltaX:0;},deltaY:function(event){return'deltaY'inevent?event.deltaY:// Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
'wheelDeltaY'inevent?-event.wheelDeltaY:// Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
'wheelDelta'inevent?-event.wheelDelta:0;},deltaZ:0,// Browsers without "deltaMode" is reporting in raw wheel delta where one
// notch on the scroll is always +/- 120, roughly equivalent to pixels.
// A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
// ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
deltaMode:0});varSyntheticWheelEvent=createSyntheticEvent(WheelEventInterface);varEND_KEYCODES=[9,13,27,32];// Tab, Return, Esc, Space
varSTART_KEYCODE=229;varcanUseCompositionEvent=canUseDOM&&'CompositionEvent'inwindow;vardocumentMode=null;if(canUseDOM&&'documentMode'indocument){documentMode=document.documentMode;}// Webkit offers a very useful `textInput` event that can be used to
// directly represent `beforeInput`. The IE `textinput` event is not as
// useful, so we don't use it.
varcanUseTextInputEvent=canUseDOM&&'TextEvent'inwindow&&!documentMode;// In IE9+, we have access to composition events, but the data supplied
// by the native compositionend event may be incorrect. Japanese ideographic
// spaces, for instance (\u3000) are not recorded correctly.
varuseFallbackCompositionData=canUseDOM&&(!canUseCompositionEvent||documentMode&&documentMode>8&&documentMode<=11);varSPACEBAR_CODE=32;varSPACEBAR_CHAR=String.fromCharCode(SPACEBAR_CODE);functionregisterEvents(){registerTwoPhaseEvent('onBeforeInput',['compositionend','keypress','textInput','paste']);registerTwoPhaseEvent('onCompositionEnd',['compositionend','focusout','keydown','keypress','keyup','mousedown']);registerTwoPhaseEvent('onCompositionStart',['compositionstart','focusout','keydown','keypress','keyup','mousedown']);registerTwoPhaseEvent('onCompositionUpdate',['compositionupdate','focusout','keydown','keypress','keyup','mousedown']);}// Track whether we've ever handled a keypress on the space key.
if(!isComposing&&eventType==='onCompositionStart'){isComposing=initialize(nativeEventTarget);}elseif(eventType==='onCompositionEnd'){if(isComposing){fallbackData=getData();}}}varlisteners=accumulateTwoPhaseListeners(targetInst,eventType);if(listeners.length>0){varevent=newSyntheticCompositionEvent(eventType,domEventName,null,nativeEvent,nativeEventTarget);dispatchQueue.push({event:event,listeners:listeners});if(fallbackData){// Inject data generated from fallback path into the synthetic event.
// This matches the property of native CompositionEventInterface.
// try to extract the composed characters from the fallback object.
// If composition event is available, we extract a string only at
// compositionevent, otherwise extract it at fallback events.
if(isComposing){if(domEventName==='compositionend'||!canUseCompositionEvent&&isFallbackCompositionEnd(domEventName,nativeEvent)){varchars=getData();reset();isComposing=false;returnchars;}returnnull;}switch(domEventName){case'paste':// If a paste event occurs after a keypress, throw out the input
// chars. Paste events should not lead to BeforeInput events.
// doesn't fire when text is deleted, but conveniently, selectionchange
// appears to fire in all of the remaining cases so we catch those and
// forward the event if the value has changed
// In either case, we don't want to call the event handler if the value
// is changed from JS so we redefine a setter for `.value` that updates
// our activeElementValue variable, allowing us to ignore those changes
//
// stopWatching() should be a noop here but we call it just in case we
// missed a blur event somehow.
stopWatchingForValueChange();startWatchingForValueChange(target,targetInst);}elseif(domEventName==='focusout'){stopWatchingForValueChange();}}// For IE8 and IE9.
functiongetTargetInstForInputEventPolyfill(domEventName,targetInst){if(domEventName==='selectionchange'||domEventName==='keyup'||domEventName==='keydown'){// On the selectionchange event, the target is just document which isn't
// helpful for us so just check activeElement instead.
//
// 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
// propertychange on the first input event after setting `value` from a
// script and fires only keydown, keypress, keyup. Catching keyup usually
// gets it and catching keydown lets us fire an event for the first
// keystroke if user does a key repeat (it'll be a little delayed: right
// before the second keystroke). Other input methods (e.g., paste) seem to
// This approach works across all browsers, whereas `change` does not fire
// until `blur` in IE8.
varnodeName=elem.nodeName;returnnodeName&&nodeName.toLowerCase()==='input'&&(elem.type==='checkbox'||elem.type==='radio');}functiongetTargetInstForClickEvent(domEventName,targetInst){if(domEventName==='click'){returngetInstIfValueChanged(targetInst);}}functiongetTargetInstForInputOrChangeEvent(domEventName,targetInst){if(domEventName==='input'||domEventName==='change'){returngetInstIfValueChanged(targetInst);}}functionhandleControlledInputBlur(node){varstate=node._wrapperState;if(!state||!state.controlled||node.type!=='number'){return;}{// If controlled, assign the value attribute to the current value on blur
// the event in the out event of the other target. If this is replayed,
// then it's because we couldn't dispatch against this target previously
// so we have to do it now instead.
varrelated=nativeEvent.relatedTarget||nativeEvent.fromElement;if(related){// If the related node is managed by React, we can assume that we have
// already dispatched the corresponding events during its mouseout.
if(getClosestInstanceFromNode(related)||isContainerMarkedAsRoot(related)){return;}}}if(!isOutEvent&&!isOverEvent){// Must not be a mouse or pointer in or out - ignoring.
return;}varwin;// TODO: why is this nullable in the types but we read from it?
if(nativeEventTarget.window===nativeEventTarget){// `nativeEventTarget` is probably a window object.
win=nativeEventTarget;}else{// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
vardoc=nativeEventTarget.ownerDocument;if(doc){win=doc.defaultView||doc.parentWindow;}else{win=window;}}varfrom;varto;if(isOutEvent){var_related=nativeEvent.relatedTarget||nativeEvent.toElement;from=targetInst;to=_related?getClosestInstanceFromNode(_related):null;if(to!==null){varnearestMounted=getNearestMountedFiber(to);if(to!==nearestMounted||to.tag!==HostComponent&&to.tag!==HostText){to=null;}}}else{// Moving to a node from outside the window.
from=null;to=targetInst;}if(from===to){// Nothing pertains to our managed components.
return;}varSyntheticEventCtor=SyntheticMouseEvent;varleaveEventType='onMouseLeave';varenterEventType='onMouseEnter';vareventTypePrefix='mouse';if(domEventName==='pointerout'||domEventName==='pointerover'){SyntheticEventCtor=SyntheticPointerEvent;leaveEventType='onPointerLeave';enterEventType='onPointerEnter';eventTypePrefix='pointer';}varfromNode=from==null?win:getNodeFromInstance(from);vartoNode=to==null?win:getNodeFromInstance(to);varleave=newSyntheticEventCtor(leaveEventType,eventTypePrefix+'leave',from,nativeEvent,nativeEventTarget);leave.target=fromNode;leave.relatedTarget=toNode;varenter=null;// We should only process this nativeEvent if we are processing
// the first ancestor. Next time, we will ignore the event.
parentNode=node;node=next;}while(true){if(node===outerNode){// If `outerNode` has children, this is always the second time visiting
// it. If it has no children, this is still the first loop, and the only
// valid selection is anchorNode and focusNode both equal to this node
// and both offsets 0, in which case we will have handled above.
breakouter;}if(parentNode===anchorNode&&++indexWithinAnchor===anchorOffset){start=length;}if(parentNode===focusNode&&++indexWithinFocus===focusOffset){end=length;}if((next=node.nextSibling)!==null){break;}node=parentNode;parentNode=node.parentNode;}// Moving from `node` to its next sibling `next`.
node=next;}if(start===-1||end===-1){// This should never happen. (Would happen if the anchor/focus nodes aren't
// (For instance: TinyMCE editor used in a list component that supports pasting to add more,
// fails when pasting 100+ items)
if(!win.getSelection){return;}varselection=win.getSelection();varlength=node.textContent.length;varstart=Math.min(offsets.start,length);varend=offsets.end===undefined?start:Math.min(offsets.end,length);// IE 11 uses modern selection, but doesn't support the extend method.
// Flip backward selections, so we can set with a single range.
if(!selection.extend&&start>end){vartemp=end;end=start;start=temp;}varstartMarker=getNodeForCharacterOffset(node,start);varendMarker=getNodeForCharacterOffset(node,end);if(startMarker&&endMarker){if(selection.rangeCount===1&&selection.anchorNode===startMarker.node&&selection.anchorOffset===startMarker.offset&&selection.focusNode===endMarker.node&&selection.focusOffset===endMarker.offset){return;}varrange=doc.createRange();range.setStart(startMarker.node,startMarker.offset);selection.removeAllRanges();if(start>end){selection.addRange(range);selection.extend(endMarker.node,endMarker.offset);}else{range.setEnd(endMarker.node,endMarker.offset);selection.addRange(range);}}}functionisTextNode(node){returnnode&&node.nodeType===TEXT_NODE;}functioncontainsNode(outerNode,innerNode){if(!outerNode||!innerNode){returnfalse;}elseif(outerNode===innerNode){returntrue;}elseif(isTextNode(outerNode)){returnfalse;}elseif(isTextNode(innerNode)){returncontainsNode(outerNode,innerNode.parentNode);}elseif('contains'inouterNode){returnouterNode.contains(innerNode);}elseif(outerNode.compareDocumentPosition){return!!(outerNode.compareDocumentPosition(innerNode)&16);}else{returnfalse;}}functionisInDocument(node){returnnode&&node.ownerDocument&&containsNode(node.ownerDocument.documentElement,node);}functionisSameOriginFrame(iframe){try{// Accessing the contentDocument of a HTMLIframeElement can cause the browser
// to throw, e.g. if it has a cross-origin src attribute.
// Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
// iframe.contentDocument.defaultView;
// A safety way is to access one of the cross origin properties: Window or Location
// Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
// fires only on input and textarea thus if there's no focused element we
// won't dispatch.
vardoc=getEventTargetDocument(nativeEventTarget);if(mouseDown||activeElement$1==null||activeElement$1!==getActiveElement(doc)){return;}// Only fire when selection has actually changed.
case'focusin':if(isTextInputElement(targetNode)||targetNode.contentEditable==='true'){activeElement$1=targetNode;activeElementInst$1=targetInst;lastSelection=null;}break;case'focusout':activeElement$1=null;activeElementInst$1=null;lastSelection=null;break;// Don't fire the event while the user is dragging. This matches the
// semantics of the native select event.
case'mousedown':mouseDown=true;break;case'contextmenu':case'mouseup':case'dragend':mouseDown=false;constructSelectEvent(dispatchQueue,nativeEvent,nativeEventTarget);break;// Chrome and IE fire non-standard event when selection is changed (and
// sometimes when it hasn't). IE's event fires out of order with respect
// to key and input events on deletion, so we discard it.
//
// Firefox doesn't support selectionchange, so check selection status
// after each key entry. The selection changes after keydown and before
// keyup, but we check on keydown as well in the case of holding down a
// key, when multiple keydown events are fired but only one keyup is.
// This is also our approach for IE handling, for the reason above.
case'selectionchange':if(skipSelectionChangeEvent){break;}// falls through
case'keydown':case'keyup':constructSelectEvent(dispatchQueue,nativeEvent,nativeEventTarget);}}functionextractEvents$4(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget,eventSystemFlags,targetContainer){varreactName=topLevelEventsToReactNames.get(domEventName);if(reactName===undefined){return;}varSyntheticEventCtor=SyntheticEvent;varreactEventType=domEventName;switch(domEventName){case'keypress':// Firefox creates a keypress event for function keys too. This removes
// the unwanted keypress events. Enter is however both printable and
// non-printable. One would expect Tab to be as well (but it isn't).
if(getEventCharCode(nativeEvent)===0){return;}/* falls through */case'keydown':case'keyup':SyntheticEventCtor=SyntheticKeyboardEvent;break;case'focusin':reactEventType='focus';SyntheticEventCtor=SyntheticFocusEvent;break;case'focusout':reactEventType='blur';SyntheticEventCtor=SyntheticFocusEvent;break;case'beforeblur':case'afterblur':SyntheticEventCtor=SyntheticFocusEvent;break;case'click':// Firefox creates a click event on right mouse clicks. This removes the
// unwanted click events.
if(nativeEvent.button===2){return;}/* falls through */case'auxclick':case'dblclick':case'mousedown':case'mousemove':case'mouseup':// TODO: Disabled elements should not respond to mouse events
/* falls through */case'mouseout':case'mouseover':case'contextmenu':SyntheticEventCtor=SyntheticMouseEvent;break;case'drag':case'dragend':case'dragenter':case'dragexit':case'dragleave':case'dragover':case'dragstart':case'drop':SyntheticEventCtor=SyntheticDragEvent;break;case'touchcancel':case'touchend':case'touchmove':case'touchstart':SyntheticEventCtor=SyntheticTouchEvent;break;caseANIMATION_END:caseANIMATION_ITERATION:caseANIMATION_START:SyntheticEventCtor=SyntheticAnimationEvent;break;caseTRANSITION_END:SyntheticEventCtor=SyntheticTransitionEvent;break;case'scroll':SyntheticEventCtor=SyntheticUIEvent;break;case'wheel':SyntheticEventCtor=SyntheticWheelEvent;break;case'copy':case'cut':case'paste':SyntheticEventCtor=SyntheticClipboardEvent;break;case'gotpointercapture':case'lostpointercapture':case'pointercancel':case'pointerdown':case'pointermove':case'pointerout':case'pointerover':case'pointerup':SyntheticEventCtor=SyntheticPointerEvent;break;}varinCapturePhase=(eventSystemFlags&IS_CAPTURE_PHASE)!==0;{// Some events don't bubble in the browser.
// In the past, React has always bubbled them, but this can be surprising.
// We're going to try aligning closer to the browser behavior by not bubbling
// them in React either. We'll start by not bubbling onScroll, and then expand.
varaccumulateTargetOnly=!inCapturePhase&&// TODO: ideally, we'd eventually add all events from
// nonDelegatedEvents list in DOMPluginEventSystem.
// Then we can remove this special list.
// This is a breaking change that can wait until React 18.
var_event=newSyntheticEventCtor(reactName,reactEventType,null,nativeEvent,nativeEventTarget);dispatchQueue.push({event:_event,listeners:_listeners});}}}// TODO: remove top-level side effect.
registerSimpleEvents();registerEvents$2();registerEvents$1();registerEvents$3();registerEvents();functionextractEvents$5(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget,eventSystemFlags,targetContainer){// TODO: we should remove the concept of a "SimpleEventPlugin".
// This is the basic functionality of the event system. All
// the other plugins are essentially polyfills. So the plugin
// should probably be inlined somewhere and have its logic
// be core the to event system. This would potentially allow
// us to ship builds of React without the polyfilled plugins below.
extractEvents$4(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget,eventSystemFlags);varshouldProcessPolyfillPlugins=(eventSystemFlags&SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS)===0;// We don't process these events unless we are in the
// event's native "bubble" phase, which means that we're
// not in the capture phase. That's because we emulate
// the capture phase here still. This is a trade-off,
// because in an ideal world we would not emulate and use
// the phases properly, like we do with the SimpleEvent
// plugin. However, the plugins below either expect
// emulation (EnterLeave) or use state localized to that
// plugin (BeforeInput, Change, Select). The state in
// these modules complicates things, as you'll essentially
// get the case where the capture phase event might change
// state, only for the following bubble event to come in
// later and not trigger anything as the state now
// invalidates the heuristics of the event plugin. We
// could alter all these plugins to work in such ways, but
// that might cause other unknown side-effects that we
// can't forsee right now.
if(shouldProcessPolyfillPlugins){extractEvents$2(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget,eventSystemFlags);extractEvents$1(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget);extractEvents$3(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget);extractEvents(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget);}}// List of events that need to be individually attached to media elements.
varmediaEventTypes=['abort','canplay','canplaythrough','durationchange','emptied','encrypted','ended','error','loadeddata','loadedmetadata','loadstart','pause','play','playing','progress','ratechange','seeked','seeking','stalled','suspend','timeupdate','volumechange','waiting'];// We should not delegate these events to the container, but rather
// set them on the actual target element itself. This is primarily
// because these events do not consistently bubble in the DOM.
varnonDelegatedEvents=newSet(['cancel','close','invalid','load','scroll','toggle'].concat(mediaEventTypes));functionexecuteDispatch(event,listener,currentTarget){vartype=event.type||'unknown-event';event.currentTarget=currentTarget;invokeGuardedCallbackAndCatchFirstError(type,listener,undefined,event);event.currentTarget=null;}functionprocessDispatchQueueItemsInOrder(event,dispatchListeners,inCapturePhase){varpreviousInstance;if(inCapturePhase){for(vari=dispatchListeners.length-1;i>=0;i--){var_dispatchListeners$i=dispatchListeners[i],instance=_dispatchListeners$i.instance,currentTarget=_dispatchListeners$i.currentTarget,listener=_dispatchListeners$i.listener;if(instance!==previousInstance&&event.isPropagationStopped()){return;}executeDispatch(event,listener,currentTarget);previousInstance=instance;}}else{for(var_i=0;_i<dispatchListeners.length;_i++){var_dispatchListeners$_i=dispatchListeners[_i],_instance=_dispatchListeners$_i.instance,_currentTarget=_dispatchListeners$_i.currentTarget,_listener=_dispatchListeners$_i.listener;if(_instance!==previousInstance&&event.isPropagationStopped()){return;}executeDispatch(event,_listener,_currentTarget);previousInstance=_instance;}}}functionprocessDispatchQueue(dispatchQueue,eventSystemFlags){varinCapturePhase=(eventSystemFlags&IS_CAPTURE_PHASE)!==0;for(vari=0;i<dispatchQueue.length;i++){var_dispatchQueue$i=dispatchQueue[i],event=_dispatchQueue$i.event,listeners=_dispatchQueue$i.listeners;processDispatchQueueItemsInOrder(event,listeners,inCapturePhase);// event system doesn't use pooling.
}// This would be a good time to rethrow if any of the event handlers threw.
rethrowCaughtError();}functiondispatchEventsForPlugins(domEventName,eventSystemFlags,nativeEvent,targetInst,targetContainer){varnativeEventTarget=getEventTarget(nativeEvent);vardispatchQueue=[];extractEvents$5(dispatchQueue,domEventName,targetInst,nativeEvent,nativeEventTarget,eventSystemFlags);processDispatchQueue(dispatchQueue,eventSystemFlags);}functionlistenToNonDelegatedEvent(domEventName,targetElement){varisCapturePhaseListener=false;varlistenerSet=getEventListenerSet(targetElement);varlistenerSetKey=getListenerSetKey(domEventName,isCapturePhaseListener);if(!listenerSet.has(listenerSetKey)){addTrappedEventListener(targetElement,domEventName,IS_NON_DELEGATED,isCapturePhaseListener);listenerSet.add(listenerSetKey);}}varlisteningMarker='_reactListening'+Math.random().toString(36).slice(2);functionlistenToAllSupportedEvents(rootContainerElement){{if(rootContainerElement[listeningMarker]){// Performance optimization: don't iterate through events
// for the same portal container or root node more than once.
// TODO: once we remove the flag, we may be able to also
// remove some of the bookkeeping maps used for laziness.
return;}rootContainerElement[listeningMarker]=true;allNativeEvents.forEach(function(domEventName){if(!nonDelegatedEvents.has(domEventName)){listenToNativeEvent(domEventName,false,rootContainerElement,null);}listenToNativeEvent(domEventName,true,rootContainerElement,null);});}}functionlistenToNativeEvent(domEventName,isCapturePhaseListener,rootContainerElement,targetElement){vareventSystemFlags=arguments.length>4&&arguments[4]!==undefined?arguments[4]:0;vartarget=rootContainerElement;// selectionchange needs to be attached to the document
// otherwise it won't capture incoming events that are only
// triggered on the document directly.
if(domEventName==='selectionchange'&&rootContainerElement.nodeType!==DOCUMENT_NODE){target=rootContainerElement.ownerDocument;}// If the event can be delegated (or is capture phase), we can
// register it to the root container. Otherwise, we should
// register the event to the target element and mark it as
// a non-delegated event.
if(targetElement!==null&&!isCapturePhaseListener&&nonDelegatedEvents.has(domEventName)){// For all non-delegated events, apart from scroll, we attach
// their event listeners to the respective elements that their
// events fire on. That means we can skip this step, as event
// listener has already been added previously. However, we
// special case the scroll event because the reality is that any
// element can scroll.
// TODO: ideally, we'd eventually apply the same logic to all
// events from the nonDelegatedEvents list. Then we can remove
// this special case and use the same logic for all events.
if(domEventName!=='scroll'){return;}eventSystemFlags|=IS_NON_DELEGATED;target=targetElement;}varlistenerSet=getEventListenerSet(target);varlistenerSetKey=getListenerSetKey(domEventName,isCapturePhaseListener);// If the listener entry is empty or we should upgrade, then
// we need to trap an event listener onto the target.
if(!listenerSet.has(listenerSetKey)){if(isCapturePhaseListener){eventSystemFlags|=IS_CAPTURE_PHASE;}addTrappedEventListener(target,domEventName,eventSystemFlags,isCapturePhaseListener);listenerSet.add(listenerSetKey);}}functionaddTrappedEventListener(targetContainer,domEventName,eventSystemFlags,isCapturePhaseListener,isDeferredListenerForLegacyFBSupport){varlistener=createEventListenerWrapperWithPriority(targetContainer,domEventName,eventSystemFlags);// If passive option is not supported, then the event will be
// active and not passive.
varisPassiveListener=undefined;if(passiveBrowserEventsSupported){// Browsers introduced an intervention, making these events
// passive by default on document. React doesn't bind them
// to document anymore, but changing this now would undo
// the performance wins from the change. So we emulate
// the existing behavior manually on the roots now.
// https://github.com/facebook/react/issues/19651
if(domEventName==='touchstart'||domEventName==='touchmove'||domEventName==='wheel'){isPassiveListener=true;}}targetContainer=targetContainer;varunsubscribeListener;// When legacyFBSupport is enabled, it's for when we
if(isCapturePhaseListener){if(isPassiveListener!==undefined){unsubscribeListener=addEventCaptureListenerWithPassiveFlag(targetContainer,domEventName,listener,isPassiveListener);}else{unsubscribeListener=addEventCaptureListener(targetContainer,domEventName,listener);}}else{if(isPassiveListener!==undefined){unsubscribeListener=addEventBubbleListenerWithPassiveFlag(targetContainer,domEventName,listener,isPassiveListener);}else{unsubscribeListener=addEventBubbleListener(targetContainer,domEventName,listener);}}}functionisMatchingRootContainer(grandContainer,targetContainer){returngrandContainer===targetContainer||grandContainer.nodeType===COMMENT_NODE&&grandContainer.parentNode===targetContainer;}functiondispatchEventForPluginEventSystem(domEventName,eventSystemFlags,nativeEvent,targetInst,targetContainer){varancestorInst=targetInst;if((eventSystemFlags&IS_EVENT_HANDLE_NON_MANAGED_NODE)===0&&(eventSystemFlags&IS_NON_DELEGATED)===0){vartargetContainerNode=targetContainer;// If we are using the legacy FB support flag, we
if(targetInst!==null){// The below logic attempts to work out if we need to change
// the target fiber to a different ancestor. We had similar logic
// in the legacy event system, except the big difference between
// systems is that the modern event system now has an event listener
// attached to each React Root and React Portal Root. Together,
// the DOM nodes representing these roots are the "rootContainer".
// To figure out which ancestor instance we should use, we traverse
// up the fiber tree from the target instance and attempt to find
// root boundaries that match that of our current "rootContainer".
// If we find that "rootContainer", we find the parent fiber
// sub-tree for that root and make that our ancestor instance.
varnode=targetInst;mainLoop:while(true){if(node===null){return;}varnodeTag=node.tag;if(nodeTag===HostRoot||nodeTag===HostPortal){varcontainer=node.stateNode.containerInfo;if(isMatchingRootContainer(container,targetContainerNode)){break;}if(nodeTag===HostPortal){// The target is a portal, but it's not the rootContainer we're looking for.
// Normally portals handle their own events all the way down to the root.
// So we should be able to stop now. However, we don't know if this portal
// was part of *our* root.
vargrandNode=node.return;while(grandNode!==null){vargrandTag=grandNode.tag;if(grandTag===HostRoot||grandTag===HostPortal){vargrandContainer=grandNode.stateNode.containerInfo;if(isMatchingRootContainer(grandContainer,targetContainerNode)){// This is the rootContainer we're looking for and we found it as
// a parent of the Portal. That means we can ignore it because the
// Portal will bubble through to us.
return;}}grandNode=grandNode.return;}}// Now we need to find it's corresponding host fiber in the other
// tree. To do this we can use getClosestInstanceFromNode, but we
// need to validate that the fiber is a host instance, otherwise
// we need to traverse up through the DOM till we find the correct
// node that is from the other tree.
while(container!==null){varparentNode=getClosestInstanceFromNode(container);if(parentNode===null){return;}varparentTag=parentNode.tag;if(parentTag===HostComponent||parentTag===HostText){node=ancestorInst=parentNode;continuemainLoop;}container=container.parentNode;}}node=node.return;}}}batchedEventUpdates(function(){returndispatchEventsForPlugins(domEventName,eventSystemFlags,nativeEvent,ancestorInst);});}functioncreateDispatchListener(instance,listener,currentTarget){return{instance:instance,listener:listener,currentTarget:currentTarget};}functionaccumulateSinglePhaseListeners(targetFiber,reactName,nativeEventType,inCapturePhase,accumulateTargetOnly){varcaptureName=reactName!==null?reactName+'Capture':null;varreactEventName=inCapturePhase?captureName:reactName;varlisteners=[];varinstance=targetFiber;varlastHostComponent=null;// Accumulate all instances and listeners via the target -> root path.
while(instance!==null){var_instance2=instance,stateNode=_instance2.stateNode,tag=_instance2.tag;// Handle listeners that are on HostComponents (i.e. <div>)
if(reactEventName!==null){varlistener=getListener(instance,reactEventName);if(listener!=null){listeners.push(createDispatchListener(instance,listener,lastHostComponent));}}}// If we are only accumulating events for the target, then we don't
// continue to propagate through the React fiber tree to find other
// listeners.
if(accumulateTargetOnly){break;}instance=instance.return;}returnlisteners;}// We should only use this function for:
// - BeforeInputEventPlugin
// - ChangeEventPlugin
// - SelectEventPlugin
// This is because we only process these plugins
// in the bubble phase, so we need to accumulate two
// phase event listeners (via emulation).
functionaccumulateTwoPhaseListeners(targetFiber,reactName){varcaptureName=reactName+'Capture';varlisteners=[];varinstance=targetFiber;// Accumulate all instances and listeners via the target -> root path.
while(instance!==null){var_instance3=instance,stateNode=_instance3.stateNode,tag=_instance3.tag;// Handle listeners that are on HostComponents (i.e. <div>)
if(tag===HostComponent&&stateNode!==null){varcurrentTarget=stateNode;varcaptureListener=getListener(instance,captureName);if(captureListener!=null){listeners.unshift(createDispatchListener(instance,captureListener,currentTarget));}varbubbleListener=getListener(instance,reactName);if(bubbleListener!=null){listeners.push(createDispatchListener(instance,bubbleListener,currentTarget));}}instance=instance.return;}returnlisteners;}functiongetParent(inst){if(inst===null){returnnull;}do{inst=inst.return;// TODO: If this is a HostRoot we might want to bail out.
// That is depending on if we want nested subtrees (layers) to bubble
// events to their parent. We could also go through parentNode on the
// host node but that wouldn't work for React Native and doesn't let us
while(depthA-depthB>0){nodeA=getParent(nodeA);depthA--;}// If B is deeper, crawl up.
while(depthB-depthA>0){nodeB=getParent(nodeB);depthB--;}// Walk in lockstep until we find a match.
vardepth=depthA;while(depth--){if(nodeA===nodeB||nodeB!==null&&nodeA===nodeB.alternate){returnnodeA;}nodeA=getParent(nodeA);nodeB=getParent(nodeB);}returnnull;}functionaccumulateEnterLeaveListenersForEvent(dispatchQueue,event,target,common,inCapturePhase){varregistrationName=event._reactName;varlisteners=[];varinstance=target;while(instance!==null){if(instance===common){break;}var_instance4=instance,alternate=_instance4.alternate,stateNode=_instance4.stateNode,tag=_instance4.tag;if(alternate!==null&&alternate===common){break;}if(tag===HostComponent&&stateNode!==null){varcurrentTarget=stateNode;if(inCapturePhase){varcaptureListener=getListener(instance,registrationName);if(captureListener!=null){listeners.unshift(createDispatchListener(instance,captureListener,currentTarget));}}elseif(!inCapturePhase){varbubbleListener=getListener(instance,registrationName);if(bubbleListener!=null){listeners.push(createDispatchListener(instance,bubbleListener,currentTarget));}}}instance=instance.return;}if(listeners.length!==0){dispatchQueue.push({event:event,listeners:listeners});}}// We should only use this function for:
// - EnterLeaveEventPlugin
// This is because we only process this plugin
// in the bubble phase, so we need to accumulate two
// phase event listeners.
functionaccumulateEnterLeaveTwoPhaseListeners(dispatchQueue,leaveEvent,enterEvent,from,to){varcommon=from&&to?getLowestCommonAncestor(from,to):null;if(from!==null){accumulateEnterLeaveListenersForEvent(dispatchQueue,leaveEvent,from,common,false);}if(to!==null&&enterEvent!==null){accumulateEnterLeaveListenersForEvent(dispatchQueue,enterEvent,to,common,true);}}functiongetListenerSetKey(domEventName,capture){returndomEventName+"__"+(capture?'capture':'bubble');}vardidWarnInvalidHydration=false;varDANGEROUSLY_SET_INNER_HTML='dangerouslySetInnerHTML';varSUPPRESS_CONTENT_EDITABLE_WARNING='suppressContentEditableWarning';varSUPPRESS_HYDRATION_WARNING='suppressHydrationWarning';varAUTOFOCUS='autoFocus';varCHILDREN='children';varSTYLE='style';varHTML$1='__html';varHTML_NAMESPACE$1=Namespaces.html;varwarnedUnknownTags;varsuppressHydrationWarning;varvalidatePropertiesInDevelopment;varwarnForTextDifference;varwarnForPropDifference;varwarnForExtraAttributes;varwarnForInvalidEventListener;varcanDiffStyleForHydrationWarning;varnormalizeMarkupForTextOrAttribute;varnormalizeHTML;{warnedUnknownTags={// There are working polyfills for <dialog>. Let people use it.
dialog:true,// Electron ships a custom <webview> tag to display external web content in
// an isolated frame and process.
// This tag is not present in non Electron environments such as JSDom which
webview:true};validatePropertiesInDevelopment=function(type,props){validateProperties(type,props);validateProperties$1(type,props);validateProperties$2(type,props,{registrationNameDependencies:registrationNameDependencies,possibleRegistrationNames:possibleRegistrationNames});};// IE 11 parses & normalizes the style attribute as opposed to other
// browsers. It adds spaces and sorts the properties in some
// non-alphabetical order. Handling that would require sorting CSS
// properties in the client & server versions or applying
// `expectedStyle` to a temporary DOM node to read its `style` attribute
// normalized. Since it only affects IE, we're skipping style warnings
// in that browser completely in favor of doing all that work.
// See https://github.com/facebook/react/issues/11807
canDiffStyleForHydrationWarning=canUseDOM&&!document.documentMode;// HTML parsing normalizes CR and CRLF to LF.
// It also can turn \u0000 into \uFFFD inside attributes.
// If we have a mismatch, it might be caused by that.
// We will still patch up in this case but not fire the warning.
varNORMALIZE_NEWLINES_REGEX=/\r\n?/g;varNORMALIZE_NULL_AND_REPLACEMENT_REGEX=/\u0000|\uFFFD/g;normalizeMarkupForTextOrAttribute=function(markup){varmarkupString=typeofmarkup==='string'?markup:''+markup;returnmarkupString.replace(NORMALIZE_NEWLINES_REGEX,'\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX,'');};warnForTextDifference=function(serverText,clientText){if(didWarnInvalidHydration){return;}varnormalizedClientText=normalizeMarkupForTextOrAttribute(clientText);varnormalizedServerText=normalizeMarkupForTextOrAttribute(serverText);if(normalizedServerText===normalizedClientText){return;}didWarnInvalidHydration=true;error('Text content did not match. Server: "%s" Client: "%s"',normalizedServerText,normalizedClientText);};warnForPropDifference=function(propName,serverValue,clientValue){if(didWarnInvalidHydration){return;}varnormalizedClientValue=normalizeMarkupForTextOrAttribute(clientValue);varnormalizedServerValue=normalizeMarkupForTextOrAttribute(serverValue);if(normalizedServerValue===normalizedClientValue){return;}didWarnInvalidHydration=true;error('Prop `%s` did not match. Server: %s Client: %s',propName,JSON.stringify(normalizedServerValue),JSON.stringify(normalizedClientValue));};warnForExtraAttributes=function(attributeNames){if(didWarnInvalidHydration){return;}didWarnInvalidHydration=true;varnames=[];attributeNames.forEach(function(name){names.push(name);});error('Extra attributes from the server: %s',names);};warnForInvalidEventListener=function(registrationName,listener){if(listener===false){error('Expected `%s` listener to be a function, instead got `false`.\n\n'+'If you used to conditionally omit it with %s={condition && value}, '+'pass %s={condition ? value : undefined} instead.',registrationName,registrationName,registrationName);}else{error('Expected `%s` listener to be a function, instead got a value of `%s` type.',registrationName,typeoflistener);}};// Parse the HTML and read it back to normalize the HTML string so that it
// can be used for comparison.
normalizeHTML=function(parent,html){// We could have created a separate document here to avoid
// re-initializing custom elements if they exist. But this breaks
// how <noscript> is being handled. So we use the same document.
// See the discussion in https://github.com/facebook/react/pull/11157.
vartestElement=parent.namespaceURI===HTML_NAMESPACE$1?parent.ownerDocument.createElement(parent.tagName):parent.ownerDocument.createElementNS(parent.namespaceURI,parent.tagName);testElement.innerHTML=html;returntestElement.innerHTML;};}functiongetOwnerDocumentFromRootContainer(rootContainerElement){returnrootContainerElement.nodeType===DOCUMENT_NODE?rootContainerElement:rootContainerElement.ownerDocument;}functionnoop(){}functiontrapClickOnNonInteractiveElement(node){// Mobile Safari does not fire properly bubble click events on
// non-interactive elements, which means delegated click listeners do not
// fire. The workaround for this bug involves attaching an empty click
// Just set it using the onclick property so that we don't have to manage any
// bookkeeping for it. Not sure if we need to clear it when the listener is
// removed.
// TODO: Only do this for the relevant Safaris maybe?
node.onclick=noop;}functionsetInitialDOMProperties(tag,domElement,rootContainerElement,nextProps,isCustomComponentTag){for(varpropKeyinnextProps){if(!nextProps.hasOwnProperty(propKey)){continue;}varnextProp=nextProps[propKey];if(propKey===STYLE){{if(nextProp){// Freeze the next style object so that we can assume it won't be
// mutated. We have already warned for this in the past.
Object.freeze(nextProp);}}// Relies on `updateStylesByID` not mutating `styleUpdates`.
setValueForStyles(domElement,nextProp);}elseif(propKey===DANGEROUSLY_SET_INNER_HTML){varnextHtml=nextProp?nextProp[HTML$1]:undefined;if(nextHtml!=null){setInnerHTML(domElement,nextHtml);}}elseif(propKey===CHILDREN){if(typeofnextProp==='string'){// Avoid setting initial textContent when the text is empty. In IE11 setting
// textContent on a <textarea> will cause the placeholder to not
// show within the <textarea> until it has been focused and blurred again.
for(vari=0;i<updatePayload.length;i+=2){varpropKey=updatePayload[i];varpropValue=updatePayload[i+1];if(propKey===STYLE){setValueForStyles(domElement,propValue);}elseif(propKey===DANGEROUSLY_SET_INNER_HTML){setInnerHTML(domElement,propValue);}elseif(propKey===CHILDREN){setTextContent(domElement,propValue);}else{setValueForProperty(domElement,propKey,propValue,isCustomComponentTag);}}}functioncreateElement(type,props,rootContainerElement,parentNamespace){varisCustomComponentTag;// We create tags in the namespace of their parent container, except HTML
// tags get no namespace.
varownerDocument=getOwnerDocumentFromRootContainer(rootContainerElement);vardomElement;varnamespaceURI=parentNamespace;if(namespaceURI===HTML_NAMESPACE$1){namespaceURI=getIntrinsicNamespace(type);}if(namespaceURI===HTML_NAMESPACE$1){{isCustomComponentTag=isCustomComponent(type,props);// Should this check be gated by parent namespace? Not sure we want to
// allow <SVG> or <mATH>.
if(!isCustomComponentTag&&type!==type.toLowerCase()){error('<%s /> is using incorrect casing. '+'Use PascalCase for React components, '+'or lowercase for HTML elements.',type);}}if(type==='script'){// Create the script via .innerHTML so its "parser-inserted" flag is
varfirstChild=div.firstChild;domElement=div.removeChild(firstChild);}elseif(typeofprops.is==='string'){// $FlowIssue `createElement` should be updated for Web Components
domElement=ownerDocument.createElement(type,{is:props.is});}else{// Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
// See discussion in https://github.com/facebook/react/pull/6896
// and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
domElement=ownerDocument.createElement(type);// Normally attributes are assigned in `setInitialDOMProperties`, however the `multiple` and `size`
// attributes on `select`s needs to be added before `option`s are inserted.
// This prevents:
// - a bug where the `select` does not scroll to the correct option because singular
// `select` elements automatically pick the first item #13222
// - a bug where the `select` set the first item as selected despite the `size` attribute #14239
// See https://github.com/facebook/react/issues/13222
// and https://github.com/facebook/react/issues/14239
if(type==='select'){varnode=domElement;if(props.multiple){node.multiple=true;}elseif(props.size){// Setting a size greater than 1 causes a select to behave like `multiple=true`, where
// it is possible that no option is selected.
//
// This is only necessary when a select in "single selection mode".
node.size=props.size;}}}}else{domElement=ownerDocument.createElementNS(namespaceURI,type);}{if(namespaceURI===HTML_NAMESPACE$1){if(!isCustomComponentTag&&Object.prototype.toString.call(domElement)==='[object HTMLUnknownElement]'&&!Object.prototype.hasOwnProperty.call(warnedUnknownTags,type)){warnedUnknownTags[type]=true;error('The tag <%s> is unrecognized in this browser. '+'If you meant to render a React component, start its name with '+'an uppercase letter.',type);}}}returndomElement;}functioncreateTextNode(text,rootContainerElement){returngetOwnerDocumentFromRootContainer(rootContainerElement).createTextNode(text);}functionsetInitialProperties(domElement,tag,rawProps,rootContainerElement){varisCustomComponentTag=isCustomComponent(tag,rawProps);{validatePropertiesInDevelopment(tag,rawProps);}// TODO: Make sure that we check isMounted before firing any of these events.
varprops;switch(tag){case'dialog':listenToNonDelegatedEvent('cancel',domElement);listenToNonDelegatedEvent('close',domElement);props=rawProps;break;case'iframe':case'object':case'embed':// We listen to this event in case to ensure emulated bubble
// listeners still fire for the load event.
listenToNonDelegatedEvent('load',domElement);props=rawProps;break;case'video':case'audio':// We listen to these events in case to ensure emulated bubble
// listeners still fire for all the media events.
for(vari=0;i<mediaEventTypes.length;i++){listenToNonDelegatedEvent(mediaEventTypes[i],domElement);}props=rawProps;break;case'source':// We listen to this event in case to ensure emulated bubble
// listeners still fire for the error event.
listenToNonDelegatedEvent('error',domElement);props=rawProps;break;case'img':case'image':case'link':// We listen to these events in case to ensure emulated bubble
// listeners still fire for error and load events.
listenToNonDelegatedEvent('error',domElement);listenToNonDelegatedEvent('load',domElement);props=rawProps;break;case'details':// We listen to this event in case to ensure emulated bubble
// listeners still fire for the toggle event.
listenToNonDelegatedEvent('toggle',domElement);props=rawProps;break;case'input':initWrapperState(domElement,rawProps);props=getHostProps(domElement,rawProps);// We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent('invalid',domElement);break;case'option':validateProps(domElement,rawProps);props=getHostProps$1(domElement,rawProps);break;case'select':initWrapperState$1(domElement,rawProps);props=getHostProps$2(domElement,rawProps);// We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent('invalid',domElement);break;case'textarea':initWrapperState$2(domElement,rawProps);props=getHostProps$3(domElement,rawProps);// We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent('invalid',domElement);break;default:props=rawProps;}assertValidProps(tag,props);setInitialDOMProperties(tag,domElement,rootContainerElement,props,isCustomComponentTag);switch(tag){case'input':// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);postMountWrapper(domElement,rawProps,false);break;case'textarea':// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);postMountWrapper$3(domElement);break;case'option':postMountWrapper$1(domElement,rawProps);break;case'select':postMountWrapper$2(domElement,rawProps);break;default:if(typeofprops.onClick==='function'){// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);}break;}}// Calculate the diff between the two objects.
functiondiffProperties(domElement,tag,lastRawProps,nextRawProps,rootContainerElement){{validatePropertiesInDevelopment(tag,nextRawProps);}varupdatePayload=null;varlastProps;varnextProps;switch(tag){case'input':lastProps=getHostProps(domElement,lastRawProps);nextProps=getHostProps(domElement,nextRawProps);updatePayload=[];break;case'option':lastProps=getHostProps$1(domElement,lastRawProps);nextProps=getHostProps$1(domElement,nextRawProps);updatePayload=[];break;case'select':lastProps=getHostProps$2(domElement,lastRawProps);nextProps=getHostProps$2(domElement,nextRawProps);updatePayload=[];break;case'textarea':lastProps=getHostProps$3(domElement,lastRawProps);nextProps=getHostProps$3(domElement,nextRawProps);updatePayload=[];break;default:lastProps=lastRawProps;nextProps=nextRawProps;if(typeoflastProps.onClick!=='function'&&typeofnextProps.onClick==='function'){// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);}break;}assertValidProps(tag,nextProps);varpropKey;varstyleName;varstyleUpdates=null;for(propKeyinlastProps){if(nextProps.hasOwnProperty(propKey)||!lastProps.hasOwnProperty(propKey)||lastProps[propKey]==null){continue;}if(propKey===STYLE){varlastStyle=lastProps[propKey];for(styleNameinlastStyle){if(lastStyle.hasOwnProperty(styleName)){if(!styleUpdates){styleUpdates={};}styleUpdates[styleName]='';}}}elseif(propKey===DANGEROUSLY_SET_INNER_HTML||propKey===CHILDREN);elseif(propKey===SUPPRESS_CONTENT_EDITABLE_WARNING||propKey===SUPPRESS_HYDRATION_WARNING);elseif(propKey===AUTOFOCUS);elseif(registrationNameDependencies.hasOwnProperty(propKey)){// This is a special case. If any listener updates we need to ensure
// that the "current" fiber pointer gets updated so we need a commit
// to update this element.
if(!updatePayload){updatePayload=[];}}else{// For all other deleted properties we add it to the queue. We use
// the allowed property list in the commit phase instead.
(updatePayload=updatePayload||[]).push(propKey,null);}}for(propKeyinnextProps){varnextProp=nextProps[propKey];varlastProp=lastProps!=null?lastProps[propKey]:undefined;if(!nextProps.hasOwnProperty(propKey)||nextProp===lastProp||nextProp==null&&lastProp==null){continue;}if(propKey===STYLE){{if(nextProp){// Freeze the next style object so that we can assume it won't be
// mutated. We have already warned for this in the past.
Object.freeze(nextProp);}}if(lastProp){// Unset styles on `lastProp` but not on `nextProp`.
for(styleNameinlastProp){if(lastProp.hasOwnProperty(styleName)&&(!nextProp||!nextProp.hasOwnProperty(styleName))){if(!styleUpdates){styleUpdates={};}styleUpdates[styleName]='';}}// Update styles that changed since `lastProp`.
for(styleNameinnextProp){if(nextProp.hasOwnProperty(styleName)&&lastProp[styleName]!==nextProp[styleName]){if(!styleUpdates){styleUpdates={};}styleUpdates[styleName]=nextProp[styleName];}}}else{// Relies on `updateStylesByID` not mutating `styleUpdates`.
if(!styleUpdates){if(!updatePayload){updatePayload=[];}updatePayload.push(propKey,styleUpdates);}styleUpdates=nextProp;}}elseif(propKey===DANGEROUSLY_SET_INNER_HTML){varnextHtml=nextProp?nextProp[HTML$1]:undefined;varlastHtml=lastProp?lastProp[HTML$1]:undefined;if(nextHtml!=null){if(lastHtml!==nextHtml){(updatePayload=updatePayload||[]).push(propKey,nextHtml);}}}elseif(propKey===CHILDREN){if(typeofnextProp==='string'||typeofnextProp==='number'){(updatePayload=updatePayload||[]).push(propKey,''+nextProp);}}elseif(propKey===SUPPRESS_CONTENT_EDITABLE_WARNING||propKey===SUPPRESS_HYDRATION_WARNING);elseif(registrationNameDependencies.hasOwnProperty(propKey)){if(nextProp!=null){// We eagerly listen to this even though we haven't committed yet.
if(typeofnextProp!=='function'){warnForInvalidEventListener(propKey,nextProp);}if(propKey==='onScroll'){listenToNonDelegatedEvent('scroll',domElement);}}if(!updatePayload&&lastProp!==nextProp){// This is a special case. If any listener updates we need to ensure
// that the "current" props pointer gets updated so we need a commit
// to update this element.
updatePayload=[];}}elseif(typeofnextProp==='object'&&nextProp!==null&&nextProp.$$typeof===REACT_OPAQUE_ID_TYPE){// If we encounter useOpaqueReference's opaque object, this means we are hydrating.
// In this case, call the opaque object's toString function which generates a new client
// ID so client and server IDs match and throws to rerender.
nextProp.toString();}else{// For any other property we always add it to the queue and then we
// filter it out using the allowed property list during the commit.
(updatePayload=updatePayload||[]).push(propKey,nextProp);}}if(styleUpdates){{validateShorthandPropertyCollisionInDev(styleUpdates,nextProps[STYLE]);}(updatePayload=updatePayload||[]).push(STYLE,styleUpdates);}returnupdatePayload;}// Apply the diff.
// In the middle of an update, it is possible to have multiple checked.
// When a checked radio tries to change name, browser makes another radio's checked false.
if(tag==='input'&&nextRawProps.type==='radio'&&nextRawProps.name!=null){updateChecked(domElement,nextRawProps);}varwasCustomComponentTag=isCustomComponent(tag,lastRawProps);varisCustomComponentTag=isCustomComponent(tag,nextRawProps);// Apply the diff.
updateDOMProperties(domElement,updatePayload,wasCustomComponentTag,isCustomComponentTag);// TODO: Ensure that an update gets scheduled if any of the special props
// changed.
switch(tag){case'input':// Update the wrapper around inputs *after* updating props. This has to
// happen after `updateDOMProperties`. Otherwise HTML5 input validations
// raise warnings and prevent the new value from being assigned.
updateWrapper(domElement,nextRawProps);break;case'textarea':updateWrapper$1(domElement,nextRawProps);break;case'select':// <select> value update needs to occur after <option> children
// reconciliation
postUpdateWrapper(domElement,nextRawProps);break;}}functiongetPossibleStandardName(propName){{varlowerCasedName=propName.toLowerCase();if(!possibleStandardNames.hasOwnProperty(lowerCasedName)){returnnull;}returnpossibleStandardNames[lowerCasedName]||null;}}functiondiffHydratedProperties(domElement,tag,rawProps,parentNamespace,rootContainerElement){varisCustomComponentTag;varextraAttributeNames;{suppressHydrationWarning=rawProps[SUPPRESS_HYDRATION_WARNING]===true;isCustomComponentTag=isCustomComponent(tag,rawProps);validatePropertiesInDevelopment(tag,rawProps);}// TODO: Make sure that we check isMounted before firing any of these events.
switch(tag){case'dialog':listenToNonDelegatedEvent('cancel',domElement);listenToNonDelegatedEvent('close',domElement);break;case'iframe':case'object':case'embed':// We listen to this event in case to ensure emulated bubble
// listeners still fire for the load event.
listenToNonDelegatedEvent('load',domElement);break;case'video':case'audio':// We listen to these events in case to ensure emulated bubble
// listeners still fire for all the media events.
for(vari=0;i<mediaEventTypes.length;i++){listenToNonDelegatedEvent(mediaEventTypes[i],domElement);}break;case'source':// We listen to this event in case to ensure emulated bubble
// listeners still fire for the error event.
listenToNonDelegatedEvent('error',domElement);break;case'img':case'image':case'link':// We listen to these events in case to ensure emulated bubble
// listeners still fire for error and load events.
listenToNonDelegatedEvent('error',domElement);listenToNonDelegatedEvent('load',domElement);break;case'details':// We listen to this event in case to ensure emulated bubble
// listeners still fire for the toggle event.
listenToNonDelegatedEvent('toggle',domElement);break;case'input':initWrapperState(domElement,rawProps);// We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent('invalid',domElement);break;case'option':validateProps(domElement,rawProps);break;case'select':initWrapperState$1(domElement,rawProps);// We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent('invalid',domElement);break;case'textarea':initWrapperState$2(domElement,rawProps);// We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent('invalid',domElement);break;}assertValidProps(tag,rawProps);{extraAttributeNames=newSet();varattributes=domElement.attributes;for(var_i=0;_i<attributes.length;_i++){varname=attributes[_i].name.toLowerCase();switch(name){// Built-in SSR attribute is allowed
case'data-reactroot':break;// Controlled attributes are not validated
// TODO: Only ignore them on controlled tags.
case'value':break;case'checked':break;case'selected':break;default:// Intentionally use the original name.
// See discussion in https://github.com/facebook/react/pull/10676.
extraAttributeNames.add(attributes[_i].name);}}}varupdatePayload=null;for(varpropKeyinrawProps){if(!rawProps.hasOwnProperty(propKey)){continue;}varnextProp=rawProps[propKey];if(propKey===CHILDREN){// For text content children we compare against textContent. This
// might match additional HTML that is hidden when we read it using
// textContent. E.g. "foo" will match "f<span>oo</span>" but that still
// satisfies our requirement. Our requirement is not to produce perfect
// HTML and attributes. Ideally we should preserve structure but it's
// ok not to if the visible content is still enough to indicate what
// even listeners these nodes might be wired up to.
// TODO: Warn if there is more than a single textNode as a child.
// TODO: Should we use domElement.firstChild.nodeValue to compare?
if(typeofnextProp==='string'){if(domElement.textContent!==nextProp){if(!suppressHydrationWarning){warnForTextDifference(domElement.textContent,nextProp);}updatePayload=[CHILDREN,nextProp];}}elseif(typeofnextProp==='number'){if(domElement.textContent!==''+nextProp){if(!suppressHydrationWarning){warnForTextDifference(domElement.textContent,nextProp);}updatePayload=[CHILDREN,''+nextProp];}}}elseif(registrationNameDependencies.hasOwnProperty(propKey)){if(nextProp!=null){if(typeofnextProp!=='function'){warnForInvalidEventListener(propKey,nextProp);}if(propKey==='onScroll'){listenToNonDelegatedEvent('scroll',domElement);}}}elseif(// Convince Flow we've calculated it (it's DEV-only in this method.)
typeofisCustomComponentTag==='boolean'){// Validate that the properties correspond to their expected values.
varserverValue=void0;varpropertyInfo=getPropertyInfo(propKey);if(suppressHydrationWarning);elseif(propKey===SUPPRESS_CONTENT_EDITABLE_WARNING||propKey===SUPPRESS_HYDRATION_WARNING||// Controlled attributes are not validated
// TODO: Only ignore them on controlled tags.
propKey==='value'||propKey==='checked'||propKey==='selected');elseif(propKey===DANGEROUSLY_SET_INNER_HTML){varserverHTML=domElement.innerHTML;varnextHtml=nextProp?nextProp[HTML$1]:undefined;if(nextHtml!=null){varexpectedHTML=normalizeHTML(domElement,nextHtml);if(expectedHTML!==serverHTML){warnForPropDifference(propKey,serverHTML,expectedHTML);}}}elseif(propKey===STYLE){// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey);if(canDiffStyleForHydrationWarning){varexpectedStyle=createDangerousStringForStyles(nextProp);serverValue=domElement.getAttribute('style');if(expectedStyle!==serverValue){warnForPropDifference(propKey,serverValue,expectedStyle);}}}elseif(isCustomComponentTag){// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey.toLowerCase());serverValue=getValueForAttribute(domElement,propKey,nextProp);if(nextProp!==serverValue){warnForPropDifference(propKey,serverValue,nextProp);}}elseif(!shouldIgnoreAttribute(propKey,propertyInfo,isCustomComponentTag)&&!shouldRemoveAttribute(propKey,nextProp,propertyInfo,isCustomComponentTag)){varisMismatchDueToBadCasing=false;if(propertyInfo!==null){// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propertyInfo.attributeName);serverValue=getValueForProperty(domElement,propKey,nextProp,propertyInfo);}else{varownNamespace=parentNamespace;if(ownNamespace===HTML_NAMESPACE$1){ownNamespace=getIntrinsicNamespace(tag);}if(ownNamespace===HTML_NAMESPACE$1){// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey.toLowerCase());}else{varstandardName=getPossibleStandardName(propKey);if(standardName!==null&&standardName!==propKey){// If an SVG prop is supplied with bad casing, it will
// be successfully parsed from HTML, but will produce a mismatch
// (and would be incorrectly rendered on the client).
// However, we already warn about bad casing elsewhere.
// So we'll skip the misleading extra mismatch warning in this case.
isMismatchDueToBadCasing=true;// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(standardName);}// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey);}serverValue=getValueForAttribute(domElement,propKey,nextProp);}if(nextProp!==serverValue&&!isMismatchDueToBadCasing){warnForPropDifference(propKey,serverValue,nextProp);}}}}{// $FlowFixMe - Should be inferred as not undefined.
if(extraAttributeNames.size>0&&!suppressHydrationWarning){// $FlowFixMe - Should be inferred as not undefined.
warnForExtraAttributes(extraAttributeNames);}}switch(tag){case'input':// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);postMountWrapper(domElement,rawProps,true);break;case'textarea':// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);postMountWrapper$3(domElement);break;case'select':case'option':// For input and textarea we current always set the value property at
// post mount to force it to diverge from attributes. However, for
// option and select we don't quite do the same thing and select
// is not resilient to the DOM state changing so we don't do that here.
// TODO: Consider not doing this for input and textarea.
break;default:if(typeofrawProps.onClick==='function'){// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);}break;}returnupdatePayload;}functiondiffHydratedText(textNode,text){varisDifferent=textNode.nodeValue!==text;returnisDifferent;}functionwarnForUnmatchedText(textNode,text){{warnForTextDifference(textNode.nodeValue,text);}}functionwarnForDeletedHydratableElement(parentNode,child){{if(didWarnInvalidHydration){return;}didWarnInvalidHydration=true;error('Did not expect server HTML to contain a <%s> in <%s>.',child.nodeName.toLowerCase(),parentNode.nodeName.toLowerCase());}}functionwarnForDeletedHydratableText(parentNode,child){{if(didWarnInvalidHydration){return;}didWarnInvalidHydration=true;error('Did not expect server HTML to contain the text node "%s" in <%s>.',child.nodeValue,parentNode.nodeName.toLowerCase());}}functionwarnForInsertedHydratedElement(parentNode,tag,props){{if(didWarnInvalidHydration){return;}didWarnInvalidHydration=true;error('Expected server HTML to contain a matching <%s> in <%s>.',tag,parentNode.nodeName.toLowerCase());}}functionwarnForInsertedHydratedText(parentNode,text){{if(text===''){// We expect to insert empty text nodes since they're not represented in
// the HTML.
// TODO: Remove this special case if we can just avoid inserting empty
// text nodes.
return;}if(didWarnInvalidHydration){return;}didWarnInvalidHydration=true;error('Expected server HTML to contain a matching text node for "%s" in <%s>.',text,parentNode.nodeName.toLowerCase());}}functionrestoreControlledState$3(domElement,tag,props){switch(tag){case'input':restoreControlledState(domElement,props);return;case'textarea':restoreControlledState$2(domElement,props);return;case'select':restoreControlledState$1(domElement,props);return;}}varvalidateDOMNesting=function(){};varupdatedAncestorInfo=function(){};{// This validation code was written based on the HTML5 parsing spec:
varimpliedEndTags=['dd','dt','li','option','optgroup','p','rp','rt'];varemptyAncestorInfo={current:null,formTag:null,aTagInScope:null,buttonTagInScope:null,nobrTagInScope:null,pTagInButtonScope:null,listItemTagAutoclosing:null,dlItemTagAutoclosing:null};updatedAncestorInfo=function(oldInfo,tag){varancestorInfo=_assign({},oldInfo||emptyAncestorInfo);varinfo={tag:tag};if(inScopeTags.indexOf(tag)!==-1){ancestorInfo.aTagInScope=null;ancestorInfo.buttonTagInScope=null;ancestorInfo.nobrTagInScope=null;}if(buttonScopeTags.indexOf(tag)!==-1){ancestorInfo.pTagInButtonScope=null;}// See rules for 'li', 'dd', 'dt' start tags in
case'select':returntag==='option'||tag==='optgroup'||tag==='#text';case'optgroup':returntag==='option'||tag==='#text';// Strictly speaking, seeing an <option> doesn't mean we're in a <select>
case'html':returntag==='head'||tag==='body'||tag==='frameset';case'frameset':returntag==='frame';case'#document':returntag==='html';}// Probably in the "in body" parsing mode, so we outlaw only tag combos
// where the parsing rules cause implicit opens or closes to be added.
switch(tag){case'h1':case'h2':case'h3':case'h4':case'h5':case'h6':returnparentTag!=='h1'&&parentTag!=='h2'&&parentTag!=='h3'&&parentTag!=='h4'&&parentTag!=='h5'&&parentTag!=='h6';case'rp':case'rt':returnimpliedEndTags.indexOf(parentTag)===-1;case'body':case'caption':case'col':case'colgroup':case'frameset':case'frame':case'head':case'html':case'tbody':case'td':case'tfoot':case'th':case'thead':case'tr':// These tags are only valid with a few parents that have special child
// parsing rules -- if we're down here, then none of those matched and
// so we allow it only if we don't know what the parent is, as all other
returnancestorInfo.aTagInScope;case'nobr':returnancestorInfo.nobrTagInScope;}returnnull;};vardidWarn$1={};validateDOMNesting=function(childTag,childText,ancestorInfo){ancestorInfo=ancestorInfo||emptyAncestorInfo;varparentInfo=ancestorInfo.current;varparentTag=parentInfo&&parentInfo.tag;if(childText!=null){if(childTag!=null){error('validateDOMNesting: when childText is passed, childTag should be null');}childTag='#text';}varinvalidParent=isTagValidWithParent(childTag,parentTag)?null:parentInfo;varinvalidAncestor=invalidParent?null:findInvalidAncestorForTag(childTag,ancestorInfo);varinvalidParentOrAncestor=invalidParent||invalidAncestor;if(!invalidParentOrAncestor){return;}varancestorTag=invalidParentOrAncestor.tag;varwarnKey=!!invalidParent+'|'+childTag+'|'+ancestorTag;if(didWarn$1[warnKey]){return;}didWarn$1[warnKey]=true;vartagDisplayName=childTag;varwhitespaceInfo='';if(childTag==='#text'){if(/\S/.test(childText)){tagDisplayName='Text nodes';}else{tagDisplayName='Whitespace text nodes';whitespaceInfo=" Make sure you don't have any extra whitespace between tags on "+'each line of your source code.';}}else{tagDisplayName='<'+childTag+'>';}if(invalidParent){varinfo='';if(ancestorTag==='table'&&childTag==='tr'){info+=' Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by '+'the browser.';}error('validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s',tagDisplayName,ancestorTag,whitespaceInfo,info);}else{error('validateDOMNesting(...): %s cannot appear as a descendant of '+'<%s>.',tagDisplayName,ancestorTag);}};}varSUPPRESS_HYDRATION_WARNING$1;{SUPPRESS_HYDRATION_WARNING$1='suppressHydrationWarning';}varSUSPENSE_START_DATA='$';varSUSPENSE_END_DATA='/$';varSUSPENSE_PENDING_START_DATA='$?';varSUSPENSE_FALLBACK_START_DATA='$!';varSTYLE$1='style';vareventsEnabled=null;varselectionInformation=null;functionshouldAutoFocusHostComponent(type,props){switch(type){case'button':case'input':case'select':case'textarea':return!!props.autoFocus;}returnfalse;}functiongetRootHostContext(rootContainerInstance){vartype;varnamespace;varnodeType=rootContainerInstance.nodeType;switch(nodeType){caseDOCUMENT_NODE:caseDOCUMENT_FRAGMENT_NODE:{type=nodeType===DOCUMENT_NODE?'#document':'#fragment';varroot=rootContainerInstance.documentElement;namespace=root?root.namespaceURI:getChildNamespace(null,'');break;}default:{varcontainer=nodeType===COMMENT_NODE?rootContainerInstance.parentNode:rootContainerInstance;varownNamespace=container.namespaceURI||null;type=container.tagName;namespace=getChildNamespace(ownNamespace,type);break;}}{varvalidatedTag=type.toLowerCase();varancestorInfo=updatedAncestorInfo(null,validatedTag);return{namespace:namespace,ancestorInfo:ancestorInfo};}}functiongetChildHostContext(parentHostContext,type,rootContainerInstance){{varparentHostContextDev=parentHostContext;varnamespace=getChildNamespace(parentHostContextDev.namespace,type);varancestorInfo=updatedAncestorInfo(parentHostContextDev.ancestorInfo,type);return{namespace:namespace,ancestorInfo:ancestorInfo};}}functiongetPublicInstance(instance){returninstance;}functionprepareForCommit(containerInfo){eventsEnabled=isEnabled();selectionInformation=getSelectionInformation();varactiveInstance=null;setEnabled(false);returnactiveInstance;}functionresetAfterCommit(containerInfo){restoreSelection(selectionInformation);setEnabled(eventsEnabled);eventsEnabled=null;selectionInformation=null;}functioncreateInstance(type,props,rootContainerInstance,hostContext,internalInstanceHandle){varparentNamespace;{// TODO: take namespace into account when validating.
varhostContextDev=hostContext;validateDOMNesting(type,null,hostContextDev.ancestorInfo);if(typeofprops.children==='string'||typeofprops.children==='number'){varstring=''+props.children;varownAncestorInfo=updatedAncestorInfo(hostContextDev.ancestorInfo,type);validateDOMNesting(null,string,ownAncestorInfo);}parentNamespace=hostContextDev.namespace;}vardomElement=createElement(type,props,rootContainerInstance,parentNamespace);precacheFiberNode(internalInstanceHandle,domElement);updateFiberProps(domElement,props);returndomElement;}functionappendInitialChild(parentInstance,child){parentInstance.appendChild(child);}functionfinalizeInitialChildren(domElement,type,props,rootContainerInstance,hostContext){setInitialProperties(domElement,type,props,rootContainerInstance);returnshouldAutoFocusHostComponent(type,props);}functionprepareUpdate(domElement,type,oldProps,newProps,rootContainerInstance,hostContext){{varhostContextDev=hostContext;if(typeofnewProps.children!==typeofoldProps.children&&(typeofnewProps.children==='string'||typeofnewProps.children==='number')){varstring=''+newProps.children;varownAncestorInfo=updatedAncestorInfo(hostContextDev.ancestorInfo,type);validateDOMNesting(null,string,ownAncestorInfo);}}returndiffProperties(domElement,type,oldProps,newProps);}functionshouldSetTextContent(type,props){returntype==='textarea'||type==='option'||type==='noscript'||typeofprops.children==='string'||typeofprops.children==='number'||typeofprops.dangerouslySetInnerHTML==='object'&&props.dangerouslySetInnerHTML!==null&&props.dangerouslySetInnerHTML.__html!=null;}functioncreateTextInstance(text,rootContainerInstance,hostContext,internalInstanceHandle){{varhostContextDev=hostContext;validateDOMNesting(null,text,hostContextDev.ancestorInfo);}vartextNode=createTextNode(text,rootContainerInstance);precacheFiberNode(internalInstanceHandle,textNode);returntextNode;}// if a component just imports ReactDOM (e.g. for findDOMNode).
// Some environments might not have setTimeout or clearTimeout.
functioncommitMount(domElement,type,newProps,internalInstanceHandle){// Despite the naming that might imply otherwise, this method only
// fires if there is an `Update` effect scheduled during mounting.
// This happens if `finalizeInitialChildren` returns `true` (which it
// does to implement the `autoFocus` attribute on the client). But
// there are also other cases when this might happen (such as patching
// up text content during hydration mismatch). So we'll check this again.
if(shouldAutoFocusHostComponent(type,newProps)){domElement.focus();}}functioncommitUpdate(domElement,updatePayload,type,oldProps,newProps,internalInstanceHandle){// Update the props handle so that we know which props are the ones with
// with current event handlers.
updateFiberProps(domElement,newProps);// Apply the diff to the DOM node.
updateProperties(domElement,updatePayload,type,oldProps,newProps);}functionresetTextContent(domElement){setTextContent(domElement,'');}functioncommitTextUpdate(textInstance,oldText,newText){textInstance.nodeValue=newText;}functionappendChild(parentInstance,child){parentInstance.appendChild(child);}functionappendChildToContainer(container,child){varparentNode;if(container.nodeType===COMMENT_NODE){parentNode=container.parentNode;parentNode.insertBefore(child,container);}else{parentNode=container;parentNode.appendChild(child);}// This container might be used for a portal.
// If something inside a portal is clicked, that click should bubble
// through the React tree. However, on Mobile Safari the click would
// never bubble through the *DOM* tree unless an ancestor with onclick
// event exists. So we wouldn't see it and dispatch it.
// This is why we ensure that non React root containers have inline onclick
// defined.
// https://github.com/facebook/react/issues/11918
varreactRootContainer=container._reactRootContainer;if((reactRootContainer===null||reactRootContainer===undefined)&&parentNode.onclick===null){// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(parentNode);}}functioninsertBefore(parentInstance,child,beforeChild){parentInstance.insertBefore(child,beforeChild);}functioninsertInContainerBefore(container,child,beforeChild){if(container.nodeType===COMMENT_NODE){container.parentNode.insertBefore(child,beforeChild);}else{container.insertBefore(child,beforeChild);}}functionremoveChild(parentInstance,child){parentInstance.removeChild(child);}functionremoveChildFromContainer(container,child){if(container.nodeType===COMMENT_NODE){container.parentNode.removeChild(child);}else{container.removeChild(child);}}functionhideInstance(instance){// TODO: Does this work for all element types? What about MathML? Should we
functioncanHydrateInstance(instance,type,props){if(instance.nodeType!==ELEMENT_NODE||type.toLowerCase()!==instance.nodeName.toLowerCase()){returnnull;}// This has now been refined to an element node.
returninstance;}functioncanHydrateTextInstance(instance,text){if(text===''||instance.nodeType!==TEXT_NODE){// Empty strings are not parsed by HTML so there won't be a correct match here.
returnnull;}// This has now been refined to a text node.
for(;node!=null;node=node.nextSibling){varnodeType=node.nodeType;if(nodeType===ELEMENT_NODE||nodeType===TEXT_NODE){break;}}returnnode;}functiongetNextHydratableSibling(instance){returngetNextHydratable(instance.nextSibling);}functiongetFirstHydratableChild(parentInstance){returngetNextHydratable(parentInstance.firstChild);}functionhydrateInstance(instance,type,props,rootContainerInstance,hostContext,internalInstanceHandle){precacheFiberNode(internalInstanceHandle,instance);// TODO: Possibly defer this until the commit phase where all the events
// get attached.
updateFiberProps(instance,props);varparentNamespace;{varhostContextDev=hostContext;parentNamespace=hostContextDev.namespace;}returndiffHydratedProperties(instance,type,props,parentNamespace);}functionhydrateTextInstance(textInstance,text,internalInstanceHandle){precacheFiberNode(internalInstanceHandle,textInstance);returndiffHydratedText(textInstance,text);}functiongetNextHydratableInstanceAfterSuspenseInstance(suspenseInstance){varnode=suspenseInstance.nextSibling;// Skip past all nodes within this suspense boundary.
// There might be nested nodes so we need to keep track of how
// deep we are and only break out when we're back on top.
vardepth=0;while(node){if(node.nodeType===COMMENT_NODE){vardata=node.data;if(data===SUSPENSE_END_DATA){if(depth===0){returngetNextHydratableSibling(node);}else{depth--;}}elseif(data===SUSPENSE_START_DATA||data===SUSPENSE_FALLBACK_START_DATA||data===SUSPENSE_PENDING_START_DATA){depth++;}}node=node.nextSibling;}// TODO: Warn, we didn't find the end comment boundary.
returnnull;}// Returns the SuspenseInstance if this node is a direct child of a
// SuspenseInstance. I.e. if its previous sibling is a Comment with
// SUSPENSE_x_START_DATA. Otherwise, null.
functiongetParentSuspenseInstance(targetInstance){varnode=targetInstance.previousSibling;// Skip past all nodes within this suspense boundary.
// There might be nested nodes so we need to keep track of how
// deep we are and only break out when we're back on top.
vardepth=0;while(node){if(node.nodeType===COMMENT_NODE){vardata=node.data;if(data===SUSPENSE_START_DATA||data===SUSPENSE_FALLBACK_START_DATA||data===SUSPENSE_PENDING_START_DATA){if(depth===0){returnnode;}else{depth--;}}elseif(data===SUSPENSE_END_DATA){depth++;}}node=node.previousSibling;}returnnull;}functioncommitHydratedContainer(container){// Retry if any event replaying was blocked on this.
retryIfBlockedOn(container);}functioncommitHydratedSuspenseInstance(suspenseInstance){// Retry if any event replaying was blocked on this.
retryIfBlockedOn(suspenseInstance);}functiondidNotMatchHydratedContainerTextInstance(parentContainer,textInstance,text){{warnForUnmatchedText(textInstance,text);}}functiondidNotMatchHydratedTextInstance(parentType,parentProps,parentInstance,textInstance,text){if(parentProps[SUPPRESS_HYDRATION_WARNING$1]!==true){warnForUnmatchedText(textInstance,text);}}functiondidNotHydrateContainerInstance(parentContainer,instance){{if(instance.nodeType===ELEMENT_NODE){warnForDeletedHydratableElement(parentContainer,instance);}elseif(instance.nodeType===COMMENT_NODE);else{warnForDeletedHydratableText(parentContainer,instance);}}}functiondidNotHydrateInstance(parentType,parentProps,parentInstance,instance){if(parentProps[SUPPRESS_HYDRATION_WARNING$1]!==true){if(instance.nodeType===ELEMENT_NODE){warnForDeletedHydratableElement(parentInstance,instance);}elseif(instance.nodeType===COMMENT_NODE);else{warnForDeletedHydratableText(parentInstance,instance);}}}functiondidNotFindHydratableContainerInstance(parentContainer,type,props){{warnForInsertedHydratedElement(parentContainer,type);}}functiondidNotFindHydratableContainerTextInstance(parentContainer,text){{warnForInsertedHydratedText(parentContainer,text);}}functiondidNotFindHydratableInstance(parentType,parentProps,parentInstance,type,props){if(parentProps[SUPPRESS_HYDRATION_WARNING$1]!==true){warnForInsertedHydratedElement(parentInstance,type);}}functiondidNotFindHydratableTextInstance(parentType,parentProps,parentInstance,text){if(parentProps[SUPPRESS_HYDRATION_WARNING$1]!==true){warnForInsertedHydratedText(parentInstance,text);}}functiondidNotFindHydratableSuspenseInstance(parentType,parentProps,parentInstance){if(parentProps[SUPPRESS_HYDRATION_WARNING$1]!==true);}varclientId=0;functionmakeClientIdInDEV(warnOnAccessInDEV){varid='r:'+(clientId++).toString(36);return{toString:function(){warnOnAccessInDEV();returnid;},valueOf:function(){warnOnAccessInDEV();returnid;}};}functionisOpaqueHydratingObject(value){returnvalue!==null&&typeofvalue==='object'&&value.$$typeof===REACT_OPAQUE_ID_TYPE;}functionmakeOpaqueHydratingObject(attemptToReadValue){return{$$typeof:REACT_OPAQUE_ID_TYPE,toString:attemptToReadValue,valueOf:attemptToReadValue};}functionpreparePortalMount(portalInstance){{listenToAllSupportedEvents(portalInstance);}}varrandomKey=Math.random().toString(36).slice(2);varinternalInstanceKey='__reactFiber$'+randomKey;varinternalPropsKey='__reactProps$'+randomKey;varinternalContainerInstanceKey='__reactContainer$'+randomKey;varinternalEventHandlersKey='__reactEvents$'+randomKey;functionprecacheFiberNode(hostInst,node){node[internalInstanceKey]=hostInst;}functionmarkContainerAsRoot(hostRoot,node){node[internalContainerInstanceKey]=hostRoot;}functionunmarkContainerAsRoot(node){node[internalContainerInstanceKey]=null;}functionisContainerMarkedAsRoot(node){return!!node[internalContainerInstanceKey];}// Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
// If the target node is part of a hydrated or not yet rendered subtree, then
// this may also return a SuspenseComponent or HostRoot to indicate that.
// Conceptually the HostRoot fiber is a child of the Container node. So if you
// pass the Container node as the targetNode, you will not actually get the
// HostRoot back. To get to the HostRoot, you need to pass a child of it.
// The same thing applies to Suspense boundaries.
functiongetClosestInstanceFromNode(targetNode){vartargetInst=targetNode[internalInstanceKey];if(targetInst){// Don't return HostRoot or SuspenseComponent here.
returntargetInst;}// If the direct event target isn't a React owned DOM node, we need to look
// to see if one of its parents is a React owned DOM node.
varparentNode=targetNode.parentNode;while(parentNode){// We'll check if this is a container root that could include
// React nodes in the future. We need to check this first because
// if we're a child of a dehydrated container, we need to first
// find that inner container before moving on to finding the parent
// instance. Note that we don't check this field on the targetNode
// itself because the fibers are conceptually between the container
// node and the first child. It isn't surrounding the container node.
// If it's not a container, we check if it's an instance.
targetInst=parentNode[internalContainerInstanceKey]||parentNode[internalInstanceKey];if(targetInst){// Since this wasn't the direct target of the event, we might have
// stepped past dehydrated DOM nodes to get here. However they could
// also have been non-React nodes. We need to answer which one.
// If we the instance doesn't have any children, then there can't be
// a nested suspense boundary within it. So we can use this as a fast
// bailout. Most of the time, when people add non-React children to
// the tree, it is using a ref to a child-less DOM node.
// Normally we'd only need to check one of the fibers because if it
// has ever gone from having children to deleting them or vice versa
// it would have deleted the dehydrated boundary nested inside already.
// However, since the HostRoot starts out with an alternate it might
// have one on the alternate so we need to check in case this was a
// root.
varalternate=targetInst.alternate;if(targetInst.child!==null||alternate!==null&&alternate.child!==null){// Next we need to figure out if the node that skipped past is
// nested within a dehydrated boundary and if so, which one.
varsuspenseInstance=getParentSuspenseInstance(targetNode);while(suspenseInstance!==null){// We found a suspense instance. That means that we haven't
// hydrated it yet. Even though we leave the comments in the
// DOM after hydrating, and there are boundaries in the DOM
// that could already be hydrated, we wouldn't have found them
// through this pass since if the target is hydrated it would
// have had an internalInstanceKey on it.
// Let's get the fiber associated with the SuspenseComponent
// as the deepest instance.
vartargetSuspenseInst=suspenseInstance[internalInstanceKey];if(targetSuspenseInst){returntargetSuspenseInst;}// If we don't find a Fiber on the comment, it might be because
// we haven't gotten to hydrate it yet. There might still be a
// parent boundary that hasn't above this one so we need to find
// the outer most that is known.
suspenseInstance=getParentSuspenseInstance(suspenseInstance);// If we don't find one, then that should mean that the parent
// host component also hasn't hydrated yet. We can return it
// below since it will bail out on the isMounted check later.
returninst.stateNode;}// Without this first invariant, passing a non-DOM-component triggers the next
// invariant for a missing parent, which is super confusing.
{{throwError("getNodeFromInstance: Invalid argument.");}}}functiongetFiberCurrentPropsFromNode(node){returnnode[internalPropsKey]||null;}functionupdateFiberProps(node,props){node[internalPropsKey]=props;}functiongetEventListenerSet(node){varelementListenerSet=node[internalEventHandlersKey];if(elementListenerSet===undefined){elementListenerSet=node[internalEventHandlersKey]=newSet();}returnelementListenerSet;}varloggedTypeFailures={};varReactDebugCurrentFrame$1=ReactSharedInternals.ReactDebugCurrentFrame;functionsetCurrentlyValidatingElement(element){{if(element){varowner=element._owner;varstack=describeUnknownElementTypeFrameInDEV(element.type,element._source,owner?owner.type:null);ReactDebugCurrentFrame$1.setExtraStackFrame(stack);}else{ReactDebugCurrentFrame$1.setExtraStackFrame(null);}}}functioncheckPropTypes(typeSpecs,values,location,componentName,element){{// $FlowFixMe This is okay but Flow doesn't know it.
varhas=Function.call.bind(Object.prototype.hasOwnProperty);for(vartypeSpecNameintypeSpecs){if(has(typeSpecs,typeSpecName)){varerror$1=void0;// Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try{// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if(typeoftypeSpecs[typeSpecName]!=='function'){varerr=Error((componentName||'React class')+': '+location+' type `'+typeSpecName+'` is invalid; '+'it must be a function, usually from the `prop-types` package, but received `'+typeoftypeSpecs[typeSpecName]+'`.'+'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');err.name='Invariant Violation';throwerr;}error$1=typeSpecs[typeSpecName](values,typeSpecName,componentName,location,null,'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');}catch(ex){error$1=ex;}if(error$1&&!(error$1instanceofError)){setCurrentlyValidatingElement(element);error('%s: type specification of %s'+' `%s` is invalid; the type checker '+'function must return `null` or an `Error` but returned a %s. '+'You may have forgotten to pass an argument to the type checker '+'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and '+'shape all require an argument).',componentName||'React class',location,typeSpecName,typeoferror$1);setCurrentlyValidatingElement(null);}if(error$1instanceofError&&!(error$1.messageinloggedTypeFailures)){// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error$1.message]=true;setCurrentlyValidatingElement(element);error('Failed %s type: %s',location,error$1.message);setCurrentlyValidatingElement(null);}}}}}varvalueStack=[];varfiberStack;{fiberStack=[];}varindex=-1;functioncreateCursor(defaultValue){return{current:defaultValue};}functionpop(cursor,fiber){if(index<0){{error('Unexpected pop.');}return;}{if(fiber!==fiberStack[index]){error('Unexpected Fiber popped.');}}cursor.current=valueStack[index];valueStack[index]=null;{fiberStack[index]=null;}index--;}functionpush(cursor,value,fiber){index++;valueStack[index]=cursor.current;{fiberStack[index]=fiber;}cursor.current=value;}varwarnedAboutMissingGetChildContext;{warnedAboutMissingGetChildContext={};}varemptyContextObject={};{Object.freeze(emptyContextObject);}// A cursor to the current merged context object on the stack.
varcontextStackCursor=createCursor(emptyContextObject);// A cursor to a boolean indicating whether the context has changed.
vardidPerformWorkStackCursor=createCursor(false);// Keep track of the previous context object that was on the stack.
// We use this to get access to the parent context after we have already
// pushed the next context provider, and now need to merge their contexts.
varpreviousContext=emptyContextObject;functiongetUnmaskedContext(workInProgress,Component,didPushOwnContextIfProvider){{if(didPushOwnContextIfProvider&&isContextProvider(Component)){// If the fiber is a context provider itself, when we read its context
// we may have already pushed its own child context on the stack. A context
// provider should not "see" its own child context. Therefore we read the
// previous (parent) context instead for a context provider.
returnpreviousContext;}returncontextStackCursor.current;}}functioncacheContext(workInProgress,unmaskedContext,maskedContext){{varinstance=workInProgress.stateNode;instance.__reactInternalMemoizedUnmaskedChildContext=unmaskedContext;instance.__reactInternalMemoizedMaskedChildContext=maskedContext;}}functiongetMaskedContext(workInProgress,unmaskedContext){{vartype=workInProgress.type;varcontextTypes=type.contextTypes;if(!contextTypes){returnemptyContextObject;}// Avoid recreating masked context unless unmasked context has changed.
// Failing to do this will result in unnecessary calls to componentWillReceiveProps.
// This may trigger infinite loops if componentWillReceiveProps calls setState.
varinstance=workInProgress.stateNode;if(instance&&instance.__reactInternalMemoizedUnmaskedChildContext===unmaskedContext){returninstance.__reactInternalMemoizedMaskedChildContext;}varcontext={};for(varkeyincontextTypes){context[key]=unmaskedContext[key];}{varname=getComponentName(type)||'Unknown';checkPropTypes(contextTypes,context,'context',name);}// Cache unmasked context so we can avoid recreating masked context unless necessary.
// Context is created before the class component is instantiated so check for instance.
if(instance){cacheContext(workInProgress,unmaskedContext,context);}returncontext;}}functionhasContextChanged(){{returndidPerformWorkStackCursor.current;}}functionisContextProvider(type){{varchildContextTypes=type.childContextTypes;returnchildContextTypes!==null&&childContextTypes!==undefined;}}functionpopContext(fiber){{pop(didPerformWorkStackCursor,fiber);pop(contextStackCursor,fiber);}}functionpopTopLevelContextObject(fiber){{pop(didPerformWorkStackCursor,fiber);pop(contextStackCursor,fiber);}}functionpushTopLevelContextObject(fiber,context,didChange){{if(!(contextStackCursor.current===emptyContextObject)){{throwError("Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.");}}push(contextStackCursor,context,fiber);push(didPerformWorkStackCursor,didChange,fiber);}}functionprocessChildContext(fiber,type,parentContext){{varinstance=fiber.stateNode;varchildContextTypes=type.childContextTypes;// TODO (bvaughn) Replace this behavior with an invariant() in the future.
// It has only been added in Fiber to match the (unintentional) behavior in Stack.
if(typeofinstance.getChildContext!=='function'){{varcomponentName=getComponentName(type)||'Unknown';if(!warnedAboutMissingGetChildContext[componentName]){warnedAboutMissingGetChildContext[componentName]=true;error('%s.childContextTypes is specified but there is no getChildContext() method '+'on the instance. You can either define getChildContext() on %s or remove '+'childContextTypes from it.',componentName,componentName);}}returnparentContext;}varchildContext=instance.getChildContext();for(varcontextKeyinchildContext){if(!(contextKeyinchildContextTypes)){{throwError((getComponentName(type)||'Unknown')+".getChildContext(): key \""+contextKey+"\" is not defined in childContextTypes.");}}}{varname=getComponentName(type)||'Unknown';checkPropTypes(childContextTypes,childContext,'child context',name);}return_assign({},parentContext,childContext);}}functionpushContextProvider(workInProgress){{varinstance=workInProgress.stateNode;// We push the context as early as possible to ensure stack integrity.
// If the instance does not exist yet, we will push null at first,
// and replace it on the stack later when invalidating the context.
varmemoizedMergedChildContext=instance&&instance.__reactInternalMemoizedMergedChildContext||emptyContextObject;// Remember the parent context so we can merge with it later.
// Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
previousContext=contextStackCursor.current;push(contextStackCursor,memoizedMergedChildContext,workInProgress);push(didPerformWorkStackCursor,didPerformWorkStackCursor.current,workInProgress);returntrue;}}functioninvalidateContextProvider(workInProgress,type,didChange){{varinstance=workInProgress.stateNode;if(!instance){{throwError("Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.");}}if(didChange){// Merge parent and own context.
// Skip this if we're not updating due to sCU.
// This avoids unnecessarily recomputing memoized values.
varmergedContext=processChildContext(workInProgress,type,previousContext);instance.__reactInternalMemoizedMergedChildContext=mergedContext;// Replace the old (or empty) context with the new one.
// It is important to unwind the context in the reverse order.
pop(didPerformWorkStackCursor,workInProgress);pop(contextStackCursor,workInProgress);// Now push the new context and mark that it has changed.
push(contextStackCursor,mergedContext,workInProgress);push(didPerformWorkStackCursor,didChange,workInProgress);}else{pop(didPerformWorkStackCursor,workInProgress);push(didPerformWorkStackCursor,didChange,workInProgress);}}}functionfindCurrentUnmaskedContext(fiber){{// Currently this is only used with renderSubtreeIntoContainer; not sure if it
// makes sense elsewhere
if(!(isFiberMounted(fiber)&&fiber.tag===ClassComponent)){{throwError("Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.");}}varnode=fiber;do{switch(node.tag){caseHostRoot:returnnode.stateNode.context;caseClassComponent:{varComponent=node.type;if(isContextProvider(Component)){returnnode.stateNode.__reactInternalMemoizedMergedChildContext;}break;}}node=node.return;}while(node!==null);{{throwError("Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");}}}}varLegacyRoot=0;varBlockingRoot=1;varConcurrentRoot=2;varrendererID=null;varinjectedHook=null;varhasLoggedError=false;varisDevToolsPresent=typeof__REACT_DEVTOOLS_GLOBAL_HOOK__!=='undefined';functioninjectInternals(internals){if(typeof__REACT_DEVTOOLS_GLOBAL_HOOK__==='undefined'){// No DevTools
returnfalse;}varhook=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(hook.isDisabled){// This isn't a real property on the hook, but it can be set to opt out
// of DevTools integration and associated warnings and logs.
// https://github.com/facebook/react/issues/3877
returntrue;}if(!hook.supportsFiber){{error('The installed version of React DevTools is too old and will not work '+'with the current version of React. Please update React DevTools. '+'https://reactjs.org/link/react-devtools');}// DevTools exists, even though it doesn't support Fiber.
returntrue;}try{rendererID=hook.inject(internals);// We have successfully injected, so now it is safe to set up hooks.
injectedHook=hook;}catch(err){// Catch all errors because it is unsafe to throw during initialization.
{error('React instrumentation encountered an error: %s.',err);}}// DevTools exists
returntrue;}functiononScheduleRoot(root,children){{if(injectedHook&&typeofinjectedHook.onScheduleFiberRoot==='function'){try{injectedHook.onScheduleFiberRoot(rendererID,root,children);}catch(err){if(!hasLoggedError){hasLoggedError=true;error('React instrumentation encountered an error: %s',err);}}}}}functiononCommitRoot(root,priorityLevel){if(injectedHook&&typeofinjectedHook.onCommitFiberRoot==='function'){try{vardidError=(root.current.flags&DidCapture)===DidCapture;if(enableProfilerTimer){injectedHook.onCommitFiberRoot(rendererID,root,priorityLevel,didError);}}catch(err){{if(!hasLoggedError){hasLoggedError=true;error('React instrumentation encountered an error: %s',err);}}}}}functiononCommitUnmount(fiber){if(injectedHook&&typeofinjectedHook.onCommitFiberUnmount==='function'){try{injectedHook.onCommitFiberUnmount(rendererID,fiber);}catch(err){{if(!hasLoggedError){hasLoggedError=true;error('React instrumentation encountered an error: %s',err);}}}}}varScheduler_runWithPriority=Scheduler.unstable_runWithPriority,Scheduler_scheduleCallback=Scheduler.unstable_scheduleCallback,Scheduler_cancelCallback=Scheduler.unstable_cancelCallback,Scheduler_shouldYield=Scheduler.unstable_shouldYield,Scheduler_requestPaint=Scheduler.unstable_requestPaint,Scheduler_now$1=Scheduler.unstable_now,Scheduler_getCurrentPriorityLevel=Scheduler.unstable_getCurrentPriorityLevel,Scheduler_ImmediatePriority=Scheduler.unstable_ImmediatePriority,Scheduler_UserBlockingPriority=Scheduler.unstable_UserBlockingPriority,Scheduler_NormalPriority=Scheduler.unstable_NormalPriority,Scheduler_LowPriority=Scheduler.unstable_LowPriority,Scheduler_IdlePriority=Scheduler.unstable_IdlePriority;{// Provide explicit error message when production+profiling bundle of e.g.
// react-dom is used with production (non-profiling) bundle of
// scheduler/tracing
if(!(tracing$1.__interactionsRef!=null&&tracing$1.__interactionsRef.current!=null)){{throwError("It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at https://reactjs.org/link/profiling");}}}varfakeCallbackNode={};// Except for NoPriority, these correspond to Scheduler priorities. We use
// ascending numbers so we can compare them like numbers. They start at 90 to
// avoid clashing with Scheduler's priorities.
varImmediatePriority$1=99;varUserBlockingPriority$2=98;varNormalPriority$1=97;varLowPriority$1=96;varIdlePriority$1=95;// NoPriority is the absence of priority. Also React-only.
varNoPriority$1=90;varshouldYield=Scheduler_shouldYield;varrequestPaint=// Fall back gracefully if we're running an older version of Scheduler.
Scheduler_requestPaint!==undefined?Scheduler_requestPaint:function(){};varsyncQueue=null;varimmediateQueueCallbackNode=null;varisFlushingSyncQueue=false;varinitialTimeMs$1=Scheduler_now$1();// If the initial timestamp is reasonably small, use Scheduler's `now` directly.
// This will be the case for modern browsers that support `performance.now`. In
// older browsers, Scheduler falls back to `Date.now`, which returns a Unix
// timestamp. In that case, subtract the module initialization time to simulate
// the behavior of performance.now and keep our times small enough to fit
// within 32 bits.
// TODO: Consider lifting this into Scheduler.
varnow=initialTimeMs$1<10000?Scheduler_now$1:function(){returnScheduler_now$1()-initialTimeMs$1;};functiongetCurrentPriorityLevel(){switch(Scheduler_getCurrentPriorityLevel()){caseScheduler_ImmediatePriority:returnImmediatePriority$1;caseScheduler_UserBlockingPriority:returnUserBlockingPriority$2;caseScheduler_NormalPriority:returnNormalPriority$1;caseScheduler_LowPriority:returnLowPriority$1;caseScheduler_IdlePriority:returnIdlePriority$1;default:{{throwError("Unknown priority level.");}}}}functionreactPriorityToSchedulerPriority(reactPriorityLevel){switch(reactPriorityLevel){caseImmediatePriority$1:returnScheduler_ImmediatePriority;caseUserBlockingPriority$2:returnScheduler_UserBlockingPriority;caseNormalPriority$1:returnScheduler_NormalPriority;caseLowPriority$1:returnScheduler_LowPriority;caseIdlePriority$1:returnScheduler_IdlePriority;default:{{throwError("Unknown priority level.");}}}}functionrunWithPriority$1(reactPriorityLevel,fn){varpriorityLevel=reactPriorityToSchedulerPriority(reactPriorityLevel);returnScheduler_runWithPriority(priorityLevel,fn);}functionscheduleCallback(reactPriorityLevel,callback,options){varpriorityLevel=reactPriorityToSchedulerPriority(reactPriorityLevel);returnScheduler_scheduleCallback(priorityLevel,callback,options);}functionscheduleSyncCallback(callback){// Push this callback into an internal queue. We'll flush these either in
// the next tick, or earlier if something calls `flushSyncCallbackQueue`.
if(syncQueue===null){syncQueue=[callback];// Flush the queue in the next tick, at the earliest.
immediateQueueCallbackNode=Scheduler_scheduleCallback(Scheduler_ImmediatePriority,flushSyncCallbackQueueImpl);}else{// Push onto existing queue. Don't need to schedule a callback because
// we already scheduled one when we created the queue.
isFlushingSyncQueue=true;vari=0;{try{var_isSync2=true;var_queue=syncQueue;runWithPriority$1(ImmediatePriority$1,function(){for(;i<_queue.length;i++){varcallback=_queue[i];do{callback=callback(_isSync2);}while(callback!==null);}});syncQueue=null;}catch(error){// If something throws, leave the remaining callbacks on the queue.
if(syncQueue!==null){syncQueue=syncQueue.slice(i+1);}// Resume flushing in the next tick
Scheduler_scheduleCallback(Scheduler_ImmediatePriority,flushSyncCallbackQueue);throwerror;}finally{isFlushingSyncQueue=false;}}}}// TODO: this is special because it gets imported during build.
varReactVersion='17.0.2';varNoMode=0;varStrictMode=1;// TODO: Remove BlockingMode and ConcurrentMode by reading from the root
// tag instead
varBlockingMode=2;varConcurrentMode=4;varProfileMode=8;varDebugTracingMode=16;varReactCurrentBatchConfig=ReactSharedInternals.ReactCurrentBatchConfig;varNoTransition=0;functionrequestCurrentTransition(){returnReactCurrentBatchConfig.transition;}varReactStrictModeWarnings={recordUnsafeLifecycleWarnings:function(fiber,instance){},flushPendingUnsafeLifecycleWarnings:function(){},recordLegacyContextWarning:function(fiber,instance){},flushLegacyContextWarning:function(){},discardPendingWarnings:function(){}};{varfindStrictRoot=function(fiber){varmaybeStrictRoot=null;varnode=fiber;while(node!==null){if(node.mode&StrictMode){maybeStrictRoot=node;}node=node.return;}returnmaybeStrictRoot;};varsetToSortedString=function(set){vararray=[];set.forEach(function(value){array.push(value);});returnarray.sort().join(', ');};varpendingComponentWillMountWarnings=[];varpendingUNSAFE_ComponentWillMountWarnings=[];varpendingComponentWillReceivePropsWarnings=[];varpendingUNSAFE_ComponentWillReceivePropsWarnings=[];varpendingComponentWillUpdateWarnings=[];varpendingUNSAFE_ComponentWillUpdateWarnings=[];// Tracks components we have already warned about.
vardidWarnAboutUnsafeLifecycles=newSet();ReactStrictModeWarnings.recordUnsafeLifecycleWarnings=function(fiber,instance){// Dedup strategy: Warn once per component.
if(didWarnAboutUnsafeLifecycles.has(fiber.type)){return;}if(typeofinstance.componentWillMount==='function'&&// Don't warn about react-lifecycles-compat polyfilled components.
instance.componentWillMount.__suppressDeprecationWarning!==true){pendingComponentWillMountWarnings.push(fiber);}if(fiber.mode&StrictMode&&typeofinstance.UNSAFE_componentWillMount==='function'){pendingUNSAFE_ComponentWillMountWarnings.push(fiber);}if(typeofinstance.componentWillReceiveProps==='function'&&instance.componentWillReceiveProps.__suppressDeprecationWarning!==true){pendingComponentWillReceivePropsWarnings.push(fiber);}if(fiber.mode&StrictMode&&typeofinstance.UNSAFE_componentWillReceiveProps==='function'){pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);}if(typeofinstance.componentWillUpdate==='function'&&instance.componentWillUpdate.__suppressDeprecationWarning!==true){pendingComponentWillUpdateWarnings.push(fiber);}if(fiber.mode&StrictMode&&typeofinstance.UNSAFE_componentWillUpdate==='function'){pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);}};ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings=function(){// We do an initial pass to gather component names
varcomponentWillMountUniqueNames=newSet();if(pendingComponentWillMountWarnings.length>0){pendingComponentWillMountWarnings.forEach(function(fiber){componentWillMountUniqueNames.add(getComponentName(fiber.type)||'Component');didWarnAboutUnsafeLifecycles.add(fiber.type);});pendingComponentWillMountWarnings=[];}varUNSAFE_componentWillMountUniqueNames=newSet();if(pendingUNSAFE_ComponentWillMountWarnings.length>0){pendingUNSAFE_ComponentWillMountWarnings.forEach(function(fiber){UNSAFE_componentWillMountUniqueNames.add(getComponentName(fiber.type)||'Component');didWarnAboutUnsafeLifecycles.add(fiber.type);});pendingUNSAFE_ComponentWillMountWarnings=[];}varcomponentWillReceivePropsUniqueNames=newSet();if(pendingComponentWillReceivePropsWarnings.length>0){pendingComponentWillReceivePropsWarnings.forEach(function(fiber){componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type)||'Component');didWarnAboutUnsafeLifecycles.add(fiber.type);});pendingComponentWillReceivePropsWarnings=[];}varUNSAFE_componentWillReceivePropsUniqueNames=newSet();if(pendingUNSAFE_ComponentWillReceivePropsWarnings.length>0){pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function(fiber){UNSAFE_componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type)||'Component');didWarnAboutUnsafeLifecycles.add(fiber.type);});pendingUNSAFE_ComponentWillReceivePropsWarnings=[];}varcomponentWillUpdateUniqueNames=newSet();if(pendingComponentWillUpdateWarnings.length>0){pendingComponentWillUpdateWarnings.forEach(function(fiber){componentWillUpdateUniqueNames.add(getComponentName(fiber.type)||'Component');didWarnAboutUnsafeLifecycles.add(fiber.type);});pendingComponentWillUpdateWarnings=[];}varUNSAFE_componentWillUpdateUniqueNames=newSet();if(pendingUNSAFE_ComponentWillUpdateWarnings.length>0){pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function(fiber){UNSAFE_componentWillUpdateUniqueNames.add(getComponentName(fiber.type)||'Component');didWarnAboutUnsafeLifecycles.add(fiber.type);});pendingUNSAFE_ComponentWillUpdateWarnings=[];}// Finally, we flush all the warnings
// UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
if(UNSAFE_componentWillMountUniqueNames.size>0){varsortedNames=setToSortedString(UNSAFE_componentWillMountUniqueNames);error('Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. '+'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n'+'* Move code with side effects to componentDidMount, and set initial state in the constructor.\n'+'\nPlease update the following components: %s',sortedNames);}if(UNSAFE_componentWillReceivePropsUniqueNames.size>0){var_sortedNames=setToSortedString(UNSAFE_componentWillReceivePropsUniqueNames);error('Using UNSAFE_componentWillReceiveProps in strict mode is not recommended '+'and may indicate bugs in your code. '+'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n'+'* Move data fetching code or side effects to componentDidUpdate.\n'+"* If you're updating state whenever props change, "+'refactor your code to use memoization techniques or move it to '+'static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n'+'\nPlease update the following components: %s',_sortedNames);}if(UNSAFE_componentWillUpdateUniqueNames.size>0){var_sortedNames2=setToSortedString(UNSAFE_componentWillUpdateUniqueNames);error('Using UNSAFE_componentWillUpdate in strict mode is not recommended '+'and may indicate bugs in your code. '+'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n'+'* Move data fetching code or side effects to componentDidUpdate.\n'+'\nPlease update the following components: %s',_sortedNames2);}if(componentWillMountUniqueNames.size>0){var_sortedNames3=setToSortedString(componentWillMountUniqueNames);warn('componentWillMount has been renamed, and is not recommended for use. '+'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n'+'* Move code with side effects to componentDidMount, and set initial state in the constructor.\n'+'* Rename componentWillMount to UNSAFE_componentWillMount to suppress '+'this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. '+'To rename all deprecated lifecycles to their new names, you can run '+'`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n'+'\nPlease update the following components: %s',_sortedNames3);}if(componentWillReceivePropsUniqueNames.size>0){var_sortedNames4=setToSortedString(componentWillReceivePropsUniqueNames);warn('componentWillReceiveProps has been renamed, and is not recommended for use. '+'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n'+'* Move data fetching code or side effects to componentDidUpdate.\n'+"* If you're updating state whenever props change, refactor your "+'code to use memoization techniques or move it to '+'static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n'+'* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress '+'this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. '+'To rename all deprecated lifecycles to their new names, you can run '+'`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n'+'\nPlease update the following components: %s',_sortedNames4);}if(componentWillUpdateUniqueNames.size>0){var_sortedNames5=setToSortedString(componentWillUpdateUniqueNames);warn('componentWillUpdate has been renamed, and is not recommended for use. '+'See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n'+'* Move data fetching code or side effects to componentDidUpdate.\n'+'* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress '+'this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. '+'To rename all deprecated lifecycles to their new names, you can run '+'`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n'+'\nPlease update the following components: %s',_sortedNames5);}};varpendingLegacyContextWarning=newMap();// Tracks components we have already warned about.
vardidWarnAboutLegacyContext=newSet();ReactStrictModeWarnings.recordLegacyContextWarning=function(fiber,instance){varstrictRoot=findStrictRoot(fiber);if(strictRoot===null){error('Expected to find a StrictMode component in a strict mode tree. '+'This error is likely caused by a bug in React. Please file an issue.');return;}// Dedup strategy: Warn once per component.
if(didWarnAboutLegacyContext.has(fiber.type)){return;}varwarningsForRoot=pendingLegacyContextWarning.get(strictRoot);if(fiber.type.contextTypes!=null||fiber.type.childContextTypes!=null||instance!==null&&typeofinstance.getChildContext==='function'){if(warningsForRoot===undefined){warningsForRoot=[];pendingLegacyContextWarning.set(strictRoot,warningsForRoot);}warningsForRoot.push(fiber);}};ReactStrictModeWarnings.flushLegacyContextWarning=function(){pendingLegacyContextWarning.forEach(function(fiberArray,strictRoot){if(fiberArray.length===0){return;}varfirstFiber=fiberArray[0];varuniqueNames=newSet();fiberArray.forEach(function(fiber){uniqueNames.add(getComponentName(fiber.type)||'Component');didWarnAboutLegacyContext.add(fiber.type);});varsortedNames=setToSortedString(uniqueNames);try{setCurrentFiber(firstFiber);error('Legacy context API has been detected within a strict-mode tree.'+'\n\nThe old API will be supported in all 16.x releases, but applications '+'using it should migrate to the new version.'+'\n\nPlease update the following components: %s'+'\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context',sortedNames);}finally{resetCurrentFiber();}});};ReactStrictModeWarnings.discardPendingWarnings=function(){pendingComponentWillMountWarnings=[];pendingUNSAFE_ComponentWillMountWarnings=[];pendingComponentWillReceivePropsWarnings=[];pendingUNSAFE_ComponentWillReceivePropsWarnings=[];pendingComponentWillUpdateWarnings=[];pendingUNSAFE_ComponentWillUpdateWarnings=[];pendingLegacyContextWarning=newMap();};}functionresolveDefaultProps(Component,baseProps){if(Component&&Component.defaultProps){// Resolve default props. Taken from ReactElement
varprops=_assign({},baseProps);vardefaultProps=Component.defaultProps;for(varpropNameindefaultProps){if(props[propName]===undefined){props[propName]=defaultProps[propName];}}returnprops;}returnbaseProps;}// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
// Math.pow(2, 30) - 1
// 0b111111111111111111111111111111
varMAX_SIGNED_31_BIT_INT=1073741823;varvalueCursor=createCursor(null);varrendererSigil;{// Use this to detect multiple renderers using the same context
rendererSigil={};}varcurrentlyRenderingFiber=null;varlastContextDependency=null;varlastContextWithAllBitsObserved=null;varisDisallowedContextReadInDEV=false;functionresetContextDependencies(){// This is called right before React yields execution, to ensure `readContext`
// cannot be called outside the render phase.
currentlyRenderingFiber=null;lastContextDependency=null;lastContextWithAllBitsObserved=null;{isDisallowedContextReadInDEV=false;}}functionenterDisallowedContextReadInDEV(){{isDisallowedContextReadInDEV=true;}}functionexitDisallowedContextReadInDEV(){{isDisallowedContextReadInDEV=false;}}functionpushProvider(providerFiber,nextValue){varcontext=providerFiber.type._context;{push(valueCursor,context._currentValue,providerFiber);context._currentValue=nextValue;{if(context._currentRenderer!==undefined&&context._currentRenderer!==null&&context._currentRenderer!==rendererSigil){error('Detected multiple renderers concurrently rendering the '+'same context provider. This is currently unsupported.');}context._currentRenderer=rendererSigil;}}}functionpopProvider(providerFiber){varcurrentValue=valueCursor.current;pop(valueCursor,providerFiber);varcontext=providerFiber.type._context;{context._currentValue=currentValue;}}functioncalculateChangedBits(context,newValue,oldValue){if(objectIs(oldValue,newValue)){// No change
return0;}else{varchangedBits=typeofcontext._calculateChangedBits==='function'?context._calculateChangedBits(oldValue,newValue):MAX_SIGNED_31_BIT_INT;{if((changedBits&MAX_SIGNED_31_BIT_INT)!==changedBits){error('calculateChangedBits: Expected the return value to be a '+'31-bit integer. Instead received: %s',changedBits);}}returnchangedBits|0;}}functionscheduleWorkOnParentPath(parent,renderLanes){// Update the child lanes of all the ancestors, including the alternates.
varnode=parent;while(node!==null){varalternate=node.alternate;if(!isSubsetOfLanes(node.childLanes,renderLanes)){node.childLanes=mergeLanes(node.childLanes,renderLanes);if(alternate!==null){alternate.childLanes=mergeLanes(alternate.childLanes,renderLanes);}}elseif(alternate!==null&&!isSubsetOfLanes(alternate.childLanes,renderLanes)){alternate.childLanes=mergeLanes(alternate.childLanes,renderLanes);}else{// Neither alternate was updated, which means the rest of the
// ancestor path already has sufficient priority.
break;}node=node.return;}}functionpropagateContextChange(workInProgress,context,changedBits,renderLanes){varfiber=workInProgress.child;if(fiber!==null){// Set the return pointer of the child to the work-in-progress fiber.
fiber.return=workInProgress;}while(fiber!==null){varnextFiber=void0;// Visit this fiber.
varlist=fiber.dependencies;if(list!==null){nextFiber=fiber.child;vardependency=list.firstContext;while(dependency!==null){// Check if the context matches.
if(dependency.context===context&&(dependency.observedBits&changedBits)!==0){// Match! Schedule an update on this fiber.
if(fiber.tag===ClassComponent){// Schedule a force update on the work-in-progress.
varupdate=createUpdate(NoTimestamp,pickArbitraryLane(renderLanes));update.tag=ForceUpdate;// TODO: Because we don't have a work-in-progress, this will add the
// update to the current fiber, too, which means it will persist even if
// this render is thrown away. Since it's a race condition, not sure it's
// worth fixing.
enqueueUpdate(fiber,update);}fiber.lanes=mergeLanes(fiber.lanes,renderLanes);varalternate=fiber.alternate;if(alternate!==null){alternate.lanes=mergeLanes(alternate.lanes,renderLanes);}scheduleWorkOnParentPath(fiber.return,renderLanes);// Mark the updated lanes on the list, too.
list.lanes=mergeLanes(list.lanes,renderLanes);// Since we already found a match, we can stop traversing the
// dependency list.
break;}dependency=dependency.next;}}elseif(fiber.tag===ContextProvider){// Don't scan deeper if this is a matching provider
nextFiber=fiber.child;}if(nextFiber!==null){// Set the return pointer of the child to the work-in-progress fiber.
nextFiber.return=fiber;}else{// No child. Traverse to next sibling.
nextFiber=fiber;while(nextFiber!==null){if(nextFiber===workInProgress){// We're back to the root of this subtree. Exit.
nextFiber=null;break;}varsibling=nextFiber.sibling;if(sibling!==null){// Set the return pointer of the sibling to the work-in-progress fiber.
sibling.return=nextFiber.return;nextFiber=sibling;break;}// No more siblings. Traverse up.
nextFiber=nextFiber.return;}}fiber=nextFiber;}}functionprepareToReadContext(workInProgress,renderLanes){currentlyRenderingFiber=workInProgress;lastContextDependency=null;lastContextWithAllBitsObserved=null;vardependencies=workInProgress.dependencies;if(dependencies!==null){varfirstContext=dependencies.firstContext;if(firstContext!==null){if(includesSomeLane(dependencies.lanes,renderLanes)){// Context list has a pending update. Mark that this fiber performed work.
markWorkInProgressReceivedUpdate();}// Reset the work-in-progress list
dependencies.firstContext=null;}}}functionreadContext(context,observedBits){{// This warning would fire if you read context inside a Hook like useMemo.
// Unlike the class check below, it's not enforced in production for perf.
if(isDisallowedContextReadInDEV){error('Context can only be read while React is rendering. '+'In classes, you can read it in the render method or getDerivedStateFromProps. '+'In function components, you can read it directly in the function body, but not '+'inside Hooks like useReducer() or useMemo().');}}if(lastContextWithAllBitsObserved===context);elseif(observedBits===false||observedBits===0);else{varresolvedObservedBits;// Avoid deopting on observable arguments or heterogeneous types.
if(typeofobservedBits!=='number'||observedBits===MAX_SIGNED_31_BIT_INT){// Observe all updates.
lastContextWithAllBitsObserved=context;resolvedObservedBits=MAX_SIGNED_31_BIT_INT;}else{resolvedObservedBits=observedBits;}varcontextItem={context:context,observedBits:resolvedObservedBits,next:null};if(lastContextDependency===null){if(!(currentlyRenderingFiber!==null)){{throwError("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");}}// This is the first dependency for this component. Create a new list.
lastContextDependency=contextItem;currentlyRenderingFiber.dependencies={lanes:NoLanes,firstContext:contextItem,responders:null};}else{// Append a new context item.
lastContextDependency=lastContextDependency.next=contextItem;}}returncontext._currentValue;}varUpdateState=0;varReplaceState=1;varForceUpdate=2;varCaptureUpdate=3;// Global state that is reset at the beginning of calling `processUpdateQueue`.
// It should only be read right after calling `processUpdateQueue`, via
// `checkHasForceUpdateAfterProcessing`.
varhasForceUpdate=false;vardidWarnUpdateInsideUpdate;varcurrentlyProcessingQueue;{didWarnUpdateInsideUpdate=false;currentlyProcessingQueue=null;}functioninitializeUpdateQueue(fiber){varqueue={baseState:fiber.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null},effects:null};fiber.updateQueue=queue;}functioncloneUpdateQueue(current,workInProgress){// Clone the update queue from current. Unless it's already a clone.
varqueue=workInProgress.updateQueue;varcurrentQueue=current.updateQueue;if(queue===currentQueue){varclone={baseState:currentQueue.baseState,firstBaseUpdate:currentQueue.firstBaseUpdate,lastBaseUpdate:currentQueue.lastBaseUpdate,shared:currentQueue.shared,effects:currentQueue.effects};workInProgress.updateQueue=clone;}}functioncreateUpdate(eventTime,lane){varupdate={eventTime:eventTime,lane:lane,tag:UpdateState,payload:null,callback:null,next:null};returnupdate;}functionenqueueUpdate(fiber,update){varupdateQueue=fiber.updateQueue;if(updateQueue===null){// Only occurs if the fiber has been unmounted.
return;}varsharedQueue=updateQueue.shared;varpending=sharedQueue.pending;if(pending===null){// This is the first update. Create a circular list.
update.next=update;}else{update.next=pending.next;pending.next=update;}sharedQueue.pending=update;{if(currentlyProcessingQueue===sharedQueue&&!didWarnUpdateInsideUpdate){error('An update (setState, replaceState, or forceUpdate) was scheduled '+'from inside an update function. Update functions should be pure, '+'with zero side-effects. Consider using componentDidUpdate or a '+'callback.');didWarnUpdateInsideUpdate=true;}}}functionenqueueCapturedUpdate(workInProgress,capturedUpdate){// Captured updates are updates that are thrown by a child during the render
// phase. They should be discarded if the render is aborted. Therefore,
// we should only put them on the work-in-progress queue, not the current one.
varqueue=workInProgress.updateQueue;// Check if the work-in-progress queue is a clone.
varcurrent=workInProgress.alternate;if(current!==null){varcurrentQueue=current.updateQueue;if(queue===currentQueue){// The work-in-progress queue is the same as current. This happens when
// we bail out on a parent fiber that then captures an error thrown by
// a child. Since we want to append the update only to the work-in
// -progress queue, we need to clone the updates. We usually clone during
// processUpdateQueue, but that didn't happen in this case because we
// skipped over the parent when we bailed out.
varnewFirst=null;varnewLast=null;varfirstBaseUpdate=queue.firstBaseUpdate;if(firstBaseUpdate!==null){// Loop through the updates and clone them.
varupdate=firstBaseUpdate;do{varclone={eventTime:update.eventTime,lane:update.lane,tag:update.tag,payload:update.payload,callback:update.callback,next:null};if(newLast===null){newFirst=newLast=clone;}else{newLast.next=clone;newLast=clone;}update=update.next;}while(update!==null);// Append the captured update the end of the cloned list.
if(newLast===null){newFirst=newLast=capturedUpdate;}else{newLast.next=capturedUpdate;newLast=capturedUpdate;}}else{// There are no base updates.
newFirst=newLast=capturedUpdate;}queue={baseState:currentQueue.baseState,firstBaseUpdate:newFirst,lastBaseUpdate:newLast,shared:currentQueue.shared,effects:currentQueue.effects};workInProgress.updateQueue=queue;return;}}// Append the update to the end of the list.
varlastBaseUpdate=queue.lastBaseUpdate;if(lastBaseUpdate===null){queue.firstBaseUpdate=capturedUpdate;}else{lastBaseUpdate.next=capturedUpdate;}queue.lastBaseUpdate=capturedUpdate;}functiongetStateFromUpdate(workInProgress,queue,update,prevState,nextProps,instance){switch(update.tag){caseReplaceState:{varpayload=update.payload;if(typeofpayload==='function'){// Updater function
{enterDisallowedContextReadInDEV();}varnextState=payload.call(instance,prevState,nextProps);{if(workInProgress.mode&StrictMode){disableLogs();try{payload.call(instance,prevState,nextProps);}finally{reenableLogs();}}exitDisallowedContextReadInDEV();}returnnextState;}// State object
caseUpdateState:{var_payload=update.payload;varpartialState;if(typeof_payload==='function'){// Updater function
{enterDisallowedContextReadInDEV();}partialState=_payload.call(instance,prevState,nextProps);{if(workInProgress.mode&StrictMode){disableLogs();try{_payload.call(instance,prevState,nextProps);}finally{reenableLogs();}}exitDisallowedContextReadInDEV();}}else{// Partial state object
partialState=_payload;}if(partialState===null||partialState===undefined){// Null and undefined are treated as no-ops.
returnprevState;}// Merge the partial state and the previous state.
return_assign({},prevState,partialState);}caseForceUpdate:{hasForceUpdate=true;returnprevState;}}returnprevState;}functionprocessUpdateQueue(workInProgress,props,instance,renderLanes){// This is always non-null on a ClassComponent or HostRoot
varqueue=workInProgress.updateQueue;hasForceUpdate=false;{currentlyProcessingQueue=queue.shared;}varfirstBaseUpdate=queue.firstBaseUpdate;varlastBaseUpdate=queue.lastBaseUpdate;// Check if there are pending updates. If so, transfer them to the base queue.
varpendingQueue=queue.shared.pending;if(pendingQueue!==null){queue.shared.pending=null;// The pending queue is circular. Disconnect the pointer between first
// and last so that it's non-circular.
varlastPendingUpdate=pendingQueue;varfirstPendingUpdate=lastPendingUpdate.next;lastPendingUpdate.next=null;// Append pending updates to base queue
if(lastBaseUpdate===null){firstBaseUpdate=firstPendingUpdate;}else{lastBaseUpdate.next=firstPendingUpdate;}lastBaseUpdate=lastPendingUpdate;// If there's a current queue, and it's different from the base queue, then
// we need to transfer the updates to that queue, too. Because the base
// queue is a singly-linked list with no cycles, we can append to both
// lists and take advantage of structural sharing.
// TODO: Pass `current` as argument
varcurrent=workInProgress.alternate;if(current!==null){// This is always non-null on a ClassComponent or HostRoot
varcurrentQueue=current.updateQueue;varcurrentLastBaseUpdate=currentQueue.lastBaseUpdate;if(currentLastBaseUpdate!==lastBaseUpdate){if(currentLastBaseUpdate===null){currentQueue.firstBaseUpdate=firstPendingUpdate;}else{currentLastBaseUpdate.next=firstPendingUpdate;}currentQueue.lastBaseUpdate=lastPendingUpdate;}}}// These values may change as we process the queue.
if(firstBaseUpdate!==null){// Iterate through the list of updates to compute the result.
varnewState=queue.baseState;// TODO: Don't need to accumulate this. Instead, we can remove renderLanes
// from the original lanes.
varnewLanes=NoLanes;varnewBaseState=null;varnewFirstBaseUpdate=null;varnewLastBaseUpdate=null;varupdate=firstBaseUpdate;do{varupdateLane=update.lane;varupdateEventTime=update.eventTime;if(!isSubsetOfLanes(renderLanes,updateLane)){// Priority is insufficient. Skip this update. If this is the first
// skipped update, the previous update/state is the new base
// update/state.
varclone={eventTime:updateEventTime,lane:updateLane,tag:update.tag,payload:update.payload,callback:update.callback,next:null};if(newLastBaseUpdate===null){newFirstBaseUpdate=newLastBaseUpdate=clone;newBaseState=newState;}else{newLastBaseUpdate=newLastBaseUpdate.next=clone;}// Update the remaining priority in the queue.
newLanes=mergeLanes(newLanes,updateLane);}else{// This update does have sufficient priority.
if(newLastBaseUpdate!==null){var_clone={eventTime:updateEventTime,// This update is going to be committed so we never want uncommit
// it. Using NoLane works because 0 is a subset of all bitmasks, so
// this will never be skipped by the check above.
lane:NoLane,tag:update.tag,payload:update.payload,callback:update.callback,next:null};newLastBaseUpdate=newLastBaseUpdate.next=_clone;}// Process this update.
newState=getStateFromUpdate(workInProgress,queue,update,newState,props,instance);varcallback=update.callback;if(callback!==null){workInProgress.flags|=Callback;vareffects=queue.effects;if(effects===null){queue.effects=[update];}else{effects.push(update);}}}update=update.next;if(update===null){pendingQueue=queue.shared.pending;if(pendingQueue===null){break;}else{// An update was scheduled from inside a reducer. Add the new
// pending updates to the end of the list and keep processing.
var_lastPendingUpdate=pendingQueue;// Intentionally unsound. Pending updates form a circular list, but we
// unravel them when transferring them to the base queue.
var_firstPendingUpdate=_lastPendingUpdate.next;_lastPendingUpdate.next=null;update=_firstPendingUpdate;queue.lastBaseUpdate=_lastPendingUpdate;queue.shared.pending=null;}}}while(true);if(newLastBaseUpdate===null){newBaseState=newState;}queue.baseState=newBaseState;queue.firstBaseUpdate=newFirstBaseUpdate;queue.lastBaseUpdate=newLastBaseUpdate;// Set the remaining expiration time to be whatever is remaining in the queue.
// This should be fine because the only two other things that contribute to
// expiration time are props and context. We're already in the middle of the
// begin phase by the time we start processing the queue, so we've already
// dealt with the props. Context in components that specify
// shouldComponentUpdate is tricky; but we'll have to account for
// that regardless.
markSkippedUpdateLanes(newLanes);workInProgress.lanes=newLanes;workInProgress.memoizedState=newState;}{currentlyProcessingQueue=null;}}functioncallCallback(callback,context){if(!(typeofcallback==='function')){{throwError("Invalid argument passed as callback. Expected a function. Instead received: "+callback);}}callback.call(context);}functionresetHasForceUpdateBeforeProcessing(){hasForceUpdate=false;}functioncheckHasForceUpdateAfterProcessing(){returnhasForceUpdate;}functioncommitUpdateQueue(finishedWork,finishedQueue,instance){// Commit the effects
vareffects=finishedQueue.effects;finishedQueue.effects=null;if(effects!==null){for(vari=0;i<effects.length;i++){vareffect=effects[i];varcallback=effect.callback;if(callback!==null){effect.callback=null;callCallback(callback,instance);}}}}varfakeInternalInstance={};varisArray=Array.isArray;// React.Component uses a shared frozen object by default.
// We'll use it to determine whether we need to initialize legacy refs.
varemptyRefsObject=newReact.Component().refs;vardidWarnAboutStateAssignmentForComponent;vardidWarnAboutUninitializedState;vardidWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;vardidWarnAboutLegacyLifecyclesAndDerivedState;vardidWarnAboutUndefinedDerivedState;varwarnOnUndefinedDerivedState;varwarnOnInvalidCallback;vardidWarnAboutDirectlyAssigningPropsToState;vardidWarnAboutContextTypeAndContextTypes;vardidWarnAboutInvalidateContextType;{didWarnAboutStateAssignmentForComponent=newSet();didWarnAboutUninitializedState=newSet();didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate=newSet();didWarnAboutLegacyLifecyclesAndDerivedState=newSet();didWarnAboutDirectlyAssigningPropsToState=newSet();didWarnAboutUndefinedDerivedState=newSet();didWarnAboutContextTypeAndContextTypes=newSet();didWarnAboutInvalidateContextType=newSet();vardidWarnOnInvalidCallback=newSet();warnOnInvalidCallback=function(callback,callerName){if(callback===null||typeofcallback==='function'){return;}varkey=callerName+'_'+callback;if(!didWarnOnInvalidCallback.has(key)){didWarnOnInvalidCallback.add(key);error('%s(...): Expected the last optional `callback` argument to be a '+'function. Instead received: %s.',callerName,callback);}};warnOnUndefinedDerivedState=function(type,partialState){if(partialState===undefined){varcomponentName=getComponentName(type)||'Component';if(!didWarnAboutUndefinedDerivedState.has(componentName)){didWarnAboutUndefinedDerivedState.add(componentName);error('%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. '+'You have returned undefined.',componentName);}}};// This is so gross but it's at least non-critical and can be removed if
// it causes problems. This is meant to give a nicer error message for
// ...)) which otherwise throws a "_processChildContext is not a function"
// exception.
Object.defineProperty(fakeInternalInstance,'_processChildContext',{enumerable:false,value:function(){{{throwError("_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn't supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal).");}}}});Object.freeze(fakeInternalInstance);}functionapplyDerivedStateFromProps(workInProgress,ctor,getDerivedStateFromProps,nextProps){varprevState=workInProgress.memoizedState;{if(workInProgress.mode&StrictMode){disableLogs();try{// Invoke the function an extra time to help detect side-effects.
getDerivedStateFromProps(nextProps,prevState);}finally{reenableLogs();}}}varpartialState=getDerivedStateFromProps(nextProps,prevState);{warnOnUndefinedDerivedState(ctor,partialState);}// Merge the partial state and the previous state.
varmemoizedState=partialState===null||partialState===undefined?prevState:_assign({},prevState,partialState);workInProgress.memoizedState=memoizedState;// Once the update queue is empty, persist the derived state onto the
// base state.
if(workInProgress.lanes===NoLanes){// Queue is always non-null for classes
varupdateQueue=workInProgress.updateQueue;updateQueue.baseState=memoizedState;}}varclassComponentUpdater={isMounted:isMounted,enqueueSetState:function(inst,payload,callback){varfiber=get(inst);vareventTime=requestEventTime();varlane=requestUpdateLane(fiber);varupdate=createUpdate(eventTime,lane);update.payload=payload;if(callback!==undefined&&callback!==null){{warnOnInvalidCallback(callback,'setState');}update.callback=callback;}enqueueUpdate(fiber,update);scheduleUpdateOnFiber(fiber,lane,eventTime);},enqueueReplaceState:function(inst,payload,callback){varfiber=get(inst);vareventTime=requestEventTime();varlane=requestUpdateLane(fiber);varupdate=createUpdate(eventTime,lane);update.tag=ReplaceState;update.payload=payload;if(callback!==undefined&&callback!==null){{warnOnInvalidCallback(callback,'replaceState');}update.callback=callback;}enqueueUpdate(fiber,update);scheduleUpdateOnFiber(fiber,lane,eventTime);},enqueueForceUpdate:function(inst,callback){varfiber=get(inst);vareventTime=requestEventTime();varlane=requestUpdateLane(fiber);varupdate=createUpdate(eventTime,lane);update.tag=ForceUpdate;if(callback!==undefined&&callback!==null){{warnOnInvalidCallback(callback,'forceUpdate');}update.callback=callback;}enqueueUpdate(fiber,update);scheduleUpdateOnFiber(fiber,lane,eventTime);}};functioncheckShouldComponentUpdate(workInProgress,ctor,oldProps,newProps,oldState,newState,nextContext){varinstance=workInProgress.stateNode;if(typeofinstance.shouldComponentUpdate==='function'){{if(workInProgress.mode&StrictMode){disableLogs();try{// Invoke the function an extra time to help detect side-effects.
instance.shouldComponentUpdate(newProps,newState,nextContext);}finally{reenableLogs();}}}varshouldUpdate=instance.shouldComponentUpdate(newProps,newState,nextContext);{if(shouldUpdate===undefined){error('%s.shouldComponentUpdate(): Returned undefined instead of a '+'boolean value. Make sure to return true or false.',getComponentName(ctor)||'Component');}}returnshouldUpdate;}if(ctor.prototype&&ctor.prototype.isPureReactComponent){return!shallowEqual(oldProps,newProps)||!shallowEqual(oldState,newState);}returntrue;}functioncheckClassInstance(workInProgress,ctor,newProps){varinstance=workInProgress.stateNode;{varname=getComponentName(ctor)||'Component';varrenderPresent=instance.render;if(!renderPresent){if(ctor.prototype&&typeofctor.prototype.render==='function'){error('%s(...): No `render` method found on the returned component '+'instance: did you accidentally return an object from the constructor?',name);}else{error('%s(...): No `render` method found on the returned component '+'instance: you may have forgotten to define `render`.',name);}}if(instance.getInitialState&&!instance.getInitialState.isReactClassApproved&&!instance.state){error('getInitialState was defined on %s, a plain JavaScript class. '+'This is only supported for classes created using React.createClass. '+'Did you mean to define a state property instead?',name);}if(instance.getDefaultProps&&!instance.getDefaultProps.isReactClassApproved){error('getDefaultProps was defined on %s, a plain JavaScript class. '+'This is only supported for classes created using React.createClass. '+'Use a static property to define defaultProps instead.',name);}if(instance.propTypes){error('propTypes was defined as an instance property on %s. Use a static '+'property to define propTypes instead.',name);}if(instance.contextType){error('contextType was defined as an instance property on %s. Use a static '+'property to define contextType instead.',name);}{if(instance.contextTypes){error('contextTypes was defined as an instance property on %s. Use a static '+'property to define contextTypes instead.',name);}if(ctor.contextType&&ctor.contextTypes&&!didWarnAboutContextTypeAndContextTypes.has(ctor)){didWarnAboutContextTypeAndContextTypes.add(ctor);error('%s declares both contextTypes and contextType static properties. '+'The legacy contextTypes property will be ignored.',name);}}if(typeofinstance.componentShouldUpdate==='function'){error('%s has a method called '+'componentShouldUpdate(). Did you mean shouldComponentUpdate()? '+'The name is phrased as a question because the function is '+'expected to return a value.',name);}if(ctor.prototype&&ctor.prototype.isPureReactComponent&&typeofinstance.shouldComponentUpdate!=='undefined'){error('%s has a method called shouldComponentUpdate(). '+'shouldComponentUpdate should not be used when extending React.PureComponent. '+'Please extend React.Component if shouldComponentUpdate is used.',getComponentName(ctor)||'A pure component');}if(typeofinstance.componentDidUnmount==='function'){error('%s has a method called '+'componentDidUnmount(). But there is no such lifecycle method. '+'Did you mean componentWillUnmount()?',name);}if(typeofinstance.componentDidReceiveProps==='function'){error('%s has a method called '+'componentDidReceiveProps(). But there is no such lifecycle method. '+'If you meant to update the state in response to changing props, '+'use componentWillReceiveProps(). If you meant to fetch data or '+'run side-effects or mutations after React has updated the UI, use componentDidUpdate().',name);}if(typeofinstance.componentWillRecieveProps==='function'){error('%s has a method called '+'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?',name);}if(typeofinstance.UNSAFE_componentWillRecieveProps==='function'){error('%s has a method called '+'UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?',name);}varhasMutatedProps=instance.props!==newProps;if(instance.props!==undefined&&hasMutatedProps){error('%s(...): When calling super() in `%s`, make sure to pass '+"upthesame
set(instance,workInProgress);{instance._reactInternalInstance=fakeInternalInstance;}}functionconstructClassInstance(workInProgress,ctor,props){varisLegacyContextConsumer=false;varunmaskedContext=emptyContextObject;varcontext=emptyContextObject;varcontextType=ctor.contextType;{if('contextType'inctor){varisValid=// Allow null for conditional declaration
contextType===null||contextType!==undefined&&contextType.$$typeof===REACT_CONTEXT_TYPE&&contextType._context===undefined;// Not a <Context.Consumer>
if(!isValid&&!didWarnAboutInvalidateContextType.has(ctor)){didWarnAboutInvalidateContextType.add(ctor);varaddendum='';if(contextType===undefined){addendum=' However, it is set to undefined. '+'This can be caused by a typo or by mixing up named and default imports. '+'This can also happen due to a circular dependency, so '+'try moving the createContext() call to a separate file.';}elseif(typeofcontextType!=='object'){addendum=' However, it is set to a '+typeofcontextType+'.';}elseif(contextType.$$typeof===REACT_PROVIDER_TYPE){addendum=' Did you accidentally pass the Context.Provider instead?';}elseif(contextType._context!==undefined){// <Context.Consumer>
addendum=' Did you accidentally pass the Context.Consumer instead?';}else{addendum=' However, it is set to an object with keys {'+Object.keys(contextType).join(', ')+'}.';}error('%s defines an invalid contextType. '+'contextType should point to the Context object returned by React.createContext().%s',getComponentName(ctor)||'Component',addendum);}}}if(typeofcontextType==='object'&&contextType!==null){context=readContext(contextType);}else{unmaskedContext=getUnmaskedContext(workInProgress,ctor,true);varcontextTypes=ctor.contextTypes;isLegacyContextConsumer=contextTypes!==null&&contextTypes!==undefined;context=isLegacyContextConsumer?getMaskedContext(workInProgress,unmaskedContext):emptyContextObject;}// Instantiate twice to help detect side-effects.
}finally{reenableLogs();}}}varinstance=newctor(props,context);varstate=workInProgress.memoizedState=instance.state!==null&&instance.state!==undefined?instance.state:null;adoptClassInstance(workInProgress,instance);{if(typeofctor.getDerivedStateFromProps==='function'&&state===null){varcomponentName=getComponentName(ctor)||'Component';if(!didWarnAboutUninitializedState.has(componentName)){didWarnAboutUninitializedState.add(componentName);error('`%s` uses `getDerivedStateFromProps` but its initial state is '+'%s. This is not recommended. Instead, define the initial state by '+'assigning an object to `this.state` in the constructor of `%s`. '+'This ensures that `getDerivedStateFromProps` arguments have a consistent shape.',componentName,instance.state===null?'null':'undefined',componentName);}}// If new component APIs are defined, "unsafe" lifecycles won't be called.
// Warn about these lifecycles if they are present.
// Don't warn about react-lifecycles-compat polyfilled methods though.
if(typeofctor.getDerivedStateFromProps==='function'||typeofinstance.getSnapshotBeforeUpdate==='function'){varfoundWillMountName=null;varfoundWillReceivePropsName=null;varfoundWillUpdateName=null;if(typeofinstance.componentWillMount==='function'&&instance.componentWillMount.__suppressDeprecationWarning!==true){foundWillMountName='componentWillMount';}elseif(typeofinstance.UNSAFE_componentWillMount==='function'){foundWillMountName='UNSAFE_componentWillMount';}if(typeofinstance.componentWillReceiveProps==='function'&&instance.componentWillReceiveProps.__suppressDeprecationWarning!==true){foundWillReceivePropsName='componentWillReceiveProps';}elseif(typeofinstance.UNSAFE_componentWillReceiveProps==='function'){foundWillReceivePropsName='UNSAFE_componentWillReceiveProps';}if(typeofinstance.componentWillUpdate==='function'&&instance.componentWillUpdate.__suppressDeprecationWarning!==true){foundWillUpdateName='componentWillUpdate';}elseif(typeofinstance.UNSAFE_componentWillUpdate==='function'){foundWillUpdateName='UNSAFE_componentWillUpdate';}if(foundWillMountName!==null||foundWillReceivePropsName!==null||foundWillUpdateName!==null){var_componentName=getComponentName(ctor)||'Component';varnewApiName=typeofctor.getDerivedStateFromProps==='function'?'getDerivedStateFromProps()':'getSnapshotBeforeUpdate()';if(!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)){didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);error('Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n'+'%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n'+'The above lifecycles should be removed. Learn more about this warning here:\n'+'https://reactjs.org/link/unsafe-component-lifecycles',_componentName,newApiName,foundWillMountName!==null?"\n "+foundWillMountName:'',foundWillReceivePropsName!==null?"\n "+foundWillReceivePropsName:'',foundWillUpdateName!==null?"\n "+foundWillUpdateName:'');}}}}// Cache unmasked context so we can avoid recreating masked context unless necessary.
// ReactFiberContext usually updates this cache but can't for newly-created instances.
if(isLegacyContextConsumer){cacheContext(workInProgress,unmaskedContext,context);}returninstance;}functioncallComponentWillMount(workInProgress,instance){varoldState=instance.state;if(typeofinstance.componentWillMount==='function'){instance.componentWillMount();}if(typeofinstance.UNSAFE_componentWillMount==='function'){instance.UNSAFE_componentWillMount();}if(oldState!==instance.state){{error('%s.componentWillMount(): Assigning directly to this.state is '+"deprecated (except inside a component's "+'constructor). Use setState instead.',getComponentName(workInProgress.type)||'Component');}classComponentUpdater.enqueueReplaceState(instance,instance.state,null);}}functioncallComponentWillReceiveProps(workInProgress,instance,newProps,nextContext){varoldState=instance.state;if(typeofinstance.componentWillReceiveProps==='function'){instance.componentWillReceiveProps(newProps,nextContext);}if(typeofinstance.UNSAFE_componentWillReceiveProps==='function'){instance.UNSAFE_componentWillReceiveProps(newProps,nextContext);}if(instance.state!==oldState){{varcomponentName=getComponentName(workInProgress.type)||'Component';if(!didWarnAboutStateAssignmentForComponent.has(componentName)){didWarnAboutStateAssignmentForComponent.add(componentName);error('%s.componentWillReceiveProps(): Assigning directly to '+"this.state is deprecated (except inside a component's "+'constructor). Use setState instead.',componentName);}}classComponentUpdater.enqueueReplaceState(instance,instance.state,null);}}// Invokes the mount life-cycles on a previously never rendered instance.
functionmountClassInstance(workInProgress,ctor,newProps,renderLanes){{checkClassInstance(workInProgress,ctor,newProps);}varinstance=workInProgress.stateNode;instance.props=newProps;instance.state=workInProgress.memoizedState;instance.refs=emptyRefsObject;initializeUpdateQueue(workInProgress);varcontextType=ctor.contextType;if(typeofcontextType==='object'&&contextType!==null){instance.context=readContext(contextType);}else{varunmaskedContext=getUnmaskedContext(workInProgress,ctor,true);instance.context=getMaskedContext(workInProgress,unmaskedContext);}{if(instance.state===newProps){varcomponentName=getComponentName(ctor)||'Component';if(!didWarnAboutDirectlyAssigningPropsToState.has(componentName)){didWarnAboutDirectlyAssigningPropsToState.add(componentName);error('%s: It is not recommended to assign props directly to state '+"because updates to props won't be reflected in state. "+'In most cases, it is better to use props directly.',componentName);}}if(workInProgress.mode&StrictMode){ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress,instance);}{ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress,instance);}}processUpdateQueue(workInProgress,newProps,instance,renderLanes);instance.state=workInProgress.memoizedState;vargetDerivedStateFromProps=ctor.getDerivedStateFromProps;if(typeofgetDerivedStateFromProps==='function'){applyDerivedStateFromProps(workInProgress,ctor,getDerivedStateFromProps,newProps);instance.state=workInProgress.memoizedState;}// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if(typeofctor.getDerivedStateFromProps!=='function'&&typeofinstance.getSnapshotBeforeUpdate!=='function'&&(typeofinstance.UNSAFE_componentWillMount==='function'||typeofinstance.componentWillMount==='function')){callComponentWillMount(workInProgress,instance);// If we had additional state updates during this life-cycle, let's
// process them now.
processUpdateQueue(workInProgress,newProps,instance,renderLanes);instance.state=workInProgress.memoizedState;}if(typeofinstance.componentDidMount==='function'){workInProgress.flags|=Update;}}functionresumeMountClassInstance(workInProgress,ctor,newProps,renderLanes){varinstance=workInProgress.stateNode;varoldProps=workInProgress.memoizedProps;instance.props=oldProps;varoldContext=instance.context;varcontextType=ctor.contextType;varnextContext=emptyContextObject;if(typeofcontextType==='object'&&contextType!==null){nextContext=readContext(contextType);}else{varnextLegacyUnmaskedContext=getUnmaskedContext(workInProgress,ctor,true);nextContext=getMaskedContext(workInProgress,nextLegacyUnmaskedContext);}vargetDerivedStateFromProps=ctor.getDerivedStateFromProps;varhasNewLifecycles=typeofgetDerivedStateFromProps==='function'||typeofinstance.getSnapshotBeforeUpdate==='function';// Note: During these life-cycles, instance.props/instance.state are what
// ever the previously attempted to render - not the "current". However,
// during componentDidUpdate we pass the "current" props.
// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if(!hasNewLifecycles&&(typeofinstance.UNSAFE_componentWillReceiveProps==='function'||typeofinstance.componentWillReceiveProps==='function')){if(oldProps!==newProps||oldContext!==nextContext){callComponentWillReceiveProps(workInProgress,instance,newProps,nextContext);}}resetHasForceUpdateBeforeProcessing();varoldState=workInProgress.memoizedState;varnewState=instance.state=oldState;processUpdateQueue(workInProgress,newProps,instance,renderLanes);newState=workInProgress.memoizedState;if(oldProps===newProps&&oldState===newState&&!hasContextChanged()&&!checkHasForceUpdateAfterProcessing()){// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if(typeofinstance.componentDidMount==='function'){workInProgress.flags|=Update;}returnfalse;}if(typeofgetDerivedStateFromProps==='function'){applyDerivedStateFromProps(workInProgress,ctor,getDerivedStateFromProps,newProps);newState=workInProgress.memoizedState;}varshouldUpdate=checkHasForceUpdateAfterProcessing()||checkShouldComponentUpdate(workInProgress,ctor,oldProps,newProps,oldState,newState,nextContext);if(shouldUpdate){// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if(!hasNewLifecycles&&(typeofinstance.UNSAFE_componentWillMount==='function'||typeofinstance.componentWillMount==='function')){if(typeofinstance.componentWillMount==='function'){instance.componentWillMount();}if(typeofinstance.UNSAFE_componentWillMount==='function'){instance.UNSAFE_componentWillMount();}}if(typeofinstance.componentDidMount==='function'){workInProgress.flags|=Update;}}else{// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if(typeofinstance.componentDidMount==='function'){workInProgress.flags|=Update;}// If shouldComponentUpdate returned false, we should still update the
// memoized state to indicate that this work can be reused.
workInProgress.memoizedProps=newProps;workInProgress.memoizedState=newState;}// Update the existing instance's state, props, and context pointers even
// if shouldComponentUpdate returns false.
instance.props=newProps;instance.state=newState;instance.context=nextContext;returnshouldUpdate;}// Invokes the update life-cycles and returns false if it shouldn't rerender.
functionupdateClassInstance(current,workInProgress,ctor,newProps,renderLanes){varinstance=workInProgress.stateNode;cloneUpdateQueue(current,workInProgress);varunresolvedOldProps=workInProgress.memoizedProps;varoldProps=workInProgress.type===workInProgress.elementType?unresolvedOldProps:resolveDefaultProps(workInProgress.type,unresolvedOldProps);instance.props=oldProps;varunresolvedNewProps=workInProgress.pendingProps;varoldContext=instance.context;varcontextType=ctor.contextType;varnextContext=emptyContextObject;if(typeofcontextType==='object'&&contextType!==null){nextContext=readContext(contextType);}else{varnextUnmaskedContext=getUnmaskedContext(workInProgress,ctor,true);nextContext=getMaskedContext(workInProgress,nextUnmaskedContext);}vargetDerivedStateFromProps=ctor.getDerivedStateFromProps;varhasNewLifecycles=typeofgetDerivedStateFromProps==='function'||typeofinstance.getSnapshotBeforeUpdate==='function';// Note: During these life-cycles, instance.props/instance.state are what
// ever the previously attempted to render - not the "current". However,
// during componentDidUpdate we pass the "current" props.
// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if(!hasNewLifecycles&&(typeofinstance.UNSAFE_componentWillReceiveProps==='function'||typeofinstance.componentWillReceiveProps==='function')){if(unresolvedOldProps!==unresolvedNewProps||oldContext!==nextContext){callComponentWillReceiveProps(workInProgress,instance,newProps,nextContext);}}resetHasForceUpdateBeforeProcessing();varoldState=workInProgress.memoizedState;varnewState=instance.state=oldState;processUpdateQueue(workInProgress,newProps,instance,renderLanes);newState=workInProgress.memoizedState;if(unresolvedOldProps===unresolvedNewProps&&oldState===newState&&!hasContextChanged()&&!checkHasForceUpdateAfterProcessing()){// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if(typeofinstance.componentDidUpdate==='function'){if(unresolvedOldProps!==current.memoizedProps||oldState!==current.memoizedState){workInProgress.flags|=Update;}}if(typeofinstance.getSnapshotBeforeUpdate==='function'){if(unresolvedOldProps!==current.memoizedProps||oldState!==current.memoizedState){workInProgress.flags|=Snapshot;}}returnfalse;}if(typeofgetDerivedStateFromProps==='function'){applyDerivedStateFromProps(workInProgress,ctor,getDerivedStateFromProps,newProps);newState=workInProgress.memoizedState;}varshouldUpdate=checkHasForceUpdateAfterProcessing()||checkShouldComponentUpdate(workInProgress,ctor,oldProps,newProps,oldState,newState,nextContext);if(shouldUpdate){// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if(!hasNewLifecycles&&(typeofinstance.UNSAFE_componentWillUpdate==='function'||typeofinstance.componentWillUpdate==='function')){if(typeofinstance.componentWillUpdate==='function'){instance.componentWillUpdate(newProps,newState,nextContext);}if(typeofinstance.UNSAFE_componentWillUpdate==='function'){instance.UNSAFE_componentWillUpdate(newProps,newState,nextContext);}}if(typeofinstance.componentDidUpdate==='function'){workInProgress.flags|=Update;}if(typeofinstance.getSnapshotBeforeUpdate==='function'){workInProgress.flags|=Snapshot;}}else{// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if(typeofinstance.componentDidUpdate==='function'){if(unresolvedOldProps!==current.memoizedProps||oldState!==current.memoizedState){workInProgress.flags|=Update;}}if(typeofinstance.getSnapshotBeforeUpdate==='function'){if(unresolvedOldProps!==current.memoizedProps||oldState!==current.memoizedState){workInProgress.flags|=Snapshot;}}// If shouldComponentUpdate returned false, we should still update the
// memoized props/state to indicate that this work can be reused.
workInProgress.memoizedProps=newProps;workInProgress.memoizedState=newState;}// Update the existing instance's state, props, and context pointers even
*/ownerHasKeyUseWarning={};ownerHasFunctionTypeWarning={};warnForMissingKey=function(child,returnFiber){if(child===null||typeof child!=='object'){return;}if(!child._store||child._store.validated||child.key!=null){return;}if(!(typeof child._store==='object')){{throw Error("React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.");}}child._store.validated=true;var componentName=getComponentName(returnFiber.type)||'Component';if(ownerHasKeyUseWarning[componentName]){return;}ownerHasKeyUseWarning[componentName]=true;error('Each child in a list should have a unique '+'"key" prop. See https://reactjs.org/link/warning-keysfor'+'moreinformation.');};}var isArray$1=Array.isArray;function coerceRef(returnFiber,current,element){var mixedRef=element.ref;if(mixedRef!==null&&typeof mixedRef!=='function'&&typeof mixedRef!=='object'){{// TODO: Clean this up once we turn on the string ref warning for
// everyone, because the strict mode case will no longer be relevant
if((returnFiber.mode&StrictMode||warnAboutStringRefs)&&// We warn in ReactElement.js if owner and self are equal for string refs
// because these cannot be automatically converted to an arrow function
// using a codemod. Therefore, we don't have to warn about string refs again.
!(element._owner&&element._self&&element._owner.stateNode!==element._self)){varcomponentName=getComponentName(returnFiber.type)||'Component';if(!didWarnAboutStringRefs[componentName]){{error('A string ref, "%s", has been found within a strict mode tree. '+'String refs are a source of potential bugs and should be avoided. '+'We recommend using useRef() or createRef() instead. '+'Learn more about using refs safely here: '+'https://reactjs.org/link/strict-mode-string-ref',mixedRef);}didWarnAboutStringRefs[componentName]=true;}}}if(element._owner){varowner=element._owner;varinst;if(owner){varownerFiber=owner;if(!(ownerFiber.tag===ClassComponent)){{throwError("Function components cannot have string refs. We recommend using useRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref");}}inst=ownerFiber.stateNode;}if(!inst){{throwError("Missing owner for string ref "+mixedRef+". This error is likely caused by a bug in React. Please file an issue.");}}varstringRef=''+mixedRef;// Check if previous string ref matches new string ref
if(current!==null&¤t.ref!==null&&typeofcurrent.ref==='function'&¤t.ref._stringRef===stringRef){returncurrent.ref;}varref=function(value){varrefs=inst.refs;if(refs===emptyRefsObject){// This is a lazy pooled frozen object, so we need to initialize.
refs=inst.refs={};}if(value===null){deleterefs[stringRef];}else{refs[stringRef]=value;}};ref._stringRef=stringRef;returnref;}else{if(!(typeofmixedRef==='string')){{throwError("Expected ref to be a function, a string, an object returned by React.createRef(), or null.");}}if(!element._owner){{throwError("Element ref was specified as a string ("+mixedRef+") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://reactjs.org/link/refs-must-have-owner for more information.");}}}}returnmixedRef;}functionthrowOnInvalidObjectType(returnFiber,newChild){if(returnFiber.type!=='textarea'){{{throwError("Objects are not valid as a React child (found: "+(Object.prototype.toString.call(newChild)==='[object Object]'?'object with keys {'+Object.keys(newChild).join(', ')+'}':newChild)+"). If you meant to render a collection of children, use an array instead.");}}}}functionwarnOnFunctionType(returnFiber){{varcomponentName=getComponentName(returnFiber.type)||'Component';if(ownerHasFunctionTypeWarning[componentName]){return;}ownerHasFunctionTypeWarning[componentName]=true;error('Functions are not valid as a React child. This may happen if '+'you return a Component instead of <Component /> from render. '+'Or maybe you meant to call this function rather than return it.');}}// We avoid inlining this to avoid potential deopts from using try/catch.
// to be able to optimize each path individually by branching early. This needs
// a compiler or we can do it manually. Helpers that don't need this branching
returnnull;}// TODO: For the shouldClone case, this could be micro-optimized a bit by
// assuming that after the first child we've already added everything.
varchildToDelete=currentFirstChild;while(childToDelete!==null){deleteChild(returnFiber,childToDelete);childToDelete=childToDelete.sibling;}returnnull;}functionmapRemainingChildren(returnFiber,currentFirstChild){// Add the remaining children to a temporary map so that we can find them by
// keys quickly. Implicit (null) keys get added to this set with their index
// instead.
varexistingChildren=newMap();varexistingChild=currentFirstChild;while(existingChild!==null){if(existingChild.key!==null){existingChildren.set(existingChild.key,existingChild);}else{existingChildren.set(existingChild.index,existingChild);}existingChild=existingChild.sibling;}returnexistingChildren;}functionuseFiber(fiber,pendingProps){// We currently set sibling to null and index to 0 here because it is easy
// to forget to do before returning it. E.g. for the single child case.
varexisting=useFiber(current,textContent);existing.return=returnFiber;returnexisting;}}functionupdateElement(returnFiber,current,element,lanes){if(current!==null){if(current.elementType===element.type||// Keep this check inline so it only runs on the false path:
isCompatibleFamilyForHotReloading(current,element)){// Move based on index
varexisting=useFiber(current,fragment);existing.return=returnFiber;returnexisting;}}functioncreateChild(returnFiber,newChild,lanes){if(typeofnewChild==='string'||typeofnewChild==='number'){// Text nodes don't have keys. If the previous node is implicitly keyed
// we can continue to replace it without aborting even if it is not a text
// node.
varcreated=createFiberFromText(''+newChild,returnFiber.mode,lanes);created.return=returnFiber;returncreated;}if(typeofnewChild==='object'&&newChild!==null){switch(newChild.$$typeof){caseREACT_ELEMENT_TYPE:{var_created=createFiberFromElement(newChild,returnFiber.mode,lanes);_created.ref=coerceRef(returnFiber,null,newChild);_created.return=returnFiber;return_created;}caseREACT_PORTAL_TYPE:{var_created2=createFiberFromPortal(newChild,returnFiber.mode,lanes);_created2.return=returnFiber;return_created2;}}if(isArray$1(newChild)||getIteratorFn(newChild)){var_created3=createFiberFromFragment(newChild,returnFiber.mode,lanes,null);_created3.return=returnFiber;return_created3;}throwOnInvalidObjectType(returnFiber,newChild);}{if(typeofnewChild==='function'){warnOnFunctionType(returnFiber);}}returnnull;}functionupdateSlot(returnFiber,oldFiber,newChild,lanes){// Update the fiber if the keys match, otherwise return null.
varkey=oldFiber!==null?oldFiber.key:null;if(typeofnewChild==='string'||typeofnewChild==='number'){// Text nodes don't have keys. If the previous node is implicitly keyed
// we can continue to replace it without aborting even if it is not a text
// node.
if(key!==null){returnnull;}returnupdateTextNode(returnFiber,oldFiber,''+newChild,lanes);}if(typeofnewChild==='object'&&newChild!==null){switch(newChild.$$typeof){caseREACT_ELEMENT_TYPE:{if(newChild.key===key){if(newChild.type===REACT_FRAGMENT_TYPE){returnupdateFragment(returnFiber,oldFiber,newChild.props.children,lanes,key);}returnupdateElement(returnFiber,oldFiber,newChild,lanes);}else{returnnull;}}caseREACT_PORTAL_TYPE:{if(newChild.key===key){returnupdatePortal(returnFiber,oldFiber,newChild,lanes);}else{returnnull;}}}if(isArray$1(newChild)||getIteratorFn(newChild)){if(key!==null){returnnull;}returnupdateFragment(returnFiber,oldFiber,newChild,lanes,null);}throwOnInvalidObjectType(returnFiber,newChild);}{if(typeofnewChild==='function'){warnOnFunctionType(returnFiber);}}returnnull;}functionupdateFromMap(existingChildren,returnFiber,newIdx,newChild,lanes){if(typeofnewChild==='string'||typeofnewChild==='number'){// Text nodes don't have keys, so we neither have to check the old nor
// new node for the key. If both are text nodes, they match.
// don't have backpointers on fibers. I'm trying to see how far we can get
// with that model. If it ends up not being worth the tradeoffs, we can
// add it later.
// Even with a two ended optimization, we'd want to optimize for the case
// where there are few changes and brute force the comparison instead of
// going for the Map. It'd like to explore hitting that path first in
// forward-only mode and only go for the Map once we notice that we need
// lots of look ahead. This doesn't handle reversal as well as two ended
// search but that's unusual. Besides, for the two ended optimization to
// work on Iterables, we'd need to copy the whole set.
// In this first iteration, we'll just live with hitting the bad case
// (adding everything to a Map) in for every insert/move.
// If you change this code, also update reconcileChildrenIterator() which
// uses the same algorithm.
{// First, validate keys.
varknownKeys=null;for(vari=0;i<newChildren.length;i++){varchild=newChildren[i];knownKeys=warnOnInvalidKey(child,knownKeys,returnFiber);}}varresultingFirstChild=null;varpreviousNewFiber=null;varoldFiber=currentFirstChild;varlastPlacedIndex=0;varnewIdx=0;varnextOldFiber=null;for(;oldFiber!==null&&newIdx<newChildren.length;newIdx++){if(oldFiber.index>newIdx){nextOldFiber=oldFiber;oldFiber=null;}else{nextOldFiber=oldFiber.sibling;}varnewFiber=updateSlot(returnFiber,oldFiber,newChildren[newIdx],lanes);if(newFiber===null){// TODO: This breaks on empty slots like null children. That's
// unfortunate because it triggers the slow path all the time. We need
// a better way to communicate whether this was a miss or null,
// boolean, undefined, etc.
if(oldFiber===null){oldFiber=nextOldFiber;}break;}if(shouldTrackSideEffects){if(oldFiber&&newFiber.alternate===null){// We matched the slot, but we didn't reuse the existing fiber, so we
// need to delete the existing child.
deleteChild(returnFiber,oldFiber);}}lastPlacedIndex=placeChild(newFiber,lastPlacedIndex,newIdx);if(previousNewFiber===null){// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild=newFiber;}else{// TODO: Defer siblings if we're not at the right index for this slot.
// I.e. if we had null values before, then we want to defer this
// for each null value. However, we also don't want to call updateSlot
// with the previous one.
previousNewFiber.sibling=newFiber;}previousNewFiber=newFiber;oldFiber=nextOldFiber;}if(newIdx===newChildren.length){// We've reached the end of the new children. We can delete the rest.
deleteRemainingChildren(returnFiber,oldFiber);returnresultingFirstChild;}if(oldFiber===null){// If we don't have any more existing children we can choose a fast path
// since the rest will all be insertions.
for(;newIdx<newChildren.length;newIdx++){var_newFiber=createChild(returnFiber,newChildren[newIdx],lanes);if(_newFiber===null){continue;}lastPlacedIndex=placeChild(_newFiber,lastPlacedIndex,newIdx);if(previousNewFiber===null){// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild=_newFiber;}else{previousNewFiber.sibling=_newFiber;}previousNewFiber=_newFiber;}returnresultingFirstChild;}// Add all children to a key map for quick lookups.
varexistingChildren=mapRemainingChildren(returnFiber,oldFiber);// Keep scanning and use the map to restore deleted items as moves.
for(;newIdx<newChildren.length;newIdx++){var_newFiber2=updateFromMap(existingChildren,returnFiber,newIdx,newChildren[newIdx],lanes);if(_newFiber2!==null){if(shouldTrackSideEffects){if(_newFiber2.alternate!==null){// The new fiber is a work in progress, but if there exists a
// current, that means that we reused the fiber. We need to delete
// it from the child list so that we don't add it to the deletion
// list.
existingChildren.delete(_newFiber2.key===null?newIdx:_newFiber2.key);}}lastPlacedIndex=placeChild(_newFiber2,lastPlacedIndex,newIdx);if(previousNewFiber===null){resultingFirstChild=_newFiber2;}else{previousNewFiber.sibling=_newFiber2;}previousNewFiber=_newFiber2;}}if(shouldTrackSideEffects){// Any existing children that weren't consumed above were deleted. We need
// to add them to the deletion list.
existingChildren.forEach(function(child){returndeleteChild(returnFiber,child);});}returnresultingFirstChild;}functionreconcileChildrenIterator(returnFiber,currentFirstChild,newChildrenIterable,lanes){// This is the same implementation as reconcileChildrenArray(),
// but using the iterator instead.
variteratorFn=getIteratorFn(newChildrenIterable);if(!(typeofiteratorFn==='function')){{throwError("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");}}{// We don't support rendering Generators because it's a mutation.
// See https://github.com/facebook/react/issues/12995
if(typeofSymbol==='function'&&// $FlowFixMe Flow doesn't know about toStringTag
newChildrenIterable[Symbol.toStringTag]==='Generator'){if(!didWarnAboutGenerators){error('Using Generators as children is unsupported and will likely yield '+'unexpected results because enumerating a generator mutates it. '+'You may convert it to an array with `Array.from()` or the '+'`[...spread]` operator before rendering. Keep in mind '+'you might need to polyfill these features for older browsers.');}didWarnAboutGenerators=true;}// Warn about using Maps as children
if(newChildrenIterable.entries===iteratorFn){if(!didWarnAboutMaps){error('Using Maps as children is not supported. '+'Use an array of keyed ReactElements instead.');}didWarnAboutMaps=true;}// First, validate keys.
// We'll get a different iterator later for the main pass.
var_newChildren=iteratorFn.call(newChildrenIterable);if(_newChildren){varknownKeys=null;var_step=_newChildren.next();for(;!_step.done;_step=_newChildren.next()){varchild=_step.value;knownKeys=warnOnInvalidKey(child,knownKeys,returnFiber);}}}varnewChildren=iteratorFn.call(newChildrenIterable);if(!(newChildren!=null)){{throwError("An iterable object provided no iterator.");}}varresultingFirstChild=null;varpreviousNewFiber=null;varoldFiber=currentFirstChild;varlastPlacedIndex=0;varnewIdx=0;varnextOldFiber=null;varstep=newChildren.next();for(;oldFiber!==null&&!step.done;newIdx++,step=newChildren.next()){if(oldFiber.index>newIdx){nextOldFiber=oldFiber;oldFiber=null;}else{nextOldFiber=oldFiber.sibling;}varnewFiber=updateSlot(returnFiber,oldFiber,step.value,lanes);if(newFiber===null){// TODO: This breaks on empty slots like null children. That's
// unfortunate because it triggers the slow path all the time. We need
// a better way to communicate whether this was a miss or null,
// boolean, undefined, etc.
if(oldFiber===null){oldFiber=nextOldFiber;}break;}if(shouldTrackSideEffects){if(oldFiber&&newFiber.alternate===null){// We matched the slot, but we didn't reuse the existing fiber, so we
// need to delete the existing child.
deleteChild(returnFiber,oldFiber);}}lastPlacedIndex=placeChild(newFiber,lastPlacedIndex,newIdx);if(previousNewFiber===null){// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild=newFiber;}else{// TODO: Defer siblings if we're not at the right index for this slot.
// I.e. if we had null values before, then we want to defer this
// for each null value. However, we also don't want to call updateSlot
// with the previous one.
previousNewFiber.sibling=newFiber;}previousNewFiber=newFiber;oldFiber=nextOldFiber;}if(step.done){// We've reached the end of the new children. We can delete the rest.
deleteRemainingChildren(returnFiber,oldFiber);returnresultingFirstChild;}if(oldFiber===null){// If we don't have any more existing children we can choose a fast path
// since the rest will all be insertions.
for(;!step.done;newIdx++,step=newChildren.next()){var_newFiber3=createChild(returnFiber,step.value,lanes);if(_newFiber3===null){continue;}lastPlacedIndex=placeChild(_newFiber3,lastPlacedIndex,newIdx);if(previousNewFiber===null){// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild=_newFiber3;}else{previousNewFiber.sibling=_newFiber3;}previousNewFiber=_newFiber3;}returnresultingFirstChild;}// Add all children to a key map for quick lookups.
varexistingChildren=mapRemainingChildren(returnFiber,oldFiber);// Keep scanning and use the map to restore deleted items as moves.
for(;!step.done;newIdx++,step=newChildren.next()){var_newFiber4=updateFromMap(existingChildren,returnFiber,newIdx,step.value,lanes);if(_newFiber4!==null){if(shouldTrackSideEffects){if(_newFiber4.alternate!==null){// The new fiber is a work in progress, but if there exists a
// current, that means that we reused the fiber. We need to delete
// it from the child list so that we don't add it to the deletion
// list.
existingChildren.delete(_newFiber4.key===null?newIdx:_newFiber4.key);}}lastPlacedIndex=placeChild(_newFiber4,lastPlacedIndex,newIdx);if(previousNewFiber===null){resultingFirstChild=_newFiber4;}else{previousNewFiber.sibling=_newFiber4;}previousNewFiber=_newFiber4;}}if(shouldTrackSideEffects){// Any existing children that weren't consumed above were deleted. We need
// to add them to the deletion list.
existingChildren.forEach(function(child){returndeleteChild(returnFiber,child);});}returnresultingFirstChild;}functionreconcileSingleTextNode(returnFiber,currentFirstChild,textContent,lanes){// There's no need to check for keys on text nodes since we don't have a
// way to define them.
if(currentFirstChild!==null&¤tFirstChild.tag===HostText){// We already have an existing node so let's just update it and delete
// the rest.
deleteRemainingChildren(returnFiber,currentFirstChild.sibling);varexisting=useFiber(currentFirstChild,textContent);existing.return=returnFiber;returnexisting;}// The existing first child is not a text node so we need to create one
// and delete the existing ones.
deleteRemainingChildren(returnFiber,currentFirstChild);varcreated=createFiberFromText(textContent,returnFiber.mode,lanes);created.return=returnFiber;returncreated;}functionreconcileSingleElement(returnFiber,currentFirstChild,element,lanes){varkey=element.key;varchild=currentFirstChild;while(child!==null){// TODO: If key === null and child.key === null, then this only applies to
// the first item in the list.
if(child.key===key){switch(child.tag){caseFragment:{if(element.type===REACT_FRAGMENT_TYPE){deleteRemainingChildren(returnFiber,child.sibling);varexisting=useFiber(child,element.props.children);existing.return=returnFiber;{existing._debugSource=element._source;existing._debugOwner=element._owner;}returnexisting;}break;}caseBlock:// We intentionally fallthrough here if enableBlocksAPI is not on.
// eslint-disable-next-lined no-fallthrough
default:{if(child.elementType===element.type||// Keep this check inline so it only runs on the false path:
deleteRemainingChildren(returnFiber,child);break;}else{deleteChild(returnFiber,child);}child=child.sibling;}if(element.type===REACT_FRAGMENT_TYPE){varcreated=createFiberFromFragment(element.props.children,returnFiber.mode,lanes,element.key);created.return=returnFiber;returncreated;}else{var_created4=createFiberFromElement(element,returnFiber.mode,lanes);_created4.ref=coerceRef(returnFiber,currentFirstChild,element);_created4.return=returnFiber;return_created4;}}functionreconcileSinglePortal(returnFiber,currentFirstChild,portal,lanes){varkey=portal.key;varchild=currentFirstChild;while(child!==null){// TODO: If key === null and child.key === null, then this only applies to
// the first item in the list.
if(child.key===key){if(child.tag===HostPortal&&child.stateNode.containerInfo===portal.containerInfo&&child.stateNode.implementation===portal.implementation){deleteRemainingChildren(returnFiber,child.sibling);varexisting=useFiber(child,portal.children||[]);existing.return=returnFiber;returnexisting;}else{deleteRemainingChildren(returnFiber,child);break;}}else{deleteChild(returnFiber,child);}child=child.sibling;}varcreated=createFiberFromPortal(portal,returnFiber.mode,lanes);created.return=returnFiber;returncreated;}// This API will tag the children with the side-effect of the reconciliation
// itself. They will be added to the side-effect list as we pass through the
// children and the parent.
functionreconcileChildFibers(returnFiber,currentFirstChild,newChild,lanes){// This function is not recursive.
// If the top level item is an array, we treat it as a set of children,
// not as a fragment. Nested arrays on the other hand will be treated as
// fragment nodes. Recursion happens at the normal flow.
// Handle top level unkeyed fragments as if they were arrays.
// This leads to an ambiguity between <>{[...]}</> and <>...</>.
varisObject=typeofnewChild==='object'&&newChild!==null;if(isObject){switch(newChild.$$typeof){caseREACT_ELEMENT_TYPE:returnplaceSingleChild(reconcileSingleElement(returnFiber,currentFirstChild,newChild,lanes));caseREACT_PORTAL_TYPE:returnplaceSingleChild(reconcileSinglePortal(returnFiber,currentFirstChild,newChild,lanes));}}if(typeofnewChild==='string'||typeofnewChild==='number'){returnplaceSingleChild(reconcileSingleTextNode(returnFiber,currentFirstChild,''+newChild,lanes));}if(isArray$1(newChild)){returnreconcileChildrenArray(returnFiber,currentFirstChild,newChild,lanes);}if(getIteratorFn(newChild)){returnreconcileChildrenIterator(returnFiber,currentFirstChild,newChild,lanes);}if(isObject){throwOnInvalidObjectType(returnFiber,newChild);}{if(typeofnewChild==='function'){warnOnFunctionType(returnFiber);}}if(typeofnewChild==='undefined'&&!isUnkeyedTopLevelFragment){// If the new child is undefined, and the return fiber is a composite
// component, throw an error. If Fiber return types are disabled,
// we already threw above.
switch(returnFiber.tag){caseClassComponent:{{varinstance=returnFiber.stateNode;if(instance.render._isMockFunction){// We allow auto-mocks to proceed as if they're returning null.
break;}}}// Intentionally fall through to the next case, which handles both
// functions and classes
// eslint-disable-next-lined no-fallthrough
caseBlock:caseFunctionComponent:caseForwardRef:caseSimpleMemoComponent:{{{throwError((getComponentName(returnFiber.type)||'Component')+"(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.");}}}}}// Remaining cases are all treated as empty.
returndeleteRemainingChildren(returnFiber,currentFirstChild);}returnreconcileChildFibers;}varreconcileChildFibers=ChildReconciler(true);varmountChildFibers=ChildReconciler(false);functioncloneChildFibers(current,workInProgress){if(!(current===null||workInProgress.child===current.child)){{throwError("Resuming work not yet implemented.");}}if(workInProgress.child===null){return;}varcurrentChild=workInProgress.child;varnewChild=createWorkInProgress(currentChild,currentChild.pendingProps);workInProgress.child=newChild;newChild.return=workInProgress;while(currentChild.sibling!==null){currentChild=currentChild.sibling;newChild=newChild.sibling=createWorkInProgress(currentChild,currentChild.pendingProps);newChild.return=workInProgress;}newChild.sibling=null;}// Reset a workInProgress child set to prepare it for a second pass.
functionresetChildFibers(workInProgress,lanes){varchild=workInProgress.child;while(child!==null){resetWorkInProgress(child,lanes);child=child.sibling;}}varNO_CONTEXT={};varcontextStackCursor$1=createCursor(NO_CONTEXT);varcontextFiberStackCursor=createCursor(NO_CONTEXT);varrootInstanceStackCursor=createCursor(NO_CONTEXT);functionrequiredContext(c){if(!(c!==NO_CONTEXT)){{throwError("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.");}}returnc;}functiongetRootHostContainer(){varrootInstance=requiredContext(rootInstanceStackCursor.current);returnrootInstance;}functionpushHostContainer(fiber,nextRootInstance){// Push current root instance onto the stack;
// This allows us to reset root when portals are popped.
push(rootInstanceStackCursor,nextRootInstance,fiber);// Track the context and the Fiber that provided it.
// This enables us to pop only Fibers that provide unique contexts.
push(contextFiberStackCursor,fiber,fiber);// Finally, we need to push the host context to the stack.
// However, we can't just call getRootHostContext() and push it because
// we'd have a different number of entries on the stack depending on
// whether getRootHostContext() throws somewhere in renderer code or not.
// So we push an empty value first. This lets us safely unwind on errors.
push(contextStackCursor$1,NO_CONTEXT,fiber);varnextRootContext=getRootHostContext(nextRootInstance);// Now that we know this function doesn't throw, replace it.
pop(contextStackCursor$1,fiber);push(contextStackCursor$1,nextRootContext,fiber);}functionpopHostContainer(fiber){pop(contextStackCursor$1,fiber);pop(contextFiberStackCursor,fiber);pop(rootInstanceStackCursor,fiber);}functiongetHostContext(){varcontext=requiredContext(contextStackCursor$1.current);returncontext;}functionpushHostContext(fiber){varrootInstance=requiredContext(rootInstanceStackCursor.current);varcontext=requiredContext(contextStackCursor$1.current);varnextContext=getChildHostContext(context,fiber.type);// Don't push this Fiber's context unless it's unique.
if(context===nextContext){return;}// Track the context and the Fiber that provided it.
// This enables us to pop only Fibers that provide unique contexts.
push(contextFiberStackCursor,fiber,fiber);push(contextStackCursor$1,nextContext,fiber);}functionpopHostContext(fiber){// Do not pop unless this Fiber provided the current context.
// pushHostContext() only pushes Fibers that provide unique contexts.
if(contextFiberStackCursor.current!==fiber){return;}pop(contextStackCursor$1,fiber);pop(contextFiberStackCursor,fiber);}varDefaultSuspenseContext=0;// The Suspense Context is split into two parts. The lower bits is
// inherited deeply down the subtree. The upper bits only affect
// this immediate suspense boundary and gets reset each new
// boundary or suspense list.
varSubtreeSuspenseContextMask=1;// Subtree Flags:
// InvisibleParentSuspenseContext indicates that one of our parent Suspense
// boundaries is not currently showing visible main content.
// Either because it is already showing a fallback or is not mounted at all.
// We can use this to determine if it is desirable to trigger a fallback at
// the parent. If not, then we might need to trigger undesirable boundaries
// and/or suspend the commit to avoid hiding the parent content.
// ForceSuspenseFallback can be used by SuspenseList to force newly added
// items into their fallback state during one of the render passes.
varForceSuspenseFallback=2;varsuspenseStackCursor=createCursor(DefaultSuspenseContext);functionhasSuspenseContext(parentContext,flag){return(parentContext&flag)!==0;}functionsetDefaultShallowSuspenseContext(parentContext){returnparentContext&SubtreeSuspenseContextMask;}functionsetShallowSuspenseContext(parentContext,shallowContext){returnparentContext&SubtreeSuspenseContextMask|shallowContext;}functionaddSubtreeSuspenseContext(parentContext,subtreeContext){returnparentContext|subtreeContext;}functionpushSuspenseContext(fiber,newContext){push(suspenseStackCursor,newContext,fiber);}functionpopSuspenseContext(fiber){pop(suspenseStackCursor,fiber);}functionshouldCaptureSuspense(workInProgress,hasInvisibleParent){// If it was the primary children that just suspended, capture and render the
// fallback. Otherwise, don't capture and bubble to the next boundary.
varnextState=workInProgress.memoizedState;if(nextState!==null){if(nextState.dehydrated!==null){// A dehydrated boundary always captures.
returntrue;}returnfalse;}varprops=workInProgress.memoizedProps;// In order to capture, the Suspense component must have a fallback prop.
if(props.unstable_avoidThisFallback!==true){returntrue;}// If it's a boundary we should avoid, then we prefer to bubble up to the
// parent boundary if it is currently invisible.
if(hasInvisibleParent){returnfalse;}// If the parent is not able to handle it, we must handle it.
returntrue;}functionfindFirstSuspended(row){varnode=row;while(node!==null){if(node.tag===SuspenseComponent){varstate=node.memoizedState;if(state!==null){vardehydrated=state.dehydrated;if(dehydrated===null||isSuspenseInstancePending(dehydrated)||isSuspenseInstanceFallback(dehydrated)){returnnode;}}}elseif(node.tag===SuspenseListComponent&&// revealOrder undefined can't be trusted because it don't
// keep track of whether it suspended or not.
node.memoizedProps.revealOrder!==undefined){vardidSuspend=(node.flags&DidCapture)!==NoFlags;if(didSuspend){returnnode;}}elseif(node.child!==null){node.child.return=node;node=node.child;continue;}if(node===row){returnnull;}while(node.sibling===null){if(node.return===null||node.return===row){returnnull;}node=node.return;}node.sibling.return=node.return;node=node.sibling;}returnnull;}varNoFlags$1=/* */0;// Represents whether effect should fire.
varHasEffect=/* */1;// Represents the phase in which the effect (not the clean-up) fires.
varLayout=/* */2;varPassive$1=/* */4;// This may have been an insertion or a hydration.
varhydrationParentFiber=null;varnextHydratableInstance=null;varisHydrating=false;functionenterHydrationState(fiber){varparentInstance=fiber.stateNode.containerInfo;nextHydratableInstance=getFirstHydratableChild(parentInstance);hydrationParentFiber=fiber;isHydrating=true;returntrue;}functiondeleteHydratableInstance(returnFiber,instance){{switch(returnFiber.tag){caseHostRoot:didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo,instance);break;caseHostComponent:didNotHydrateInstance(returnFiber.type,returnFiber.memoizedProps,returnFiber.stateNode,instance);break;}}varchildToDelete=createFiberFromHostInstanceForDeletion();childToDelete.stateNode=instance;childToDelete.return=returnFiber;childToDelete.flags=Deletion;// This might seem like it belongs on progressedFirstDeletion. However,
// these children are not part of the reconciliation list of children.
// Even if we abort and rereconcile the children, that will try to hydrate
// again and the nodes are still in the host tree so these will be
// recreated.
if(returnFiber.lastEffect!==null){returnFiber.lastEffect.nextEffect=childToDelete;returnFiber.lastEffect=childToDelete;}else{returnFiber.firstEffect=returnFiber.lastEffect=childToDelete;}}functioninsertNonHydratedInstance(returnFiber,fiber){fiber.flags=fiber.flags&~Hydrating|Placement;{switch(returnFiber.tag){caseHostRoot:{varparentContainer=returnFiber.stateNode.containerInfo;switch(fiber.tag){caseHostComponent:vartype=fiber.type;varprops=fiber.pendingProps;didNotFindHydratableContainerInstance(parentContainer,type);break;caseHostText:vartext=fiber.pendingProps;didNotFindHydratableContainerTextInstance(parentContainer,text);break;}break;}caseHostComponent:{varparentType=returnFiber.type;varparentProps=returnFiber.memoizedProps;varparentInstance=returnFiber.stateNode;switch(fiber.tag){caseHostComponent:var_type=fiber.type;var_props=fiber.pendingProps;didNotFindHydratableInstance(parentType,parentProps,parentInstance,_type);break;caseHostText:var_text=fiber.pendingProps;didNotFindHydratableTextInstance(parentType,parentProps,parentInstance,_text);break;caseSuspenseComponent:didNotFindHydratableSuspenseInstance(parentType,parentProps);break;}break;}default:return;}}}functiontryHydrate(fiber,nextInstance){switch(fiber.tag){caseHostComponent:{vartype=fiber.type;varprops=fiber.pendingProps;varinstance=canHydrateInstance(nextInstance,type);if(instance!==null){fiber.stateNode=instance;returntrue;}returnfalse;}caseHostText:{vartext=fiber.pendingProps;vartextInstance=canHydrateTextInstance(nextInstance,text);if(textInstance!==null){fiber.stateNode=textInstance;returntrue;}returnfalse;}caseSuspenseComponent:{returnfalse;}default:returnfalse;}}functiontryToClaimNextHydratableInstance(fiber){if(!isHydrating){return;}varnextInstance=nextHydratableInstance;if(!nextInstance){// Nothing to hydrate. Make it an insertion.
insertNonHydratedInstance(hydrationParentFiber,fiber);isHydrating=false;hydrationParentFiber=fiber;return;}varfirstAttemptedInstance=nextInstance;if(!tryHydrate(fiber,nextInstance)){// If we can't hydrate this instance let's try the next one.
// We use this as a heuristic. It's based on intuition and not data so it
// might be flawed or unnecessary.
nextInstance=getNextHydratableSibling(firstAttemptedInstance);if(!nextInstance||!tryHydrate(fiber,nextInstance)){// Nothing to hydrate. Make it an insertion.
insertNonHydratedInstance(hydrationParentFiber,fiber);isHydrating=false;hydrationParentFiber=fiber;return;}// We matched the next one, we'll now assume that the first one was
// superfluous and we'll delete it. Since we can't eagerly delete it
// we'll have to schedule a deletion. To do that, this node needs a dummy
// fiber associated with it.
deleteHydratableInstance(hydrationParentFiber,firstAttemptedInstance);}hydrationParentFiber=fiber;nextHydratableInstance=getFirstHydratableChild(nextInstance);}functionprepareToHydrateHostInstance(fiber,rootContainerInstance,hostContext){varinstance=fiber.stateNode;varupdatePayload=hydrateInstance(instance,fiber.type,fiber.memoizedProps,rootContainerInstance,hostContext,fiber);// TODO: Type this specific to this type of component.
fiber.updateQueue=updatePayload;// If the update payload indicates that there is a change or if there
// is a new ref we mark this as an update.
if(updatePayload!==null){returntrue;}returnfalse;}functionprepareToHydrateHostTextInstance(fiber){vartextInstance=fiber.stateNode;vartextContent=fiber.memoizedProps;varshouldUpdate=hydrateTextInstance(textInstance,textContent,fiber);{if(shouldUpdate){// We assume that prepareToHydrateHostTextInstance is called in a context where the
// hydration parent is the parent host component of this host text.
varreturnFiber=hydrationParentFiber;if(returnFiber!==null){switch(returnFiber.tag){caseHostRoot:{varparentContainer=returnFiber.stateNode.containerInfo;didNotMatchHydratedContainerTextInstance(parentContainer,textInstance,textContent);break;}caseHostComponent:{varparentType=returnFiber.type;varparentProps=returnFiber.memoizedProps;varparentInstance=returnFiber.stateNode;didNotMatchHydratedTextInstance(parentType,parentProps,parentInstance,textInstance,textContent);break;}}}}}returnshouldUpdate;}functionskipPastDehydratedSuspenseInstance(fiber){varsuspenseState=fiber.memoizedState;varsuspenseInstance=suspenseState!==null?suspenseState.dehydrated:null;if(!suspenseInstance){{throwError("Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue.");}}returngetNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);}functionpopToNextHostParent(fiber){varparent=fiber.return;while(parent!==null&&parent.tag!==HostComponent&&parent.tag!==HostRoot&&parent.tag!==SuspenseComponent){parent=parent.return;}hydrationParentFiber=parent;}functionpopHydrationState(fiber){if(fiber!==hydrationParentFiber){// We're deeper than the current hydration context, inside an inserted
// tree.
returnfalse;}if(!isHydrating){// If we're not currently hydrating but we're in a hydration context, then
// we were an insertion and now need to pop up reenter hydration of our
// siblings.
popToNextHostParent(fiber);isHydrating=true;returnfalse;}vartype=fiber.type;// If we have any remaining hydratable nodes, we need to delete them now.
// We only do this deeper than head and body since they tend to have random
// other nodes in them. We also ignore components with pure text content in
// side of them.
// TODO: Better heuristic.
if(fiber.tag!==HostComponent||type!=='head'&&type!=='body'&&!shouldSetTextContent(type,fiber.memoizedProps)){varnextInstance=nextHydratableInstance;while(nextInstance){deleteHydratableInstance(fiber,nextInstance);nextInstance=getNextHydratableSibling(nextInstance);}}popToNextHostParent(fiber);if(fiber.tag===SuspenseComponent){nextHydratableInstance=skipPastDehydratedSuspenseInstance(fiber);}else{nextHydratableInstance=hydrationParentFiber?getNextHydratableSibling(fiber.stateNode):null;}returntrue;}functionresetHydrationState(){hydrationParentFiber=null;nextHydratableInstance=null;isHydrating=false;}functiongetIsHydrating(){returnisHydrating;}// and should be reset before starting a new render.
// This tracks which mutable sources need to be reset after a render.
varworkInProgressSources=[];varrendererSigil$1;{// Used to detect multiple renderers using the same mutable source.
rendererSigil$1={};}functionmarkSourceAsDirty(mutableSource){workInProgressSources.push(mutableSource);}functionresetWorkInProgressVersions(){for(vari=0;i<workInProgressSources.length;i++){varmutableSource=workInProgressSources[i];{mutableSource._workInProgressVersionPrimary=null;}}workInProgressSources.length=0;}functiongetWorkInProgressVersion(mutableSource){{returnmutableSource._workInProgressVersionPrimary;}}functionsetWorkInProgressVersion(mutableSource,version){{mutableSource._workInProgressVersionPrimary=version;}workInProgressSources.push(mutableSource);}functionwarnAboutMultipleRenderersDEV(mutableSource){{{if(mutableSource._currentPrimaryRenderer==null){mutableSource._currentPrimaryRenderer=rendererSigil$1;}elseif(mutableSource._currentPrimaryRenderer!==rendererSigil$1){error('Detected multiple renderers concurrently rendering the '+'same mutable source. This is currently unsupported.');}}}}// Eager reads the version of a mutable source and stores it on the root.
varReactCurrentDispatcher$1=ReactSharedInternals.ReactCurrentDispatcher,ReactCurrentBatchConfig$1=ReactSharedInternals.ReactCurrentBatchConfig;vardidWarnAboutMismatchedHooksForComponent;vardidWarnAboutUseOpaqueIdentifier;{didWarnAboutUseOpaqueIdentifier={};didWarnAboutMismatchedHooksForComponent=newSet();}// These are set right before calling the component.
varrenderLanes=NoLanes;// The work-in-progress fiber. I've named it differently to distinguish it from
// the work-in-progress hook.
varcurrentlyRenderingFiber$1=null;// Hooks are stored as a linked list on the fiber's memoizedState field. The
// current hook list is the list that belongs to the current fiber. The
// work-in-progress hook list is a new list that will be added to the
// work-in-progress fiber.
varcurrentHook=null;varworkInProgressHook=null;// Whether an update was scheduled at any point during the render phase. This
// does not get reset if we do another render pass; only when we're completely
// finished evaluating this component. This is an optimization so we know
// whether we need to clear render phase updates after a throw.
vardidScheduleRenderPhaseUpdate=false;// Where an update was scheduled only during the current render pass. This
// gets reset after each attempt.
// TODO: Maybe there's some way to consolidate this with
// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
vardidScheduleRenderPhaseUpdateDuringThisPass=false;varRE_RENDER_LIMIT=25;// In DEV, this is the name of the currently executing primitive hook
varcurrentHookNameInDev=null;// In DEV, this list ensures that hooks are called in the same order between renders.
// The list stores the order of hooks used during the initial render (mount).
// Subsequent renders (updates) reference this list.
varhookTypesDev=null;varhookTypesUpdateIndexDev=-1;// In DEV, this tracks whether currently rendering component needs to ignore
// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
// When true, such Hooks will always be "remounted". Only used during hot reload.
varignorePreviousDependencies=false;functionmountHookTypesDev(){{varhookName=currentHookNameInDev;if(hookTypesDev===null){hookTypesDev=[hookName];}else{hookTypesDev.push(hookName);}}}functionupdateHookTypesDev(){{varhookName=currentHookNameInDev;if(hookTypesDev!==null){hookTypesUpdateIndexDev++;if(hookTypesDev[hookTypesUpdateIndexDev]!==hookName){warnOnHookMismatchInDev(hookName);}}}}functioncheckDepsAreArrayDev(deps){{if(deps!==undefined&&deps!==null&&!Array.isArray(deps)){// Verify deps, but only on mount to avoid extra checks.
// It's unlikely their type would change as usually you define them inline.
error('%s received a final argument that is not an array (instead, received `%s`). When '+'specified, the final argument must be an array.',currentHookNameInDev,typeofdeps);}}}functionwarnOnHookMismatchInDev(currentHookName){{varcomponentName=getComponentName(currentlyRenderingFiber$1.type);if(!didWarnAboutMismatchedHooksForComponent.has(componentName)){didWarnAboutMismatchedHooksForComponent.add(componentName);if(hookTypesDev!==null){vartable='';varsecondColumnStart=30;for(vari=0;i<=hookTypesUpdateIndexDev;i++){varoldHookName=hookTypesDev[i];varnewHookName=i===hookTypesUpdateIndexDev?currentHookName:oldHookName;varrow=i+1+". "+oldHookName;// Extra space so second column lines up
// lol @ IE not supporting String#repeat
while(row.length<secondColumnStart){row+=' ';}row+=newHookName+'\n';table+=row;}error('React has detected a change in the order of Hooks called by %s. '+'This will lead to bugs and errors if not fixed. '+'For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n'+' Previous render Next render\n'+' ------------------------------------------------------\n'+'%s'+' ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n',componentName,table);}}}}functionthrowInvalidHookError(){{{throwError("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");}}}functionareHookInputsEqual(nextDeps,prevDeps){{if(ignorePreviousDependencies){// Only true when this component is being hot reloaded.
returnfalse;}}if(prevDeps===null){{error('%s received a final argument during this render, but not during '+'the previous render. Even though the final argument is optional, '+'its type cannot change between renders.',currentHookNameInDev);}returnfalse;}{// Don't bother comparing lengths in prod because these arrays should be
// passed inline.
if(nextDeps.length!==prevDeps.length){error('The final argument passed to %s changed size between renders. The '+'order and size of this array must remain constant.\n\n'+'Previous: %s\n'+'Incoming: %s',currentHookNameInDev,"["+prevDeps.join(', ')+"]","["+nextDeps.join(', ')+"]");}}for(vari=0;i<prevDeps.length&&i<nextDeps.length;i++){if(objectIs(nextDeps[i],prevDeps[i])){continue;}returnfalse;}returntrue;}functionrenderWithHooks(current,workInProgress,Component,props,secondArg,nextRenderLanes){renderLanes=nextRenderLanes;currentlyRenderingFiber$1=workInProgress;{hookTypesDev=current!==null?current._debugHookTypes:null;hookTypesUpdateIndexDev=-1;// Used for hot reloading:
ignorePreviousDependencies=current!==null&¤t.type!==workInProgress.type;}workInProgress.memoizedState=null;workInProgress.updateQueue=null;workInProgress.lanes=NoLanes;// The following should have already been reset
// currentHook = null;
// workInProgressHook = null;
// didScheduleRenderPhaseUpdate = false;
// TODO Warn if no hooks are used at all during mount, then some are used during update.
// Currently we will identify the update render as a mount because memoizedState === null.
// This is tricky because it's valid for certain types of components (e.g. React.lazy)
// Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
// Non-stateful hooks (e.g. context) don't get added to memoizedState,
// so memoizedState would be null during updates and mounts.
{if(current!==null&¤t.memoizedState!==null){ReactCurrentDispatcher$1.current=HooksDispatcherOnUpdateInDEV;}elseif(hookTypesDev!==null){// This dispatcher handles an edge case where a component is updating,
// but no stateful hooks have been used.
// We want to match the production code behavior (which will use HooksDispatcherOnMount),
// but with the extra DEV validation to ensure hooks ordering hasn't changed.
// This dispatcher does that.
ReactCurrentDispatcher$1.current=HooksDispatcherOnMountWithHookTypesInDEV;}else{ReactCurrentDispatcher$1.current=HooksDispatcherOnMountInDEV;}}varchildren=Component(props,secondArg);// Check if there was a render phase update
if(didScheduleRenderPhaseUpdateDuringThisPass){// Keep rendering in a loop for as long as render phase updates continue to
// be scheduled. Use a counter to prevent infinite loops.
varnumberOfReRenders=0;do{didScheduleRenderPhaseUpdateDuringThisPass=false;if(!(numberOfReRenders<RE_RENDER_LIMIT)){{throwError("Too many re-renders. React limits the number of renders to prevent an infinite loop.");}}numberOfReRenders+=1;{// Even when hot reloading, allow dependencies to stabilize
// after first render to prevent infinite render phase updates.
ignorePreviousDependencies=false;}// Start over from the beginning of the list
currentHook=null;workInProgressHook=null;workInProgress.updateQueue=null;{// Also validate hook order for cascading updates.
hookTypesUpdateIndexDev=-1;}ReactCurrentDispatcher$1.current=HooksDispatcherOnRerenderInDEV;children=Component(props,secondArg);}while(didScheduleRenderPhaseUpdateDuringThisPass);}// We can assume the previous dispatcher is always this one, since we set it
// at the beginning of the render phase and there's no re-entrancy.
ReactCurrentDispatcher$1.current=ContextOnlyDispatcher;{workInProgress._debugHookTypes=hookTypesDev;}// This check uses currentHook so that it works the same in DEV and prod bundles.
// hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
vardidRenderTooFewHooks=currentHook!==null&¤tHook.next!==null;renderLanes=NoLanes;currentlyRenderingFiber$1=null;currentHook=null;workInProgressHook=null;{currentHookNameInDev=null;hookTypesDev=null;hookTypesUpdateIndexDev=-1;}didScheduleRenderPhaseUpdate=false;if(!!didRenderTooFewHooks){{throwError("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");}}returnchildren;}functionbailoutHooks(current,workInProgress,lanes){workInProgress.updateQueue=current.updateQueue;workInProgress.flags&=~(Passive|Update);current.lanes=removeLanes(current.lanes,lanes);}functionresetHooksAfterThrow(){// We can assume the previous dispatcher is always this one, since we set it
// at the beginning of the render phase and there's no re-entrancy.
ReactCurrentDispatcher$1.current=ContextOnlyDispatcher;if(didScheduleRenderPhaseUpdate){// There were render phase updates. These are only valid for this render
// phase, which we are now aborting. Remove the updates from the queues so
// they do not persist to the next render. Do not remove updates from hooks
// that weren't processed.
//
// Only reset the updates from the queue if it has a clone. If it does
// not have a clone, that means it wasn't processed, and the updates were
// scheduled before we entered the render phase.
varhook=currentlyRenderingFiber$1.memoizedState;while(hook!==null){varqueue=hook.queue;if(queue!==null){queue.pending=null;}hook=hook.next;}didScheduleRenderPhaseUpdate=false;}renderLanes=NoLanes;currentlyRenderingFiber$1=null;currentHook=null;workInProgressHook=null;{hookTypesDev=null;hookTypesUpdateIndexDev=-1;currentHookNameInDev=null;isUpdatingOpaqueValueInRenderPhase=false;}didScheduleRenderPhaseUpdateDuringThisPass=false;}functionmountWorkInProgressHook(){varhook={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};if(workInProgressHook===null){// This is the first hook in the list
currentlyRenderingFiber$1.memoizedState=workInProgressHook=hook;}else{// Append to the end of the list
workInProgressHook=workInProgressHook.next=hook;}returnworkInProgressHook;}functionupdateWorkInProgressHook(){// This function is used both for updates and for re-renders triggered by a
// render phase update. It assumes there is either a current hook we can
// clone, or a work-in-progress hook from a previous render pass that we can
// use as a base. When we reach the end of the base list, we must switch to
// the dispatcher used for mounts.
varnextCurrentHook;if(currentHook===null){varcurrent=currentlyRenderingFiber$1.alternate;if(current!==null){nextCurrentHook=current.memoizedState;}else{nextCurrentHook=null;}}else{nextCurrentHook=currentHook.next;}varnextWorkInProgressHook;if(workInProgressHook===null){nextWorkInProgressHook=currentlyRenderingFiber$1.memoizedState;}else{nextWorkInProgressHook=workInProgressHook.next;}if(nextWorkInProgressHook!==null){// There's already a work-in-progress. Reuse it.
workInProgressHook=nextWorkInProgressHook;nextWorkInProgressHook=workInProgressHook.next;currentHook=nextCurrentHook;}else{// Clone from the current hook.
if(!(nextCurrentHook!==null)){{throwError("Rendered more hooks than during the previous render.");}}currentHook=nextCurrentHook;varnewHook={memoizedState:currentHook.memoizedState,baseState:currentHook.baseState,baseQueue:currentHook.baseQueue,queue:currentHook.queue,next:null};if(workInProgressHook===null){// This is the first hook in the list.
currentlyRenderingFiber$1.memoizedState=workInProgressHook=newHook;}else{// Append to the end of the list.
workInProgressHook=workInProgressHook.next=newHook;}}returnworkInProgressHook;}functioncreateFunctionComponentUpdateQueue(){return{lastEffect:null};}functionbasicStateReducer(state,action){// $FlowFixMe: Flow doesn't like mixed types
returntypeofaction==='function'?action(state):action;}functionmountReducer(reducer,initialArg,init){varhook=mountWorkInProgressHook();varinitialState;if(init!==undefined){initialState=init(initialArg);}else{initialState=initialArg;}hook.memoizedState=hook.baseState=initialState;varqueue=hook.queue={pending:null,dispatch:null,lastRenderedReducer:reducer,lastRenderedState:initialState};vardispatch=queue.dispatch=dispatchAction.bind(null,currentlyRenderingFiber$1,queue);return[hook.memoizedState,dispatch];}functionupdateReducer(reducer,initialArg,init){varhook=updateWorkInProgressHook();varqueue=hook.queue;if(!(queue!==null)){{throwError("Should have a queue. This is likely a bug in React. Please file an issue.");}}queue.lastRenderedReducer=reducer;varcurrent=currentHook;// The last rebase update that is NOT part of the base state.
varbaseQueue=current.baseQueue;// The last pending update that hasn't been processed yet.
varpendingQueue=queue.pending;if(pendingQueue!==null){// We have new updates that haven't been processed yet.
// We'll add them to the base queue.
if(baseQueue!==null){// Merge the pending queue and the base queue.
varbaseFirst=baseQueue.next;varpendingFirst=pendingQueue.next;baseQueue.next=pendingFirst;pendingQueue.next=baseFirst;}{if(current.baseQueue!==baseQueue){// Internal invariant that should never happen, but feasibly could in
// the future if we implement resuming, or some form of that.
error('Internal error: Expected work-in-progress queue to be a clone. '+'This is a bug in React.');}}current.baseQueue=baseQueue=pendingQueue;queue.pending=null;}if(baseQueue!==null){// We have a queue to process.
varfirst=baseQueue.next;varnewState=current.baseState;varnewBaseState=null;varnewBaseQueueFirst=null;varnewBaseQueueLast=null;varupdate=first;do{varupdateLane=update.lane;if(!isSubsetOfLanes(renderLanes,updateLane)){// Priority is insufficient. Skip this update. If this is the first
// skipped update, the previous update/state is the new base
// update/state.
varclone={lane:updateLane,action:update.action,eagerReducer:update.eagerReducer,eagerState:update.eagerState,next:null};if(newBaseQueueLast===null){newBaseQueueFirst=newBaseQueueLast=clone;newBaseState=newState;}else{newBaseQueueLast=newBaseQueueLast.next=clone;}// Update the remaining priority in the queue.
// TODO: Don't need to accumulate this. Instead, we can remove
// renderLanes from the original lanes.
currentlyRenderingFiber$1.lanes=mergeLanes(currentlyRenderingFiber$1.lanes,updateLane);markSkippedUpdateLanes(updateLane);}else{// This update does have sufficient priority.
if(newBaseQueueLast!==null){var_clone={// This update is going to be committed so we never want uncommit
// it. Using NoLane works because 0 is a subset of all bitmasks, so
// this will never be skipped by the check above.
lane:NoLane,action:update.action,eagerReducer:update.eagerReducer,eagerState:update.eagerState,next:null};newBaseQueueLast=newBaseQueueLast.next=_clone;}// Process this update.
if(update.eagerReducer===reducer){// If this update was processed eagerly, and its reducer matches the
// current reducer, we can use the eagerly computed state.
newState=update.eagerState;}else{varaction=update.action;newState=reducer(newState,action);}}update=update.next;}while(update!==null&&update!==first);if(newBaseQueueLast===null){newBaseState=newState;}else{newBaseQueueLast.next=newBaseQueueFirst;}// Mark that the fiber performed work, but only if the new state is
// different from the current state.
if(!objectIs(newState,hook.memoizedState)){markWorkInProgressReceivedUpdate();}hook.memoizedState=newState;hook.baseState=newBaseState;hook.baseQueue=newBaseQueueLast;queue.lastRenderedState=newState;}vardispatch=queue.dispatch;return[hook.memoizedState,dispatch];}functionrerenderReducer(reducer,initialArg,init){varhook=updateWorkInProgressHook();varqueue=hook.queue;if(!(queue!==null)){{throwError("Should have a queue. This is likely a bug in React. Please file an issue.");}}queue.lastRenderedReducer=reducer;// This is a re-render. Apply the new render phase updates to the previous
// work-in-progress hook.
vardispatch=queue.dispatch;varlastRenderPhaseUpdate=queue.pending;varnewState=hook.memoizedState;if(lastRenderPhaseUpdate!==null){// The queue doesn't persist past this render pass.
queue.pending=null;varfirstRenderPhaseUpdate=lastRenderPhaseUpdate.next;varupdate=firstRenderPhaseUpdate;do{// Process this render phase update. We don't have to check the
// priority because it will always be the same as the current
// render's.
varaction=update.action;newState=reducer(newState,action);update=update.next;}while(update!==firstRenderPhaseUpdate);// Mark that the fiber performed work, but only if the new state is
// different from the current state.
if(!objectIs(newState,hook.memoizedState)){markWorkInProgressReceivedUpdate();}hook.memoizedState=newState;// Don't persist the state accumulated from the render phase updates to
// the base state unless the queue is empty.
// TODO: Not sure if this is the desired semantics, but it's what we
// do for gDSFP. I can't remember why.
if(hook.baseQueue===null){hook.baseState=newState;}queue.lastRenderedState=newState;}return[newState,dispatch];}functionreadFromUnsubcribedMutableSource(root,source,getSnapshot){{warnAboutMultipleRenderersDEV(source);}vargetVersion=source._getVersion;varversion=getVersion(source._source);// Is it safe for this component to read from this source during the current render?
varisSafeToReadFromSource=false;// Check the version first.
// If this render has already been started with a specific version,
// we can use it alone to determine if we can safely read from the source.
varcurrentRenderVersion=getWorkInProgressVersion(source);if(currentRenderVersion!==null){// It's safe to read if the store hasn't been mutated since the last time
// we read something.
isSafeToReadFromSource=currentRenderVersion===version;}else{// If there's no version, then this is the first time we've read from the
// source during the current render pass, so we need to do a bit more work.
// What we need to determine is if there are any hooks that already
// subscribed to the source, and if so, whether there are any pending
// mutations that haven't been synchronized yet.
//
// If there are no pending mutations, then `root.mutableReadLanes` will be
// empty, and we know we can safely read.
//
// If there *are* pending mutations, we may still be able to safely read
// if the currently rendering lanes are inclusive of the pending mutation
// lanes, since that guarantees that the value we're about to read from
// the source is consistent with the values that we read during the most
// recent mutation.
isSafeToReadFromSource=isSubsetOfLanes(renderLanes,root.mutableReadLanes);if(isSafeToReadFromSource){// If it's safe to read from this source during the current render,
// store the version in case other components read from it.
// A changed version number will let those components know to throw and restart the render.
setWorkInProgressVersion(source,version);}}if(isSafeToReadFromSource){varsnapshot=getSnapshot(source._source);{if(typeofsnapshot==='function'){error('Mutable source should not return a function as the snapshot value. '+'Functions may close over mutable values and cause tearing.');}}returnsnapshot;}else{// This handles the special case of a mutable source being shared between renderers.
// In that case, if the source is mutated between the first and second renderer,
// The second renderer don't know that it needs to reset the WIP version during unwind,
// (because the hook only marks sources as dirty if it's written to their WIP version).
// That would cause this tear check to throw again and eventually be visible to the user.
// We can avoid this infinite loop by explicitly marking the source as dirty.
//
// This can lead to tearing in the first renderer when it resumes,
// but there's nothing we can do about that (short of throwing here and refusing to continue the render).
markSourceAsDirty(source);{{throwError("Cannot read from mutable source during the current render without tearing. This is a bug in React. Please file an issue.");}}}}functionuseMutableSource(hook,source,getSnapshot,subscribe){varroot=getWorkInProgressRoot();if(!(root!==null)){{throwError("Expected a work-in-progress root. This is a bug in React. Please file an issue.");}}vargetVersion=source._getVersion;varversion=getVersion(source._source);vardispatcher=ReactCurrentDispatcher$1.current;// eslint-disable-next-line prefer-const
var_dispatcher$useState=dispatcher.useState(function(){returnreadFromUnsubcribedMutableSource(root,source,getSnapshot);}),currentSnapshot=_dispatcher$useState[0],setSnapshot=_dispatcher$useState[1];varsnapshot=currentSnapshot;// Grab a handle to the state hook as well.
// We use it to clear the pending update queue if we have a new source.
varstateHook=workInProgressHook;varmemoizedState=hook.memoizedState;varrefs=memoizedState.refs;varprevGetSnapshot=refs.getSnapshot;varprevSource=memoizedState.source;varprevSubscribe=memoizedState.subscribe;varfiber=currentlyRenderingFiber$1;hook.memoizedState={refs:refs,source:source,subscribe:subscribe};// Sync the values needed by our subscription handler after each commit.
dispatcher.useEffect(function(){refs.getSnapshot=getSnapshot;// Normally the dispatch function for a state hook never changes,
// but this hook recreates the queue in certain cases to avoid updates from stale sources.
// handleChange() below needs to reference the dispatch function without re-subscribing,
// so we use a ref to ensure that it always has the latest version.
refs.setSnapshot=setSnapshot;// Check for a possible change between when we last rendered now.
varmaybeNewVersion=getVersion(source._source);if(!objectIs(version,maybeNewVersion)){varmaybeNewSnapshot=getSnapshot(source._source);{if(typeofmaybeNewSnapshot==='function'){error('Mutable source should not return a function as the snapshot value. '+'Functions may close over mutable values and cause tearing.');}}if(!objectIs(snapshot,maybeNewSnapshot)){setSnapshot(maybeNewSnapshot);varlane=requestUpdateLane(fiber);markRootMutableRead(root,lane);}// If the source mutated between render and now,
// there may be state updates already scheduled from the old source.
// Entangle the updates so that they render in the same batch.
markRootEntangled(root,root.mutableReadLanes);}},[getSnapshot,source,subscribe]);// If we got a new source or subscribe function, re-subscribe in a passive effect.
dispatcher.useEffect(function(){varhandleChange=function(){varlatestGetSnapshot=refs.getSnapshot;varlatestSetSnapshot=refs.setSnapshot;try{latestSetSnapshot(latestGetSnapshot(source._source));// Record a pending mutable source update with the same expiration time.
varlane=requestUpdateLane(fiber);markRootMutableRead(root,lane);}catch(error){// A selector might throw after a source mutation.
// e.g. it might try to read from a part of the store that no longer exists.
// In this case we should still schedule an update with React.
// Worst case the selector will throw again and then an error boundary will handle it.
latestSetSnapshot(function(){throwerror;});}};varunsubscribe=subscribe(source._source,handleChange);{if(typeofunsubscribe!=='function'){error('Mutable source subscribe function must return an unsubscribe function.');}}returnunsubscribe;},[source,subscribe]);// If any of the inputs to useMutableSource change, reading is potentially unsafe.
//
// If either the source or the subscription have changed we can't can't trust the update queue.
// Maybe the source changed in a way that the old subscription ignored but the new one depends on.
//
// If the getSnapshot function changed, we also shouldn't rely on the update queue.
// It's possible that the underlying source was mutated between the when the last "change" event fired,
// and when the current render (with the new getSnapshot function) is processed.
//
// In both cases, we need to throw away pending updates (since they are no longer relevant)
// and treat reading from the source as we do in the mount case.
if(!objectIs(prevGetSnapshot,getSnapshot)||!objectIs(prevSource,source)||!objectIs(prevSubscribe,subscribe)){// Create a new queue and setState method,
// So if there are interleaved updates, they get pushed to the older queue.
// When this becomes current, the previous queue and dispatch method will be discarded,
// including any interleaving updates that occur.
varnewQueue={pending:null,dispatch:null,lastRenderedReducer:basicStateReducer,lastRenderedState:snapshot};newQueue.dispatch=setSnapshot=dispatchAction.bind(null,currentlyRenderingFiber$1,newQueue);stateHook.queue=newQueue;stateHook.baseQueue=null;snapshot=readFromUnsubcribedMutableSource(root,source,getSnapshot);stateHook.memoizedState=stateHook.baseState=snapshot;}returnsnapshot;}functionmountMutableSource(source,getSnapshot,subscribe){varhook=mountWorkInProgressHook();hook.memoizedState={refs:{getSnapshot:getSnapshot,setSnapshot:null},source:source,subscribe:subscribe};returnuseMutableSource(hook,source,getSnapshot,subscribe);}functionupdateMutableSource(source,getSnapshot,subscribe){varhook=updateWorkInProgressHook();returnuseMutableSource(hook,source,getSnapshot,subscribe);}functionmountState(initialState){varhook=mountWorkInProgressHook();if(typeofinitialState==='function'){// $FlowFixMe: Flow doesn't like mixed types
next:null};varcomponentUpdateQueue=currentlyRenderingFiber$1.updateQueue;if(componentUpdateQueue===null){componentUpdateQueue=createFunctionComponentUpdateQueue();currentlyRenderingFiber$1.updateQueue=componentUpdateQueue;componentUpdateQueue.lastEffect=effect.next=effect;}else{varlastEffect=componentUpdateQueue.lastEffect;if(lastEffect===null){componentUpdateQueue.lastEffect=effect.next=effect;}else{varfirstEffect=lastEffect.next;lastEffect.next=effect;effect.next=firstEffect;componentUpdateQueue.lastEffect=effect;}}returneffect;}functionmountRef(initialValue){varhook=mountWorkInProgressHook();varref={current:initialValue};{Object.seal(ref);}hook.memoizedState=ref;returnref;}functionupdateRef(initialValue){varhook=updateWorkInProgressHook();returnhook.memoizedState;}functionmountEffectImpl(fiberFlags,hookFlags,create,deps){varhook=mountWorkInProgressHook();varnextDeps=deps===undefined?null:deps;currentlyRenderingFiber$1.flags|=fiberFlags;hook.memoizedState=pushEffect(HasEffect|hookFlags,create,undefined,nextDeps);}functionupdateEffectImpl(fiberFlags,hookFlags,create,deps){varhook=updateWorkInProgressHook();varnextDeps=deps===undefined?null:deps;vardestroy=undefined;if(currentHook!==null){varprevEffect=currentHook.memoizedState;destroy=prevEffect.destroy;if(nextDeps!==null){varprevDeps=prevEffect.deps;if(areHookInputsEqual(nextDeps,prevDeps)){pushEffect(hookFlags,create,destroy,nextDeps);return;}}}currentlyRenderingFiber$1.flags|=fiberFlags;hook.memoizedState=pushEffect(HasEffect|hookFlags,create,destroy,nextDeps);}functionmountEffect(create,deps){{// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if('undefined'!==typeofjest){warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);}}returnmountEffectImpl(Update|Passive,Passive$1,create,deps);}functionupdateEffect(create,deps){{// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if('undefined'!==typeofjest){warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);}}returnupdateEffectImpl(Update|Passive,Passive$1,create,deps);}functionmountLayoutEffect(create,deps){returnmountEffectImpl(Update,Layout,create,deps);}functionupdateLayoutEffect(create,deps){returnupdateEffectImpl(Update,Layout,create,deps);}functionimperativeHandleEffect(create,ref){if(typeofref==='function'){varrefCallback=ref;var_inst=create();refCallback(_inst);returnfunction(){refCallback(null);};}elseif(ref!==null&&ref!==undefined){varrefObject=ref;{if(!refObject.hasOwnProperty('current')){error('Expected useImperativeHandle() first argument to either be a '+'ref callback or React.createRef() object. Instead received: %s.','an object with keys {'+Object.keys(refObject).join(', ')+'}');}}var_inst2=create();refObject.current=_inst2;returnfunction(){refObject.current=null;};}}functionmountImperativeHandle(ref,create,deps){{if(typeofcreate!=='function'){error('Expected useImperativeHandle() second argument to be a function '+'that creates a handle. Instead received: %s.',create!==null?typeofcreate:'null');}}// TODO: If deps are provided, should we skip comparing the ref itself?
vareffectDeps=deps!==null&&deps!==undefined?deps.concat([ref]):null;returnmountEffectImpl(Update,Layout,imperativeHandleEffect.bind(null,create,ref),effectDeps);}functionupdateImperativeHandle(ref,create,deps){{if(typeofcreate!=='function'){error('Expected useImperativeHandle() second argument to be a function '+'that creates a handle. Instead received: %s.',create!==null?typeofcreate:'null');}}// TODO: If deps are provided, should we skip comparing the ref itself?
vareffectDeps=deps!==null&&deps!==undefined?deps.concat([ref]):null;returnupdateEffectImpl(Update,Layout,imperativeHandleEffect.bind(null,create,ref),effectDeps);}functionmountDebugValue(value,formatterFn){// This hook is normally a no-op.
// The react-debug-hooks package injects its own implementation
// so that e.g. DevTools can display custom hook values.
}varupdateDebugValue=mountDebugValue;functionmountCallback(callback,deps){varhook=mountWorkInProgressHook();varnextDeps=deps===undefined?null:deps;hook.memoizedState=[callback,nextDeps];returncallback;}functionupdateCallback(callback,deps){varhook=updateWorkInProgressHook();varnextDeps=deps===undefined?null:deps;varprevState=hook.memoizedState;if(prevState!==null){if(nextDeps!==null){varprevDeps=prevState[1];if(areHookInputsEqual(nextDeps,prevDeps)){returnprevState[0];}}}hook.memoizedState=[callback,nextDeps];returncallback;}functionmountMemo(nextCreate,deps){varhook=mountWorkInProgressHook();varnextDeps=deps===undefined?null:deps;varnextValue=nextCreate();hook.memoizedState=[nextValue,nextDeps];returnnextValue;}functionupdateMemo(nextCreate,deps){varhook=updateWorkInProgressHook();varnextDeps=deps===undefined?null:deps;varprevState=hook.memoizedState;if(prevState!==null){// Assume these are defined. If they're not, areHookInputsEqual will warn.
if(nextDeps!==null){varprevDeps=prevState[1];if(areHookInputsEqual(nextDeps,prevDeps)){returnprevState[0];}}}varnextValue=nextCreate();hook.memoizedState=[nextValue,nextDeps];returnnextValue;}functionmountDeferredValue(value){var_mountState=mountState(value),prevValue=_mountState[0],setValue=_mountState[1];mountEffect(function(){varprevTransition=ReactCurrentBatchConfig$1.transition;ReactCurrentBatchConfig$1.transition=1;try{setValue(value);}finally{ReactCurrentBatchConfig$1.transition=prevTransition;}},[value]);returnprevValue;}functionupdateDeferredValue(value){var_updateState=updateState(),prevValue=_updateState[0],setValue=_updateState[1];updateEffect(function(){varprevTransition=ReactCurrentBatchConfig$1.transition;ReactCurrentBatchConfig$1.transition=1;try{setValue(value);}finally{ReactCurrentBatchConfig$1.transition=prevTransition;}},[value]);returnprevValue;}functionrerenderDeferredValue(value){var_rerenderState=rerenderState(),prevValue=_rerenderState[0],setValue=_rerenderState[1];updateEffect(function(){varprevTransition=ReactCurrentBatchConfig$1.transition;ReactCurrentBatchConfig$1.transition=1;try{setValue(value);}finally{ReactCurrentBatchConfig$1.transition=prevTransition;}},[value]);returnprevValue;}functionstartTransition(setPending,callback){varpriorityLevel=getCurrentPriorityLevel();{runWithPriority$1(priorityLevel<UserBlockingPriority$2?UserBlockingPriority$2:priorityLevel,function(){setPending(true);});runWithPriority$1(priorityLevel>NormalPriority$1?NormalPriority$1:priorityLevel,function(){varprevTransition=ReactCurrentBatchConfig$1.transition;ReactCurrentBatchConfig$1.transition=1;try{setPending(false);callback();}finally{ReactCurrentBatchConfig$1.transition=prevTransition;}});}}functionmountTransition(){var_mountState2=mountState(false),isPending=_mountState2[0],setPending=_mountState2[1];// The `start` method can be stored on a ref, since `setPending`
// never changes.
varstart=startTransition.bind(null,setPending);mountRef(start);return[start,isPending];}functionupdateTransition(){var_updateState2=updateState(),isPending=_updateState2[0];varstartRef=updateRef();varstart=startRef.current;return[start,isPending];}functionrerenderTransition(){var_rerenderState2=rerenderState(),isPending=_rerenderState2[0];varstartRef=updateRef();varstart=startRef.current;return[start,isPending];}varisUpdatingOpaqueValueInRenderPhase=false;functiongetIsUpdatingOpaqueValueInRenderPhaseInDEV(){{returnisUpdatingOpaqueValueInRenderPhase;}}functionwarnOnOpaqueIdentifierAccessInDEV(fiber){{// TODO: Should warn in effects and callbacks, too
varname=getComponentName(fiber.type)||'Unknown';if(getIsRendering()&&!didWarnAboutUseOpaqueIdentifier[name]){error('The object passed back from useOpaqueIdentifier is meant to be '+'passed through to attributes only. Do not read the '+'value directly.');didWarnAboutUseOpaqueIdentifier[name]=true;}}}functionmountOpaqueIdentifier(){varmakeId=makeClientIdInDEV.bind(null,warnOnOpaqueIdentifierAccessInDEV.bind(null,currentlyRenderingFiber$1));if(getIsHydrating()){vardidUpgrade=false;varfiber=currentlyRenderingFiber$1;varreadValue=function(){if(!didUpgrade){// Only upgrade once. This works even inside the render phase because
// the update is added to a shared queue, which outlasts the
// in-progress render.
didUpgrade=true;{isUpdatingOpaqueValueInRenderPhase=true;setId(makeId());isUpdatingOpaqueValueInRenderPhase=false;warnOnOpaqueIdentifierAccessInDEV(fiber);}}{{throwError("The object passed back from useOpaqueIdentifier is meant to be passed through to attributes only. Do not read the value directly.");}}};varid=makeOpaqueHydratingObject(readValue);varsetId=mountState(id)[1];if((currentlyRenderingFiber$1.mode&BlockingMode)===NoMode){currentlyRenderingFiber$1.flags|=Update|Passive;pushEffect(HasEffect|Passive$1,function(){setId(makeId());},undefined,null);}returnid;}else{var_id=makeId();mountState(_id);return_id;}}functionupdateOpaqueIdentifier(){varid=updateState()[0];returnid;}functionrerenderOpaqueIdentifier(){varid=rerenderState()[0];returnid;}functiondispatchAction(fiber,queue,action){{if(typeofarguments[3]==='function'){error("State updates from the useState() and useReducer() Hooks don't support the "+'second callback argument. To execute a side effect after '+'rendering, declare it in the component body with useEffect().');}}vareventTime=requestEventTime();varlane=requestUpdateLane(fiber);varupdate={lane:lane,action:action,eagerReducer:null,eagerState:null,next:null};// Append the update to the end of the list.
varpending=queue.pending;if(pending===null){// This is the first update. Create a circular list.
update.next=update;}else{update.next=pending.next;pending.next=update;}queue.pending=update;varalternate=fiber.alternate;if(fiber===currentlyRenderingFiber$1||alternate!==null&&alternate===currentlyRenderingFiber$1){// This is a render phase update. Stash it in a lazily-created map of
// queue -> linked list of updates. After this render pass, we'll restart
// and apply the stashed updates on top of the work-in-progress hook.
didScheduleRenderPhaseUpdateDuringThisPass=didScheduleRenderPhaseUpdate=true;}else{if(fiber.lanes===NoLanes&&(alternate===null||alternate.lanes===NoLanes)){// The queue is currently empty, which means we can eagerly compute the
// next state before entering the render phase. If the new state is the
// same as the current state, we may be able to bail out entirely.
varlastRenderedReducer=queue.lastRenderedReducer;if(lastRenderedReducer!==null){varprevDispatcher;{prevDispatcher=ReactCurrentDispatcher$1.current;ReactCurrentDispatcher$1.current=InvalidNestedHooksDispatcherOnUpdateInDEV;}try{varcurrentState=queue.lastRenderedState;vareagerState=lastRenderedReducer(currentState,action);// Stash the eagerly computed state, and the reducer used to compute
// it, on the update object. If the reducer hasn't changed by the
// time we enter the render phase, then the eager state can be used
// without calling the reducer again.
update.eagerReducer=lastRenderedReducer;update.eagerState=eagerState;if(objectIs(eagerState,currentState)){// Fast path. We can bail out without scheduling React to re-render.
// It's still possible that we'll need to rebase this update later,
// if the component re-renders for a different reason and by that
// time the reducer has changed.
return;}}catch(error){// Suppress the error. It will throw again in the render phase.
}finally{{ReactCurrentDispatcher$1.current=prevDispatcher;}}}}{// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if('undefined'!==typeofjest){warnIfNotScopedWithMatchingAct(fiber);warnIfNotCurrentlyActingUpdatesInDev(fiber);}}scheduleUpdateOnFiber(fiber,lane,eventTime);}}varContextOnlyDispatcher={readContext:readContext,useCallback:throwInvalidHookError,useContext:throwInvalidHookError,useEffect:throwInvalidHookError,useImperativeHandle:throwInvalidHookError,useLayoutEffect:throwInvalidHookError,useMemo:throwInvalidHookError,useReducer:throwInvalidHookError,useRef:throwInvalidHookError,useState:throwInvalidHookError,useDebugValue:throwInvalidHookError,useDeferredValue:throwInvalidHookError,useTransition:throwInvalidHookError,useMutableSource:throwInvalidHookError,useOpaqueIdentifier:throwInvalidHookError,unstable_isNewReconciler:enableNewReconciler};varHooksDispatcherOnMountInDEV=null;varHooksDispatcherOnMountWithHookTypesInDEV=null;varHooksDispatcherOnUpdateInDEV=null;varHooksDispatcherOnRerenderInDEV=null;varInvalidNestedHooksDispatcherOnMountInDEV=null;varInvalidNestedHooksDispatcherOnUpdateInDEV=null;varInvalidNestedHooksDispatcherOnRerenderInDEV=null;{varwarnInvalidContextAccess=function(){error('Context can only be read while React is rendering. '+'In classes, you can read it in the render method or getDerivedStateFromProps. '+'In function components, you can read it directly in the function body, but not '+'inside Hooks like useReducer() or useMemo().');};varwarnInvalidHookAccess=function(){error('Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. '+'You can only call Hooks at the top level of your React function. '+'For more information, see '+'https://reactjs.org/link/rules-of-hooks');};HooksDispatcherOnMountInDEV={readContext:function(context,observedBits){returnreadContext(context,observedBits);},useCallback:function(callback,deps){currentHookNameInDev='useCallback';mountHookTypesDev();checkDepsAreArrayDev(deps);returnmountCallback(callback,deps);},useContext:function(context,observedBits){currentHookNameInDev='useContext';mountHookTypesDev();returnreadContext(context,observedBits);},useEffect:function(create,deps){currentHookNameInDev='useEffect';mountHookTypesDev();checkDepsAreArrayDev(deps);returnmountEffect(create,deps);},useImperativeHandle:function(ref,create,deps){currentHookNameInDev='useImperativeHandle';mountHookTypesDev();checkDepsAreArrayDev(deps);returnmountImperativeHandle(ref,create,deps);},useLayoutEffect:function(create,deps){currentHookNameInDev='useLayoutEffect';mountHookTypesDev();checkDepsAreArrayDev(deps);returnmountLayoutEffect(create,deps);},useMemo:function(create,deps){currentHookNameInDev='useMemo';mountHookTypesDev();checkDepsAreArrayDev(deps);varprevDispatcher=ReactCurrentDispatcher$1.current;ReactCurrentDispatcher$1.current=InvalidNestedHooksDispatcherOnMountInDEV;try{returnmountMemo(create,deps);}finally{ReactCurrentDispatcher$1.current=prevDispatcher;}},useReducer:function(reducer,initialArg,init){currentHookNameInDev='useReducer';mountHookTypesDev();varprevDispatcher=ReactCurrentDispatcher$1.current;ReactCurrentDispatcher$1.current=InvalidNestedHooksDispatcherOnMountInDEV;try{returnmountReducer(reducer,initialArg,init);}finally{ReactCurrentDispatcher$1.current=prevDispatcher;}},useRef:function(initialValue){currentHookNameInDev='useRef';mountHookTypesDev();returnmountRef(initialValue);},useState:function(initialState){currentHookNameInDev='useState';mountHookTypesDev();varprevDispatcher=ReactCurrentDispatcher$1.current;ReactCurrentDispatcher$1.current=InvalidNestedHooksDispatcherOnMountInDEV;try{returnmountState(initialState);}finally{ReactCurrentDispatcher$1.current=prevDispatcher;}},useDebugValue:function(value,formatterFn){currentHookNameInDev='useDebugValue';mountHookTypesDev();returnmountDebugValue();},useDeferredValue:function(value){currentHookNameInDev='useDeferredValue';mountHookTypesDev();returnmountDeferredValue(value);},useTransition:function(){currentHookNameInDev='useTransition';mountHookTypesDev();returnmountTransition();},useMutableSource:function(source,getSnapshot,subscribe){currentHookNameInDev='useMutableSource';
// after we rerender. This is used as a helper in special cases
// where we should count the work of multiple passes.
varchild=fiber.child;while(child){fiber.actualDuration+=child.actualDuration;child=child.sibling;}}varReactCurrentOwner$1=ReactSharedInternals.ReactCurrentOwner;vardidReceiveUpdate=false;vardidWarnAboutBadClass;vardidWarnAboutModulePatternComponent;vardidWarnAboutContextTypeOnFunctionComponent;vardidWarnAboutGetDerivedStateOnFunctionComponent;vardidWarnAboutFunctionRefs;vardidWarnAboutReassigningProps;vardidWarnAboutRevealOrder;vardidWarnAboutTailOptions;{didWarnAboutBadClass={};didWarnAboutModulePatternComponent={};didWarnAboutContextTypeOnFunctionComponent={};didWarnAboutGetDerivedStateOnFunctionComponent={};didWarnAboutFunctionRefs={};didWarnAboutReassigningProps=false;didWarnAboutRevealOrder={};didWarnAboutTailOptions={};}functionreconcileChildren(current,workInProgress,nextChildren,renderLanes){if(current===null){// If this is a fresh new component that hasn't been rendered yet, we
// won't update its child set by applying minimal side-effects. Instead,
// we will add them all to the child before it gets rendered. That means
// we can optimize this reconciliation pass by not tracking side-effects.
workInProgress.child=mountChildFibers(workInProgress,null,nextChildren,renderLanes);}else{// If the current child is the same as the work in progress, it means that
// we haven't yet started any work on these children. Therefore, we use
// the clone algorithm to create a copy of all the current children.
// If we had any progressed work already, that is invalid at this point so
// let's throw it out.
workInProgress.child=reconcileChildFibers(workInProgress,current.child,nextChildren,renderLanes);}}functionforceUnmountCurrentAndReconcile(current,workInProgress,nextChildren,renderLanes){// This function is fork of reconcileChildren. It's used in cases where we
// want to reconcile without matching against the existing set. This has the
// effect of all current children being unmounted; even if the type and key
// are the same, the old child is unmounted and a new child is created.
//
// To do this, we're going to go through the reconcile algorithm twice. In
// the first pass, we schedule a deletion for all the current children by
// passing null.
workInProgress.child=reconcileChildFibers(workInProgress,current.child,null,renderLanes);// In the second pass, we mount the new children. The trick here is that we
// pass null in place of where we usually pass the current child set. This has
// the effect of remounting all children regardless of whether their
// identities match.
workInProgress.child=reconcileChildFibers(workInProgress,null,nextChildren,renderLanes);}functionupdateForwardRef(current,workInProgress,Component,nextProps,renderLanes){// TODO: current can be non-null here even if the component
// hasn't yet mounted. This happens after the first render suspends.
// We'll need to figure out if this is fine or can cause issues.
{if(workInProgress.type!==workInProgress.elementType){// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
Component.defaultProps===undefined){varresolvedType=type;{resolvedType=resolveFunctionForHotReloading(type);}// If this is a plain function component without default props,
// and with only the default shallow comparison, we upgrade it
// to a SimpleMemoComponent to allow fast path updates.
workInProgress.tag=SimpleMemoComponent;workInProgress.type=resolvedType;{validateFunctionComponentInDev(workInProgress,type);}returnupdateSimpleMemoComponent(current,workInProgress,resolvedType,nextProps,updateLanes,renderLanes);}{varinnerPropTypes=type.propTypes;if(innerPropTypes){// Inner memo component props aren't currently validated in createElement.
// We could move it there, but we'd still need this for lazy code path.
'prop',getComponentName(type));}}varchild=createFiberFromTypeAndProps(Component.type,null,nextProps,workInProgress,workInProgress.mode,renderLanes);child.ref=workInProgress.ref;child.return=workInProgress;workInProgress.child=child;returnchild;}{var_type=Component.type;var_innerPropTypes=_type.propTypes;if(_innerPropTypes){// Inner memo component props aren't currently validated in createElement.
// We could move it there, but we'd still need this for lazy code path.
'prop',getComponentName(_type));}}varcurrentChild=current.child;// This is always exactly one child
if(!includesSomeLane(updateLanes,renderLanes)){// This will be the props with resolved defaultProps,
// unlike current.memoizedProps which will be the unresolved ones.
varprevProps=currentChild.memoizedProps;// Default to shallow comparison
varcompare=Component.compare;compare=compare!==null?compare:shallowEqual;if(compare(prevProps,nextProps)&¤t.ref===workInProgress.ref){returnbailoutOnAlreadyFinishedWork(current,workInProgress,renderLanes);}}// React DevTools reads this flag.
workInProgress.flags|=PerformedWork;varnewChild=createWorkInProgress(currentChild,nextProps);newChild.ref=workInProgress.ref;newChild.return=workInProgress;workInProgress.child=newChild;returnnewChild;}functionupdateSimpleMemoComponent(current,workInProgress,Component,nextProps,updateLanes,renderLanes){// TODO: current can be non-null here even if the component
// hasn't yet mounted. This happens when the inner render suspends.
// We'll need to figure out if this is fine or can cause issues.
{if(workInProgress.type!==workInProgress.elementType){// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
varouterMemoType=workInProgress.elementType;if(outerMemoType.$$typeof===REACT_LAZY_TYPE){// We warn when you define propTypes on lazy()
// so let's just skip over it to find memo() outer wrapper.
// Inner props for memo are validated later.
varlazyComponent=outerMemoType;varpayload=lazyComponent._payload;varinit=lazyComponent._init;try{outerMemoType=init(payload);}catch(x){outerMemoType=null;}// Inner propTypes will be validated in the function component path.
varouterPropTypes=outerMemoType&&outerMemoType.propTypes;if(outerPropTypes){checkPropTypes(outerPropTypes,nextProps,// Resolved (SimpleMemoComponent has no defaultProps)
'prop',getComponentName(outerMemoType));}}}}if(current!==null){varprevProps=current.memoizedProps;if(shallowEqual(prevProps,nextProps)&¤t.ref===workInProgress.ref&&// Prevent bailout if the implementation changed due to hot reload.
workInProgress.type===current.type){didReceiveUpdate=false;if(!includesSomeLane(renderLanes,updateLanes)){// The pending lanes were cleared at the beginning of beginWork. We're
// about to bail out, but there might be other lanes that weren't
// included in the current render. Usually, the priority level of the
// remaining updates is accumlated during the evaluation of the
// component (i.e. when processing the update queue). But since since
// we're bailing out early *without* evaluating the component, we need
// to account for it here, too. Reset to the value of the current fiber.
// NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
// because a MemoComponent fiber does not have hooks or an update queue;
// rather, it wraps around an inner component, which may or may not
// contains hooks.
// TODO: Move the reset at in beginWork out of the common path so that
// this is no longer necessary.
workInProgress.lanes=current.lanes;returnbailoutOnAlreadyFinishedWork(current,workInProgress,renderLanes);}elseif((current.flags&ForceUpdateForLegacySuspense)!==NoFlags){// This is a special case that only exists for legacy mode.
// See https://github.com/facebook/react/pull/19216.
didReceiveUpdate=true;}}}returnupdateFunctionComponent(current,workInProgress,Component,nextProps,renderLanes);}functionupdateOffscreenComponent(current,workInProgress,renderLanes){varnextProps=workInProgress.pendingProps;varnextChildren=nextProps.children;varprevState=current!==null?current.memoizedState:null;if(nextProps.mode==='hidden'||nextProps.mode==='unstable-defer-without-hiding'){if((workInProgress.mode&ConcurrentMode)===NoMode){// In legacy sync mode, don't defer the subtree. Render it now.
// TODO: Figure out what we should do in Blocking mode.
varnextState={baseLanes:NoLanes};workInProgress.memoizedState=nextState;pushRenderLanes(workInProgress,renderLanes);}elseif(!includesSomeLane(renderLanes,OffscreenLane)){varnextBaseLanes;if(prevState!==null){varprevBaseLanes=prevState.baseLanes;nextBaseLanes=mergeLanes(prevBaseLanes,renderLanes);}else{nextBaseLanes=renderLanes;}// Schedule this fiber to re-render at offscreen priority. Then bailout.
{markSpawnedWork(OffscreenLane);}workInProgress.lanes=workInProgress.childLanes=laneToLanes(OffscreenLane);var_nextState={baseLanes:nextBaseLanes};workInProgress.memoizedState=_nextState;// We're about to bail out, but we need to push this to the stack anyway
// to avoid a push/pop misalignment.
pushRenderLanes(workInProgress,nextBaseLanes);returnnull;}else{// Rendering at offscreen, so we can clear the base lanes.
var_nextState2={baseLanes:NoLanes};workInProgress.memoizedState=_nextState2;// Push the lanes that were skipped when we bailed out.
varsubtreeRenderLanes=prevState!==null?prevState.baseLanes:renderLanes;pushRenderLanes(workInProgress,subtreeRenderLanes);}}else{var_subtreeRenderLanes;if(prevState!==null){_subtreeRenderLanes=mergeLanes(prevState.baseLanes,renderLanes);// Since we're not hidden anymore, reset the state
workInProgress.memoizedState=null;}else{// We weren't previously hidden, and we still aren't, so there's nothing
// special to do. Need to push to the stack regardless, though, to avoid
// a push/pop misalignment.
_subtreeRenderLanes=renderLanes;}pushRenderLanes(workInProgress,_subtreeRenderLanes);}reconcileChildren(current,workInProgress,nextChildren,renderLanes);returnworkInProgress.child;}// Note: These happen to have identical begin phases, for now. We shouldn't hold
// ourselves to this constraint, though. If the behavior diverges, we should
// fork the function.
varupdateLegacyHiddenComponent=updateOffscreenComponent;functionupdateFragment(current,workInProgress,renderLanes){varnextChildren=workInProgress.pendingProps;reconcileChildren(current,workInProgress,nextChildren,renderLanes);returnworkInProgress.child;}functionupdateMode(current,workInProgress,renderLanes){varnextChildren=workInProgress.pendingProps.children;reconcileChildren(current,workInProgress,nextChildren,renderLanes);returnworkInProgress.child;}functionupdateProfiler(current,workInProgress,renderLanes){{workInProgress.flags|=Update;// Reset effect durations for the next eventual effect phase.
// These are reset during render to allow the DevTools commit hook a chance to read them,
varstateNode=workInProgress.stateNode;stateNode.effectDuration=0;stateNode.passiveEffectDuration=0;}varnextProps=workInProgress.pendingProps;varnextChildren=nextProps.children;reconcileChildren(current,workInProgress,nextChildren,renderLanes);returnworkInProgress.child;}functionmarkRef(current,workInProgress){varref=workInProgress.ref;if(current===null&&ref!==null||current!==null&¤t.ref!==ref){// Schedule a Ref effect
workInProgress.flags|=Ref;}}functionupdateFunctionComponent(current,workInProgress,Component,nextProps,renderLanes){{if(workInProgress.type!==workInProgress.elementType){// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
'prop',getComponentName(Component));}}}varcontext;{varunmaskedContext=getUnmaskedContext(workInProgress,Component,true);context=getMaskedContext(workInProgress,unmaskedContext);}varnextChildren;prepareToReadContext(workInProgress,renderLanes);{ReactCurrentOwner$1.current=workInProgress;setIsRendering(true);nextChildren=renderWithHooks(current,workInProgress,Component,nextProps,context,renderLanes);if(workInProgress.mode&StrictMode){disableLogs();try{nextChildren=renderWithHooks(current,workInProgress,Component,nextProps,context,renderLanes);}finally{reenableLogs();}}setIsRendering(false);}if(current!==null&&!didReceiveUpdate){bailoutHooks(current,workInProgress,renderLanes);returnbailoutOnAlreadyFinishedWork(current,workInProgress,renderLanes);}// React DevTools reads this flag.
workInProgress.flags|=PerformedWork;reconcileChildren(current,workInProgress,nextChildren,renderLanes);returnworkInProgress.child;}functionupdateClassComponent(current,workInProgress,Component,nextProps,renderLanes){{if(workInProgress.type!==workInProgress.elementType){// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
'prop',getComponentName(Component));}}}// Push context providers early to prevent context stack mismatches.
// During mounting we don't know the child context yet as the instance doesn't exist.
// We will invalidate the child context in finishClassComponent() right after rendering.
varhasContext;if(isContextProvider(Component)){hasContext=true;pushContextProvider(workInProgress);}else{hasContext=false;}prepareToReadContext(workInProgress,renderLanes);varinstance=workInProgress.stateNode;varshouldUpdate;if(instance===null){if(current!==null){// A class component without an instance only mounts if it suspended
// inside a non-concurrent tree, in an inconsistent state. We want to
// treat it like a new mount, even though an empty version of it already
// committed. Disconnect the alternate pointers.
current.alternate=null;workInProgress.alternate=null;// Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags|=Placement;}// In the initial pass we might need to construct the instance.
constructClassInstance(workInProgress,Component,nextProps);mountClassInstance(workInProgress,Component,nextProps,renderLanes);shouldUpdate=true;}elseif(current===null){// In a resume, we'll already have an instance we can reuse.
shouldUpdate=resumeMountClassInstance(workInProgress,Component,nextProps,renderLanes);}else{shouldUpdate=updateClassInstance(current,workInProgress,Component,nextProps,renderLanes);}varnextUnitOfWork=finishClassComponent(current,workInProgress,Component,shouldUpdate,hasContext,renderLanes);{varinst=workInProgress.stateNode;if(shouldUpdate&&inst.props!==nextProps){if(!didWarnAboutReassigningProps){error('It looks like %s is reassigning its own `this.props` while rendering. '+'This is not supported and can lead to confusing bugs.',getComponentName(workInProgress.type)||'a component');}didWarnAboutReassigningProps=true;}}returnnextUnitOfWork;}functionfinishClassComponent(current,workInProgress,Component,shouldUpdate,hasContext,renderLanes){// Refs should update even if shouldComponentUpdate returns false
markRef(current,workInProgress);vardidCaptureError=(workInProgress.flags&DidCapture)!==NoFlags;if(!shouldUpdate&&!didCaptureError){// Context providers should defer to sCU for rendering
ReactCurrentOwner$1.current=workInProgress;varnextChildren;if(didCaptureError&&typeofComponent.getDerivedStateFromError!=='function'){// If we captured an error, but getDerivedStateFromError is not defined,
// unmount all the children. componentDidCatch will schedule an update to
// re-render a fallback. This is temporary until we migrate everyone to
// the new API.
// TODO: Warn in a future release.
nextChildren=null;{stopProfilerTimerIfRunning();}}else{{setIsRendering(true);nextChildren=instance.render();if(workInProgress.mode&StrictMode){disableLogs();try{instance.render();}finally{reenableLogs();}}setIsRendering(false);}}// React DevTools reads this flag.
workInProgress.flags|=PerformedWork;if(current!==null&&didCaptureError){// If we're recovering from an error, reconcile without reusing any of
// the existing children. Conceptually, the normal children and the children
// that are shown on error are two different sets, so we shouldn't reuse
// normal children even if their identities match.
forceUnmountCurrentAndReconcile(current,workInProgress,nextChildren,renderLanes);}else{reconcileChildren(current,workInProgress,nextChildren,renderLanes);}// Memoize state using the values we just used to render.
// TODO: Restructure so we never read values from the instance.
workInProgress.memoizedState=instance.state;// The context might have changed so we need to recalculate it.
if(hasContext){invalidateContextProvider(workInProgress,Component,true);}returnworkInProgress.child;}functionpushHostRootContext(workInProgress){varroot=workInProgress.stateNode;if(root.pendingContext){pushTopLevelContextObject(workInProgress,root.pendingContext,root.pendingContext!==root.context);}elseif(root.context){// Should always be set
pushTopLevelContextObject(workInProgress,root.context,false);}pushHostContainer(workInProgress,root.containerInfo);}functionupdateHostRoot(current,workInProgress,renderLanes){pushHostRootContext(workInProgress);varupdateQueue=workInProgress.updateQueue;if(!(current!==null&&updateQueue!==null)){{throwError("If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue.");}}varnextProps=workInProgress.pendingProps;varprevState=workInProgress.memoizedState;varprevChildren=prevState!==null?prevState.element:null;cloneUpdateQueue(current,workInProgress);processUpdateQueue(workInProgress,nextProps,null,renderLanes);varnextState=workInProgress.memoizedState;// Caution: React DevTools currently depends on this property
// being called "element".
varnextChildren=nextState.element;if(nextChildren===prevChildren){resetHydrationState();returnbailoutOnAlreadyFinishedWork(current,workInProgress,renderLanes);}varroot=workInProgress.stateNode;if(root.hydrate&&enterHydrationState(workInProgress)){// If we don't have any current children this might be the first pass.
// We always try to hydrate. If this isn't a hydration pass there won't
// be any children to hydrate which is effectively the same thing as
// not hydrating.
{varmutableSourceEagerHydrationData=root.mutableSourceEagerHydrationData;if(mutableSourceEagerHydrationData!=null){for(vari=0;i<mutableSourceEagerHydrationData.length;i+=2){varmutableSource=mutableSourceEagerHydrationData[i];varversion=mutableSourceEagerHydrationData[i+1];setWorkInProgressVersion(mutableSource,version);}}}varchild=mountChildFibers(workInProgress,null,nextChildren,renderLanes);workInProgress.child=child;varnode=child;while(node){// Mark each child as hydrating. This is a fast path to know whether this
// tree is part of a hydrating tree. This is used to determine if a child
// node has fully mounted yet, and for scheduling event replaying.
// Conceptually this is similar to Placement in that a new subtree is
// inserted into the React tree here. It just happens to not need DOM
// mutations because it already exists.
node.flags=node.flags&~Placement|Hydrating;node=node.sibling;}}else{// Otherwise reset hydration state in case we aborted and resumed another
// root.
reconcileChildren(current,workInProgress,nextChildren,renderLanes);resetHydrationState();}returnworkInProgress.child;}functionupdateHostComponent(current,workInProgress,renderLanes){pushHostContext(workInProgress);if(current===null){tryToClaimNextHydratableInstance(workInProgress);}vartype=workInProgress.type;varnextProps=workInProgress.pendingProps;varprevProps=current!==null?current.memoizedProps:null;varnextChildren=nextProps.children;varisDirectTextChild=shouldSetTextContent(type,nextProps);if(isDirectTextChild){// We special case a direct text child of a host node. This is a common
// case. We won't handle it as a reified child. We will instead handle
// this in the host environment that also has access to this prop. That
// avoids allocating another HostText fiber and traversing it.
nextChildren=null;}elseif(prevProps!==null&&shouldSetTextContent(type,prevProps)){// If we're switching from a direct text child to a normal child, or to
// empty, we need to schedule the text content to be reset.
workInProgress.flags|=ContentReset;}markRef(current,workInProgress);reconcileChildren(current,workInProgress,nextChildren,renderLanes);returnworkInProgress.child;}functionupdateHostText(current,workInProgress){if(current===null){tryToClaimNextHydratableInstance(workInProgress);}// Nothing to do here. This is terminal. We'll do the completion step
// immediately after.
returnnull;}functionmountLazyComponent(_current,workInProgress,elementType,updateLanes,renderLanes){if(_current!==null){// A lazy component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate=null;workInProgress.alternate=null;// Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags|=Placement;}varprops=workInProgress.pendingProps;varlazyComponent=elementType;varpayload=lazyComponent._payload;varinit=lazyComponent._init;varComponent=init(payload);// Store the unwrapped component in the type.
workInProgress.type=Component;varresolvedTag=workInProgress.tag=resolveLazyComponentTag(Component);varresolvedProps=resolveDefaultProps(Component,props);varchild;switch(resolvedTag){caseFunctionComponent:{{validateFunctionComponentInDev(workInProgress,Component);workInProgress.type=Component=resolveFunctionForHotReloading(Component);}child=updateFunctionComponent(null,workInProgress,Component,resolvedProps,renderLanes);returnchild;}caseClassComponent:{{workInProgress.type=Component=resolveClassForHotReloading(Component);}child=updateClassComponent(null,workInProgress,Component,resolvedProps,renderLanes);returnchild;}caseForwardRef:{{workInProgress.type=Component=resolveForwardRefForHotReloading(Component);}child=updateForwardRef(null,workInProgress,Component,resolvedProps,renderLanes);returnchild;}caseMemoComponent:{{if(workInProgress.type!==workInProgress.elementType){varouterPropTypes=Component.propTypes;if(outerPropTypes){checkPropTypes(outerPropTypes,resolvedProps,// Resolved for outer only
'prop',getComponentName(Component));}}}child=updateMemoComponent(null,workInProgress,Component,resolveDefaultProps(Component.type,resolvedProps),// The inner type can have defaults too
updateLanes,renderLanes);returnchild;}}varhint='';{if(Component!==null&&typeofComponent==='object'&&Component.$$typeof===REACT_LAZY_TYPE){hint=' Did you wrap a component in React.lazy() more than once?';}}// This message intentionally doesn't mention ForwardRef or MemoComponent
// because the fact that it's a separate type of work is an
// implementation detail.
{{throwError("Element type is invalid. Received a promise that resolves to: "+Component+". Lazy element type must resolve to a class or function."+hint);}}}functionmountIncompleteClassComponent(_current,workInProgress,Component,nextProps,renderLanes){if(_current!==null){// An incomplete component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate=null;workInProgress.alternate=null;// Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags|=Placement;}// Promote the fiber to a class and try rendering again.
workInProgress.tag=ClassComponent;// The rest of this function is a fork of `updateClassComponent`
// Push context providers early to prevent context stack mismatches.
// During mounting we don't know the child context yet as the instance doesn't exist.
// We will invalidate the child context in finishClassComponent() right after rendering.
varhasContext;if(isContextProvider(Component)){hasContext=true;pushContextProvider(workInProgress);}else{hasContext=false;}prepareToReadContext(workInProgress,renderLanes);constructClassInstance(workInProgress,Component,nextProps);mountClassInstance(workInProgress,Component,nextProps,renderLanes);returnfinishClassComponent(null,workInProgress,Component,true,hasContext,renderLanes);}functionmountIndeterminateComponent(_current,workInProgress,Component,renderLanes){if(_current!==null){// An indeterminate component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate=null;workInProgress.alternate=null;// Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags|=Placement;}varprops=workInProgress.pendingProps;varcontext;{varunmaskedContext=getUnmaskedContext(workInProgress,Component,false);context=getMaskedContext(workInProgress,unmaskedContext);}prepareToReadContext(workInProgress,renderLanes);varvalue;{if(Component.prototype&&typeofComponent.prototype.render==='function'){varcomponentName=getComponentName(Component)||'Unknown';if(!didWarnAboutBadClass[componentName]){error("The <%s /> component appears to have a render method, but doesn't extend React.Component. "+'This is likely to cause errors. Change %s to extend React.Component instead.',componentName,componentName);didWarnAboutBadClass[componentName]=true;}}if(workInProgress.mode&StrictMode){ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress,null);}setIsRendering(true);ReactCurrentOwner$1.current=workInProgress;value=renderWithHooks(null,workInProgress,Component,props,context,renderLanes);setIsRendering(false);}// React DevTools reads this flag.
workInProgress.flags|=PerformedWork;{// Support for module components is deprecated and is removed behind a flag.
// Whether or not it would crash later, we want to show a good message in DEV first.
if(typeofvalue==='object'&&value!==null&&typeofvalue.render==='function'&&value.$$typeof===undefined){var_componentName=getComponentName(Component)||'Unknown';if(!didWarnAboutModulePatternComponent[_componentName]){error('The <%s /> component appears to be a function component that returns a class instance. '+'Change %s to a class that extends React.Component instead. '+"If you can't use a class try assigning the prototype on the function as a workaround. "+"`%s.prototype = React.Component.prototype`. Don't use an arrow function since it "+'cannot be called with `new` by React.',_componentName,_componentName,_componentName);didWarnAboutModulePatternComponent[_componentName]=true;}}}if(// Run these checks in production only if the flag is off.
// Eventually we'll delete this branch altogether.
typeofvalue==='object'&&value!==null&&typeofvalue.render==='function'&&value.$$typeof===undefined){{var_componentName2=getComponentName(Component)||'Unknown';if(!didWarnAboutModulePatternComponent[_componentName2]){error('The <%s /> component appears to be a function component that returns a class instance. '+'Change %s to a class that extends React.Component instead. '+"If you can't use a class try assigning the prototype on the function as a workaround. "+"`%s.prototype = React.Component.prototype`. Don't use an arrow function since it "+'cannot be called with `new` by React.',_componentName2,_componentName2,_componentName2);didWarnAboutModulePatternComponent[_componentName2]=true;}}// Proceed under the assumption that this is a class instance
workInProgress.tag=ClassComponent;// Throw out any hooks that were used.
workInProgress.memoizedState=null;workInProgress.updateQueue=null;// Push context providers early to prevent context stack mismatches.
// During mounting we don't know the child context yet as the instance doesn't exist.
// We will invalidate the child context in finishClassComponent() right after rendering.
varhasContext=false;if(isContextProvider(Component)){hasContext=true;pushContextProvider(workInProgress);}else{hasContext=false;}workInProgress.memoizedState=value.state!==null&&value.state!==undefined?value.state:null;initializeUpdateQueue(workInProgress);vargetDerivedStateFromProps=Component.getDerivedStateFromProps;if(typeofgetDerivedStateFromProps==='function'){applyDerivedStateFromProps(workInProgress,Component,getDerivedStateFromProps,props);}adoptClassInstance(workInProgress,value);mountClassInstance(workInProgress,Component,props,renderLanes);returnfinishClassComponent(null,workInProgress,Component,true,hasContext,renderLanes);}else{// Proceed under the assumption that this is a function component
workInProgress.tag=FunctionComponent;{if(workInProgress.mode&StrictMode){disableLogs();try{value=renderWithHooks(null,workInProgress,Component,props,context,renderLanes);}finally{reenableLogs();}}}reconcileChildren(null,workInProgress,value,renderLanes);{validateFunctionComponentInDev(workInProgress,Component);}returnworkInProgress.child;}}functionvalidateFunctionComponentInDev(workInProgress,Component){{if(Component){if(Component.childContextTypes){error('%s(...): childContextTypes cannot be defined on a function component.',Component.displayName||Component.name||'Component');}}if(workInProgress.ref!==null){varinfo='';varownerName=getCurrentFiberOwnerNameInDevOrNull();if(ownerName){info+='\n\nCheck the render method of `'+ownerName+'`.';}varwarningKey=ownerName||workInProgress._debugID||'';vardebugSource=workInProgress._debugSource;if(debugSource){warningKey=debugSource.fileName+':'+debugSource.lineNumber;}if(!didWarnAboutFunctionRefs[warningKey]){didWarnAboutFunctionRefs[warningKey]=true;error('Function components cannot be given refs. '+'Attempts to access this ref will fail. '+'Did you mean to use React.forwardRef()?%s',info);}}if(typeofComponent.getDerivedStateFromProps==='function'){var_componentName3=getComponentName(Component)||'Unknown';if(!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]){error('%s: Function components do not support getDerivedStateFromProps.',_componentName3);didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]=true;}}if(typeofComponent.contextType==='object'&&Component.contextType!==null){var_componentName4=getComponentName(Component)||'Unknown';if(!didWarnAboutContextTypeOnFunctionComponent[_componentName4]){error('%s: Function components do not support contextType.',_componentName4);didWarnAboutContextTypeOnFunctionComponent[_componentName4]=true;}}}}varSUSPENDED_MARKER={dehydrated:null,retryLane:NoLane};functionmountSuspenseOffscreenState(renderLanes){return{baseLanes:renderLanes};}functionupdateSuspenseOffscreenState(prevOffscreenState,renderLanes){return{baseLanes:mergeLanes(prevOffscreenState.baseLanes,renderLanes)};}// TODO: Probably should inline this back
functionshouldRemainOnFallback(suspenseContext,current,workInProgress,renderLanes){// If we're already showing a fallback, there are cases where we need to
// remain on that fallback regardless of whether the content has resolved.
// For example, SuspenseList coordinates when nested content appears.
if(current!==null){varsuspenseState=current.memoizedState;if(suspenseState===null){// Currently showing content. Don't hide it, even if ForceSuspenseFallack
// is true. More precise name might be "ForceRemainSuspenseFallback".
// Note: This is a factoring smell. Can't remain on a fallback if there's
// no fallback to remain on.
returnfalse;}}// Not currently showing content. Consult the Suspense context.
returnhasSuspenseContext(suspenseContext,ForceSuspenseFallback);}functiongetRemainingWorkInPrimaryTree(current,renderLanes){// TODO: Should not remove render lanes that were pinged during this render
returnremoveLanes(current.childLanes,renderLanes);}functionupdateSuspenseComponent(current,workInProgress,renderLanes){varnextProps=workInProgress.pendingProps;// This is used by DevTools to force a boundary to suspend.
{if(shouldSuspend(workInProgress)){workInProgress.flags|=DidCapture;}}varsuspenseContext=suspenseStackCursor.current;varshowFallback=false;vardidSuspend=(workInProgress.flags&DidCapture)!==NoFlags;if(didSuspend||shouldRemainOnFallback(suspenseContext,current)){// Something in this boundary's subtree already suspended. Switch to
// rendering the fallback children.
showFallback=true;workInProgress.flags&=~DidCapture;}else{// Attempting the main content
if(current===null||current.memoizedState!==null){// This is a new mount or this boundary is already showing a fallback state.
// Mark this subtree context as having at least one invisible parent that could
// handle the fallback state.
// Boundaries without fallbacks or should be avoided are not considered since
// they cannot handle preferred fallback states.
if(nextProps.fallback!==undefined&&nextProps.unstable_avoidThisFallback!==true){suspenseContext=addSubtreeSuspenseContext(suspenseContext,InvisibleParentSuspenseContext);}}}suspenseContext=setDefaultShallowSuspenseContext(suspenseContext);pushSuspenseContext(workInProgress,suspenseContext);// OK, the next part is confusing. We're about to reconcile the Suspense
// boundary's children. This involves some custom reconcilation logic. Two
// main reasons this is so complicated.
//
// First, Legacy Mode has different semantics for backwards compatibility. The
// primary tree will commit in an inconsistent state, so when we do the
// second pass to render the fallback, we do some exceedingly, uh, clever
// hacks to make that not totally break. Like transferring effects and
// deletions from hidden tree. In Concurrent Mode, it's much simpler,
// because we bailout on the primary tree completely and leave it in its old
// state, no effects. Same as what we do for Offscreen (except that
// Offscreen doesn't have the first render pass).
//
// Second is hydration. During hydration, the Suspense fiber has a slightly
// different layout, where the child points to a dehydrated fragment, which
// contains the DOM rendered by the server.
//
// Third, even if you set all that aside, Suspense is like error boundaries in
// that we first we try to render one tree, and if that fails, we render again
// and switch to a different tree. Like a try/catch block. So we have to track
// which branch we're currently rendering. Ideally we would model this using
// a stack.
if(current===null){// Initial mount
// If we're currently hydrating, try to hydrate this boundary.
// But only if this has a fallback.
if(nextProps.fallback!==undefined){tryToClaimNextHydratableInstance(workInProgress);// This could've been a dehydrated suspense component.
}varnextPrimaryChildren=nextProps.children;varnextFallbackChildren=nextProps.fallback;if(showFallback){varfallbackFragment=mountSuspenseFallbackChildren(workInProgress,nextPrimaryChildren,nextFallbackChildren,renderLanes);varprimaryChildFragment=workInProgress.child;primaryChildFragment.memoizedState=mountSuspenseOffscreenState(renderLanes);workInProgress.memoizedState=SUSPENDED_MARKER;returnfallbackFragment;}elseif(typeofnextProps.unstable_expectedLoadTime==='number'){// This is a CPU-bound tree. Skip this tree and show a placeholder to
// unblock the surrounding content. Then immediately retry after the
// initial commit.
var_fallbackFragment=mountSuspenseFallbackChildren(workInProgress,nextPrimaryChildren,nextFallbackChildren,renderLanes);var_primaryChildFragment=workInProgress.child;_primaryChildFragment.memoizedState=mountSuspenseOffscreenState(renderLanes);workInProgress.memoizedState=SUSPENDED_MARKER;// Since nothing actually suspended, there will nothing to ping this to
// get it started back up to attempt the next item. While in terms of
// priority this work has the same priority as this current render, it's
// not part of the same transition once the transition has committed. If
// it's sync, we still want to yield so that it can be painted.
// Conceptually, this is really the same as pinging. We can use any
// RetryLane even if it's the one currently rendering since we're leaving
// it behind on this node.
workInProgress.lanes=SomeRetryLane;{markSpawnedWork(SomeRetryLane);}return_fallbackFragment;}else{returnmountSuspensePrimaryChildren(workInProgress,nextPrimaryChildren,renderLanes);}}else{// This is an update.
// If the current fiber has a SuspenseState, that means it's already showing
// a fallback.
varprevState=current.memoizedState;if(prevState!==null){if(showFallback){var_nextFallbackChildren2=nextProps.fallback;var_nextPrimaryChildren2=nextProps.children;var_fallbackChildFragment=updateSuspenseFallbackChildren(current,workInProgress,_nextPrimaryChildren2,_nextFallbackChildren2,renderLanes);var_primaryChildFragment3=workInProgress.child;varprevOffscreenState=current.child.memoizedState;_primaryChildFragment3.memoizedState=prevOffscreenState===null?mountSuspenseOffscreenState(renderLanes):updateSuspenseOffscreenState(prevOffscreenState,renderLanes);_primaryChildFragment3.childLanes=getRemainingWorkInPrimaryTree(current,renderLanes);workInProgress.memoizedState=SUSPENDED_MARKER;return_fallbackChildFragment;}else{var_nextPrimaryChildren3=nextProps.children;var_primaryChildFragment4=updateSuspensePrimaryChildren(current,workInProgress,_nextPrimaryChildren3,renderLanes);workInProgress.memoizedState=null;return_primaryChildFragment4;}}else{// The current tree is not already showing a fallback.
if(showFallback){// Timed out.
var_nextFallbackChildren3=nextProps.fallback;var_nextPrimaryChildren4=nextProps.children;var_fallbackChildFragment2=updateSuspenseFallbackChildren(current,workInProgress,_nextPrimaryChildren4,_nextFallbackChildren3,renderLanes);var_primaryChildFragment5=workInProgress.child;var_prevOffscreenState=current.child.memoizedState;_primaryChildFragment5.memoizedState=_prevOffscreenState===null?mountSuspenseOffscreenState(renderLanes):updateSuspenseOffscreenState(_prevOffscreenState,renderLanes);_primaryChildFragment5.childLanes=getRemainingWorkInPrimaryTree(current,renderLanes);// Skip the primary children, and continue working on the
// fallback children.
workInProgress.memoizedState=SUSPENDED_MARKER;return_fallbackChildFragment2;}else{// Still haven't timed out. Continue rendering the children, like we
// normally do.
var_nextPrimaryChildren5=nextProps.children;var_primaryChildFragment6=updateSuspensePrimaryChildren(current,workInProgress,_nextPrimaryChildren5,renderLanes);workInProgress.memoizedState=null;return_primaryChildFragment6;}}}}functionmountSuspensePrimaryChildren(workInProgress,primaryChildren,renderLanes){varmode=workInProgress.mode;varprimaryChildProps={mode:'visible',children:primaryChildren};varprimaryChildFragment=createFiberFromOffscreen(primaryChildProps,mode,renderLanes,null);primaryChildFragment.return=workInProgress;workInProgress.child=primaryChildFragment;returnprimaryChildFragment;}functionmountSuspenseFallbackChildren(workInProgress,primaryChildren,fallbackChildren,renderLanes){varmode=workInProgress.mode;varprogressedPrimaryFragment=workInProgress.child;varprimaryChildProps={mode:'hidden',children:primaryChildren};varprimaryChildFragment;varfallbackChildFragment;if((mode&BlockingMode)===NoMode&&progressedPrimaryFragment!==null){// In legacy mode, we commit the primary tree as if it successfully
// completed, even though it's in an inconsistent state.
primaryChildFragment=progressedPrimaryFragment;primaryChildFragment.childLanes=NoLanes;primaryChildFragment.pendingProps=primaryChildProps;if(workInProgress.mode&ProfileMode){// Reset the durations from the first pass so they aren't included in the
// final amounts. This seems counterintuitive, since we're intentionally
// not measuring part of the render phase, but this makes it match what we
// do in Concurrent Mode.
primaryChildFragment.actualDuration=0;primaryChildFragment.actualStartTime=-1;primaryChildFragment.selfBaseDuration=0;primaryChildFragment.treeBaseDuration=0;}fallbackChildFragment=createFiberFromFragment(fallbackChildren,mode,renderLanes,null);}else{primaryChildFragment=createFiberFromOffscreen(primaryChildProps,mode,NoLanes,null);fallbackChildFragment=createFiberFromFragment(fallbackChildren,mode,renderLanes,null);}primaryChildFragment.return=workInProgress;fallbackChildFragment.return=workInProgress;primaryChildFragment.sibling=fallbackChildFragment;workInProgress.child=primaryChildFragment;returnfallbackChildFragment;}functioncreateWorkInProgressOffscreenFiber(current,offscreenProps){// The props argument to `createWorkInProgress` is `any` typed, so we use this
// wrapper function to constrain it.
returncreateWorkInProgress(current,offscreenProps);}functionupdateSuspensePrimaryChildren(current,workInProgress,primaryChildren,renderLanes){varcurrentPrimaryChildFragment=current.child;varcurrentFallbackChildFragment=currentPrimaryChildFragment.sibling;varprimaryChildFragment=createWorkInProgressOffscreenFiber(currentPrimaryChildFragment,{mode:'visible',children:primaryChildren});if((workInProgress.mode&BlockingMode)===NoMode){primaryChildFragment.lanes=renderLanes;}primaryChildFragment.return=workInProgress;primaryChildFragment.sibling=null;if(currentFallbackChildFragment!==null){// Delete the fallback child fragment
currentFallbackChildFragment.nextEffect=null;currentFallbackChildFragment.flags=Deletion;workInProgress.firstEffect=workInProgress.lastEffect=currentFallbackChildFragment;}workInProgress.child=primaryChildFragment;returnprimaryChildFragment;}functionupdateSuspenseFallbackChildren(current,workInProgress,primaryChildren,fallbackChildren,renderLanes){varmode=workInProgress.mode;varcurrentPrimaryChildFragment=current.child;varcurrentFallbackChildFragment=currentPrimaryChildFragment.sibling;varprimaryChildProps={mode:'hidden',children:primaryChildren};varprimaryChildFragment;if(// In legacy mode, we commit the primary tree as if it successfully
// completed, even though it's in an inconsistent state.
(mode&BlockingMode)===NoMode&&// Make sure we're on the second pass, i.e. the primary child fragment was
// already cloned. In legacy mode, the only case where this isn't true is
// when DevTools forces us to display a fallback; we skip the first render
// pass entirely and go straight to rendering the fallback. (In Concurrent
// Mode, SuspenseList can also trigger this scenario, but this is a legacy-
// only codepath.)
workInProgress.child!==currentPrimaryChildFragment){varprogressedPrimaryFragment=workInProgress.child;primaryChildFragment=progressedPrimaryFragment;primaryChildFragment.childLanes=NoLanes;primaryChildFragment.pendingProps=primaryChildProps;if(workInProgress.mode&ProfileMode){// Reset the durations from the first pass so they aren't included in the
// final amounts. This seems counterintuitive, since we're intentionally
// not measuring part of the render phase, but this makes it match what we
// do in Concurrent Mode.
primaryChildFragment.actualDuration=0;primaryChildFragment.actualStartTime=-1;primaryChildFragment.selfBaseDuration=currentPrimaryChildFragment.selfBaseDuration;primaryChildFragment.treeBaseDuration=currentPrimaryChildFragment.treeBaseDuration;}// The fallback fiber was added as a deletion effect during the first pass.
// However, since we're going to remain on the fallback, we no longer want
// to delete it. So we need to remove it from the list. Deletions are stored
// on the same list as effects. We want to keep the effects from the primary
// tree. So we copy the primary child fragment's effect list, which does not
// include the fallback deletion effect.
varprogressedLastEffect=primaryChildFragment.lastEffect;if(progressedLastEffect!==null){workInProgress.firstEffect=primaryChildFragment.firstEffect;workInProgress.lastEffect=progressedLastEffect;progressedLastEffect.nextEffect=null;}else{// TODO: Reset this somewhere else? Lol legacy mode is so weird.
workInProgress.firstEffect=workInProgress.lastEffect=null;}}else{primaryChildFragment=createWorkInProgressOffscreenFiber(currentPrimaryChildFragment,primaryChildProps);}varfallbackChildFragment;if(currentFallbackChildFragment!==null){fallbackChildFragment=createWorkInProgress(currentFallbackChildFragment,fallbackChildren);}else{fallbackChildFragment=createFiberFromFragment(fallbackChildren,mode,renderLanes,null);// Needs a placement effect because the parent (the Suspense boundary) already
// mounted but this is a new fiber.
fallbackChildFragment.flags|=Placement;}fallbackChildFragment.return=workInProgress;primaryChildFragment.return=workInProgress;primaryChildFragment.sibling=fallbackChildFragment;workInProgress.child=primaryChildFragment;returnfallbackChildFragment;}functionscheduleWorkOnFiber(fiber,renderLanes){fiber.lanes=mergeLanes(fiber.lanes,renderLanes);varalternate=fiber.alternate;if(alternate!==null){alternate.lanes=mergeLanes(alternate.lanes,renderLanes);}scheduleWorkOnParentPath(fiber.return,renderLanes);}functionpropagateSuspenseContextChange(workInProgress,firstChild,renderLanes){// Mark any Suspense boundaries with fallbacks as having work to do.
// If they were previously forced into fallbacks, they may now be able
// to unblock.
varnode=firstChild;while(node!==null){if(node.tag===SuspenseComponent){varstate=node.memoizedState;if(state!==null){scheduleWorkOnFiber(node,renderLanes);}}elseif(node.tag===SuspenseListComponent){// If the tail is hidden there might not be an Suspense boundaries
// to schedule work on. In this case we have to schedule it on the
// list itself.
// We don't have to traverse to the children of the list since
// the list will propagate the change when it rerenders.
scheduleWorkOnFiber(node,renderLanes);}elseif(node.child!==null){node.child.return=node;node=node.child;continue;}if(node===workInProgress){return;}while(node.sibling===null){if(node.return===null||node.return===workInProgress){return;}node=node.return;}node.sibling.return=node.return;node=node.sibling;}}functionfindLastContentRow(firstChild){// This is going to find the last row among these children that is already
// showing content on the screen, as opposed to being in fallback state or
// new. If a row has multiple Suspense boundaries, any of them being in the
// fallback state, counts as the whole row being in a fallback state.
// Note that the "rows" will be workInProgress, but any nested children
// will still be current since we haven't rendered them yet. The mounted
// order may not be the same as the new order. We use the new order.
varrow=firstChild;varlastContentRow=null;while(row!==null){varcurrentRow=row.alternate;// New rows can't be content rows.
if(currentRow!==null&&findFirstSuspended(currentRow)===null){lastContentRow=row;}row=row.sibling;}returnlastContentRow;}functionvalidateRevealOrder(revealOrder){{if(revealOrder!==undefined&&revealOrder!=='forwards'&&revealOrder!=='backwards'&&revealOrder!=='together'&&!didWarnAboutRevealOrder[revealOrder]){didWarnAboutRevealOrder[revealOrder]=true;if(typeofrevealOrder==='string'){switch(revealOrder.toLowerCase()){case'together':case'forwards':case'backwards':{error('"%s" is not a valid value for revealOrder on <SuspenseList />. '+'Use lowercase "%s" instead.',revealOrder,revealOrder.toLowerCase());break;}case'forward':case'backward':{error('"%s" is not a valid value for revealOrder on <SuspenseList />. '+'React uses the -s suffix in the spelling. Use "%ss" instead.',revealOrder,revealOrder.toLowerCase());break;}default:error('"%s" is not a supported revealOrder on <SuspenseList />. '+'Did you mean "together", "forwards" or "backwards"?',revealOrder);break;}}else{error('%s is not a supported value for revealOrder on <SuspenseList />. '+'Did you mean "together", "forwards" or "backwards"?',revealOrder);}}}}functionvalidateTailOptions(tailMode,revealOrder){{if(tailMode!==undefined&&!didWarnAboutTailOptions[tailMode]){if(tailMode!=='collapsed'&&tailMode!=='hidden'){didWarnAboutTailOptions[tailMode]=true;error('"%s" is not a supported value for tail on <SuspenseList />. '+'Did you mean "collapsed" or "hidden"?',tailMode);}elseif(revealOrder!=='forwards'&&revealOrder!=='backwards'){didWarnAboutTailOptions[tailMode]=true;error('<SuspenseList tail="%s" /> is only valid if revealOrder is '+'"forwards" or "backwards". '+'Did you mean to specify revealOrder="forwards"?',tailMode);}}}}functionvalidateSuspenseListNestedChild(childSlot,index){{varisArray=Array.isArray(childSlot);varisIterable=!isArray&&typeofgetIteratorFn(childSlot)==='function';if(isArray||isIterable){vartype=isArray?'array':'iterable';error('A nested %s was passed to row #%s in <SuspenseList />. Wrap it in '+'an additional SuspenseList to configure its revealOrder: '+'<SuspenseList revealOrder=...> ... '+'<SuspenseList revealOrder=...>{%s}</SuspenseList> ... '+'</SuspenseList>',type,index,type);returnfalse;}}returntrue;}functionvalidateSuspenseListChildren(children,revealOrder){{if((revealOrder==='forwards'||revealOrder==='backwards')&&children!==undefined&&children!==null&&children!==false){if(Array.isArray(children)){for(vari=0;i<children.length;i++){if(!validateSuspenseListNestedChild(children[i],i)){return;}}}else{variteratorFn=getIteratorFn(children);if(typeofiteratorFn==='function'){varchildrenIterator=iteratorFn.call(children);if(childrenIterator){varstep=childrenIterator.next();var_i=0;for(;!step.done;step=childrenIterator.next()){if(!validateSuspenseListNestedChild(step.value,_i)){return;}_i++;}}}else{error('A single row was passed to a <SuspenseList revealOrder="%s" />. '+'This is not useful since it needs multiple rows. '+'Did you mean to pass multiple children or an array?',revealOrder);}}}}}functioninitSuspenseListRenderState(workInProgress,isBackwards,tail,lastContentRow,tailMode,lastEffectBeforeRendering){varrenderState=workInProgress.memoizedState;if(renderState===null){workInProgress.memoizedState={isBackwards:isBackwards,rendering:null,renderingStartTime:0,last:lastContentRow,tail:tail,tailMode:tailMode,lastEffect:lastEffectBeforeRendering};}else{// We can reuse the existing object from previous renders.
renderState.isBackwards=isBackwards;renderState.rendering=null;renderState.renderingStartTime=0;renderState.last=lastContentRow;renderState.tail=tail;renderState.tailMode=tailMode;renderState.lastEffect=lastEffectBeforeRendering;}}// This can end up rendering this component multiple passes.
// The first pass splits the children fibers into two sets. A head and tail.
// We first render the head. If anything is in fallback state, we do another
// pass through beginWork to rerender all children (including the tail) with
// the force suspend context. If the first render didn't have anything in
// in fallback state. Then we render each row in the tail one-by-one.
// That happens in the completeWork phase without going back to beginWork.
functionupdateSuspenseListComponent(current,workInProgress,renderLanes){varnextProps=workInProgress.pendingProps;varrevealOrder=nextProps.revealOrder;vartailMode=nextProps.tail;varnewChildren=nextProps.children;validateRevealOrder(revealOrder);validateTailOptions(tailMode,revealOrder);validateSuspenseListChildren(newChildren,revealOrder);reconcileChildren(current,workInProgress,newChildren,renderLanes);varsuspenseContext=suspenseStackCursor.current;varshouldForceFallback=hasSuspenseContext(suspenseContext,ForceSuspenseFallback);if(shouldForceFallback){suspenseContext=setShallowSuspenseContext(suspenseContext,ForceSuspenseFallback);workInProgress.flags|=DidCapture;}else{vardidSuspendBefore=current!==null&&(current.flags&DidCapture)!==NoFlags;if(didSuspendBefore){// If we previously forced a fallback, we need to schedule work
// on any nested boundaries to let them know to try to render
// again. This is the same as context updating.
propagateSuspenseContextChange(workInProgress,workInProgress.child,renderLanes);}suspenseContext=setDefaultShallowSuspenseContext(suspenseContext);}pushSuspenseContext(workInProgress,suspenseContext);if((workInProgress.mode&BlockingMode)===NoMode){// In legacy mode, SuspenseList doesn't work so we just
// use make it a noop by treating it as the default revealOrder.
workInProgress.memoizedState=null;}else{switch(revealOrder){case'forwards':{varlastContentRow=findLastContentRow(workInProgress.child);vartail;if(lastContentRow===null){// The whole list is part of the tail.
// TODO: We could fast path by just rendering the tail now.
tail=workInProgress.child;workInProgress.child=null;}else{// Disconnect the tail rows after the content row.
tail,lastContentRow,tailMode,workInProgress.lastEffect);break;}case'backwards':{// We're going to find the first row that has existing content.
// At the same time we're going to reverse the list of everything
// we pass in the meantime. That's going to be our tail in reverse
// order.
var_tail=null;varrow=workInProgress.child;workInProgress.child=null;while(row!==null){varcurrentRow=row.alternate;// New rows can't be content rows.
if(currentRow!==null&&findFirstSuspended(currentRow)===null){// This is the beginning of the main content.
workInProgress.child=row;break;}varnextRow=row.sibling;row.sibling=_tail;_tail=row;row=nextRow;}// TODO: If workInProgress.child is null, we can continue on the tail immediately.
undefined,workInProgress.lastEffect);break;}default:{// The default reveal order is the same as not having
// a boundary.
workInProgress.memoizedState=null;}}}returnworkInProgress.child;}functionupdatePortalComponent(current,workInProgress,renderLanes){pushHostContainer(workInProgress,workInProgress.stateNode.containerInfo);varnextChildren=workInProgress.pendingProps;if(current===null){// Portals are special because we don't append the children during mount
// but at commit. Therefore we need to track insertions which the normal
// flow doesn't do during mount. This doesn't happen at the root because
// the root always starts with a "current" with a null child.
// TODO: Consider unifying this with how the root works.
workInProgress.child=reconcileChildFibers(workInProgress,null,nextChildren,renderLanes);}else{reconcileChildren(current,workInProgress,nextChildren,renderLanes);}returnworkInProgress.child;}varhasWarnedAboutUsingNoValuePropOnContextProvider=false;functionupdateContextProvider(current,workInProgress,renderLanes){varproviderType=workInProgress.type;varcontext=providerType._context;varnewProps=workInProgress.pendingProps;varoldProps=workInProgress.memoizedProps;varnewValue=newProps.value;{if(!('value'innewProps)){if(!hasWarnedAboutUsingNoValuePropOnContextProvider){hasWarnedAboutUsingNoValuePropOnContextProvider=true;error('The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?');}}varproviderPropTypes=workInProgress.type.propTypes;if(providerPropTypes){checkPropTypes(providerPropTypes,newProps,'prop','Context.Provider');}}pushProvider(workInProgress,newValue);if(oldProps!==null){varoldValue=oldProps.value;varchangedBits=calculateChangedBits(context,newValue,oldValue);if(changedBits===0){// No change. Bailout early if children are the same.
if(oldProps.children===newProps.children&&!hasContextChanged()){returnbailoutOnAlreadyFinishedWork(current,workInProgress,renderLanes);}}else{// The context value changed. Search for matching consumers and schedule
// them to update.
propagateContextChange(workInProgress,context,changedBits,renderLanes);}}varnewChildren=newProps.children;reconcileChildren(current,workInProgress,newChildren,renderLanes);returnworkInProgress.child;}varhasWarnedAboutUsingContextAsConsumer=false;functionupdateContextConsumer(current,workInProgress,renderLanes){varcontext=workInProgress.type;// The logic below for Context differs depending on PROD or DEV mode. In
// DEV mode, we create a separate object for Context.Consumer that acts
// like a proxy to Context. This proxy object adds unnecessary code in PROD
// so we use the old behaviour (Context.Consumer references Context) to
// reduce size and overhead. The separate object references context via
// a property called "_context", which also gives us the ability to check
// in DEV mode if this property exists or not and warn if it does not.
{if(context._context===undefined){// This may be because it's a Context (rather than a Consumer).
// Or it may be because it's older React where they're the same thing.
// We only want to warn if we're sure it's a new React.
if(context!==context.Consumer){if(!hasWarnedAboutUsingContextAsConsumer){hasWarnedAboutUsingContextAsConsumer=true;error('Rendering <Context> directly is not supported and will be removed in '+'a future major release. Did you mean to render <Context.Consumer> instead?');}}}else{context=context._context;}}varnewProps=workInProgress.pendingProps;varrender=newProps.children;{if(typeofrender!=='function'){error('A context consumer was rendered with multiple children, or a child '+"that isn't a function. A context consumer expects a single child "+'that is a function. If you did pass a function, make sure there '+'is no trailing or leading whitespace around it.');}}prepareToReadContext(workInProgress,renderLanes);varnewValue=readContext(context,newProps.unstable_observedBits);varnewChildren;{ReactCurrentOwner$1.current=workInProgress;setIsRendering(true);newChildren=render(newValue);setIsRendering(false);}// React DevTools reads this flag.
workInProgress.dependencies=current.dependencies;}{// Don't update "base" render times for bailouts.
stopProfilerTimerIfRunning();}markSkippedUpdateLanes(workInProgress.lanes);// Check if the children have any pending work.
if(!includesSomeLane(renderLanes,workInProgress.childLanes)){// The children don't have any work either. We can skip them.
// TODO: Once we add back resuming, we should check if the children are
// a work-in-progress set. If so, we need to transfer their effects.
returnnull;}else{// This fiber doesn't have work, but its subtree does. Clone the child
// fibers and continue.
cloneChildFibers(current,workInProgress);returnworkInProgress.child;}}functionremountFiber(current,oldWorkInProgress,newWorkInProgress){{varreturnFiber=oldWorkInProgress.return;if(returnFiber===null){thrownewError('Cannot swap the root fiber.');}// Disconnect from the old current.
// It will get deleted.
current.alternate=null;oldWorkInProgress.alternate=null;// Connect to the new tree.
newWorkInProgress.index=oldWorkInProgress.index;newWorkInProgress.sibling=oldWorkInProgress.sibling;newWorkInProgress.return=oldWorkInProgress.return;newWorkInProgress.ref=oldWorkInProgress.ref;// Replace the child/sibling pointers above it.
if(oldWorkInProgress===returnFiber.child){returnFiber.child=newWorkInProgress;}else{varprevSibling=returnFiber.child;if(prevSibling===null){thrownewError('Expected parent to have a child.');}while(prevSibling.sibling!==oldWorkInProgress){prevSibling=prevSibling.sibling;if(prevSibling===null){thrownewError('Expected to find the previous sibling.');}}prevSibling.sibling=newWorkInProgress;}// Delete the old fiber and place the new one.
// Since the old fiber is disconnected, we have to schedule it manually.
varlast=returnFiber.lastEffect;if(last!==null){last.nextEffect=current;returnFiber.lastEffect=current;}else{returnFiber.firstEffect=returnFiber.lastEffect=current;}current.nextEffect=null;current.flags=Deletion;newWorkInProgress.flags|=Placement;// Restart work from the new fiber.
returnnewWorkInProgress;}}functionbeginWork(current,workInProgress,renderLanes){varupdateLanes=workInProgress.lanes;{if(workInProgress._debugNeedsRemount&¤t!==null){// This will restart the begin phase with a new fiber.
returnremountFiber(current,workInProgress,createFiberFromTypeAndProps(workInProgress.type,workInProgress.key,workInProgress.pendingProps,workInProgress._debugOwner||null,workInProgress.mode,workInProgress.lanes));}}if(current!==null){varoldProps=current.memoizedProps;varnewProps=workInProgress.pendingProps;if(oldProps!==newProps||hasContextChanged()||// Force a re-render if the implementation changed due to hot reload:
workInProgress.type!==current.type){// If props or context changed, mark the fiber as having performed work.
// This may be unset if the props are determined to be equal later (memo).
didReceiveUpdate=true;}elseif(!includesSomeLane(renderLanes,updateLanes)){didReceiveUpdate=false;// This fiber does not have any pending work. Bailout without entering
// the begin phase. There's still some bookkeeping we that needs to be done
// in this optimized path, mostly pushing stuff onto the stack.
switch(workInProgress.tag){caseHostRoot:pushHostRootContext(workInProgress);resetHydrationState();break;caseHostComponent:pushHostContext(workInProgress);break;caseClassComponent:{varComponent=workInProgress.type;if(isContextProvider(Component)){pushContextProvider(workInProgress);}break;}caseHostPortal:pushHostContainer(workInProgress,workInProgress.stateNode.containerInfo);break;caseContextProvider:{varnewValue=workInProgress.memoizedProps.value;pushProvider(workInProgress,newValue);break;}caseProfiler:{// Profiler should only call onRender when one of its descendants actually rendered.
varhasChildWork=includesSomeLane(renderLanes,workInProgress.childLanes);if(hasChildWork){workInProgress.flags|=Update;}// Reset effect durations for the next eventual effect phase.
// These are reset during render to allow the DevTools commit hook a chance to read them,
varstateNode=workInProgress.stateNode;stateNode.effectDuration=0;stateNode.passiveEffectDuration=0;}break;caseSuspenseComponent:{varstate=workInProgress.memoizedState;if(state!==null){// whether to retry the primary children, or to skip over it and
// go straight to the fallback. Check the priority of the primary
// child fragment.
varprimaryChildFragment=workInProgress.child;varprimaryChildLanes=primaryChildFragment.childLanes;if(includesSomeLane(renderLanes,primaryChildLanes)){// The primary children have pending work. Use the normal path
// to attempt to render the primary children again.
returnupdateSuspenseComponent(current,workInProgress,renderLanes);}else{// The primary child fragment does not have pending work marked
// on it
pushSuspenseContext(workInProgress,setDefaultShallowSuspenseContext(suspenseStackCursor.current));// The primary children do not have pending work with sufficient
// priority. Bailout.
varchild=bailoutOnAlreadyFinishedWork(current,workInProgress,renderLanes);if(child!==null){// The fallback children have pending work. Skip over the
// primary children and work on the fallback.
returnchild.sibling;}else{returnnull;}}}else{pushSuspenseContext(workInProgress,setDefaultShallowSuspenseContext(suspenseStackCursor.current));}break;}caseSuspenseListComponent:{vardidSuspendBefore=(current.flags&DidCapture)!==NoFlags;var_hasChildWork=includesSomeLane(renderLanes,workInProgress.childLanes);if(didSuspendBefore){if(_hasChildWork){// If something was in fallback state last time, and we have all the
// same children then we're still in progressive loading state.
// Something might get unblocked by state updates or retries in the
// tree which will affect the tail. So we need to use the normal
// path to compute the correct tail.
returnupdateSuspenseListComponent(current,workInProgress,renderLanes);}// If none of the children had any work, that means that none of
// them got retried so they'll still be blocked in the same way
// as before. We can fast bail out.
workInProgress.flags|=DidCapture;}// If nothing suspended before and we're rendering the same children,
// then the tail doesn't matter. Anything new that suspends will work
// in the "together" mode, so we can continue from the state we had.
varrenderState=workInProgress.memoizedState;if(renderState!==null){// Reset to the "together" mode in case we've started a different
// update in the past but didn't complete it.
renderState.rendering=null;renderState.tail=null;renderState.lastEffect=null;}pushSuspenseContext(workInProgress,suspenseStackCursor.current);if(_hasChildWork){break;}else{// If none of the children had any work, that means that none of
// them got retried so they'll still be blocked in the same way
// as before. We can fast bail out.
returnnull;}}caseOffscreenComponent:caseLegacyHiddenComponent:{// Need to check if the tree still needs to be deferred. This is
// almost identical to the logic used in the normal update path,
// so we'll just enter that. The only difference is we'll bail out
// at the next level instead of this one, because the child props
// have not changed. Which is fine.
// TODO: Probably should refactor `beginWork` to split the bailout
// path from the normal path. I'm tempted to do a labeled break here
// but I won't :)
workInProgress.lanes=NoLanes;returnupdateOffscreenComponent(current,workInProgress,renderLanes);}}returnbailoutOnAlreadyFinishedWork(current,workInProgress,renderLanes);}else{if((current.flags&ForceUpdateForLegacySuspense)!==NoFlags){// This is a special case that only exists for legacy mode.
// See https://github.com/facebook/react/pull/19216.
didReceiveUpdate=true;}else{// An update was scheduled on this fiber, but there are no new props
// nor legacy context. Set this to false. If an update queue or context
// consumer produces a changed value, it will set this to true. Otherwise,
// the component will assume the children have not changed and bail out.
didReceiveUpdate=false;}}}else{didReceiveUpdate=false;}// Before entering the begin phase, clear pending update priority.
// TODO: This assumes that we're about to evaluate the component and process
// the update queue. However, there's an exception: SimpleMemoComponent
// sometimes bails out later in the begin phase. This indicates that we should
// move this assignment out of the common path and into each branch.
workInProgress.lanes=NoLanes;switch(workInProgress.tag){caseIndeterminateComponent:{returnmountIndeterminateComponent(current,workInProgress,workInProgress.type,renderLanes);}caseLazyComponent:{varelementType=workInProgress.elementType;returnmountLazyComponent(current,workInProgress,elementType,updateLanes,renderLanes);}caseFunctionComponent:{var_Component=workInProgress.type;varunresolvedProps=workInProgress.pendingProps;varresolvedProps=workInProgress.elementType===_Component?unresolvedProps:resolveDefaultProps(_Component,unresolvedProps);returnupdateFunctionComponent(current,workInProgress,_Component,resolvedProps,renderLanes);}caseClassComponent:{var_Component2=workInProgress.type;var_unresolvedProps=workInProgress.pendingProps;var_resolvedProps=workInProgress.elementType===_Component2?_unresolvedProps:resolveDefaultProps(_Component2,_unresolvedProps);returnupdateClassComponent(current,workInProgress,_Component2,_resolvedProps,renderLanes);}caseHostRoot:returnupdateHostRoot(current,workInProgress,renderLanes);caseHostComponent:returnupdateHostComponent(current,workInProgress,renderLanes);caseHostText:returnupdateHostText(current,workInProgress);caseSuspenseComponent:returnupdateSuspenseComponent(current,workInProgress,renderLanes);caseHostPortal:returnupdatePortalComponent(current,workInProgress,renderLanes);caseForwardRef:{vartype=workInProgress.type;var_unresolvedProps2=workInProgress.pendingProps;var_resolvedProps2=workInProgress.elementType===type?_unresolvedProps2:resolveDefaultProps(type,_unresolvedProps2);returnupdateForwardRef(current,workInProgress,type,_resolvedProps2,renderLanes);}caseFragment:returnupdateFragment(current,workInProgress,renderLanes);caseMode:returnupdateMode(current,workInProgress,renderLanes);caseProfiler:returnupdateProfiler(current,workInProgress,renderLanes);caseContextProvider:returnupdateContextProvider(current,workInProgress,renderLanes);caseContextConsumer:returnupdateContextConsumer(current,workInProgress,renderLanes);caseMemoComponent:{var_type2=workInProgress.type;var_unresolvedProps3=workInProgress.pendingProps;// Resolve outer props first, then resolve inner props.
var_resolvedProps3=resolveDefaultProps(_type2,_unresolvedProps3);{if(workInProgress.type!==workInProgress.elementType){varouterPropTypes=_type2.propTypes;if(outerPropTypes){checkPropTypes(outerPropTypes,_resolvedProps3,// Resolved for outer only
'prop',getComponentName(_type2));}}}_resolvedProps3=resolveDefaultProps(_type2.type,_resolvedProps3);returnupdateMemoComponent(current,workInProgress,_type2,_resolvedProps3,updateLanes,renderLanes);}caseSimpleMemoComponent:{returnupdateSimpleMemoComponent(current,workInProgress,workInProgress.type,workInProgress.pendingProps,updateLanes,renderLanes);}caseIncompleteClassComponent:{var_Component3=workInProgress.type;var_unresolvedProps4=workInProgress.pendingProps;var_resolvedProps4=workInProgress.elementType===_Component3?_unresolvedProps4:resolveDefaultProps(_Component3,_unresolvedProps4);returnmountIncompleteClassComponent(current,workInProgress,_Component3,_resolvedProps4,renderLanes);}caseSuspenseListComponent:{returnupdateSuspenseListComponent(current,workInProgress,renderLanes);}caseFundamentalComponent:{break;}caseScopeComponent:{break;}caseBlock:{break;}caseOffscreenComponent:{returnupdateOffscreenComponent(current,workInProgress,renderLanes);}caseLegacyHiddenComponent:{returnupdateLegacyHiddenComponent(current,workInProgress,renderLanes);}}{{throwError("Unknown unit of work tag ("+workInProgress.tag+"). This error is likely caused by a bug in React. Please file an issue.");}}}functionmarkUpdate(workInProgress){// Tag the fiber with an update effect. This turns a Placement into
appendAllChildren=function(parent,workInProgress,needsVisibilityToggle,isHidden){// We only have the top Fiber that was created but we need recurse down its
};updateHostComponent$1=function(current,workInProgress,type,newProps,rootContainerInstance){// If we have an alternate, that means this is an update and we need to
// schedule a side-effect to do the updates.
varoldProps=current.memoizedProps;if(oldProps===newProps){// In mutation mode, this is sufficient for a bailout because
// we won't touch this node even if children changed.
return;}// If we get updated because one of our children updated, we don't
// have newProps so we'll have to reuse them.
// TODO: Split the update API as separate for the props vs. children.
// Even better would be if children weren't special cased at all tho.
varinstance=workInProgress.stateNode;varcurrentHostContext=getHostContext();// TODO: Experiencing an error where oldProps is null. Suggests a host
// component is hitting the resume path. Figure out why. Possibly
// related to `hidden`.
varupdatePayload=prepareUpdate(instance,type,oldProps,newProps,rootContainerInstance,currentHostContext);// TODO: Type this specific to this type of component.
workInProgress.updateQueue=updatePayload;// If the update payload indicates that there is a change or if there
// is a new ref we mark this as an update. All the work is done in commitWork.
if(updatePayload){markUpdate(workInProgress);}};updateHostText$1=function(current,workInProgress,oldText,newText){// If the text differs, mark it as an update. All the work in done in commitWork.
if(oldText!==newText){markUpdate(workInProgress);}};}functioncutOffTailIfNeeded(renderState,hasRenderedATailFallback){if(getIsHydrating()){// If we're hydrating, we should consume as many items as we can
// so we don't leave any behind.
return;}switch(renderState.tailMode){case'hidden':{// Any insertions at the end of the tail list after this point
// should be invisible. If there are already mounted boundaries
// anything before them are not considered for collapsing.
// Therefore we need to go through the whole tail to find if
// there are any.
vartailNode=renderState.tail;varlastTailNode=null;while(tailNode!==null){if(tailNode.alternate!==null){lastTailNode=tailNode;}tailNode=tailNode.sibling;}// Next we're simply going to delete all insertions after the
// last rendered item.
if(lastTailNode===null){// All remaining items in the tail are insertions.
renderState.tail=null;}else{// Detach the insertion after the last node that was already
// inserted.
lastTailNode.sibling=null;}break;}case'collapsed':{// Any insertions at the end of the tail list after this point
// should be invisible. If there are already mounted boundaries
// anything before them are not considered for collapsing.
// Therefore we need to go through the whole tail to find if
// there are any.
var_tailNode=renderState.tail;var_lastTailNode=null;while(_tailNode!==null){if(_tailNode.alternate!==null){_lastTailNode=_tailNode;}_tailNode=_tailNode.sibling;}// Next we're simply going to delete all insertions after the
// last rendered item.
if(_lastTailNode===null){// All remaining items in the tail are insertions.
if(!hasRenderedATailFallback&&renderState.tail!==null){// We suspended during the head. We want to show at least one
// row at the tail. So we'll keep on and cut off the rest.
renderState.tail.sibling=null;}else{renderState.tail=null;}}else{// Detach the insertion after the last node that was already
// inserted.
_lastTailNode.sibling=null;}break;}}}functioncompleteWork(current,workInProgress,renderLanes){varnewProps=workInProgress.pendingProps;switch(workInProgress.tag){caseIndeterminateComponent:caseLazyComponent:caseSimpleMemoComponent:caseFunctionComponent:caseForwardRef:caseFragment:caseMode:caseProfiler:caseContextConsumer:caseMemoComponent:returnnull;caseClassComponent:{varComponent=workInProgress.type;if(isContextProvider(Component)){popContext(workInProgress);}returnnull;}caseHostRoot:{popHostContainer(workInProgress);popTopLevelContextObject(workInProgress);resetWorkInProgressVersions();varfiberRoot=workInProgress.stateNode;if(fiberRoot.pendingContext){fiberRoot.context=fiberRoot.pendingContext;fiberRoot.pendingContext=null;}if(current===null||current.child===null){// If we hydrated, pop so that we can delete any remaining children
// that weren't hydrated.
varwasHydrated=popHydrationState(workInProgress);if(wasHydrated){// If we hydrated, then we'll need to schedule an update for
// the commit side-effects on the root.
markUpdate(workInProgress);}elseif(!fiberRoot.hydrate){// Schedule an effect to clear this container at the start of the next commit.
// This handles the case of React rendering into a container with previous children.
// It's also safe to do for updates too, because current.child would only be null
// if the previous render was null (so the the container would already be empty).
workInProgress.flags|=Snapshot;}}updateHostContainer(workInProgress);returnnull;}caseHostComponent:{popHostContext(workInProgress);varrootContainerInstance=getRootHostContainer();vartype=workInProgress.type;if(current!==null&&workInProgress.stateNode!=null){updateHostComponent$1(current,workInProgress,type,newProps,rootContainerInstance);if(current.ref!==workInProgress.ref){markRef$1(workInProgress);}}else{if(!newProps){if(!(workInProgress.stateNode!==null)){{throwError("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");}}// This can happen when we abort work.
returnnull;}varcurrentHostContext=getHostContext();// TODO: Move createInstance to beginWork and keep it on a context
// "stack" as the parent. Then append children as we go in beginWork
// or completeWork depending on whether we want to add them top->down or
// bottom->up. Top->down is faster in IE11.
var_wasHydrated=popHydrationState(workInProgress);if(_wasHydrated){// TODO: Move this and createInstance step into the beginPhase
// to consolidate.
if(prepareToHydrateHostInstance(workInProgress,rootContainerInstance,currentHostContext)){// If changes to the hydrated node need to be applied at the
// commit-phase we mark this as such.
markUpdate(workInProgress);}}else{varinstance=createInstance(type,newProps,rootContainerInstance,currentHostContext,workInProgress);appendAllChildren(instance,workInProgress,false,false);workInProgress.stateNode=instance;// Certain renderers require commit-time effects for initial mount.
// (eg DOM renderer supports auto-focus for certain elements).
// Make sure such renderers get scheduled for later work.
if(finalizeInitialChildren(instance,type,newProps,rootContainerInstance)){markUpdate(workInProgress);}}if(workInProgress.ref!==null){// If there is a ref on a host node we need to schedule a callback
markRef$1(workInProgress);}}returnnull;}caseHostText:{varnewText=newProps;if(current&&workInProgress.stateNode!=null){varoldText=current.memoizedProps;// If we have an alternate, that means this is an update and we need
// to schedule a side-effect to do the updates.
updateHostText$1(current,workInProgress,oldText,newText);}else{if(typeofnewText!=='string'){if(!(workInProgress.stateNode!==null)){{throwError("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");}}// This can happen when we abort work.
}var_rootContainerInstance=getRootHostContainer();var_currentHostContext=getHostContext();var_wasHydrated2=popHydrationState(workInProgress);if(_wasHydrated2){if(prepareToHydrateHostTextInstance(workInProgress)){markUpdate(workInProgress);}}else{workInProgress.stateNode=createTextInstance(newText,_rootContainerInstance,_currentHostContext,workInProgress);}}returnnull;}caseSuspenseComponent:{popSuspenseContext(workInProgress);varnextState=workInProgress.memoizedState;if((workInProgress.flags&DidCapture)!==NoFlags){// Something suspended. Re-render with the fallback children.
workInProgress.lanes=renderLanes;// Do not reset the effect list.
if((workInProgress.mode&ProfileMode)!==NoMode){transferActualDuration(workInProgress);}returnworkInProgress;}varnextDidTimeout=nextState!==null;varprevDidTimeout=false;if(current===null){if(workInProgress.memoizedProps.fallback!==undefined){popHydrationState(workInProgress);}}else{varprevState=current.memoizedState;prevDidTimeout=prevState!==null;}if(nextDidTimeout&&!prevDidTimeout){// If this subtreee is running in blocking mode we can suspend,
// otherwise we won't suspend.
// TODO: This will still suspend a synchronous tree if anything
// in the concurrent tree already suspended during this render.
// This is a known bug.
if((workInProgress.mode&BlockingMode)!==NoMode){// TODO: Move this back to throwException because this is too late
// if this is a large tree which is common for initial loads. We
// don't know if we should restart a render or not until we get
// this marker, and this is too late.
// If this render already had a ping or lower pri updates,
// and this is the first time we know we're going to suspend we
// should be able to immediately restart from within throwException.
varhasInvisibleChildContext=current===null&&workInProgress.memoizedProps.unstable_avoidThisFallback!==true;if(hasInvisibleChildContext||hasSuspenseContext(suspenseStackCursor.current,InvisibleParentSuspenseContext)){// If this was in an invisible tree or a new render, then showing
// this boundary is ok.
renderDidSuspend();}else{// Otherwise, we're going to have to hide content so we should
// suspend for longer if possible.
renderDidSuspendDelayIfPossible();}}}{// TODO: Only schedule updates if these values are non equal, i.e. it changed.
if(nextDidTimeout||prevDidTimeout){// If this boundary just timed out, schedule an effect to attach a
// retry listener to the promise. This flag is also used to hide the
// primary children. In mutation mode, we also need the flag to
// *unhide* children that were previously hidden, so check if this
// is currently timed out, too.
workInProgress.flags|=Update;}}returnnull;}caseHostPortal:popHostContainer(workInProgress);updateHostContainer(workInProgress);if(current===null){preparePortalMount(workInProgress.stateNode.containerInfo);}returnnull;caseContextProvider:// Pop provider fiber
popProvider(workInProgress);returnnull;caseIncompleteClassComponent:{// Same as class component case. I put it down here so that the tags are
// sequential to ensure this switch is compiled to a jump table.
var_Component=workInProgress.type;if(isContextProvider(_Component)){popContext(workInProgress);}returnnull;}caseSuspenseListComponent:{popSuspenseContext(workInProgress);varrenderState=workInProgress.memoizedState;if(renderState===null){// We're running in the default, "independent" mode.
// We don't do anything in this mode.
returnnull;}vardidSuspendAlready=(workInProgress.flags&DidCapture)!==NoFlags;varrenderedTail=renderState.rendering;if(renderedTail===null){// We just rendered the head.
if(!didSuspendAlready){// This is the first pass. We need to figure out if anything is still
// suspended in the rendered set.
// If new content unsuspended, but there's still some content that
// didn't. Then we need to do a second pass that forces everything
// to keep showing their fallbacks.
// We might be suspended if something in this render pass suspended, or
// something in the previous committed pass suspended. Otherwise,
// there's no chance so we can skip the expensive call to
// findFirstSuspended.
varcannotBeSuspended=renderHasNotSuspendedYet()&&(current===null||(current.flags&DidCapture)===NoFlags);if(!cannotBeSuspended){varrow=workInProgress.child;while(row!==null){varsuspended=findFirstSuspended(row);if(suspended!==null){didSuspendAlready=true;workInProgress.flags|=DidCapture;cutOffTailIfNeeded(renderState,false);// If this is a newly suspended tree, it might not get committed as
// part of the second pass. In that case nothing will subscribe to
// its thennables. Instead, we'll transfer its thennables to the
// SuspenseList so that it can retry if they resolve.
// There might be multiple of these in the list but since we're
// going to wait for all of them anyway, it doesn't really matter
// which ones gets to ping. In theory we could get clever and keep
// track of how many dependencies remain but it gets tricky because
// in the meantime, we can add/remove/change items and dependencies.
// We might bail out of the loop before finding any but that
// doesn't matter since that means that the other boundaries that
// we did find already has their listeners attached.
varnewThennables=suspended.updateQueue;if(newThennables!==null){workInProgress.updateQueue=newThennables;workInProgress.flags|=Update;}// Rerender the whole list, but this time, we'll force fallbacks
// to stay in place.
// Reset the effect list before doing the second pass since that's now invalid.
if(renderState.lastEffect===null){workInProgress.firstEffect=null;}workInProgress.lastEffect=renderState.lastEffect;// Reset the child fibers to their original state.
resetChildFibers(workInProgress,renderLanes);// Set up the Suspense Context to force suspense and immediately
// rerender the children.
pushSuspenseContext(workInProgress,setShallowSuspenseContext(suspenseStackCursor.current,ForceSuspenseFallback));returnworkInProgress.child;}row=row.sibling;}}if(renderState.tail!==null&&now()>getRenderTargetTime()){// We have already passed our CPU deadline but we still have rows
// left in the tail. We'll just give up further attempts to render
// the main content and only render fallbacks.
workInProgress.flags|=DidCapture;didSuspendAlready=true;cutOffTailIfNeeded(renderState,false);// Since nothing actually suspended, there will nothing to ping this
// to get it started back up to attempt the next item. While in terms
// of priority this work has the same priority as this current render,
// it's not part of the same transition once the transition has
// committed. If it's sync, we still want to yield so that it can be
// painted. Conceptually, this is really the same as pinging.
// We can use any RetryLane even if it's the one currently rendering
// since we're leaving it behind on this node.
workInProgress.lanes=SomeRetryLane;{markSpawnedWork(SomeRetryLane);}}}else{cutOffTailIfNeeded(renderState,false);}// Next we're going to render the tail.
}else{// Append the rendered row to the child list.
if(!didSuspendAlready){var_suspended=findFirstSuspended(renderedTail);if(_suspended!==null){workInProgress.flags|=DidCapture;didSuspendAlready=true;// Ensure we transfer the update queue to the parent so that it doesn't
// get lost if this row ends up dropped during a second pass.
var_newThennables=_suspended.updateQueue;if(_newThennables!==null){workInProgress.updateQueue=_newThennables;workInProgress.flags|=Update;}cutOffTailIfNeeded(renderState,true);// This might have been modified.
if(renderState.tail===null&&renderState.tailMode==='hidden'&&!renderedTail.alternate&&!getIsHydrating()// We don't cut it if we're hydrating.
){// We need to delete the row we just rendered.
// Reset the effect list to what it was before we rendered this
// child. The nested children have already appended themselves.
varlastEffect=workInProgress.lastEffect=renderState.lastEffect;// Remove any effects that were appended after this point.
returnnull;}}elseif(// The time it took to render last row is greater than the remaining
// time we have to render. So rendering one more row would likely
// exceed it.
now()*2-renderState.renderingStartTime>getRenderTargetTime()&&renderLanes!==OffscreenLane){// We have now passed our CPU deadline and we'll just give up further
// attempts to render the main content and only render fallbacks.
// The assumption is that this is usually faster.
workInProgress.flags|=DidCapture;didSuspendAlready=true;cutOffTailIfNeeded(renderState,false);// Since nothing actually suspended, there will nothing to ping this
// to get it started back up to attempt the next item. While in terms
// of priority this work has the same priority as this current render,
// it's not part of the same transition once the transition has
// committed. If it's sync, we still want to yield so that it can be
// painted. Conceptually, this is really the same as pinging.
// We can use any RetryLane even if it's the one currently rendering
// since we're leaving it behind on this node.
workInProgress.lanes=SomeRetryLane;{markSpawnedWork(SomeRetryLane);}}}if(renderState.isBackwards){// The effect list of the backwards tail will have been added
// to the end. This breaks the guarantee that life-cycles fire in
// sibling order but that isn't a strong guarantee promised by React.
// Especially since these might also just pop in during future commits.
// Append to the beginning of the list.
renderedTail.sibling=workInProgress.child;workInProgress.child=renderedTail;}else{varpreviousSibling=renderState.last;if(previousSibling!==null){previousSibling.sibling=renderedTail;}else{workInProgress.child=renderedTail;}renderState.last=renderedTail;}}if(renderState.tail!==null){// We still have tail rows to render.
// Pop a row.
varnext=renderState.tail;renderState.rendering=next;renderState.tail=next.sibling;renderState.lastEffect=workInProgress.lastEffect;renderState.renderingStartTime=now();next.sibling=null;// Restore the context.
// TODO: We can probably just avoid popping it instead and only
// setting it the first time we go from not suspended to suspended.
varsuspenseContext=suspenseStackCursor.current;if(didSuspendAlready){suspenseContext=setShallowSuspenseContext(suspenseContext,ForceSuspenseFallback);}else{suspenseContext=setDefaultShallowSuspenseContext(suspenseContext);}pushSuspenseContext(workInProgress,suspenseContext);// Do a pass over the next row.
returnnext;}returnnull;}caseFundamentalComponent:{break;}caseScopeComponent:{break;}caseBlock:break;caseOffscreenComponent:caseLegacyHiddenComponent:{popRenderLanes(workInProgress);if(current!==null){var_nextState=workInProgress.memoizedState;var_prevState=current.memoizedState;varprevIsHidden=_prevState!==null;varnextIsHidden=_nextState!==null;if(prevIsHidden!==nextIsHidden&&newProps.mode!=='unstable-defer-without-hiding'){workInProgress.flags|=Update;}}returnnull;}}{{throwError("Unknown unit of work tag ("+workInProgress.tag+"). This error is likely caused by a bug in React. Please file an issue.");}}}functionunwindWork(workInProgress,renderLanes){switch(workInProgress.tag){caseClassComponent:{varComponent=workInProgress.type;if(isContextProvider(Component)){popContext(workInProgress);}varflags=workInProgress.flags;if(flags&ShouldCapture){workInProgress.flags=flags&~ShouldCapture|DidCapture;if((workInProgress.mode&ProfileMode)!==NoMode){transferActualDuration(workInProgress);}returnworkInProgress;}returnnull;}caseHostRoot:{popHostContainer(workInProgress);popTopLevelContextObject(workInProgress);resetWorkInProgressVersions();var_flags=workInProgress.flags;if(!((_flags&DidCapture)===NoFlags)){{throwError("The root failed to unmount after an error. This is likely a bug in React. Please file an issue.");}}workInProgress.flags=_flags&~ShouldCapture|DidCapture;returnworkInProgress;}caseHostComponent:{// TODO: popHydrationState
popHostContext(workInProgress);returnnull;}caseSuspenseComponent:{popSuspenseContext(workInProgress);var_flags2=workInProgress.flags;if(_flags2&ShouldCapture){workInProgress.flags=_flags2&~ShouldCapture|DidCapture;// Captured a suspense effect. Re-render the boundary.
if((workInProgress.mode&ProfileMode)!==NoMode){transferActualDuration(workInProgress);}returnworkInProgress;}returnnull;}caseSuspenseListComponent:{popSuspenseContext(workInProgress);// SuspenseList doesn't actually catch anything. It should've been
// caught by a nested boundary. If not, it should bubble through.
returnnull;}caseHostPortal:popHostContainer(workInProgress);returnnull;caseContextProvider:popProvider(workInProgress);returnnull;caseOffscreenComponent:caseLegacyHiddenComponent:popRenderLanes(workInProgress);returnnull;default:returnnull;}}functionunwindInterruptedWork(interruptedWork){switch(interruptedWork.tag){caseClassComponent:{varchildContextTypes=interruptedWork.type.childContextTypes;if(childContextTypes!==null&&childContextTypes!==undefined){popContext(interruptedWork);}break;}caseHostRoot:{popHostContainer(interruptedWork);popTopLevelContextObject(interruptedWork);resetWorkInProgressVersions();break;}caseHostComponent:{popHostContext(interruptedWork);break;}caseHostPortal:popHostContainer(interruptedWork);break;caseSuspenseComponent:popSuspenseContext(interruptedWork);break;caseSuspenseListComponent:popSuspenseContext(interruptedWork);break;caseContextProvider:popProvider(interruptedWork);break;caseOffscreenComponent:caseLegacyHiddenComponent:popRenderLanes(interruptedWork);break;}}functioncreateCapturedValue(value,source){// If the value is an error, call this function immediately after it is thrown
// so the stack is accurate.
return{value:value,source:source,stack:getStackByFiberInDevAndProd(source)};}// This module is forked in different environments.
// By default, return `true` to log errors to the console.
// Forks can return `false` if this isn't desirable.
functionshowErrorDialog(boundary,errorInfo){returntrue;}functionlogCapturedError(boundary,errorInfo){try{varlogError=showErrorDialog(boundary,errorInfo);// Allow injected showErrorDialog() to prevent default console.error logging.
// This enables renderers like ReactNative to better manage redbox behavior.
if(logError===false){return;}varerror=errorInfo.value;if(true){varsource=errorInfo.source;varstack=errorInfo.stack;varcomponentStack=stack!==null?stack:'';// Browsers support silencing uncaught errors by calling
// `preventDefault()` in window `error` handler.
// We record this information as an expando on the error.
if(error!=null&&error._suppressLogging){if(boundary.tag===ClassComponent){// The error is recoverable and was silenced.
// Ignore it and don't print the stack addendum.
// This is handy for testing error boundaries without noise.
return;}// The error is fatal. Since the silencing might have
// been accidental, we'll surface it anyway.
// However, the browser would have silenced the original error
// so we'll print it first, and then print the stack addendum.
console['error'](error);// Don't transform to our wrapper
// For a more detailed description of this block, see:
// https://github.com/facebook/react/pull/13384
}varcomponentName=source?getComponentName(source.type):null;varcomponentNameMessage=componentName?"The above error occurred in the <"+componentName+"> component:":'The above error occurred in one of your React components:';varerrorBoundaryMessage;varerrorBoundaryName=getComponentName(boundary.type);if(errorBoundaryName){errorBoundaryMessage="React will try to recreate this component tree from scratch "+("using the error boundary you provided, "+errorBoundaryName+".");}else{errorBoundaryMessage='Consider adding an error boundary to your tree to customize error handling behavior.\n'+'Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.';}varcombinedMessage=componentNameMessage+"\n"+componentStack+"\n\n"+(""+errorBoundaryMessage);// In development, we provide our own message with just the component stack.
// We don't include the original error message and JS stack because the browser
// has already printed it. Even if the application swallows the error, it is still
// displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
console['error'](combinedMessage);// Don't transform to our wrapper
}}catch(e){// This method must not throw, or React internal state will get messed up.
// If console.error is overridden, or logCapturedError() shows a dialog that throws,
// we want to report this error outside of the normal stack as a last resort.
// https://github.com/facebook/react/issues/13188
setTimeout(function(){throwe;});}}varPossiblyWeakMap$1=typeofWeakMap==='function'?WeakMap:Map;functioncreateRootErrorUpdate(fiber,errorInfo,lane){varupdate=createUpdate(NoTimestamp,lane);// Unmount the root by rendering null.
update.tag=CaptureUpdate;// Caution: React DevTools currently depends on this property
// being called "element".
update.payload={element:null};varerror=errorInfo.value;update.callback=function(){onUncaughtError(error);logCapturedError(fiber,errorInfo);};returnupdate;}functioncreateClassErrorUpdate(fiber,errorInfo,lane){varupdate=createUpdate(NoTimestamp,lane);update.tag=CaptureUpdate;vargetDerivedStateFromError=fiber.type.getDerivedStateFromError;if(typeofgetDerivedStateFromError==='function'){varerror$1=errorInfo.value;update.payload=function(){logCapturedError(fiber,errorInfo);returngetDerivedStateFromError(error$1);};}varinst=fiber.stateNode;if(inst!==null&&typeofinst.componentDidCatch==='function'){update.callback=functioncallback(){{markFailedErrorBoundaryForHotReloading(fiber);}if(typeofgetDerivedStateFromError!=='function'){// To preserve the preexisting retry behavior of error boundaries,
// we keep track of which ones already failed during this batch.
// This gets reset before we yield back to the browser.
// TODO: Warn in strict mode if getDerivedStateFromError is
// not defined.
markLegacyErrorBoundaryAsFailed(this);// Only log here if componentDidCatch is the only error boundary method defined
logCapturedError(fiber,errorInfo);}varerror$1=errorInfo.value;varstack=errorInfo.stack;this.componentDidCatch(error$1,{componentStack:stack!==null?stack:''});{if(typeofgetDerivedStateFromError!=='function'){// If componentDidCatch is the only error boundary method defined,
// then it needs to call setState to recover from errors.
// If no state update is scheduled then the boundary will swallow the error.
if(!includesSomeLane(fiber.lanes,SyncLane)){error('%s: Error boundaries should implement getDerivedStateFromError(). '+'In that method, return a state update to display an error message or fallback UI.',getComponentName(fiber.type)||'Unknown');}}}};}else{update.callback=function(){markFailedErrorBoundaryForHotReloading(fiber);};}returnupdate;}functionattachPingListener(root,wakeable,lanes){// Attach a listener to the promise to "ping" the root and retry. But only if
// one does not already exist for the lanes we're currently rendering (which
// acts like a "thread ID" here).
varpingCache=root.pingCache;varthreadIDs;if(pingCache===null){pingCache=root.pingCache=newPossiblyWeakMap$1();threadIDs=newSet();pingCache.set(wakeable,threadIDs);}else{threadIDs=pingCache.get(wakeable);if(threadIDs===undefined){threadIDs=newSet();pingCache.set(wakeable,threadIDs);}}if(!threadIDs.has(lanes)){// Memoize using the thread ID to prevent redundant listeners.
threadIDs.add(lanes);varping=pingSuspendedRoot.bind(null,root,wakeable,lanes);wakeable.then(ping,ping);}}functionthrowException(root,returnFiber,sourceFiber,value,rootRenderLanes){// The source fiber did not complete.
sourceFiber.flags|=Incomplete;// Its effect list is no longer valid.
sourceFiber.firstEffect=sourceFiber.lastEffect=null;if(value!==null&&typeofvalue==='object'&&typeofvalue.then==='function'){// This is a wakeable.
varwakeable=value;if((sourceFiber.mode&BlockingMode)===NoMode){// Reset the memoizedState to what it was before we attempted
// to render it.
varcurrentSource=sourceFiber.alternate;if(currentSource){sourceFiber.updateQueue=currentSource.updateQueue;sourceFiber.memoizedState=currentSource.memoizedState;sourceFiber.lanes=currentSource.lanes;}else{sourceFiber.updateQueue=null;sourceFiber.memoizedState=null;}}varhasInvisibleParentBoundary=hasSuspenseContext(suspenseStackCursor.current,InvisibleParentSuspenseContext);// Schedule the nearest Suspense to re-render the timed out view.
var_workInProgress=returnFiber;do{if(_workInProgress.tag===SuspenseComponent&&shouldCaptureSuspense(_workInProgress,hasInvisibleParentBoundary)){// Found the nearest boundary.
// Stash the promise on the boundary fiber. If the boundary times out, we'll
// attach another listener to flip the boundary back to its normal state.
varwakeables=_workInProgress.updateQueue;if(wakeables===null){varupdateQueue=newSet();updateQueue.add(wakeable);_workInProgress.updateQueue=updateQueue;}else{wakeables.add(wakeable);}// If the boundary is outside of blocking mode, we should *not*
// suspend the commit. Pretend as if the suspended component rendered
// null and keep rendering. In the commit phase, we'll schedule a
// subsequent synchronous update to re-render the Suspense.
//
// Note: It doesn't matter whether the component that suspended was
// inside a blocking mode tree. If the Suspense is outside of it, we
// should *not* suspend the commit.
if((_workInProgress.mode&BlockingMode)===NoMode){_workInProgress.flags|=DidCapture;sourceFiber.flags|=ForceUpdateForLegacySuspense;// We're going to commit this fiber even though it didn't complete.
// But we shouldn't call any lifecycle methods or callbacks. Remove
// all lifecycle effect tags.
sourceFiber.flags&=~(LifecycleEffectMask|Incomplete);if(sourceFiber.tag===ClassComponent){varcurrentSourceFiber=sourceFiber.alternate;if(currentSourceFiber===null){// This is a new mount. Change the tag so it's not mistaken for a
// completed class component. For example, we should not call
// componentWillUnmount if it is deleted.
sourceFiber.tag=IncompleteClassComponent;}else{// When we try rendering again, we should not reuse the current fiber,
// since it's known to be in an inconsistent state. Use a force update to
// prevent a bail out.
varupdate=createUpdate(NoTimestamp,SyncLane);update.tag=ForceUpdate;enqueueUpdate(sourceFiber,update);}}// The source fiber did not complete. Mark it with Sync priority to
// indicate that it still has pending work.
sourceFiber.lanes=mergeLanes(sourceFiber.lanes,SyncLane);// Exit without suspending.
return;}// Confirmed that the boundary is in a concurrent mode tree. Continue
// with the normal suspend path.
//
// After this we'll use a set of heuristics to determine whether this
// render pass will run to completion or restart or "suspend" the commit.
// The actual logic for this is spread out in different places.
//
// This first principle is that if we're going to suspend when we complete
// a root, then we should also restart if we get an update or ping that
// might unsuspend it, and vice versa. The only reason to suspend is
// because you think you might want to restart before committing. However,
// it doesn't make sense to restart only while in the period we're suspended.
//
// Restarting too aggressively is also not good because it starves out any
// intermediate loading state. So we use heuristics to determine when.
// Suspense Heuristics
//
// If nothing threw a Promise or all the same fallbacks are already showing,
// then don't suspend/restart.
//
// If this is an initial render of a new tree of Suspense boundaries and
// those trigger a fallback, then don't suspend/restart. We want to ensure
// that we can show the initial loading state as quickly as possible.
//
// If we hit a "Delayed" case, such as when we'd switch from content back into
// a fallback, then we should always suspend/restart. Transitions apply
// to this case. If none is defined, JND is used instead.
//
// If we're already showing a fallback and it gets "retried", allowing us to show
// another level, but there's still an inner boundary that would show a fallback,
// then we suspend/restart for 500ms since the last time we showed a fallback
// anywhere in the tree. This effectively throttles progressive loading into a
// consistent train of commits. This also gives us an opportunity to restart to
// get to the completed state slightly earlier.
//
// If there's ambiguity due to batching it's resolved in preference of:
// 1) "delayed", 2) "initial render", 3) "retry".
//
// We want to ensure that a "busy" state doesn't get force committed. We want to
// ensure that new initial loading states can commit as soon as possible.
attachPingListener(root,wakeable,rootRenderLanes);_workInProgress.flags|=ShouldCapture;_workInProgress.lanes=rootRenderLanes;return;}// This boundary already captured during this render. Continue to the next
// boundary.
_workInProgress=_workInProgress.return;}while(_workInProgress!==null);// No boundary was found. Fallthrough to error mode.
// TODO: Use invariant so the message is stripped in prod?
value=newError((getComponentName(sourceFiber.type)||'A React component')+' suspended while rendering, but no fallback UI was specified.\n'+'\n'+'Add a <Suspense fallback=...> component higher in the tree to '+'provide a loading indicator or placeholder to display.');}// We didn't find a boundary that could handle this type of exception. Start
// over and traverse parent path again, this time treating the exception
// as an error.
renderDidError();value=createCapturedValue(value,sourceFiber);varworkInProgress=returnFiber;do{switch(workInProgress.tag){caseHostRoot:{var_errorInfo=value;workInProgress.flags|=ShouldCapture;varlane=pickArbitraryLane(rootRenderLanes);workInProgress.lanes=mergeLanes(workInProgress.lanes,lane);var_update=createRootErrorUpdate(workInProgress,_errorInfo,lane);enqueueCapturedUpdate(workInProgress,_update);return;}caseClassComponent:// Capture and retry
varerrorInfo=value;varctor=workInProgress.type;varinstance=workInProgress.stateNode;if((workInProgress.flags&DidCapture)===NoFlags&&(typeofctor.getDerivedStateFromError==='function'||instance!==null&&typeofinstance.componentDidCatch==='function'&&!isAlreadyFailedLegacyErrorBoundary(instance))){workInProgress.flags|=ShouldCapture;var_lane=pickArbitraryLane(rootRenderLanes);workInProgress.lanes=mergeLanes(workInProgress.lanes,_lane);// Schedule the error boundary to re-render using updated state
var_update2=createClassErrorUpdate(workInProgress,errorInfo,_lane);enqueueCapturedUpdate(workInProgress,_update2);return;}break;}workInProgress=workInProgress.return;}while(workInProgress!==null);}vardidWarnAboutUndefinedSnapshotBeforeUpdate=null;{didWarnAboutUndefinedSnapshotBeforeUpdate=newSet();}varPossiblyWeakSet=typeofWeakSet==='function'?WeakSet:Set;varcallComponentWillUnmountWithTimer=function(current,instance){instance.props=current.memoizedProps;instance.state=current.memoizedState;{instance.componentWillUnmount();}};// Capture errors so they don't interrupt unmounting.
functionsafelyCallComponentWillUnmount(current,instance){{invokeGuardedCallback(null,callComponentWillUnmountWithTimer,null,current,instance);if(hasCaughtError()){varunmountError=clearCaughtError();captureCommitPhaseError(current,unmountError);}}}functionsafelyDetachRef(current){varref=current.ref;if(ref!==null){if(typeofref==='function'){{invokeGuardedCallback(null,ref,null,null);if(hasCaughtError()){varrefError=clearCaughtError();captureCommitPhaseError(current,refError);}}}else{ref.current=null;}}}functionsafelyCallDestroy(current,destroy){{invokeGuardedCallback(null,destroy,null);if(hasCaughtError()){varerror=clearCaughtError();captureCommitPhaseError(current,error);}}}functioncommitBeforeMutationLifeCycles(current,finishedWork){switch(finishedWork.tag){caseFunctionComponent:caseForwardRef:caseSimpleMemoComponent:caseBlock:{return;}caseClassComponent:{if(finishedWork.flags&Snapshot){if(current!==null){varprevProps=current.memoizedProps;varprevState=current.memoizedState;varinstance=finishedWork.stateNode;// We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
{if(finishedWork.type===finishedWork.elementType&&!didWarnAboutReassigningProps){if(instance.props!==finishedWork.memoizedProps){error('Expected %s props to match memoized props before '+'getSnapshotBeforeUpdate. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.props`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}if(instance.state!==finishedWork.memoizedState){error('Expected %s state to match memoized state before '+'getSnapshotBeforeUpdate. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.state`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}}}varsnapshot=instance.getSnapshotBeforeUpdate(finishedWork.elementType===finishedWork.type?prevProps:resolveDefaultProps(finishedWork.type,prevProps),prevState);{vardidWarnSet=didWarnAboutUndefinedSnapshotBeforeUpdate;if(snapshot===undefined&&!didWarnSet.has(finishedWork.type)){didWarnSet.add(finishedWork.type);error('%s.getSnapshotBeforeUpdate(): A snapshot value (or null) '+'must be returned. You have returned undefined.',getComponentName(finishedWork.type));}}instance.__reactInternalSnapshotBeforeUpdate=snapshot;}}return;}caseHostRoot:{{if(finishedWork.flags&Snapshot){varroot=finishedWork.stateNode;clearContainer(root.containerInfo);}}return;}caseHostComponent:caseHostText:caseHostPortal:caseIncompleteClassComponent:// Nothing to do for these component types
return;}{{throwError("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");}}}functioncommitHookEffectListUnmount(tag,finishedWork){varupdateQueue=finishedWork.updateQueue;varlastEffect=updateQueue!==null?updateQueue.lastEffect:null;if(lastEffect!==null){varfirstEffect=lastEffect.next;vareffect=firstEffect;do{if((effect.tag&tag)===tag){// Unmount
vardestroy=effect.destroy;effect.destroy=undefined;if(destroy!==undefined){destroy();}}effect=effect.next;}while(effect!==firstEffect);}}functioncommitHookEffectListMount(tag,finishedWork){varupdateQueue=finishedWork.updateQueue;varlastEffect=updateQueue!==null?updateQueue.lastEffect:null;if(lastEffect!==null){varfirstEffect=lastEffect.next;vareffect=firstEffect;do{if((effect.tag&tag)===tag){// Mount
varcreate=effect.create;effect.destroy=create();{vardestroy=effect.destroy;if(destroy!==undefined&&typeofdestroy!=='function'){varaddendum=void0;if(destroy===null){addendum=' You returned null. If your effect does not require clean '+'up, return undefined (or nothing).';}elseif(typeofdestroy.then==='function'){addendum='\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. '+'Instead, write the async function inside your effect '+'and call it immediately:\n\n'+'useEffect(() => {\n'+' async function fetchData() {\n'+' // You can await here\n'+' const response = await MyAPI.getData(someId);\n'+' // ...\n'+' }\n'+' fetchData();\n'+"}, [someId]); // Or [] if effect doesn't need props or state\n\n"+'Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching';}else{addendum=' You returned: '+destroy;}error('An effect function must not return anything besides a function, '+'which is used for clean-up.%s',addendum);}}}effect=effect.next;}while(effect!==firstEffect);}}functionschedulePassiveEffects(finishedWork){varupdateQueue=finishedWork.updateQueue;varlastEffect=updateQueue!==null?updateQueue.lastEffect:null;if(lastEffect!==null){varfirstEffect=lastEffect.next;vareffect=firstEffect;do{var_effect=effect,next=_effect.next,tag=_effect.tag;if((tag&Passive$1)!==NoFlags$1&&(tag&HasEffect)!==NoFlags$1){enqueuePendingPassiveHookEffectUnmount(finishedWork,effect);enqueuePendingPassiveHookEffectMount(finishedWork,effect);}effect=next;}while(effect!==firstEffect);}}functioncommitLifeCycles(finishedRoot,current,finishedWork,committedLanes){switch(finishedWork.tag){caseFunctionComponent:caseForwardRef:caseSimpleMemoComponent:caseBlock:{// At this point layout effects have already been destroyed (during mutation phase).
// This is done to prevent sibling component effects from interfering with each other,
// e.g. a destroy function in one component should never override a ref set
// by a create function in another component during the same commit.
{commitHookEffectListMount(Layout|HasEffect,finishedWork);}schedulePassiveEffects(finishedWork);return;}caseClassComponent:{varinstance=finishedWork.stateNode;if(finishedWork.flags&Update){if(current===null){// We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
{if(finishedWork.type===finishedWork.elementType&&!didWarnAboutReassigningProps){if(instance.props!==finishedWork.memoizedProps){error('Expected %s props to match memoized props before '+'componentDidMount. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.props`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}if(instance.state!==finishedWork.memoizedState){error('Expected %s state to match memoized state before '+'componentDidMount. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.state`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}}}{instance.componentDidMount();}}else{varprevProps=finishedWork.elementType===finishedWork.type?current.memoizedProps:resolveDefaultProps(finishedWork.type,current.memoizedProps);varprevState=current.memoizedState;// We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
{if(finishedWork.type===finishedWork.elementType&&!didWarnAboutReassigningProps){if(instance.props!==finishedWork.memoizedProps){error('Expected %s props to match memoized props before '+'componentDidUpdate. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.props`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}if(instance.state!==finishedWork.memoizedState){error('Expected %s state to match memoized state before '+'componentDidUpdate. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.state`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}}}{instance.componentDidUpdate(prevProps,prevState,instance.__reactInternalSnapshotBeforeUpdate);}}}// TODO: I think this is now always non-null by the time it reaches the
// commit phase. Consider removing the type check.
varupdateQueue=finishedWork.updateQueue;if(updateQueue!==null){{if(finishedWork.type===finishedWork.elementType&&!didWarnAboutReassigningProps){if(instance.props!==finishedWork.memoizedProps){error('Expected %s props to match memoized props before '+'processing the update queue. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.props`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}if(instance.state!==finishedWork.memoizedState){error('Expected %s state to match memoized state before '+'processing the update queue. '+'This might either be because of a bug in React, or because '+'a component reassigns its own `this.state`. '+'Please file an issue.',getComponentName(finishedWork.type)||'instance');}}}// We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
commitUpdateQueue(finishedWork,updateQueue,instance);}return;}caseHostRoot:{// TODO: I think this is now always non-null by the time it reaches the
// commit phase. Consider removing the type check.
var_updateQueue=finishedWork.updateQueue;if(_updateQueue!==null){var_instance=null;if(finishedWork.child!==null){switch(finishedWork.child.tag){caseHostComponent:_instance=getPublicInstance(finishedWork.child.stateNode);break;caseClassComponent:_instance=finishedWork.child.stateNode;break;}}commitUpdateQueue(finishedWork,_updateQueue,_instance);}return;}caseHostComponent:{var_instance2=finishedWork.stateNode;// Renderers may schedule work to be done after host components are mounted
// (eg DOM renderer may schedule auto-focus for inputs and form controls).
// These effects should only be committed when components are first mounted,
// aka when there is no current/alternate.
if(current===null&&finishedWork.flags&Update){vartype=finishedWork.type;varprops=finishedWork.memoizedProps;commitMount(_instance2,type,props);}return;}caseHostText:{// We have no life-cycles associated with text.
return;}caseHostPortal:{// We have no life-cycles associated with portals.
return;}caseProfiler:{{var_finishedWork$memoize2=finishedWork.memoizedProps,onCommit=_finishedWork$memoize2.onCommit,onRender=_finishedWork$memoize2.onRender;vareffectDuration=finishedWork.stateNode.effectDuration;varcommitTime=getCommitTime();if(typeofonRender==='function'){{onRender(finishedWork.memoizedProps.id,current===null?'mount':'update',finishedWork.actualDuration,finishedWork.treeBaseDuration,finishedWork.actualStartTime,commitTime,finishedRoot.memoizedInteractions);}}}return;}caseSuspenseComponent:{commitSuspenseHydrationCallbacks(finishedRoot,finishedWork);return;}caseSuspenseListComponent:caseIncompleteClassComponent:caseFundamentalComponent:caseScopeComponent:caseOffscreenComponent:caseLegacyHiddenComponent:return;}{{throwError("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");}}}functionhideOrUnhideAllChildren(finishedWork,isHidden){{// We only have the top Fiber that was inserted but we need to recurse down its
// children to find all the terminal nodes.
varnode=finishedWork;while(true){if(node.tag===HostComponent){varinstance=node.stateNode;if(isHidden){hideInstance(instance);}else{unhideInstance(node.stateNode,node.memoizedProps);}}elseif(node.tag===HostText){var_instance3=node.stateNode;if(isHidden){hideTextInstance(_instance3);}else{unhideTextInstance(_instance3,node.memoizedProps);}}elseif((node.tag===OffscreenComponent||node.tag===LegacyHiddenComponent)&&node.memoizedState!==null&&node!==finishedWork);elseif(node.child!==null){node.child.return=node;node=node.child;continue;}if(node===finishedWork){return;}while(node.sibling===null){if(node.return===null||node.return===finishedWork){return;}node=node.return;}node.sibling.return=node.return;node=node.sibling;}}}functioncommitAttachRef(finishedWork){varref=finishedWork.ref;if(ref!==null){varinstance=finishedWork.stateNode;varinstanceToUse;switch(finishedWork.tag){caseHostComponent:instanceToUse=getPublicInstance(instance);break;default:instanceToUse=instance;}// Moved outside to ensure DCE works with this flag
if(typeofref==='function'){ref(instanceToUse);}else{{if(!ref.hasOwnProperty('current')){error('Unexpected ref object provided for %s. '+'Use either a ref-setter function or React.createRef().',getComponentName(finishedWork.type));}}ref.current=instanceToUse;}}}functioncommitDetachRef(current){varcurrentRef=current.ref;if(currentRef!==null){if(typeofcurrentRef==='function'){currentRef(null);}else{currentRef.current=null;}}}// User-originating errors (lifecycles and refs) should not interrupt
// deletion, so don't let them throw. Host-originating errors should
// interrupt deletion, so it's okay
functioncommitUnmount(finishedRoot,current,renderPriorityLevel){onCommitUnmount(current);switch(current.tag){caseFunctionComponent:caseForwardRef:caseMemoComponent:caseSimpleMemoComponent:caseBlock:{varupdateQueue=current.updateQueue;if(updateQueue!==null){varlastEffect=updateQueue.lastEffect;if(lastEffect!==null){varfirstEffect=lastEffect.next;vareffect=firstEffect;do{var_effect2=effect,destroy=_effect2.destroy,tag=_effect2.tag;if(destroy!==undefined){if((tag&Passive$1)!==NoFlags$1){enqueuePendingPassiveHookEffectUnmount(current,effect);}else{{safelyCallDestroy(current,destroy);}}}effect=effect.next;}while(effect!==firstEffect);}}return;}caseClassComponent:{safelyDetachRef(current);varinstance=current.stateNode;if(typeofinstance.componentWillUnmount==='function'){safelyCallComponentWillUnmount(current,instance);}return;}caseHostComponent:{safelyDetachRef(current);return;}caseHostPortal:{// TODO: this is recursive.
// We are also not using this parent because
// the portal will get pushed immediately.
{unmountHostComponents(finishedRoot,current);}return;}caseFundamentalComponent:{return;}caseDehydratedFragment:{return;}caseScopeComponent:{return;}}}functioncommitNestedUnmounts(finishedRoot,root,renderPriorityLevel){// While we're inside a removed host node we don't want to call
// removeChild on the inner nodes because they're removed by the top
// call anyway. We also want to call componentWillUnmount on all
// composites before this host node is removed from the tree. Therefore
// we do an inner loop while we're still inside the host node.
varnode=root;while(true){commitUnmount(finishedRoot,node);// Visit children because they may contain more composite or host nodes.
// Skip portals because commitUnmount() currently visits them recursively.
if(node.child!==null&&// If we use mutation we drill down into portals using commitUnmount above.
// If we don't use mutation we drill down into portals here instead.
node.tag!==HostPortal){node.child.return=node;node=node.child;continue;}if(node===root){return;}while(node.sibling===null){if(node.return===null||node.return===root){return;}node=node.return;}node.sibling.return=node.return;node=node.sibling;}}functiondetachFiberMutation(fiber){// Cut off the return pointers to disconnect it from the tree. Ideally, we
// should clear the child pointer of the parent alternate to let this
// get GC:ed but we don't know which for sure which parent is the current
// one so we'll settle for GC:ing the subtree of this child. This child
// itself will be GC:ed when the parent updates the next time.
// Note: we cannot null out sibling here, otherwise it can cause issues
// with findDOMNode and how it requires the sibling field to carry out
// traversal in a later effect. See PR #16820. We now clear the sibling
// field after effects, see: detachFiberAfterEffects.
//
// Don't disconnect stateNode now; it will be detached in detachFiberAfterEffects.
// It may be required if the current component is an error boundary,
// and one of its descendants throws while unmounting a passive effect.
fiber.alternate=null;fiber.child=null;fiber.dependencies=null;fiber.firstEffect=null;fiber.lastEffect=null;fiber.memoizedProps=null;fiber.memoizedState=null;fiber.pendingProps=null;fiber.return=null;fiber.updateQueue=null;{fiber._debugOwner=null;}}functiongetHostParentFiber(fiber){varparent=fiber.return;while(parent!==null){if(isHostParent(parent)){returnparent;}parent=parent.return;}{{throwError("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");}}}functionisHostParent(fiber){returnfiber.tag===HostComponent||fiber.tag===HostRoot||fiber.tag===HostPortal;}functiongetHostSibling(fiber){// We're going to search forward into the tree until we find a sibling host
// node. Unfortunately, if multiple insertions are done in a row we have to
// search past them. This leads to exponential search for the next sibling.
// TODO: Find a more efficient way to do this.
varnode=fiber;siblings:while(true){// If we didn't find anything, let's try the next sibling.
while(node.sibling===null){if(node.return===null||isHostParent(node.return)){// If we pop out of the root or hit the parent the fiber we are the
// last sibling.
returnnull;}node=node.return;}node.sibling.return=node.return;node=node.sibling;while(node.tag!==HostComponent&&node.tag!==HostText&&node.tag!==DehydratedFragment){// If it is not host node and, we might have a host node inside it.
// Try to search down until we find one.
if(node.flags&Placement){// If we don't have a child, try the siblings instead.
continuesiblings;}// If we don't have a child, try the siblings instead.
// We also skip portals because they are not part of this host tree.
if(node.child===null||node.tag===HostPortal){continuesiblings;}else{node.child.return=node;node=node.child;}}// Check if this host node is stable or about to be placed.
if(!(node.flags&Placement)){// Found it!
returnnode.stateNode;}}}functioncommitPlacement(finishedWork){varparentFiber=getHostParentFiber(finishedWork);// Note: these two variables *must* always be updated together.
default:{{throwError("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.");}}}if(parentFiber.flags&ContentReset){// Reset the text content of the parent before doing any insertions
resetTextContent(parent);// Clear ContentReset from the effect tag
parentFiber.flags&=~ContentReset;}varbefore=getHostSibling(finishedWork);// We only have the top Fiber that was inserted but we need to recurse down its
// children to find all the terminal nodes.
if(isContainer){insertOrAppendPlacementNodeIntoContainer(finishedWork,before,parent);}else{insertOrAppendPlacementNode(finishedWork,before,parent);}}functioninsertOrAppendPlacementNodeIntoContainer(node,before,parent){vartag=node.tag;varisHost=tag===HostComponent||tag===HostText;if(isHost||enableFundamentalAPI){varstateNode=isHost?node.stateNode:node.stateNode.instance;if(before){insertInContainerBefore(parent,stateNode,before);}else{appendChildToContainer(parent,stateNode);}}elseif(tag===HostPortal);else{varchild=node.child;if(child!==null){insertOrAppendPlacementNodeIntoContainer(child,before,parent);varsibling=child.sibling;while(sibling!==null){insertOrAppendPlacementNodeIntoContainer(sibling,before,parent);sibling=sibling.sibling;}}}}functioninsertOrAppendPlacementNode(node,before,parent){vartag=node.tag;varisHost=tag===HostComponent||tag===HostText;if(isHost||enableFundamentalAPI){varstateNode=isHost?node.stateNode:node.stateNode.instance;if(before){insertBefore(parent,stateNode,before);}else{appendChild(parent,stateNode);}}elseif(tag===HostPortal);else{varchild=node.child;if(child!==null){insertOrAppendPlacementNode(child,before,parent);varsibling=child.sibling;while(sibling!==null){insertOrAppendPlacementNode(sibling,before,parent);sibling=sibling.sibling;}}}}functionunmountHostComponents(finishedRoot,current,renderPriorityLevel){// We only have the top Fiber that was deleted but we need to recurse down its
// children to find all the terminal nodes.
varnode=current;// Each iteration, currentParent is populated with node's host parent if not
// currentParentIsValid.
varcurrentParentIsValid=false;// Note: these two variables *must* always be updated together.
varcurrentParent;varcurrentParentIsContainer;while(true){if(!currentParentIsValid){varparent=node.return;findParent:while(true){if(!(parent!==null)){{throwError("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");}}varparentStateNode=parent.stateNode;switch(parent.tag){caseHostComponent:currentParent=parentStateNode;currentParentIsContainer=false;breakfindParent;caseHostRoot:currentParent=parentStateNode.containerInfo;currentParentIsContainer=true;breakfindParent;caseHostPortal:currentParent=parentStateNode.containerInfo;currentParentIsContainer=true;breakfindParent;}parent=parent.return;}currentParentIsValid=true;}if(node.tag===HostComponent||node.tag===HostText){commitNestedUnmounts(finishedRoot,node);// After all the children have unmounted, it is now safe to remove the
// node from the tree.
if(currentParentIsContainer){removeChildFromContainer(currentParent,node.stateNode);}else{removeChild(currentParent,node.stateNode);}// Don't visit children because we already visited them.
}elseif(node.tag===HostPortal){if(node.child!==null){// When we go into a portal, it becomes the parent to remove from.
// We will reassign it back when we pop the portal on the way up.
currentParent=node.stateNode.containerInfo;currentParentIsContainer=true;// Visit children because portals might contain host components.
node.child.return=node;node=node.child;continue;}}else{commitUnmount(finishedRoot,node);// Visit children because we may find more host components below.
if(node.child!==null){node.child.return=node;node=node.child;continue;}}if(node===current){return;}while(node.sibling===null){if(node.return===null||node.return===current){return;}node=node.return;if(node.tag===HostPortal){// When we go out of the portal, we need to restore the parent.
// Since we don't keep a stack of them, we will search for it.
currentParentIsValid=false;}}node.sibling.return=node.return;node=node.sibling;}}functioncommitDeletion(finishedRoot,current,renderPriorityLevel){{// Recursively delete all host nodes from the parent.
// Detach refs and call componentWillUnmount() on the whole subtree.
unmountHostComponents(finishedRoot,current);}varalternate=current.alternate;detachFiberMutation(current);if(alternate!==null){detachFiberMutation(alternate);}}functioncommitWork(current,finishedWork){switch(finishedWork.tag){caseFunctionComponent:caseForwardRef:caseMemoComponent:caseSimpleMemoComponent:caseBlock:{// Layout effects are destroyed during the mutation phase so that all
// destroy functions for all fibers are called before any create functions.
// This prevents sibling component effects from interfering with each other,
// e.g. a destroy function in one component should never override a ref set
// by a create function in another component during the same commit.
{commitHookEffectListUnmount(Layout|HasEffect,finishedWork);}return;}caseClassComponent:{return;}caseHostComponent:{varinstance=finishedWork.stateNode;if(instance!=null){// Commit the work prepared earlier.
varnewProps=finishedWork.memoizedProps;// For hydration we reuse the update path but we treat the oldProps
// as the newProps. The updatePayload will contain the real change in
// this case.
varoldProps=current!==null?current.memoizedProps:newProps;vartype=finishedWork.type;// TODO: Type the updateQueue to be specific to host components.
varupdatePayload=finishedWork.updateQueue;finishedWork.updateQueue=null;if(updatePayload!==null){commitUpdate(instance,updatePayload,type,oldProps,newProps);}}return;}caseHostText:{if(!(finishedWork.stateNode!==null)){{throwError("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.");}}vartextInstance=finishedWork.stateNode;varnewText=finishedWork.memoizedProps;// For hydration we reuse the update path but we treat the oldProps
// as the newProps. The updatePayload will contain the real change in
// this case.
varoldText=current!==null?current.memoizedProps:newText;commitTextUpdate(textInstance,oldText,newText);return;}caseHostRoot:{{var_root=finishedWork.stateNode;if(_root.hydrate){// We've just hydrated. No need to hydrate again.
_root.hydrate=false;commitHydratedContainer(_root.containerInfo);}}return;}caseProfiler:{return;}caseSuspenseComponent:{commitSuspenseComponent(finishedWork);attachSuspenseRetryListeners(finishedWork);return;}caseSuspenseListComponent:{attachSuspenseRetryListeners(finishedWork);return;}caseIncompleteClassComponent:{return;}caseFundamentalComponent:{break;}caseScopeComponent:{break;}caseOffscreenComponent:caseLegacyHiddenComponent:{varnewState=finishedWork.memoizedState;varisHidden=newState!==null;hideOrUnhideAllChildren(finishedWork,isHidden);return;}}{{throwError("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");}}}functioncommitSuspenseComponent(finishedWork){varnewState=finishedWork.memoizedState;if(newState!==null){markCommitTimeOfFallback();{// Hide the Offscreen component that contains the primary children. TODO:
// Ideally, this effect would have been scheduled on the Offscreen fiber
// itself. That's how unhiding works: the Offscreen component schedules an
// effect on itself. However, in this case, the component didn't complete,
// so the fiber was never added to the effect list in the normal path. We
// could have appended it to the effect list in the Suspense component's
// second pass, but doing it this way is less complicated. This would be
// simpler if we got rid of the effect list and traversed the tree, like
// we're planning to do.
varprimaryChildParent=finishedWork.child;hideOrUnhideAllChildren(primaryChildParent,true);}}}functioncommitSuspenseHydrationCallbacks(finishedRoot,finishedWork){varnewState=finishedWork.memoizedState;if(newState===null){varcurrent=finishedWork.alternate;if(current!==null){varprevState=current.memoizedState;if(prevState!==null){varsuspenseInstance=prevState.dehydrated;if(suspenseInstance!==null){commitHydratedSuspenseInstance(suspenseInstance);}}}}}functionattachSuspenseRetryListeners(finishedWork){// If this boundary just timed out, then it will have a set of wakeables.
// For each wakeable, attach a listener so that when it resolves, React
// attempts to re-render the boundary in the primary (pre-timeout) state.
varwakeables=finishedWork.updateQueue;if(wakeables!==null){finishedWork.updateQueue=null;varretryCache=finishedWork.stateNode;if(retryCache===null){retryCache=finishedWork.stateNode=newPossiblyWeakSet();}wakeables.forEach(function(wakeable){// Memoize using the boundary fiber to prevent redundant listeners.
varretry=resolveRetryWakeable.bind(null,finishedWork,wakeable);if(!retryCache.has(wakeable)){{if(wakeable.__reactDoNotTraceInteractions!==true){retry=tracing$1.unstable_wrap(retry);}}retryCache.add(wakeable);wakeable.then(retry,retry);}});}}// This function detects when a Suspense boundary goes from visible to hidden.
// It returns false if the boundary is already hidden.
// TODO: Use an effect tag.
functionisSuspenseBoundaryBeingHidden(current,finishedWork){if(current!==null){varoldState=current.memoizedState;if(oldState===null||oldState.dehydrated!==null){varnewState=finishedWork.memoizedState;returnnewState!==null&&newState.dehydrated===null;}}returnfalse;}functioncommitResetTextContent(current){resetTextContent(current.stateNode);}varCOMPONENT_TYPE=0;varHAS_PSEUDO_CLASS_TYPE=1;varROLE_TYPE=2;varTEST_NAME_TYPE=3;varTEXT_TYPE=4;if(typeofSymbol==='function'&&Symbol.for){varsymbolFor$1=Symbol.for;COMPONENT_TYPE=symbolFor$1('selector.component');HAS_PSEUDO_CLASS_TYPE=symbolFor$1('selector.has_pseudo_class');ROLE_TYPE=symbolFor$1('selector.role');TEST_NAME_TYPE=symbolFor$1('selector.test_id');TEXT_TYPE=symbolFor$1('selector.text');}varcommitHooks=[];functiononCommitRoot$1(){{commitHooks.forEach(function(commitHook){returncommitHook();});}}varceil=Math.ceil;varReactCurrentDispatcher$2=ReactSharedInternals.ReactCurrentDispatcher,ReactCurrentOwner$2=ReactSharedInternals.ReactCurrentOwner,IsSomeRendererActing=ReactSharedInternals.IsSomeRendererActing;varNoContext=/* */0;varBatchedContext=/* */1;varEventContext=/* */2;varDiscreteEventContext=/* */4;varLegacyUnbatchedContext=/* */8;varRenderContext=/* */16;varCommitContext=/* */32;varRetryAfterError=/* */64;varRootIncomplete=0;varRootFatalErrored=1;varRootErrored=2;varRootSuspended=3;varRootSuspendedWithDelay=4;varRootCompleted=5;// Describes where we are in the React execution stack
varexecutionContext=NoContext;// The root we're working on
varworkInProgressRoot=null;// The fiber we're working on
varworkInProgress=null;// The lanes we're rendering
varworkInProgressRootRenderLanes=NoLanes;// Stack that allows components to change the render lanes for its subtree
// This is a superset of the lanes we started working on at the root. The only
// case where it's different from `workInProgressRootRenderLanes` is when we
// enter a subtree that is hidden and needs to be unhidden: Suspense and
// Offscreen component.
//
// Most things in the work loop should deal with workInProgressRootRenderLanes.
// Most things in begin/complete phases should deal with subtreeRenderLanes.
varsubtreeRenderLanes=NoLanes;varsubtreeRenderLanesCursor=createCursor(NoLanes);// Whether to root completed, errored, suspended, etc.
varworkInProgressRootExitStatus=RootIncomplete;// A fatal error, if one is thrown
varworkInProgressRootFatalError=null;// "Included" lanes refer to lanes that were worked on during this render. It's
// slightly different than `renderLanes` because `renderLanes` can change as you
// enter and exit an Offscreen tree. This value is the combination of all render
// lanes for the entire render phase.
varworkInProgressRootIncludedLanes=NoLanes;// The work left over by components that were visited during this render. Only
// includes unprocessed updates, not work in bailed out children.
varworkInProgressRootSkippedLanes=NoLanes;// Lanes that were updated (in an interleaved event) during this render.
varworkInProgressRootUpdatedLanes=NoLanes;// Lanes that were pinged (in an interleaved event) during this render.
varworkInProgressRootPingedLanes=NoLanes;varmostRecentlyUpdatedRoot=null;// The most recent time we committed a fallback. This lets us ensure a train
// model where we don't commit new loading states in too quick succession.
varglobalMostRecentFallbackTime=0;varFALLBACK_THROTTLE_MS=500;// The absolute time for when we should start giving up on rendering
// more and prefer CPU suspense heuristics instead.
varworkInProgressRootRenderTargetTime=Infinity;// How long a render is supposed to take before we start following CPU
// suspense heuristics and opt out of rendering more content.
varRENDER_TIMEOUT_MS=500;functionresetRenderTimer(){workInProgressRootRenderTargetTime=now()+RENDER_TIMEOUT_MS;}functiongetRenderTargetTime(){returnworkInProgressRootRenderTargetTime;}varnextEffect=null;varhasUncaughtError=false;varfirstUncaughtError=null;varlegacyErrorBoundariesThatAlreadyFailed=null;varrootDoesHavePassiveEffects=false;varrootWithPendingPassiveEffects=null;varpendingPassiveEffectsRenderPriority=NoPriority$1;varpendingPassiveEffectsLanes=NoLanes;varpendingPassiveHookEffectsMount=[];varpendingPassiveHookEffectsUnmount=[];varrootsWithPendingDiscreteUpdates=null;// Use these to prevent an infinite loop of nested updates
varNESTED_UPDATE_LIMIT=50;varnestedUpdateCount=0;varrootWithNestedUpdates=null;varNESTED_PASSIVE_UPDATE_LIMIT=50;varnestedPassiveUpdateCount=0;// Marks the need to reschedule pending interactions at these lanes
// during the commit phase. This enables them to be traced across components
// that spawn new work during render. E.g. hidden boundaries, suspended SSR
// hydration or SuspenseList.
// TODO: Can use a bitmask instead of an array
varspawnedWorkDuringRender=null;// If two updates are scheduled within the same event, we should treat their
// event times as simultaneous, even if the actual clock time has advanced
// between the first and second call.
varcurrentEventTime=NoTimestamp;varcurrentEventWipLanes=NoLanes;varcurrentEventPendingLanes=NoLanes;// Dev only flag that tracks if passive effects are currently being flushed.
// We warn about state updates for unmounted components differently in this case.
varisFlushingPassiveEffects=false;varfocusedInstanceHandle=null;varshouldFireAfterActiveInstanceBlur=false;functiongetWorkInProgressRoot(){returnworkInProgressRoot;}functionrequestEventTime(){if((executionContext&(RenderContext|CommitContext))!==NoContext){// We're inside React, so it's fine to read the actual time.
returnnow();}// We're not inside React, so we may be in the middle of a browser event.
if(currentEventTime!==NoTimestamp){// Use the same start time for all updates until we enter React again.
returncurrentEventTime;}// This is the first update since React yielded. Compute a new start time.
currentEventTime=now();returncurrentEventTime;}functionrequestUpdateLane(fiber){// Special cases
varmode=fiber.mode;if((mode&BlockingMode)===NoMode){returnSyncLane;}elseif((mode&ConcurrentMode)===NoMode){returngetCurrentPriorityLevel()===ImmediatePriority$1?SyncLane:SyncBatchedLane;}// The algorithm for assigning an update to a lane should be stable for all
// updates at the same priority within the same event. To do this, the inputs
// to the algorithm must be the same. For example, we use the `renderLanes`
// to avoid choosing a lane that is already in the middle of rendering.
//
// However, the "included" lanes could be mutated in between updates in the
// same event, like if you perform an update inside `flushSync`. Or any other
// code path that might call `prepareFreshStack`.
//
// The trick we use is to cache the first of each of these inputs within an
// event. Then reset the cached values once we can be sure the event is over.
// Our heuristic for that is whenever we enter a concurrent work loop.
//
// We'll do the same for `currentEventPendingLanes` below.
if(currentEventWipLanes===NoLanes){currentEventWipLanes=workInProgressRootIncludedLanes;}varisTransition=requestCurrentTransition()!==NoTransition;if(isTransition){if(currentEventPendingLanes!==NoLanes){currentEventPendingLanes=mostRecentlyUpdatedRoot!==null?mostRecentlyUpdatedRoot.pendingLanes:NoLanes;}returnfindTransitionLane(currentEventWipLanes,currentEventPendingLanes);}// TODO: Remove this dependency on the Scheduler priority.
// To do that, we're replacing it with an update lane priority.
varschedulerPriority=getCurrentPriorityLevel();// The old behavior was using the priority level of the Scheduler.
// This couples React to the Scheduler internals, so we're replacing it
// with the currentUpdateLanePriority above. As an example of how this
// could be problematic, if we're not inside `Scheduler.runWithPriority`,
// then we'll get the priority of the current running Scheduler task,
// which is probably not what we want.
varlane;if(// TODO: Temporary. We're removing the concept of discrete updates.
(executionContext&DiscreteEventContext)!==NoContext&&schedulerPriority===UserBlockingPriority$2){lane=findUpdateLane(InputDiscreteLanePriority,currentEventWipLanes);}else{varschedulerLanePriority=schedulerPriorityToLanePriority(schedulerPriority);lane=findUpdateLane(schedulerLanePriority,currentEventWipLanes);}returnlane;}functionrequestRetryLane(fiber){// This is a fork of `requestUpdateLane` designed specifically for Suspense
// "retries" — a special update that attempts to flip a Suspense boundary
// from its placeholder state to its primary/resolved state.
// Special cases
varmode=fiber.mode;if((mode&BlockingMode)===NoMode){returnSyncLane;}elseif((mode&ConcurrentMode)===NoMode){returngetCurrentPriorityLevel()===ImmediatePriority$1?SyncLane:SyncBatchedLane;}// See `requestUpdateLane` for explanation of `currentEventWipLanes`
if(currentEventWipLanes===NoLanes){currentEventWipLanes=workInProgressRootIncludedLanes;}returnfindRetryLane(currentEventWipLanes);}functionscheduleUpdateOnFiber(fiber,lane,eventTime){checkForNestedUpdates();warnAboutRenderPhaseUpdatesInDEV(fiber);varroot=markUpdateLaneFromFiberToRoot(fiber,lane);if(root===null){warnAboutUpdateOnUnmountedFiberInDEV(fiber);returnnull;}// Mark that the root has a pending update.
markRootUpdated(root,lane,eventTime);if(root===workInProgressRoot){// Received an update to a tree that's in the middle of rendering. Mark
// that there was an interleaved update work on this root. Unless the
// `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
// phase update. In that case, we don't treat render phase updates as if
// they were interleaved, for backwards compat reasons.
{workInProgressRootUpdatedLanes=mergeLanes(workInProgressRootUpdatedLanes,lane);}if(workInProgressRootExitStatus===RootSuspendedWithDelay){// The root already suspended with a delay, which means this render
// definitely won't finish. Since we have a new update, let's mark it as
// suspended now, right before marking the incoming update. This has the
// effect of interrupting the current render and switching to the update.
// TODO: Make sure this doesn't override pings that happen while we've
// already started rendering.
markRootSuspended$1(root,workInProgressRootRenderLanes);}}// TODO: requestUpdateLanePriority also reads the priority. Pass the
// priority as an argument to that function and this one.
varpriorityLevel=getCurrentPriorityLevel();if(lane===SyncLane){if(// Check if we're inside unbatchedUpdates
(executionContext&LegacyUnbatchedContext)!==NoContext&&// Check if we're not already rendering
(executionContext&(RenderContext|CommitContext))===NoContext){// Register pending interactions on the root to avoid losing traced interaction data.
schedulePendingInteractions(root,lane);// This is a legacy edge case. The initial mount of a ReactDOM.render-ed
// root inside of batchedUpdates should be synchronous, but layout updates
// should be deferred until the end of the batch.
performSyncWorkOnRoot(root);}else{ensureRootIsScheduled(root,eventTime);schedulePendingInteractions(root,lane);if(executionContext===NoContext){// Flush the synchronous work now, unless we're already working or inside
// a batch. This is intentionally inside scheduleUpdateOnFiber instead of
// scheduleCallbackForFiber to preserve the ability to schedule a callback
// without immediately flushing it. We only do this for user-initiated
// updates, to preserve historical behavior of legacy mode.
resetRenderTimer();flushSyncCallbackQueue();}}}else{// Schedule a discrete update but only if it's not Sync.
if((executionContext&DiscreteEventContext)!==NoContext&&(// Only updates at user-blocking priority or greater are considered
// discrete, even inside a discrete event.
priorityLevel===UserBlockingPriority$2||priorityLevel===ImmediatePriority$1)){// This is the result of a discrete event. Track the lowest priority
// discrete update per root so we can flush them early, if needed.
if(rootsWithPendingDiscreteUpdates===null){rootsWithPendingDiscreteUpdates=newSet([root]);}else{rootsWithPendingDiscreteUpdates.add(root);}}// Schedule other updates after in case the callback is sync.
ensureRootIsScheduled(root,eventTime);schedulePendingInteractions(root,lane);}// We use this when assigning a lane for a transition inside
// `requestUpdateLane`. We assume it's the same as the root being updated,
// since in the common case of a single root app it probably is. If it's not
// the same root, then it's not a huge deal, we just might batch more stuff
// together more than necessary.
mostRecentlyUpdatedRoot=root;}// This is split into a separate function so we can mark a fiber with pending
// work without treating it as a typical update that originates from an event;
// e.g. retrying a Suspense boundary isn't an update, but it does schedule work
// on a fiber.
functionmarkUpdateLaneFromFiberToRoot(sourceFiber,lane){// Update the source fiber's lanes
sourceFiber.lanes=mergeLanes(sourceFiber.lanes,lane);varalternate=sourceFiber.alternate;if(alternate!==null){alternate.lanes=mergeLanes(alternate.lanes,lane);}{if(alternate===null&&(sourceFiber.flags&(Placement|Hydrating))!==NoFlags){warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);}}// Walk the parent path to the root and update the child expiration time.
varnode=sourceFiber;varparent=sourceFiber.return;while(parent!==null){parent.childLanes=mergeLanes(parent.childLanes,lane);alternate=parent.alternate;if(alternate!==null){alternate.childLanes=mergeLanes(alternate.childLanes,lane);}else{{if((parent.flags&(Placement|Hydrating))!==NoFlags){warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);}}}node=parent;parent=parent.return;}if(node.tag===HostRoot){varroot=node.stateNode;returnroot;}else{returnnull;}}// Use this function to schedule a task for a root. There's only one task per
// root; if a task was already scheduled, we'll check to make sure the priority
// of the existing task is the same as the priority of the next level that the
// root has work on. This function is called on every update, and right before
// exiting a task.
functionensureRootIsScheduled(root,currentTime){varexistingCallbackNode=root.callbackNode;// Check if any lanes are being starved by other work. If so, mark them as
// expired so we know to work on those next.
markStarvedLanesAsExpired(root,currentTime);// Determine the next lanes to work on, and their priority.
varnextLanes=getNextLanes(root,root===workInProgressRoot?workInProgressRootRenderLanes:NoLanes);// This returns the priority level computed during the `getNextLanes` call.
varnewCallbackPriority=returnNextLanesPriority();if(nextLanes===NoLanes){// Special case: There's nothing to work on.
if(existingCallbackNode!==null){cancelCallback(existingCallbackNode);root.callbackNode=null;root.callbackPriority=NoLanePriority;}return;}// Check if there's an existing task. We may be able to reuse it.
if(existingCallbackNode!==null){varexistingCallbackPriority=root.callbackPriority;if(existingCallbackPriority===newCallbackPriority){// The priority hasn't changed. We can reuse the existing task. Exit.
return;}// The priority changed. Cancel the existing callback. We'll schedule a new
// one below.
cancelCallback(existingCallbackNode);}// Schedule a new callback.
varnewCallbackNode;if(newCallbackPriority===SyncLanePriority){// Special case: Sync React callbacks are scheduled on a special
// internal queue
newCallbackNode=scheduleSyncCallback(performSyncWorkOnRoot.bind(null,root));}elseif(newCallbackPriority===SyncBatchedLanePriority){newCallbackNode=scheduleCallback(ImmediatePriority$1,performSyncWorkOnRoot.bind(null,root));}else{varschedulerPriorityLevel=lanePriorityToSchedulerPriority(newCallbackPriority);newCallbackNode=scheduleCallback(schedulerPriorityLevel,performConcurrentWorkOnRoot.bind(null,root));}root.callbackPriority=newCallbackPriority;root.callbackNode=newCallbackNode;}// This is the entry point for every concurrent task, i.e. anything that
// goes through Scheduler.
functionperformConcurrentWorkOnRoot(root){// Since we know we're in a React event, we can clear the current
// event time. The next update will compute a new event time.
currentEventTime=NoTimestamp;currentEventWipLanes=NoLanes;currentEventPendingLanes=NoLanes;if(!((executionContext&(RenderContext|CommitContext))===NoContext)){{throwError("Should not already be working.");}}// Flush any pending passive effects before deciding which lanes to work on,
// in case they schedule additional work.
varoriginalCallbackNode=root.callbackNode;vardidFlushPassiveEffects=flushPassiveEffects();if(didFlushPassiveEffects){// Something in the passive effect phase may have canceled the current task.
// Check if the task node for this root was changed.
if(root.callbackNode!==originalCallbackNode){// The current task was canceled. Exit. We don't need to call
// `ensureRootIsScheduled` because the check above implies either that
// there's a new task, or that there's no remaining work on this root.
returnnull;}}// Determine the next expiration time to work on, using the fields stored
// on the root.
varlanes=getNextLanes(root,root===workInProgressRoot?workInProgressRootRenderLanes:NoLanes);if(lanes===NoLanes){// Defensive coding. This is never expected to happen.
returnnull;}varexitStatus=renderRootConcurrent(root,lanes);if(includesSomeLane(workInProgressRootIncludedLanes,workInProgressRootUpdatedLanes)){// The render included lanes that were updated during the render phase.
// For example, when unhiding a hidden tree, we include all the lanes
// that were previously skipped when the tree was hidden. That set of
// lanes is a superset of the lanes we started rendering with.
//
// So we'll throw out the current work and restart.
prepareFreshStack(root,NoLanes);}elseif(exitStatus!==RootIncomplete){if(exitStatus===RootErrored){executionContext|=RetryAfterError;// If an error occurred during hydration,
// discard server response and fall back to client side render.
if(root.hydrate){root.hydrate=false;clearContainer(root.containerInfo);}// If something threw an error, try rendering one more time. We'll render
// synchronously to block concurrent data mutations, and we'll includes
// all pending updates are included. If it still fails after the second
// attempt, we'll give up and commit the resulting tree.
lanes=getLanesToRetrySynchronouslyOnError(root);if(lanes!==NoLanes){exitStatus=renderRootSync(root,lanes);}}if(exitStatus===RootFatalErrored){varfatalError=workInProgressRootFatalError;prepareFreshStack(root,NoLanes);markRootSuspended$1(root,lanes);ensureRootIsScheduled(root,now());throwfatalError;}// We now have a consistent tree. The next step is either to commit it,
// or, if something suspended, wait to commit it after a timeout.
varfinishedWork=root.current.alternate;root.finishedWork=finishedWork;root.finishedLanes=lanes;finishConcurrentRender(root,exitStatus,lanes);}ensureRootIsScheduled(root,now());if(root.callbackNode===originalCallbackNode){// The task node scheduled for this root is the same one that's
// currently executed. Need to return a continuation.
returnperformConcurrentWorkOnRoot.bind(null,root);}returnnull;}functionfinishConcurrentRender(root,exitStatus,lanes){switch(exitStatus){caseRootIncomplete:caseRootFatalErrored:{{{throwError("Root did not complete. This is a bug in React.");}}}// Flow knows about invariant, so it complains if I add a break
// statement, but eslint doesn't know about invariant, so it complains
// if I do. eslint-disable-next-line no-fallthrough
caseRootErrored:{// We should have already attempted to retry this tree. If we reached
// this point, it errored again. Commit it.
commitRoot(root);break;}caseRootSuspended:{markRootSuspended$1(root,lanes);// We have an acceptable loading state. We need to figure out if we
// should immediately commit it or wait a bit.
if(includesOnlyRetries(lanes)&&// do not delay if we're inside an act() scope
!shouldForceFlushFallbacksInDEV()){// This render only included retries, no updates. Throttle committing
// retries so that we don't show too many loading states too quickly.
varmsUntilTimeout=globalMostRecentFallbackTime+FALLBACK_THROTTLE_MS-now();// Don't bother with a very short suspense time.
if(msUntilTimeout>10){varnextLanes=getNextLanes(root,NoLanes);if(nextLanes!==NoLanes){// There's additional work on this root.
break;}varsuspendedLanes=root.suspendedLanes;if(!isSubsetOfLanes(suspendedLanes,lanes)){// We should prefer to render the fallback of at the last
// suspended level. Ping the last suspended level to try
// rendering it again.
// FIXME: What if the suspended lanes are Idle? Should not restart.
vareventTime=requestEventTime();markRootPinged(root,suspendedLanes);break;}// The render is suspended, it hasn't timed out, and there's no
// lower priority work to do. Instead of committing the fallback
// immediately, wait for more data to arrive.
root.timeoutHandle=scheduleTimeout(commitRoot.bind(null,root),msUntilTimeout);break;}}// The work expired. Commit immediately.
commitRoot(root);break;}caseRootSuspendedWithDelay:{markRootSuspended$1(root,lanes);if(includesOnlyTransitions(lanes)){// This is a transition, so we should exit without committing a
// placeholder and without scheduling a timeout. Delay indefinitely
// until we receive more data.
break;}{// This is not a transition, but we did trigger an avoided state.
// Schedule a placeholder to display after a short delay, using the Just
// Noticeable Difference.
// TODO: Is the JND optimization worth the added complexity? If this is
// the only reason we track the event time, then probably not.
// Consider removing.
varmostRecentEventTime=getMostRecentEventTime(root,lanes);vareventTimeMs=mostRecentEventTime;vartimeElapsedMs=now()-eventTimeMs;var_msUntilTimeout=jnd(timeElapsedMs)-timeElapsedMs;// Don't bother with a very short suspense time.
if(_msUntilTimeout>10){// Instead of committing the fallback immediately, wait for more data
// to arrive.
root.timeoutHandle=scheduleTimeout(commitRoot.bind(null,root),_msUntilTimeout);break;}}// Commit the placeholder.
commitRoot(root);break;}caseRootCompleted:{// The work completed. Ready to commit.
commitRoot(root);break;}default:{{{throwError("Unknown root exit status.");}}}}}functionmarkRootSuspended$1(root,suspendedLanes){// When suspending, we should always exclude lanes that were pinged or (more
// rarely, since we try to avoid it) updated during the render phase.
// TODO: Lol maybe there's a better way to factor this besides this
// obnoxiously named function :)
suspendedLanes=removeLanes(suspendedLanes,workInProgressRootPingedLanes);suspendedLanes=removeLanes(suspendedLanes,workInProgressRootUpdatedLanes);markRootSuspended(root,suspendedLanes);}// This is the entry point for synchronous tasks that don't go
// through Scheduler
functionperformSyncWorkOnRoot(root){if(!((executionContext&(RenderContext|CommitContext))===NoContext)){{throwError("Should not already be working.");}}flushPassiveEffects();varlanes;varexitStatus;if(root===workInProgressRoot&&includesSomeLane(root.expiredLanes,workInProgressRootRenderLanes)){// There's a partial tree, and at least one of its lanes has expired. Finish
// rendering it before rendering the rest of the expired work.
lanes=workInProgressRootRenderLanes;exitStatus=renderRootSync(root,lanes);if(includesSomeLane(workInProgressRootIncludedLanes,workInProgressRootUpdatedLanes)){// The render included lanes that were updated during the render phase.
// For example, when unhiding a hidden tree, we include all the lanes
// that were previously skipped when the tree was hidden. That set of
// lanes is a superset of the lanes we started rendering with.
//
// Note that this only happens when part of the tree is rendered
// concurrently. If the whole tree is rendered synchronously, then there
// are no interleaved events.
lanes=getNextLanes(root,lanes);exitStatus=renderRootSync(root,lanes);}}else{lanes=getNextLanes(root,NoLanes);exitStatus=renderRootSync(root,lanes);}if(root.tag!==LegacyRoot&&exitStatus===RootErrored){executionContext|=RetryAfterError;// If an error occurred during hydration,
// discard server response and fall back to client side render.
if(root.hydrate){root.hydrate=false;clearContainer(root.containerInfo);}// If something threw an error, try rendering one more time. We'll render
// synchronously to block concurrent data mutations, and we'll includes
// all pending updates are included. If it still fails after the second
// attempt, we'll give up and commit the resulting tree.
lanes=getLanesToRetrySynchronouslyOnError(root);if(lanes!==NoLanes){exitStatus=renderRootSync(root,lanes);}}if(exitStatus===RootFatalErrored){varfatalError=workInProgressRootFatalError;prepareFreshStack(root,NoLanes);markRootSuspended$1(root,lanes);ensureRootIsScheduled(root,now());throwfatalError;}// We now have a consistent tree. Because this is a sync render, we
// will commit it even if something suspended.
varfinishedWork=root.current.alternate;root.finishedWork=finishedWork;root.finishedLanes=lanes;commitRoot(root);// Before exiting, make sure there's a callback scheduled for the next
// pending level.
ensureRootIsScheduled(root,now());returnnull;}functionflushDiscreteUpdates(){// TODO: Should be able to flush inside batchedUpdates, but not inside `act`.
// However, `act` uses `batchedUpdates`, so there's no way to distinguish
// those two cases. Need to fix this before exposing flushDiscreteUpdates
// as a public API.
if((executionContext&(BatchedContext|RenderContext|CommitContext))!==NoContext){{if((executionContext&RenderContext)!==NoContext){error('unstable_flushDiscreteUpdates: Cannot flush updates when React is '+'already rendering.');}}// We're already rendering, so we can't synchronously flush pending work.
// This is probably a nested event dispatch triggered by a lifecycle/effect,
// like `el.focus()`. Exit.
return;}flushPendingDiscreteUpdates();// If the discrete updates scheduled passive effects, flush them now so that
// they fire before the next serial event.
flushPassiveEffects();}functionflushPendingDiscreteUpdates(){if(rootsWithPendingDiscreteUpdates!==null){// For each root with pending discrete updates, schedule a callback to
// immediately flush them.
varroots=rootsWithPendingDiscreteUpdates;rootsWithPendingDiscreteUpdates=null;roots.forEach(function(root){markDiscreteUpdatesExpired(root);ensureRootIsScheduled(root,now());});}// Now flush the immediate queue.
flushSyncCallbackQueue();}functionbatchedUpdates$1(fn,a){varprevExecutionContext=executionContext;executionContext|=BatchedContext;try{returnfn(a);}finally{executionContext=prevExecutionContext;if(executionContext===NoContext){// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();flushSyncCallbackQueue();}}}functionbatchedEventUpdates$1(fn,a){varprevExecutionContext=executionContext;executionContext|=EventContext;try{returnfn(a);}finally{executionContext=prevExecutionContext;if(executionContext===NoContext){// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();flushSyncCallbackQueue();}}}functiondiscreteUpdates$1(fn,a,b,c,d){varprevExecutionContext=executionContext;executionContext|=DiscreteEventContext;{try{returnrunWithPriority$1(UserBlockingPriority$2,fn.bind(null,a,b,c,d));}finally{executionContext=prevExecutionContext;if(executionContext===NoContext){// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();flushSyncCallbackQueue();}}}}functionunbatchedUpdates(fn,a){varprevExecutionContext=executionContext;executionContext&=~BatchedContext;executionContext|=LegacyUnbatchedContext;try{returnfn(a);}finally{executionContext=prevExecutionContext;if(executionContext===NoContext){// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();flushSyncCallbackQueue();}}}functionflushSync(fn,a){varprevExecutionContext=executionContext;if((prevExecutionContext&(RenderContext|CommitContext))!==NoContext){{error('flushSync was called from inside a lifecycle method. React cannot '+'flush when React is already rendering. Consider moving this call to '+'a scheduler task or micro task.');}returnfn(a);}executionContext|=BatchedContext;{try{if(fn){returnrunWithPriority$1(ImmediatePriority$1,fn.bind(null,a));}else{returnundefined;}}finally{executionContext=prevExecutionContext;// Flush the immediate callbacks that were scheduled during this batch.
// Note that this will happen even if batchedUpdates is higher up
// the stack.
flushSyncCallbackQueue();}}}functionpushRenderLanes(fiber,lanes){push(subtreeRenderLanesCursor,subtreeRenderLanes,fiber);subtreeRenderLanes=mergeLanes(subtreeRenderLanes,lanes);workInProgressRootIncludedLanes=mergeLanes(workInProgressRootIncludedLanes,lanes);}functionpopRenderLanes(fiber){subtreeRenderLanes=subtreeRenderLanesCursor.current;pop(subtreeRenderLanesCursor,fiber);}functionprepareFreshStack(root,lanes){root.finishedWork=null;root.finishedLanes=NoLanes;vartimeoutHandle=root.timeoutHandle;if(timeoutHandle!==noTimeout){// The root previous suspended and scheduled a timeout to commit a fallback
// state. Now that we have additional work, cancel the timeout.
root.timeoutHandle=noTimeout;// $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
cancelTimeout(timeoutHandle);}if(workInProgress!==null){varinterruptedWork=workInProgress.return;while(interruptedWork!==null){unwindInterruptedWork(interruptedWork);interruptedWork=interruptedWork.return;}}workInProgressRoot=root;workInProgress=createWorkInProgress(root.current,null);workInProgressRootRenderLanes=subtreeRenderLanes=workInProgressRootIncludedLanes=lanes;workInProgressRootExitStatus=RootIncomplete;workInProgressRootFatalError=null;workInProgressRootSkippedLanes=NoLanes;workInProgressRootUpdatedLanes=NoLanes;workInProgressRootPingedLanes=NoLanes;{spawnedWorkDuringRender=null;}{ReactStrictModeWarnings.discardPendingWarnings();}}functionhandleError(root,thrownValue){do{varerroredWork=workInProgress;try{// Reset module-level state that was set during the render phase.
resetContextDependencies();resetHooksAfterThrow();resetCurrentFiber();// TODO: I found and added this missing line while investigating a
// separate issue. Write a regression test using string refs.
ReactCurrentOwner$2.current=null;if(erroredWork===null||erroredWork.return===null){// Expected to be working on a non-root fiber. This is a fatal error
// because there's no ancestor that can handle it; the root is
// supposed to capture all errors that weren't caught by an error
// boundary.
workInProgressRootExitStatus=RootFatalErrored;workInProgressRootFatalError=thrownValue;// Set `workInProgress` to null. This represents advancing to the next
// sibling, or the parent if there are no siblings. But since the root
// has no siblings nor a parent, we set it to null. Usually this is
// handled by `completeUnitOfWork` or `unwindWork`, but since we're
// intentionally not calling those, we need set it here.
// TODO: Consider calling `unwindWork` to pop the contexts.
workInProgress=null;return;}if(enableProfilerTimer&&erroredWork.mode&ProfileMode){// Record the time spent rendering before an error was thrown. This
// avoids inaccurate Profiler durations in the case of a
// suspended render.
stopProfilerTimerIfRunningAndRecordDelta(erroredWork,true);}throwException(root,erroredWork.return,erroredWork,thrownValue,workInProgressRootRenderLanes);completeUnitOfWork(erroredWork);}catch(yetAnotherThrownValue){// Something in the return path also threw.
thrownValue=yetAnotherThrownValue;if(workInProgress===erroredWork&&erroredWork!==null){// If this boundary has already errored, then we had trouble processing
// the error. Bubble it to the next boundary.
erroredWork=erroredWork.return;workInProgress=erroredWork;}else{erroredWork=workInProgress;}continue;}// Return to the normal work loop.
return;}while(true);}functionpushDispatcher(){varprevDispatcher=ReactCurrentDispatcher$2.current;ReactCurrentDispatcher$2.current=ContextOnlyDispatcher;if(prevDispatcher===null){// The React isomorphic package does not include a default dispatcher.
// Instead the first renderer will lazily attach one, in order to give
// nicer error messages.
returnContextOnlyDispatcher;}else{returnprevDispatcher;}}functionpopDispatcher(prevDispatcher){ReactCurrentDispatcher$2.current=prevDispatcher;}functionpushInteractions(root){{varprevInteractions=tracing$1.__interactionsRef.current;tracing$1.__interactionsRef.current=root.memoizedInteractions;returnprevInteractions;}}functionpopInteractions(prevInteractions){{tracing$1.__interactionsRef.current=prevInteractions;}}functionmarkCommitTimeOfFallback(){globalMostRecentFallbackTime=now();}functionmarkSkippedUpdateLanes(lane){workInProgressRootSkippedLanes=mergeLanes(lane,workInProgressRootSkippedLanes);}functionrenderDidSuspend(){if(workInProgressRootExitStatus===RootIncomplete){workInProgressRootExitStatus=RootSuspended;}}functionrenderDidSuspendDelayIfPossible(){if(workInProgressRootExitStatus===RootIncomplete||workInProgressRootExitStatus===RootSuspended){workInProgressRootExitStatus=RootSuspendedWithDelay;}// Check if there are updates that we skipped tree that might have unblocked
// this render.
if(workInProgressRoot!==null&&(includesNonIdleWork(workInProgressRootSkippedLanes)||includesNonIdleWork(workInProgressRootUpdatedLanes))){// Mark the current render as suspended so that we switch to working on
// the updates that were skipped. Usually we only suspend at the end of
// the render phase.
// TODO: We should probably always mark the root as suspended immediately
// (inside this function), since by suspending at the end of the render
// phase introduces a potential mistake where we suspend lanes that were
// pinged or updated while we were rendering.
markRootSuspended$1(workInProgressRoot,workInProgressRootRenderLanes);}}functionrenderDidError(){if(workInProgressRootExitStatus!==RootCompleted){workInProgressRootExitStatus=RootErrored;}}// Called during render to determine if anything has suspended.
// Returns false if we're not sure.
functionrenderHasNotSuspendedYet(){// If something errored or completed, we can't really be sure,
// so those are false.
returnworkInProgressRootExitStatus===RootIncomplete;}functionrenderRootSync(root,lanes){varprevExecutionContext=executionContext;executionContext|=RenderContext;varprevDispatcher=pushDispatcher();// If the root or lanes have changed, throw out the existing stack
// and prepare a fresh one. Otherwise we'll continue where we left off.
if(workInProgressRoot!==root||workInProgressRootRenderLanes!==lanes){prepareFreshStack(root,lanes);startWorkOnPendingInteractions(root,lanes);}varprevInteractions=pushInteractions(root);do{try{workLoopSync();break;}catch(thrownValue){handleError(root,thrownValue);}}while(true);resetContextDependencies();{popInteractions(prevInteractions);}executionContext=prevExecutionContext;popDispatcher(prevDispatcher);if(workInProgress!==null){// This is a sync render, so we should have finished the whole tree.
{{throwError("Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");}}}workInProgressRoot=null;workInProgressRootRenderLanes=NoLanes;returnworkInProgressRootExitStatus;}// The work loop is an extremely hot path. Tell Closure not to inline it.
/** @noinline */functionworkLoopSync(){// Already timed out, so perform work without checking if we need to yield.
while(workInProgress!==null){performUnitOfWork(workInProgress);}}functionrenderRootConcurrent(root,lanes){varprevExecutionContext=executionContext;executionContext|=RenderContext;varprevDispatcher=pushDispatcher();// If the root or lanes have changed, throw out the existing stack
// and prepare a fresh one. Otherwise we'll continue where we left off.
if(workInProgressRoot!==root||workInProgressRootRenderLanes!==lanes){resetRenderTimer();prepareFreshStack(root,lanes);startWorkOnPendingInteractions(root,lanes);}varprevInteractions=pushInteractions(root);do{try{workLoopConcurrent();break;}catch(thrownValue){handleError(root,thrownValue);}}while(true);resetContextDependencies();{popInteractions(prevInteractions);}popDispatcher(prevDispatcher);executionContext=prevExecutionContext;if(workInProgress!==null){returnRootIncomplete;}else{workInProgressRoot=null;workInProgressRootRenderLanes=NoLanes;// Return the final exit status.
returnworkInProgressRootExitStatus;}}/** @noinline */functionworkLoopConcurrent(){// Perform work until Scheduler asks us to yield
while(workInProgress!==null&&!shouldYield()){performUnitOfWork(workInProgress);}}functionperformUnitOfWork(unitOfWork){// The current, flushed, state of this fiber is the alternate. Ideally
// nothing should rely on this, but relying on it here means that we don't
// need an additional field on the work in progress.
varcurrent=unitOfWork.alternate;setCurrentFiber(unitOfWork);varnext;if((unitOfWork.mode&ProfileMode)!==NoMode){startProfilerTimer(unitOfWork);next=beginWork$1(current,unitOfWork,subtreeRenderLanes);stopProfilerTimerIfRunningAndRecordDelta(unitOfWork,true);}else{next=beginWork$1(current,unitOfWork,subtreeRenderLanes);}resetCurrentFiber();unitOfWork.memoizedProps=unitOfWork.pendingProps;if(next===null){// If this doesn't spawn new work, complete the current work.
completeUnitOfWork(unitOfWork);}else{workInProgress=next;}ReactCurrentOwner$2.current=null;}functioncompleteUnitOfWork(unitOfWork){// Attempt to complete the current unit of work, then move to the next
// sibling. If there are no more siblings, return to the parent fiber.
varcompletedWork=unitOfWork;do{// The current, flushed, state of this fiber is the alternate. Ideally
// nothing should rely on this, but relying on it here means that we don't
// need an additional field on the work in progress.
varcurrent=completedWork.alternate;varreturnFiber=completedWork.return;// Check if the work completed or if something threw.
if((completedWork.flags&Incomplete)===NoFlags){setCurrentFiber(completedWork);varnext=void0;if((completedWork.mode&ProfileMode)===NoMode){next=completeWork(current,completedWork,subtreeRenderLanes);}else{startProfilerTimer(completedWork);next=completeWork(current,completedWork,subtreeRenderLanes);// Update render duration assuming we didn't error.
stopProfilerTimerIfRunningAndRecordDelta(completedWork,false);}resetCurrentFiber();if(next!==null){// Completing this fiber spawned new work. Work on that next.
workInProgress=next;return;}resetChildLanes(completedWork);if(returnFiber!==null&&// Do not append effects to parents if a sibling failed to complete
(returnFiber.flags&Incomplete)===NoFlags){// Append all the effects of the subtree and this fiber onto the effect
// list of the parent. The completion order of the children affects the
// side-effect order.
if(returnFiber.firstEffect===null){returnFiber.firstEffect=completedWork.firstEffect;}if(completedWork.lastEffect!==null){if(returnFiber.lastEffect!==null){returnFiber.lastEffect.nextEffect=completedWork.firstEffect;}returnFiber.lastEffect=completedWork.lastEffect;}// If this fiber had side-effects, we append it AFTER the children's
// side-effects. We can perform certain side-effects earlier if needed,
// by doing multiple passes over the effect list. We don't want to
// schedule our own side-effect on our own list because if end up
// reusing children we'll schedule this effect onto itself since we're
// at the end.
varflags=completedWork.flags;// Skip both NoWork and PerformedWork tags when creating the effect
// list. PerformedWork effect is read by React DevTools but shouldn't be
// committed.
if(flags>PerformedWork){if(returnFiber.lastEffect!==null){returnFiber.lastEffect.nextEffect=completedWork;}else{returnFiber.firstEffect=completedWork;}returnFiber.lastEffect=completedWork;}}}else{// This fiber did not complete because something threw. Pop values off
// the stack without entering the complete phase. If this is a boundary,
// capture values if possible.
var_next=unwindWork(completedWork);// Because this fiber did not complete, don't reset its expiration time.
if(_next!==null){// If completing this work spawned new work, do that next. We'll come
// back here again.
// Since we're restarting, remove anything that is not a host effect
// from the effect tag.
_next.flags&=HostEffectMask;workInProgress=_next;return;}if((completedWork.mode&ProfileMode)!==NoMode){// Record the render duration for the fiber that errored.
stopProfilerTimerIfRunningAndRecordDelta(completedWork,false);// Include the time spent working on failed children before continuing.
varactualDuration=completedWork.actualDuration;varchild=completedWork.child;while(child!==null){actualDuration+=child.actualDuration;child=child.sibling;}completedWork.actualDuration=actualDuration;}if(returnFiber!==null){// Mark the parent fiber as incomplete and clear its effect list.
returnFiber.firstEffect=returnFiber.lastEffect=null;returnFiber.flags|=Incomplete;}}varsiblingFiber=completedWork.sibling;if(siblingFiber!==null){// If there is more work to do in this returnFiber, do that next.
workInProgress=siblingFiber;return;}// Otherwise, return to the parent
completedWork=returnFiber;// Update the next thing we're working on in case something throws.
workInProgress=completedWork;}while(completedWork!==null);// We've reached the root.
if(workInProgressRootExitStatus===RootIncomplete){workInProgressRootExitStatus=RootCompleted;}}functionresetChildLanes(completedWork){if(// TODO: Move this check out of the hot path by moving `resetChildLanes`
// to switch statement in `completeWork`.
(completedWork.tag===LegacyHiddenComponent||completedWork.tag===OffscreenComponent)&&completedWork.memoizedState!==null&&!includesSomeLane(subtreeRenderLanes,OffscreenLane)&&(completedWork.mode&ConcurrentMode)!==NoLanes){// The children of this component are hidden. Don't bubble their
// expiration times.
return;}varnewChildLanes=NoLanes;// Bubble up the earliest expiration time.
if((completedWork.mode&ProfileMode)!==NoMode){// In profiling mode, resetChildExpirationTime is also used to reset
// profiler durations.
varactualDuration=completedWork.actualDuration;vartreeBaseDuration=completedWork.selfBaseDuration;// When a fiber is cloned, its actualDuration is reset to 0. This value will
// only be updated if work is done on the fiber (i.e. it doesn't bailout).
// When work is done, it should bubble to the parent's actualDuration. If
// the fiber has not been cloned though, (meaning no work was done), then
// this value will reflect the amount of time spent working on a previous
// render. In that case it should not bubble. We determine whether it was
// cloned by comparing the child pointer.
varshouldBubbleActualDurations=completedWork.alternate===null||completedWork.child!==completedWork.alternate.child;varchild=completedWork.child;while(child!==null){newChildLanes=mergeLanes(newChildLanes,mergeLanes(child.lanes,child.childLanes));if(shouldBubbleActualDurations){actualDuration+=child.actualDuration;}treeBaseDuration+=child.treeBaseDuration;child=child.sibling;}varisTimedOutSuspense=completedWork.tag===SuspenseComponent&&completedWork.memoizedState!==null;if(isTimedOutSuspense){// Don't count time spent in a timed out Suspense subtree as part of the base duration.
varprimaryChildFragment=completedWork.child;if(primaryChildFragment!==null){treeBaseDuration-=primaryChildFragment.treeBaseDuration;}}completedWork.actualDuration=actualDuration;completedWork.treeBaseDuration=treeBaseDuration;}else{var_child=completedWork.child;while(_child!==null){newChildLanes=mergeLanes(newChildLanes,mergeLanes(_child.lanes,_child.childLanes));_child=_child.sibling;}}completedWork.childLanes=newChildLanes;}functioncommitRoot(root){varrenderPriorityLevel=getCurrentPriorityLevel();runWithPriority$1(ImmediatePriority$1,commitRootImpl.bind(null,root,renderPriorityLevel));returnnull;}functioncommitRootImpl(root,renderPriorityLevel){do{// `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
// means `flushPassiveEffects` will sometimes result in additional
// passive effects. So we need to keep flushing in a loop until there are
// no more pending effects.
// TODO: Might be better if `flushPassiveEffects` did not automatically
// flush synchronous work at the end, to avoid factoring hazards like this.
flushPassiveEffects();}while(rootWithPendingPassiveEffects!==null);flushRenderPhaseStrictModeWarningsInDEV();if(!((executionContext&(RenderContext|CommitContext))===NoContext)){{throwError("Should not already be working.");}}varfinishedWork=root.finishedWork;varlanes=root.finishedLanes;if(finishedWork===null){returnnull;}root.finishedWork=null;root.finishedLanes=NoLanes;if(!(finishedWork!==root.current)){{throwError("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.");}}// commitRoot never returns a continuation; it always finishes synchronously.
// So we can clear these now to allow a new callback to be scheduled.
root.callbackNode=null;// Update the first and last pending times on this root. The new first
// pending time is whatever is left on the root fiber.
varremainingLanes=mergeLanes(finishedWork.lanes,finishedWork.childLanes);markRootFinished(root,remainingLanes);// Clear already finished discrete updates in case that a later call of
// `flushDiscreteUpdates` starts a useless render pass which may cancels
// a scheduled timeout.
if(rootsWithPendingDiscreteUpdates!==null){if(!hasDiscreteLanes(remainingLanes)&&rootsWithPendingDiscreteUpdates.has(root)){rootsWithPendingDiscreteUpdates.delete(root);}}if(root===workInProgressRoot){// We can reset these now that they are finished.
workInProgressRoot=null;workInProgress=null;workInProgressRootRenderLanes=NoLanes;}// Get the list of effects.
varfirstEffect;if(finishedWork.flags>PerformedWork){// A fiber's effect list consists only of its children, not itself. So if
// the root has an effect, we need to add it to the end of the list. The
// resulting list is the set that would belong to the root's parent, if it
// had one; that is, all the effects in the tree including the root.
if(finishedWork.lastEffect!==null){finishedWork.lastEffect.nextEffect=finishedWork;firstEffect=finishedWork.firstEffect;}else{firstEffect=finishedWork;}}else{// There is no effect on the root.
firstEffect=finishedWork.firstEffect;}if(firstEffect!==null){varprevExecutionContext=executionContext;executionContext|=CommitContext;varprevInteractions=pushInteractions(root);// Reset this to null before calling lifecycles
ReactCurrentOwner$2.current=null;// The commit phase is broken into several sub-phases. We do a separate pass
// of the effect list for each phase: all mutation effects come before all
// layout effects, and so on.
// The first phase a "before mutation" phase. We use this phase to read the
// state of the host tree right before we mutate it. This is where
// getSnapshotBeforeUpdate is called.
focusedInstanceHandle=prepareForCommit(root.containerInfo);shouldFireAfterActiveInstanceBlur=false;nextEffect=firstEffect;do{{invokeGuardedCallback(null,commitBeforeMutationEffects,null);if(hasCaughtError()){if(!(nextEffect!==null)){{throwError("Should be working on an effect.");}}varerror=clearCaughtError();captureCommitPhaseError(nextEffect,error);nextEffect=nextEffect.nextEffect;}}}while(nextEffect!==null);// We no longer need to track the active instance fiber
focusedInstanceHandle=null;{// Mark the current commit time to be shared by all Profilers in this
// batch. This enables them to be grouped later.
recordCommitTime();}// The next phase is the mutation phase, where we mutate the host tree.
nextEffect=firstEffect;do{{invokeGuardedCallback(null,commitMutationEffects,null,root,renderPriorityLevel);if(hasCaughtError()){if(!(nextEffect!==null)){{throwError("Should be working on an effect.");}}var_error=clearCaughtError();captureCommitPhaseError(nextEffect,_error);nextEffect=nextEffect.nextEffect;}}}while(nextEffect!==null);resetAfterCommit(root.containerInfo);// The work-in-progress tree is now the current tree. This must come after
// the mutation phase, so that the previous tree is still current during
// componentWillUnmount, but before the layout phase, so that the finished
// work is current during componentDidMount/Update.
root.current=finishedWork;// The next phase is the layout phase, where we call effects that read
// the host tree after it's been mutated. The idiomatic use case for this is
// layout, but class component lifecycles also fire here for legacy reasons.
nextEffect=firstEffect;do{{invokeGuardedCallback(null,commitLayoutEffects,null,root,lanes);if(hasCaughtError()){if(!(nextEffect!==null)){{throwError("Should be working on an effect.");}}var_error2=clearCaughtError();captureCommitPhaseError(nextEffect,_error2);nextEffect=nextEffect.nextEffect;}}}while(nextEffect!==null);nextEffect=null;// Tell Scheduler to yield at the end of the frame, so the browser has an
// opportunity to paint.
requestPaint();{popInteractions(prevInteractions);}executionContext=prevExecutionContext;}else{// No effects.
root.current=finishedWork;// Measure these anyway so the flamegraph explicitly shows that there were
// no effects.
// TODO: Maybe there's a better way to report this.
{recordCommitTime();}}varrootDidHavePassiveEffects=rootDoesHavePassiveEffects;if(rootDoesHavePassiveEffects){// This commit has passive effects. Stash a reference to them. But don't
// schedule a callback until after flushing layout work.
rootDoesHavePassiveEffects=false;rootWithPendingPassiveEffects=root;pendingPassiveEffectsLanes=lanes;pendingPassiveEffectsRenderPriority=renderPriorityLevel;}else{// We are done with the effect chain at this point so let's clear the
// nextEffect pointers to assist with GC. If we have passive effects, we'll
// clear this in flushPassiveEffects.
nextEffect=firstEffect;while(nextEffect!==null){varnextNextEffect=nextEffect.nextEffect;nextEffect.nextEffect=null;if(nextEffect.flags&Deletion){detachFiberAfterEffects(nextEffect);}nextEffect=nextNextEffect;}}// Read this again, since an effect might have updated it
remainingLanes=root.pendingLanes;// Check if there's remaining work on this root
if(remainingLanes!==NoLanes){{if(spawnedWorkDuringRender!==null){varexpirationTimes=spawnedWorkDuringRender;spawnedWorkDuringRender=null;for(vari=0;i<expirationTimes.length;i++){scheduleInteractions(root,expirationTimes[i],root.memoizedInteractions);}}schedulePendingInteractions(root,remainingLanes);}}else{// If there's no remaining work, we can clear the set of already failed
// error boundaries.
legacyErrorBoundariesThatAlreadyFailed=null;}{if(!rootDidHavePassiveEffects){// If there are no passive effects, then we can complete the pending interactions.
// Otherwise, we'll wait until after the passive effects are flushed.
// Wait to do this until after remaining work has been scheduled,
// so that we don't prematurely signal complete for interactions when there's e.g. hidden work.
finishPendingInteractions(root,lanes);}}if(remainingLanes===SyncLane){// Count the number of times the root synchronously re-renders without
// finishing. If there are too many, it indicates an infinite update loop.
if(root===rootWithNestedUpdates){nestedUpdateCount++;}else{nestedUpdateCount=0;rootWithNestedUpdates=root;}}else{nestedUpdateCount=0;}onCommitRoot(finishedWork.stateNode,renderPriorityLevel);{onCommitRoot$1();}// Always call this before exiting `commitRoot`, to ensure that any
// additional work on this root is scheduled.
ensureRootIsScheduled(root,now());if(hasUncaughtError){hasUncaughtError=false;var_error3=firstUncaughtError;firstUncaughtError=null;throw_error3;}if((executionContext&LegacyUnbatchedContext)!==NoContext){// a ReactDOM.render-ed root inside of batchedUpdates. The commit fired
// synchronously, but layout updates should be deferred until the end
// of the batch.
returnnull;}// If layout work was scheduled, flush it now.
flushSyncCallbackQueue();returnnull;}functioncommitBeforeMutationEffects(){while(nextEffect!==null){varcurrent=nextEffect.alternate;if(!shouldFireAfterActiveInstanceBlur&&focusedInstanceHandle!==null){if((nextEffect.flags&Deletion)!==NoFlags){if(doesFiberContain(nextEffect,focusedInstanceHandle)){shouldFireAfterActiveInstanceBlur=true;}}else{// TODO: Move this out of the hot path using a dedicated effect tag.
if(nextEffect.tag===SuspenseComponent&&isSuspenseBoundaryBeingHidden(current,nextEffect)&&doesFiberContain(nextEffect,focusedInstanceHandle)){shouldFireAfterActiveInstanceBlur=true;}}}varflags=nextEffect.flags;if((flags&Snapshot)!==NoFlags){setCurrentFiber(nextEffect);commitBeforeMutationLifeCycles(current,nextEffect);resetCurrentFiber();}if((flags&Passive)!==NoFlags){// If there are passive effects, schedule a callback to flush at
// the earliest opportunity.
if(!rootDoesHavePassiveEffects){rootDoesHavePassiveEffects=true;scheduleCallback(NormalPriority$1,function(){flushPassiveEffects();returnnull;});}}nextEffect=nextEffect.nextEffect;}}functioncommitMutationEffects(root,renderPriorityLevel){// TODO: Should probably move the bulk of this function to commitWork.
while(nextEffect!==null){setCurrentFiber(nextEffect);varflags=nextEffect.flags;if(flags&ContentReset){commitResetTextContent(nextEffect);}if(flags&Ref){varcurrent=nextEffect.alternate;if(current!==null){commitDetachRef(current);}}// The following switch statement is only concerned about placement,
// updates, and deletions. To avoid needing to add a case for every possible
// bitmap value, we remove the secondary effects from the effect tag and
// switch on that value.
varprimaryFlags=flags&(Placement|Update|Deletion|Hydrating);switch(primaryFlags){casePlacement:{commitPlacement(nextEffect);// Clear the "placement" from effect tag so that we know that this is
// inserted, before any life-cycles like componentDidMount gets called.
// TODO: findDOMNode doesn't rely on this any more but isMounted does
// and isMounted is deprecated anyway so we should be able to kill this.
var_current2=nextEffect.alternate;commitWork(_current2,nextEffect);break;}caseUpdate:{var_current3=nextEffect.alternate;commitWork(_current3,nextEffect);break;}caseDeletion:{commitDeletion(root,nextEffect);break;}}resetCurrentFiber();nextEffect=nextEffect.nextEffect;}}functioncommitLayoutEffects(root,committedLanes){while(nextEffect!==null){setCurrentFiber(nextEffect);varflags=nextEffect.flags;if(flags&(Update|Callback)){varcurrent=nextEffect.alternate;commitLifeCycles(root,current,nextEffect);}{if(flags&Ref){commitAttachRef(nextEffect);}}resetCurrentFiber();nextEffect=nextEffect.nextEffect;}}functionflushPassiveEffects(){// Returns whether passive effects were flushed.
if(pendingPassiveEffectsRenderPriority!==NoPriority$1){varpriorityLevel=pendingPassiveEffectsRenderPriority>NormalPriority$1?NormalPriority$1:pendingPassiveEffectsRenderPriority;pendingPassiveEffectsRenderPriority=NoPriority$1;{returnrunWithPriority$1(priorityLevel,flushPassiveEffectsImpl);}}returnfalse;}functionenqueuePendingPassiveHookEffectMount(fiber,effect){pendingPassiveHookEffectsMount.push(effect,fiber);if(!rootDoesHavePassiveEffects){rootDoesHavePassiveEffects=true;scheduleCallback(NormalPriority$1,function(){flushPassiveEffects();returnnull;});}}functionenqueuePendingPassiveHookEffectUnmount(fiber,effect){pendingPassiveHookEffectsUnmount.push(effect,fiber);{fiber.flags|=PassiveUnmountPendingDev;varalternate=fiber.alternate;if(alternate!==null){alternate.flags|=PassiveUnmountPendingDev;}}if(!rootDoesHavePassiveEffects){rootDoesHavePassiveEffects=true;scheduleCallback(NormalPriority$1,function(){flushPassiveEffects();returnnull;});}}functioninvokePassiveEffectCreate(effect){varcreate=effect.create;effect.destroy=create();}functionflushPassiveEffectsImpl(){if(rootWithPendingPassiveEffects===null){returnfalse;}varroot=rootWithPendingPassiveEffects;varlanes=pendingPassiveEffectsLanes;rootWithPendingPassiveEffects=null;pendingPassiveEffectsLanes=NoLanes;if(!((executionContext&(RenderContext|CommitContext))===NoContext)){{throwError("Cannot flush passive effects while already rendering.");}}{isFlushingPassiveEffects=true;}varprevExecutionContext=executionContext;executionContext|=CommitContext;varprevInteractions=pushInteractions(root);// It's important that ALL pending passive effect destroy functions are called
// before ANY passive effect create functions are called.
// Otherwise effects in sibling components might interfere with each other.
// e.g. a destroy function in one component may unintentionally override a ref
// value set by a create function in another component.
// Layout effects have the same constraint.
// First pass: Destroy stale passive effects.
varunmountEffects=pendingPassiveHookEffectsUnmount;pendingPassiveHookEffectsUnmount=[];for(vari=0;i<unmountEffects.length;i+=2){var_effect=unmountEffects[i];varfiber=unmountEffects[i+1];vardestroy=_effect.destroy;_effect.destroy=undefined;{fiber.flags&=~PassiveUnmountPendingDev;varalternate=fiber.alternate;if(alternate!==null){alternate.flags&=~PassiveUnmountPendingDev;}}if(typeofdestroy==='function'){{setCurrentFiber(fiber);{invokeGuardedCallback(null,destroy,null);}if(hasCaughtError()){if(!(fiber!==null)){{throwError("Should be working on an effect.");}}varerror=clearCaughtError();captureCommitPhaseError(fiber,error);}resetCurrentFiber();}}}// Second pass: Create new passive effects.
varmountEffects=pendingPassiveHookEffectsMount;pendingPassiveHookEffectsMount=[];for(var_i=0;_i<mountEffects.length;_i+=2){var_effect2=mountEffects[_i];var_fiber=mountEffects[_i+1];{setCurrentFiber(_fiber);{invokeGuardedCallback(null,invokePassiveEffectCreate,null,_effect2);}if(hasCaughtError()){if(!(_fiber!==null)){{throwError("Should be working on an effect.");}}var_error4=clearCaughtError();captureCommitPhaseError(_fiber,_error4);}resetCurrentFiber();}}// Note: This currently assumes there are no passive effects on the root fiber
// because the root is not part of its own effect list.
// This could change in the future.
vareffect=root.current.firstEffect;while(effect!==null){varnextNextEffect=effect.nextEffect;// Remove nextEffect pointer to assist GC
effect.nextEffect=null;if(effect.flags&Deletion){detachFiberAfterEffects(effect);}effect=nextNextEffect;}{popInteractions(prevInteractions);finishPendingInteractions(root,lanes);}{isFlushingPassiveEffects=false;}executionContext=prevExecutionContext;flushSyncCallbackQueue();// If additional passive effects were scheduled, increment a counter. If this
// exceeds the limit, we'll fire a warning.
nestedPassiveUpdateCount=rootWithPendingPassiveEffects===null?0:nestedPassiveUpdateCount+1;returntrue;}functionisAlreadyFailedLegacyErrorBoundary(instance){returnlegacyErrorBoundariesThatAlreadyFailed!==null&&legacyErrorBoundariesThatAlreadyFailed.has(instance);}functionmarkLegacyErrorBoundaryAsFailed(instance){if(legacyErrorBoundariesThatAlreadyFailed===null){legacyErrorBoundariesThatAlreadyFailed=newSet([instance]);}else{legacyErrorBoundariesThatAlreadyFailed.add(instance);}}functionprepareToThrowUncaughtError(error){if(!hasUncaughtError){hasUncaughtError=true;firstUncaughtError=error;}}varonUncaughtError=prepareToThrowUncaughtError;functioncaptureCommitPhaseErrorOnRoot(rootFiber,sourceFiber,error){varerrorInfo=createCapturedValue(error,sourceFiber);varupdate=createRootErrorUpdate(rootFiber,errorInfo,SyncLane);enqueueUpdate(rootFiber,update);vareventTime=requestEventTime();varroot=markUpdateLaneFromFiberToRoot(rootFiber,SyncLane);if(root!==null){markRootUpdated(root,SyncLane,eventTime);ensureRootIsScheduled(root,eventTime);schedulePendingInteractions(root,SyncLane);}}functioncaptureCommitPhaseError(sourceFiber,error){if(sourceFiber.tag===HostRoot){// Error was thrown at the root. There is no parent, so the root
// itself should capture it.
captureCommitPhaseErrorOnRoot(sourceFiber,sourceFiber,error);return;}varfiber=sourceFiber.return;while(fiber!==null){if(fiber.tag===HostRoot){captureCommitPhaseErrorOnRoot(fiber,sourceFiber,error);return;}elseif(fiber.tag===ClassComponent){varctor=fiber.type;varinstance=fiber.stateNode;if(typeofctor.getDerivedStateFromError==='function'||typeofinstance.componentDidCatch==='function'&&!isAlreadyFailedLegacyErrorBoundary(instance)){varerrorInfo=createCapturedValue(error,sourceFiber);varupdate=createClassErrorUpdate(fiber,errorInfo,SyncLane);enqueueUpdate(fiber,update);vareventTime=requestEventTime();varroot=markUpdateLaneFromFiberToRoot(fiber,SyncLane);if(root!==null){markRootUpdated(root,SyncLane,eventTime);ensureRootIsScheduled(root,eventTime);schedulePendingInteractions(root,SyncLane);}else{// This component has already been unmounted.
// We can't schedule any follow up work for the root because the fiber is already unmounted,
// but we can still call the log-only boundary so the error isn't swallowed.
// TODO This is only a temporary bandaid for the old reconciler fork.
// We can delete this special case once the new fork is merged.
if(typeofinstance.componentDidCatch==='function'&&!isAlreadyFailedLegacyErrorBoundary(instance)){try{instance.componentDidCatch(error,errorInfo);}catch(errorToIgnore){// TODO Ignore this error? Rethrow it?
// This is kind of an edge case.
}}}return;}}fiber=fiber.return;}}functionpingSuspendedRoot(root,wakeable,pingedLanes){varpingCache=root.pingCache;if(pingCache!==null){// The wakeable resolved, so we no longer need to memoize, because it will
// never be thrown again.
pingCache.delete(wakeable);}vareventTime=requestEventTime();markRootPinged(root,pingedLanes);if(workInProgressRoot===root&&isSubsetOfLanes(workInProgressRootRenderLanes,pingedLanes)){// Received a ping at the same priority level at which we're currently
// rendering. We might want to restart this render. This should mirror
// the logic of whether or not a root suspends once it completes.
// TODO: If we're rendering sync either due to Sync, Batched or expired,
// we should probably never restart.
// If we're suspended with delay, or if it's a retry, we'll always suspend
// so we can always restart.
if(workInProgressRootExitStatus===RootSuspendedWithDelay||workInProgressRootExitStatus===RootSuspended&&includesOnlyRetries(workInProgressRootRenderLanes)&&now()-globalMostRecentFallbackTime<FALLBACK_THROTTLE_MS){// Restart from the root.
prepareFreshStack(root,NoLanes);}else{// Even though we can't restart right now, we might get an
// opportunity later. So we mark this render as having a ping.
workInProgressRootPingedLanes=mergeLanes(workInProgressRootPingedLanes,pingedLanes);}}ensureRootIsScheduled(root,eventTime);schedulePendingInteractions(root,pingedLanes);}functionretryTimedOutBoundary(boundaryFiber,retryLane){// The boundary fiber (a Suspense component or SuspenseList component)
// previously was rendered in its fallback state. One of the promises that
// suspended it has resolved, which means at least part of the tree was
// likely unblocked. Try rendering again, at a new expiration time.
if(retryLane===NoLane){retryLane=requestRetryLane(boundaryFiber);}// TODO: Special case idle priority?
varretryCache;{retryCache=boundaryFiber.stateNode;}if(retryCache!==null){// The wakeable resolved, so we no longer need to memoize, because it will
// never be thrown again.
retryCache.delete(wakeable);}retryTimedOutBoundary(boundaryFiber,retryLane);}// Computes the next Just Noticeable Difference (JND) boundary.
// The theory is that a person can't tell the difference between small differences in time.
// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
// difference in the experience. However, waiting for longer might mean that we can avoid
// showing an intermediate loading state. The longer we have already waited, the harder it
// is to tell small differences in time. Therefore, the longer we've already waited,
// the longer we can wait additionally. At some point we have to give up though.
// We pick a train model where the next boundary commits at a consistent schedule.
// These particular numbers are vague estimates. We expect to adjust them based on research.
functionjnd(timeElapsed){returntimeElapsed<120?120:timeElapsed<480?480:timeElapsed<1080?1080:timeElapsed<1920?1920:timeElapsed<3000?3000:timeElapsed<4320?4320:ceil(timeElapsed/1960)*1960;}functioncheckForNestedUpdates(){if(nestedUpdateCount>NESTED_UPDATE_LIMIT){nestedUpdateCount=0;rootWithNestedUpdates=null;{{throwError("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.");}}}{if(nestedPassiveUpdateCount>NESTED_PASSIVE_UPDATE_LIMIT){nestedPassiveUpdateCount=0;error('Maximum update depth exceeded. This can happen when a component '+"calls setState inside useEffect, but useEffect either doesn't "+'have a dependency array, or one of the dependencies changes on '+'every render.');}}}functionflushRenderPhaseStrictModeWarningsInDEV(){{ReactStrictModeWarnings.flushLegacyContextWarning();{ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();}}}vardidWarnStateUpdateForNotYetMountedComponent=null;functionwarnAboutUpdateOnNotYetMountedFiberInDEV(fiber){{if((executionContext&RenderContext)!==NoContext){// We let the other warning about render phase updates deal with this one.
return;}if(!(fiber.mode&(BlockingMode|ConcurrentMode))){return;}vartag=fiber.tag;if(tag!==IndeterminateComponent&&tag!==HostRoot&&tag!==ClassComponent&&tag!==FunctionComponent&&tag!==ForwardRef&&tag!==MemoComponent&&tag!==SimpleMemoComponent&&tag!==Block){// Only warn for user-defined components, not internal ones like Suspense.
return;}// We show the whole stack but dedupe on the top component's name because
// the problematic code almost always lies inside that component.
varcomponentName=getComponentName(fiber.type)||'ReactComponent';if(didWarnStateUpdateForNotYetMountedComponent!==null){if(didWarnStateUpdateForNotYetMountedComponent.has(componentName)){return;}didWarnStateUpdateForNotYetMountedComponent.add(componentName);}else{didWarnStateUpdateForNotYetMountedComponent=newSet([componentName]);}varpreviousFiber=current;try{setCurrentFiber(fiber);error("Can't perform a React state update on a component that hasn't mounted yet. "+'This indicates that you have a side-effect in your render function that '+'asynchronously later calls tries to update the component. Move this work to '+'useEffect instead.');}finally{if(previousFiber){setCurrentFiber(fiber);}else{resetCurrentFiber();}}}}vardidWarnStateUpdateForUnmountedComponent=null;functionwarnAboutUpdateOnUnmountedFiberInDEV(fiber){{vartag=fiber.tag;if(tag!==HostRoot&&tag!==ClassComponent&&tag!==FunctionComponent&&tag!==ForwardRef&&tag!==MemoComponent&&tag!==SimpleMemoComponent&&tag!==Block){// Only warn for user-defined components, not internal ones like Suspense.
return;}// If there are pending passive effects unmounts for this Fiber,
// we can assume that they would have prevented this update.
if((fiber.flags&PassiveUnmountPendingDev)!==NoFlags){return;}// We show the whole stack but dedupe on the top component's name because
// the problematic code almost always lies inside that component.
varcomponentName=getComponentName(fiber.type)||'ReactComponent';if(didWarnStateUpdateForUnmountedComponent!==null){if(didWarnStateUpdateForUnmountedComponent.has(componentName)){return;}didWarnStateUpdateForUnmountedComponent.add(componentName);}else{didWarnStateUpdateForUnmountedComponent=newSet([componentName]);}if(isFlushingPassiveEffects);else{varpreviousFiber=current;try{setCurrentFiber(fiber);error("Can't perform a React state update on an unmounted component. This "+'is a no-op, but it indicates a memory leak in your application. To '+'fix, cancel all subscriptions and asynchronous tasks in %s.',tag===ClassComponent?'the componentWillUnmount method':'a useEffect cleanup function');}finally{if(previousFiber){setCurrentFiber(fiber);}else{resetCurrentFiber();}}}}}varbeginWork$1;{vardummyFiber=null;beginWork$1=function(current,unitOfWork,lanes){// If a component throws an error, we replay it again in a synchronously
// dispatched event, so that the debugger will treat it as an uncaught
// error See ReactErrorUtils for more information.
// Before entering the begin phase, copy the work-in-progress onto a dummy
// fiber. If beginWork throws, we'll use this to reset the state.
varoriginalWorkInProgressCopy=assignFiberPropertiesInDEV(dummyFiber,unitOfWork);try{returnbeginWork(current,unitOfWork,lanes);}catch(originalError){if(originalError!==null&&typeoforiginalError==='object'&&typeoforiginalError.then==='function'){// Don't replay promises. Treat everything else like an error.
throworiginalError;}// Keep this code in sync with handleError; any changes here must have
// corresponding changes there.
resetContextDependencies();resetHooksAfterThrow();// Don't reset current debug fiber, since we're about to work on the
// same fiber again.
// Unwind the failed stack frame
unwindInterruptedWork(unitOfWork);// Restore the original properties of the fiber.
assignFiberPropertiesInDEV(unitOfWork,originalWorkInProgressCopy);if(unitOfWork.mode&ProfileMode){// Reset the profiler timer.
startProfilerTimer(unitOfWork);}// Run beginWork again.
invokeGuardedCallback(null,beginWork,null,current,unitOfWork,lanes);if(hasCaughtError()){varreplayError=clearCaughtError();// `invokeGuardedCallback` sometimes sets an expando `_suppressLogging`.
// Rethrow this error instead of the original one.
throwreplayError;}else{// This branch is reachable if the render phase is impure.
throworiginalError;}}};}vardidWarnAboutUpdateInRender=false;vardidWarnAboutUpdateInRenderForAnotherComponent;{didWarnAboutUpdateInRenderForAnotherComponent=newSet();}functionwarnAboutRenderPhaseUpdatesInDEV(fiber){{if(isRendering&&(executionContext&RenderContext)!==NoContext&&!getIsUpdatingOpaqueValueInRenderPhaseInDEV()){switch(fiber.tag){caseFunctionComponent:caseForwardRef:caseSimpleMemoComponent:{varrenderingComponentName=workInProgress&&getComponentName(workInProgress.type)||'Unknown';// Dedupe by the rendering component because it's the one that needs to be fixed.
vardedupeKey=renderingComponentName;if(!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)){didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);varsetStateComponentName=getComponentName(fiber.type)||'Unknown';error('Cannot update a component (`%s`) while rendering a '+'different component (`%s`). To locate the bad setState() call inside `%s`, '+'follow the stack trace as described in https://reactjs.org/link/setstate-in-render',setStateComponentName,renderingComponentName,renderingComponentName);}break;}caseClassComponent:{if(!didWarnAboutUpdateInRender){error('Cannot update during an existing state transition (such as '+'within `render`). Render methods should be a pure '+'function of props and state.');didWarnAboutUpdateInRender=true;}break;}}}}}// a 'shared' variable that changes when act() opens/closes in tests.
varIsThisRendererActing={current:false};functionwarnIfNotScopedWithMatchingAct(fiber){{if(IsSomeRendererActing.current===true&&IsThisRendererActing.current!==true){varpreviousFiber=current;try{setCurrentFiber(fiber);error("It looks like you're using the wrong act() around your test interactions.\n"+'Be sure to use the matching version of act() corresponding to your renderer:\n\n'+'// for react-dom:\n'+// Break up imports to avoid accidentally parsing them as dependencies.
'import {act} fr'+"om 'react-dom/test-utils';\n"+'// ...\n'+'act(() => ...);\n\n'+'// for react-test-renderer:\n'+// Break up imports to avoid accidentally parsing them as dependencies.
'import TestRenderer fr'+"om react-test-renderer';\n"+'const {act} = TestRenderer;\n'+'// ...\n'+'act(() => ...);');}finally{if(previousFiber){setCurrentFiber(fiber);}else{resetCurrentFiber();}}}}}functionwarnIfNotCurrentlyActingEffectsInDEV(fiber){{if((fiber.mode&StrictMode)!==NoMode&&IsSomeRendererActing.current===false&&IsThisRendererActing.current===false){error('An update to %s ran an effect, but was not wrapped in act(...).\n\n'+'When testing, code that causes React state updates should be '+'wrapped into act(...):\n\n'+'act(() => {\n'+' /* fire events that update state */\n'+'});\n'+'/* assert on the output */\n\n'+"This ensures that you're testing the behavior the user would see "+'in the browser.'+' Learn more at https://reactjs.org/link/wrap-tests-with-act',getComponentName(fiber.type));}}}functionwarnIfNotCurrentlyActingUpdatesInDEV(fiber){{if(executionContext===NoContext&&IsSomeRendererActing.current===false&&IsThisRendererActing.current===false){varpreviousFiber=current;try{setCurrentFiber(fiber);error('An update to %s inside a test was not wrapped in act(...).\n\n'+'When testing, code that causes React state updates should be '+'wrapped into act(...):\n\n'+'act(() => {\n'+' /* fire events that update state */\n'+'});\n'+'/* assert on the output */\n\n'+"This ensures that you're testing the behavior the user would see "+'in the browser.'+' Learn more at https://reactjs.org/link/wrap-tests-with-act',getComponentName(fiber.type));}finally{if(previousFiber){setCurrentFiber(fiber);}else{resetCurrentFiber();}}}}}varwarnIfNotCurrentlyActingUpdatesInDev=warnIfNotCurrentlyActingUpdatesInDEV;// In tests, we want to enforce a mocked scheduler.
vardidWarnAboutUnmockedScheduler=false;// TODO Before we release concurrent mode, revisit this and decide whether a mocked
// scheduler is the actual recommendation. The alternative could be a testing build,
// a new lib, or whatever; we dunno just yet. This message is for early adopters
// to get their tests right.
functionwarnIfUnmockedScheduler(fiber){{if(didWarnAboutUnmockedScheduler===false&&Scheduler.unstable_flushAllWithoutAsserting===undefined){if(fiber.mode&BlockingMode||fiber.mode&ConcurrentMode){didWarnAboutUnmockedScheduler=true;error('In Concurrent or Sync modes, the "scheduler" module needs to be mocked '+'to guarantee consistent behaviour across tests and browsers. '+'For example, with jest: \n'+// Break up requires to avoid accidentally parsing them as dependencies.
"jest.mock('scheduler', () => require"+"('scheduler/unstable_mock'));\n\n"+'For more info, visit https://reactjs.org/link/mock-scheduler');}}}}functioncomputeThreadID(root,lane){// Interaction threads are unique per root and expiration time.
// NOTE: Intentionally unsound cast. All that matters is that it's a number
// and it represents a batch of work. Could make a helper function instead,
// but meh this is fine for now.
returnlane*1000+root.interactionThreadID;}functionmarkSpawnedWork(lane){if(spawnedWorkDuringRender===null){spawnedWorkDuringRender=[lane];}else{spawnedWorkDuringRender.push(lane);}}functionscheduleInteractions(root,lane,interactions){if(interactions.size>0){varpendingInteractionMap=root.pendingInteractionMap;varpendingInteractions=pendingInteractionMap.get(lane);if(pendingInteractions!=null){interactions.forEach(function(interaction){if(!pendingInteractions.has(interaction)){// Update the pending async work count for previously unscheduled interaction.
interaction.__count++;}pendingInteractions.add(interaction);});}else{pendingInteractionMap.set(lane,newSet(interactions));// Update the pending async work count for the current interactions.
interactions.forEach(function(interaction){interaction.__count++;});}varsubscriber=tracing$1.__subscriberRef.current;if(subscriber!==null){varthreadID=computeThreadID(root,lane);subscriber.onWorkScheduled(interactions,threadID);}}}functionschedulePendingInteractions(root,lane){scheduleInteractions(root,lane,tracing$1.__interactionsRef.current);}functionstartWorkOnPendingInteractions(root,lanes){// we can accurately attribute time spent working on it, And so that cascading
// work triggered during the render phase will be associated with it.
varinteractions=newSet();root.pendingInteractionMap.forEach(function(scheduledInteractions,scheduledLane){if(includesSomeLane(lanes,scheduledLane)){scheduledInteractions.forEach(function(interaction){returninteractions.add(interaction);});}});// Store the current set of interactions on the FiberRoot for a few reasons:
// We can re-use it in hot functions like performConcurrentWorkOnRoot()
// without having to recalculate it. We will also use it in commitWork() to
// pass to any Profiler onRender() hooks. This also provides DevTools with a
// way to access it when the onCommitRoot() hook is called.
root.memoizedInteractions=interactions;if(interactions.size>0){varsubscriber=tracing$1.__subscriberRef.current;if(subscriber!==null){varthreadID=computeThreadID(root,lanes);try{subscriber.onWorkStarted(interactions,threadID);}catch(error){// If the subscriber throws, rethrow it in a separate task
scheduleCallback(ImmediatePriority$1,function(){throwerror;});}}}}functionfinishPendingInteractions(root,committedLanes){varremainingLanesAfterCommit=root.pendingLanes;varsubscriber;try{subscriber=tracing$1.__subscriberRef.current;if(subscriber!==null&&root.memoizedInteractions.size>0){// FIXME: More than one lane can finish in a single commit.
varthreadID=computeThreadID(root,committedLanes);subscriber.onWorkStopped(root.memoizedInteractions,threadID);}}catch(error){// If the subscriber throws, rethrow it in a separate task
scheduleCallback(ImmediatePriority$1,function(){throwerror;});}finally{// Clear completed interactions from the pending Map.
// Unless the render was suspended or cascading work was scheduled,
// In which case– leave pending interactions until the subsequent render.
varpendingInteractionMap=root.pendingInteractionMap;pendingInteractionMap.forEach(function(scheduledInteractions,lane){// Only decrement the pending interaction count if we're done.
// If there's still work at the current priority,
// That indicates that we are waiting for suspense data.
if(!includesSomeLane(remainingLanesAfterCommit,lane)){pendingInteractionMap.delete(lane);scheduledInteractions.forEach(function(interaction){interaction.__count--;if(subscriber!==null&&interaction.__count===0){try{subscriber.onInteractionScheduledWorkCompleted(interaction);}catch(error){// If the subscriber throws, rethrow it in a separate task
scheduleCallback(ImmediatePriority$1,function(){throwerror;});}}});}});}}// `act` testing API
functionshouldForceFlushFallbacksInDEV(){// Never force flush in production. This function should get stripped out.
returnactingUpdatesScopeDepth>0;}// so we can tell if any async act() calls try to run in parallel.
varactingUpdatesScopeDepth=0;functiondetachFiberAfterEffects(fiber){fiber.sibling=null;fiber.stateNode=null;}varresolveFamily=null;// $FlowFixMe Flow gets confused by a WeakSet feature check below.
varfailedBoundaries=null;varsetRefreshHandler=function(handler){{resolveFamily=handler;}};functionresolveFunctionForHotReloading(type){{if(resolveFamily===null){// Hot reloading is disabled.
returntype;}varfamily=resolveFamily(type);if(family===undefined){returntype;}// Use the latest known implementation.
returnfamily.current;}}functionresolveClassForHotReloading(type){// No implementation differences.
returnresolveFunctionForHotReloading(type);}functionresolveForwardRefForHotReloading(type){{if(resolveFamily===null){// Hot reloading is disabled.
returntype;}varfamily=resolveFamily(type);if(family===undefined){// Check if we're dealing with a real forwardRef. Don't want to crash early.
if(type!==null&&type!==undefined&&typeoftype.render==='function'){// ForwardRef is special because its resolved .type is an object,
// but it's possible that we only have its inner render function in the map.
// If that inner render function is different, we'll build a new forwardRef type.
varcurrentRender=resolveFunctionForHotReloading(type.render);if(type.render!==currentRender){varsyntheticType={$$typeof:REACT_FORWARD_REF_TYPE,render:currentRender};if(type.displayName!==undefined){syntheticType.displayName=type.displayName;}returnsyntheticType;}}returntype;}// Use the latest known implementation.
returnfamily.current;}}functionisCompatibleFamilyForHotReloading(fiber,element){{if(resolveFamily===null){// Hot reloading is disabled.
returnfalse;}varprevType=fiber.elementType;varnextType=element.type;// If we got here, we know types aren't === equal.
varneedsCompareFamilies=false;var$$typeofNextType=typeofnextType==='object'&&nextType!==null?nextType.$$typeof:null;switch(fiber.tag){caseClassComponent:{if(typeofnextType==='function'){needsCompareFamilies=true;}break;}caseFunctionComponent:{if(typeofnextType==='function'){needsCompareFamilies=true;}elseif($$typeofNextType===REACT_LAZY_TYPE){// We don't know the inner type yet.
// We're going to assume that the lazy inner type is stable,
// and so it is sufficient to avoid reconciling it away.
// We're not going to unwrap or actually use the new lazy type.
needsCompareFamilies=true;}break;}caseForwardRef:{if($$typeofNextType===REACT_FORWARD_REF_TYPE){needsCompareFamilies=true;}elseif($$typeofNextType===REACT_LAZY_TYPE){needsCompareFamilies=true;}break;}caseMemoComponent:caseSimpleMemoComponent:{if($$typeofNextType===REACT_MEMO_TYPE){// TODO: if it was but can no longer be simple,
// we shouldn't set this.
needsCompareFamilies=true;}elseif($$typeofNextType===REACT_LAZY_TYPE){needsCompareFamilies=true;}break;}default:returnfalse;}// Check if both types have a family and it's the same one.
if(needsCompareFamilies){// Note: memo() and forwardRef() we'll compare outer rather than inner type.
// This means both of them need to be registered to preserve state.
// If we unwrapped and compared the inner types for wrappers instead,
// then we would risk falsely saying two separate memo(Foo)
// calls are equivalent because they wrap the same Foo function.
varprevFamily=resolveFamily(prevType);if(prevFamily!==undefined&&prevFamily===resolveFamily(nextType)){returntrue;}}returnfalse;}}functionmarkFailedErrorBoundaryForHotReloading(fiber){{if(resolveFamily===null){// Hot reloading is disabled.
return;}if(typeofWeakSet!=='function'){return;}if(failedBoundaries===null){failedBoundaries=newWeakSet();}failedBoundaries.add(fiber);}}varscheduleRefresh=function(root,update){{if(resolveFamily===null){// Hot reloading is disabled.
return;}varstaleFamilies=update.staleFamilies,updatedFamilies=update.updatedFamilies;flushPassiveEffects();flushSync(function(){scheduleFibersWithFamiliesRecursively(root.current,updatedFamilies,staleFamilies);});}};varscheduleRoot=function(root,element){{if(root.context!==emptyContextObject){// Super edge case: root has a legacy _renderSubtree context
// but we don't know the parentComponent so we can't pass it.
// Just ignore. We'll delete this with _renderSubtree code path later.
return;}flushPassiveEffects();flushSync(function(){updateContainer(element,root,null,null);});}};functionscheduleFibersWithFamiliesRecursively(fiber,updatedFamilies,staleFamilies){{varalternate=fiber.alternate,child=fiber.child,sibling=fiber.sibling,tag=fiber.tag,type=fiber.type;varcandidateType=null;switch(tag){caseFunctionComponent:caseSimpleMemoComponent:caseClassComponent:candidateType=type;break;caseForwardRef:candidateType=type.render;break;}if(resolveFamily===null){thrownewError('Expected resolveFamily to be set during hot reload.');}varneedsRender=false;varneedsRemount=false;if(candidateType!==null){varfamily=resolveFamily(candidateType);if(family!==undefined){if(staleFamilies.has(family)){needsRemount=true;}elseif(updatedFamilies.has(family)){if(tag===ClassComponent){needsRemount=true;}else{needsRender=true;}}}}if(failedBoundaries!==null){if(failedBoundaries.has(fiber)||alternate!==null&&failedBoundaries.has(alternate)){needsRemount=true;}}if(needsRemount){fiber._debugNeedsRemount=true;}if(needsRemount||needsRender){scheduleUpdateOnFiber(fiber,SyncLane,NoTimestamp);}if(child!==null&&!needsRemount){scheduleFibersWithFamiliesRecursively(child,updatedFamilies,staleFamilies);}if(sibling!==null){scheduleFibersWithFamiliesRecursively(sibling,updatedFamilies,staleFamilies);}}}varfindHostInstancesForRefresh=function(root,families){{varhostInstances=newSet();vartypes=newSet(families.map(function(family){returnfamily.current;}));findHostInstancesForMatchingFibersRecursively(root.current,types,hostInstances);returnhostInstances;}};functionfindHostInstancesForMatchingFibersRecursively(fiber,types,hostInstances){{varchild=fiber.child,sibling=fiber.sibling,tag=fiber.tag,type=fiber.type;varcandidateType=null;switch(tag){caseFunctionComponent:caseSimpleMemoComponent:caseClassComponent:candidateType=type;break;caseForwardRef:candidateType=type.render;break;}vardidMatch=false;if(candidateType!==null){if(types.has(candidateType)){didMatch=true;}}if(didMatch){// We have a match. This only drills down to the closest host components.
// There's no need to search deeper because for the purpose of giving
// visual feedback, "flashing" outermost parent rectangles is sufficient.
findHostInstancesForFiberShallowly(fiber,hostInstances);}else{// If there's no match, maybe there will be one further down in the child tree.
if(child!==null){findHostInstancesForMatchingFibersRecursively(child,types,hostInstances);}}if(sibling!==null){findHostInstancesForMatchingFibersRecursively(sibling,types,hostInstances);}}}functionfindHostInstancesForFiberShallowly(fiber,hostInstances){{varfoundHostInstances=findChildHostInstancesForFiberShallowly(fiber,hostInstances);if(foundHostInstances){return;}// If we didn't find any host children, fallback to closest host parent.
varnode=fiber;while(true){switch(node.tag){caseHostComponent:hostInstances.add(node.stateNode);return;caseHostPortal:hostInstances.add(node.stateNode.containerInfo);return;caseHostRoot:hostInstances.add(node.stateNode.containerInfo);return;}if(node.return===null){thrownewError('Expected to reach root first.');}node=node.return;}}}functionfindChildHostInstancesForFiberShallowly(fiber,hostInstances){{varnode=fiber;varfoundHostInstances=false;while(true){if(node.tag===HostComponent){// We got a match.
foundHostInstances=true;hostInstances.add(node.stateNode);// There may still be more, so keep searching.
}elseif(node.child!==null){node.child.return=node;node=node.child;continue;}if(node===fiber){returnfoundHostInstances;}while(node.sibling===null){if(node.return===null||node.return===fiber){returnfoundHostInstances;}node=node.return;}node.sibling.return=node.return;node=node.sibling;}}returnfalse;}varhasBadMapPolyfill;{hasBadMapPolyfill=false;try{varnonExtensibleObject=Object.preventExtensions({});/* eslint-disable no-new */newMap([[nonExtensibleObject,null]]);newSet([nonExtensibleObject]);/* eslint-enable no-new */}catch(e){// TODO: Consider warning about bad polyfills
this.flags=NoFlags;this.nextEffect=null;this.firstEffect=null;this.lastEffect=null;this.lanes=NoLanes;this.childLanes=NoLanes;this.alternate=null;{// Note: The following is done to avoid a v8 performance cliff.
//
// Initializing the fields below to smis and later updating them with
// double values will cause Fibers to end up having separate shapes.
// This behavior/bug has something to do with Object.preventExtension().
// Fortunately this only impacts DEV builds.
// Unfortunately it makes React unusably slow for some applications.
// To work around this, initialize the fields below with doubles.
this.actualDuration=Number.NaN;this.actualStartTime=Number.NaN;this.selfBaseDuration=Number.NaN;this.treeBaseDuration=Number.NaN;// It's okay to replace the initial doubles with smis after initialization.
// This won't trigger the performance cliff mentioned above,
// and it simplifies other profiler code (including DevTools).
this.actualDuration=0;this.actualStartTime=-1;this.selfBaseDuration=0;this.treeBaseDuration=0;}{// This isn't directly used but is handy for debugging internals:
this._debugID=debugCounter++;this._debugSource=null;this._debugOwner=null;this._debugNeedsRemount=false;this._debugHookTypes=null;if(!hasBadMapPolyfill&&typeofObject.preventExtensions==='function'){Object.preventExtensions(this);}}}// This is a constructor function, rather than a POJO constructor, still
// please ensure we do the following:
// 1) Nobody should add any instance methods on this. Instance methods can be
// more difficult to predict when they get optimized and they are almost
// never inlined properly in static compilers.
// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
// always know when it is a fiber.
// 3) We might want to experiment with using numeric keys since they are easier
// to optimize in a non-JIT environment.
// 4) We can easily go from a constructor to a createFiber object literal if that
// is faster.
// 5) It should be easy to port this to a C struct and keep a C implementation
// compatible.
varcreateFiber=function(tag,pendingProps,key,mode){// $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
returnnewFiberNode(tag,pendingProps,key,mode);};functionshouldConstruct$1(Component){varprototype=Component.prototype;return!!(prototype&&prototype.isReactComponent);}functionisSimpleFunctionComponent(type){returntypeoftype==='function'&&!shouldConstruct$1(type)&&type.defaultProps===undefined;}functionresolveLazyComponentTag(Component){if(typeofComponent==='function'){returnshouldConstruct$1(Component)?ClassComponent:FunctionComponent;}elseif(Component!==undefined&&Component!==null){var$$typeof=Component.$$typeof;if($$typeof===REACT_FORWARD_REF_TYPE){returnForwardRef;}if($$typeof===REACT_MEMO_TYPE){returnMemoComponent;}}returnIndeterminateComponent;}// This is used to create an alternate fiber to do work on.
functioncreateWorkInProgress(current,pendingProps){varworkInProgress=current.alternate;if(workInProgress===null){// We use a double buffering pooling technique because we know that we'll
// only ever need at most two versions of a tree. We pool the "other" unused
// node that we're free to reuse. This is lazily created to avoid allocating
// extra objects for things that are never updated. It also allow us to
workInProgress._debugID=current._debugID;workInProgress._debugSource=current._debugSource;workInProgress._debugOwner=current._debugOwner;workInProgress._debugHookTypes=current._debugHookTypes;}workInProgress.alternate=current;current.alternate=workInProgress;}else{workInProgress.pendingProps=pendingProps;// Needed because Blocks store data on type.
workInProgress.type=current.type;// We already have an alternate.
// Reset the effect tag.
workInProgress.flags=NoFlags;// The effect list is no longer valid.
workInProgress.nextEffect=null;workInProgress.firstEffect=null;workInProgress.lastEffect=null;{// We intentionally reset, rather than copy, actualDuration & actualStartTime.
// This prevents time from endlessly accumulating in new commits.
// This has the downside of resetting values for different priority renders,
// But works for yielding (the common case) and should support resuming.
workInProgress.actualDuration=0;workInProgress.actualStartTime=-1;}}workInProgress.childLanes=current.childLanes;workInProgress.lanes=current.lanes;workInProgress.child=current.child;workInProgress.memoizedProps=current.memoizedProps;workInProgress.memoizedState=current.memoizedState;workInProgress.updateQueue=current.updateQueue;// Clone the dependencies object. This is mutated during the render phase, so
// it cannot be shared with the current fiber.
varcurrentDependencies=current.dependencies;workInProgress.dependencies=currentDependencies===null?null:{lanes:currentDependencies.lanes,firstContext:currentDependencies.firstContext};// These will be overridden during the parent's reconciliation
workInProgress.sibling=current.sibling;workInProgress.index=current.index;workInProgress.ref=current.ref;{workInProgress.selfBaseDuration=current.selfBaseDuration;workInProgress.treeBaseDuration=current.treeBaseDuration;}{workInProgress._debugNeedsRemount=current._debugNeedsRemount;switch(workInProgress.tag){caseIndeterminateComponent:caseFunctionComponent:caseSimpleMemoComponent:workInProgress.type=resolveFunctionForHotReloading(current.type);break;caseClassComponent:workInProgress.type=resolveClassForHotReloading(current.type);break;caseForwardRef:workInProgress.type=resolveForwardRefForHotReloading(current.type);break;}}returnworkInProgress;}// Used to reuse a Fiber for a second pass.
functionresetWorkInProgress(workInProgress,renderLanes){// This resets the Fiber to what createFiber or createWorkInProgress would
// have set the values to before during the first pass. Ideally this wouldn't
// be necessary but unfortunately many code paths reads from the workInProgress
// when they should be reading from current and writing to workInProgress.
// We assume pendingProps, index, key, ref, return are still untouched to
// avoid doing another reconciliation.
// Reset the effect tag but keep any Placement tags, since that's something
// that child fiber is setting, not the reconciliation.
workInProgress.flags&=Placement;// The effect list is no longer valid.
workInProgress.nextEffect=null;workInProgress.firstEffect=null;workInProgress.lastEffect=null;varcurrent=workInProgress.alternate;if(current===null){// Reset to createFiber's initial values.
workInProgress.childLanes=NoLanes;workInProgress.lanes=renderLanes;workInProgress.child=null;workInProgress.memoizedProps=null;workInProgress.memoizedState=null;workInProgress.updateQueue=null;workInProgress.dependencies=null;workInProgress.stateNode=null;{// Note: We don't reset the actualTime counts. It's useful to accumulate
// actual time across multiple render passes.
workInProgress.selfBaseDuration=0;workInProgress.treeBaseDuration=0;}}else{// Reset to the cloned values that createWorkInProgress would've.
workInProgress.childLanes=current.childLanes;workInProgress.lanes=current.lanes;workInProgress.child=current.child;workInProgress.memoizedProps=current.memoizedProps;workInProgress.memoizedState=current.memoizedState;workInProgress.updateQueue=current.updateQueue;// Needed because Blocks store data on type.
workInProgress.type=current.type;// Clone the dependencies object. This is mutated during the render phase, so
// it cannot be shared with the current fiber.
varcurrentDependencies=current.dependencies;workInProgress.dependencies=currentDependencies===null?null:{lanes:currentDependencies.lanes,firstContext:currentDependencies.firstContext};{// Note: We don't reset the actualTime counts. It's useful to accumulate
// actual time across multiple render passes.
workInProgress.selfBaseDuration=current.selfBaseDuration;workInProgress.treeBaseDuration=current.treeBaseDuration;}}returnworkInProgress;}functioncreateHostRootFiber(tag){varmode;if(tag===ConcurrentRoot){mode=ConcurrentMode|BlockingMode|StrictMode;}elseif(tag===BlockingRoot){mode=BlockingMode|StrictMode;}else{mode=NoMode;}if(isDevToolsPresent){// Always collect profile timings when DevTools are present.
// This enables DevTools to start capturing timing at any point–
// Without some nodes in the tree having empty base times.
key,pendingProps,owner,mode,lanes){varfiberTag=IndeterminateComponent;// The resolved type is set if we know what the final type will be. I.e. it's not lazy.
default:{if(typeoftype==='object'&&type!==null){switch(type.$$typeof){caseREACT_PROVIDER_TYPE:fiberTag=ContextProvider;breakgetTag;caseREACT_CONTEXT_TYPE:// This is a consumer
fiberTag=ContextConsumer;breakgetTag;caseREACT_FORWARD_REF_TYPE:fiberTag=ForwardRef;{resolvedType=resolveForwardRefForHotReloading(resolvedType);}breakgetTag;caseREACT_MEMO_TYPE:fiberTag=MemoComponent;breakgetTag;caseREACT_LAZY_TYPE:fiberTag=LazyComponent;resolvedType=null;breakgetTag;caseREACT_BLOCK_TYPE:fiberTag=Block;breakgetTag;}}varinfo='';{if(type===undefined||typeoftype==='object'&&type!==null&&Object.keys(type).length===0){info+=' You likely forgot to export your component from the file '+"it's defined in, or you might have mixed up default and "+'named imports.';}varownerName=owner?getComponentName(owner.type):null;if(ownerName){info+='\n\nCheck the render method of `'+ownerName+'`.';}}{{throwError("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+(type==null?type:typeoftype)+"."+info);}}}}}varfiber=createFiber(fiberTag,pendingProps,key,mode);fiber.elementType=type;fiber.type=resolvedType;fiber.lanes=lanes;{fiber._debugOwner=owner;}returnfiber;}functioncreateFiberFromElement(element,mode,lanes){varowner=null;{owner=element._owner;}vartype=element.type;varkey=element.key;varpendingProps=element.props;varfiber=createFiberFromTypeAndProps(type,key,pendingProps,owner,mode,lanes);{fiber._debugSource=element._source;fiber._debugOwner=element._owner;}returnfiber;}functioncreateFiberFromFragment(elements,mode,lanes,key){varfiber=createFiber(Fragment,elements,key,mode);fiber.lanes=lanes;returnfiber;}functioncreateFiberFromProfiler(pendingProps,mode,lanes,key){{if(typeofpendingProps.id!=='string'){error('Profiler must specify an "id" as a prop');}}varfiber=createFiber(Profiler,pendingProps,key,mode|ProfileMode);// TODO: The Profiler fiber shouldn't have a type. It has a tag.
fiber.elementType=REACT_PROFILER_TYPE;fiber.type=REACT_PROFILER_TYPE;fiber.lanes=lanes;{fiber.stateNode={effectDuration:0,passiveEffectDuration:0};}returnfiber;}functioncreateFiberFromSuspense(pendingProps,mode,lanes,key){varfiber=createFiber(SuspenseComponent,pendingProps,key,mode);// TODO: The SuspenseComponent fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
fiber.type=REACT_SUSPENSE_TYPE;fiber.elementType=REACT_SUSPENSE_TYPE;fiber.lanes=lanes;returnfiber;}functioncreateFiberFromSuspenseList(pendingProps,mode,lanes,key){varfiber=createFiber(SuspenseListComponent,pendingProps,key,mode);{// TODO: The SuspenseListComponent fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
fiber.type=REACT_SUSPENSE_LIST_TYPE;}fiber.elementType=REACT_SUSPENSE_LIST_TYPE;fiber.lanes=lanes;returnfiber;}functioncreateFiberFromOffscreen(pendingProps,mode,lanes,key){varfiber=createFiber(OffscreenComponent,pendingProps,key,mode);// TODO: The OffscreenComponent fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
{fiber.type=REACT_OFFSCREEN_TYPE;}fiber.elementType=REACT_OFFSCREEN_TYPE;fiber.lanes=lanes;returnfiber;}functioncreateFiberFromLegacyHidden(pendingProps,mode,lanes,key){varfiber=createFiber(LegacyHiddenComponent,pendingProps,key,mode);// TODO: The LegacyHidden fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
{fiber.type=REACT_LEGACY_HIDDEN_TYPE;}fiber.elementType=REACT_LEGACY_HIDDEN_TYPE;fiber.lanes=lanes;returnfiber;}functioncreateFiberFromText(content,mode,lanes){varfiber=createFiber(HostText,content,null,mode);fiber.lanes=lanes;returnfiber;}functioncreateFiberFromHostInstanceForDeletion(){varfiber=createFiber(HostComponent,null,null,NoMode);// TODO: These should not need a type.
fiber.elementType='DELETED';fiber.type='DELETED';returnfiber;}functioncreateFiberFromPortal(portal,mode,lanes){varpendingProps=portal.children!==null?portal.children:[];varfiber=createFiber(HostPortal,pendingProps,portal.key,mode);fiber.lanes=lanes;fiber.stateNode={containerInfo:portal.containerInfo,pendingChildren:null,// Used by persistent updates
implementation:portal.implementation};returnfiber;}// Used for stashing WIP properties to replay failed work in DEV.
functionassignFiberPropertiesInDEV(target,source){if(target===null){// This Fiber's initial properties will always be overwritten.
// We only use a Fiber to ensure the same hidden class so DEV isn't slow.
target=createFiber(IndeterminateComponent,null,null,NoMode);}// This is intentionally written as a list of all properties.
// We tried to use Object.assign() instead but this is called in
// the hottest path, and Object.assign() was too slow:
// https://github.com/facebook/react/issues/12502
// This code is DEV-only so size is not a concern.
target.tag=source.tag;target.key=source.key;target.elementType=source.elementType;target.type=source.type;target.stateNode=source.stateNode;target.return=source.return;target.child=source.child;target.sibling=source.sibling;target.index=source.index;target.ref=source.ref;target.pendingProps=source.pendingProps;target.memoizedProps=source.memoizedProps;target.updateQueue=source.updateQueue;target.memoizedState=source.memoizedState;target.dependencies=source.dependencies;target.mode=source.mode;target.flags=source.flags;target.nextEffect=source.nextEffect;target.firstEffect=source.firstEffect;target.lastEffect=source.lastEffect;target.lanes=source.lanes;target.childLanes=source.childLanes;target.alternate=source.alternate;{target.actualDuration=source.actualDuration;target.actualStartTime=source.actualStartTime;target.selfBaseDuration=source.selfBaseDuration;target.treeBaseDuration=source.treeBaseDuration;}target._debugID=source._debugID;target._debugSource=source._debugSource;target._debugOwner=source._debugOwner;target._debugNeedsRemount=source._debugNeedsRemount;target._debugHookTypes=source._debugHookTypes;returntarget;}functionFiberRootNode(containerInfo,tag,hydrate){this.tag=tag;this.containerInfo=containerInfo;this.pendingChildren=null;this.current=null;this.pingCache=null;this.finishedWork=null;this.timeoutHandle=noTimeout;this.context=null;this.pendingContext=null;this.hydrate=hydrate;this.callbackNode=null;this.callbackPriority=NoLanePriority;this.eventTimes=createLaneMap(NoLanes);this.expirationTimes=createLaneMap(NoTimestamp);this.pendingLanes=NoLanes;this.suspendedLanes=NoLanes;this.pingedLanes=NoLanes;this.expiredLanes=NoLanes;this.mutableReadLanes=NoLanes;this.finishedLanes=NoLanes;this.entangledLanes=NoLanes;this.entanglements=createLaneMap(NoLanes);{this.mutableSourceEagerHydrationData=null;}{this.interactionThreadID=tracing$1.unstable_getThreadID();this.memoizedInteractions=newSet();this.pendingInteractionMap=newMap();}{switch(tag){caseBlockingRoot:this._debugRootType='createBlockingRoot()';break;caseConcurrentRoot:this._debugRootType='createRoot()';break;caseLegacyRoot:this._debugRootType='createLegacyRoot()';break;}}}functioncreateFiberRoot(containerInfo,tag,hydrate,hydrationCallbacks){varroot=newFiberRootNode(containerInfo,tag,hydrate);// stateNode is any.
varuninitializedFiber=createHostRootFiber(tag);root.current=uninitializedFiber;uninitializedFiber.stateNode=root;initializeUpdateQueue(uninitializedFiber);returnroot;}// This ensures that the version used for server rendering matches the one
// that is eventually read during hydration.
// If they don't match there's a potential tear and a full deopt render is required.
functionregisterMutableSourceForHydration(root,mutableSource){vargetVersion=mutableSource._getVersion;varversion=getVersion(mutableSource._source);// TODO Clear this data once all pending hydration work is finished.
// Retaining it forever may interfere with GC.
if(root.mutableSourceEagerHydrationData==null){root.mutableSourceEagerHydrationData=[mutableSource,version];}else{root.mutableSourceEagerHydrationData.push(mutableSource,version);}}functioncreatePortal(children,containerInfo,// TODO: figure out the API for cross-renderer implementation.
implementation){varkey=arguments.length>3&&arguments[3]!==undefined?arguments[3]:null;return{// This tag allow us to uniquely identify this as a React Portal
$$typeof:REACT_PORTAL_TYPE,key:key==null?null:''+key,children:children,containerInfo:containerInfo,implementation:implementation};}vardidWarnAboutNestedUpdates;vardidWarnAboutFindNodeInStrictMode;{didWarnAboutNestedUpdates=false;didWarnAboutFindNodeInStrictMode={};}functiongetContextForSubtree(parentComponent){if(!parentComponent){returnemptyContextObject;}varfiber=get(parentComponent);varparentContext=findCurrentUnmaskedContext(fiber);if(fiber.tag===ClassComponent){varComponent=fiber.type;if(isContextProvider(Component)){returnprocessChildContext(fiber,Component,parentContext);}}returnparentContext;}functionfindHostInstanceWithWarning(component,methodName){{varfiber=get(component);if(fiber===undefined){if(typeofcomponent.render==='function'){{{throwError("Unable to find node on an unmounted component.");}}}else{{{throwError("Argument appears to not be a ReactComponent. Keys: "+Object.keys(component));}}}}varhostFiber=findCurrentHostFiber(fiber);if(hostFiber===null){returnnull;}if(hostFiber.mode&StrictMode){varcomponentName=getComponentName(fiber.type)||'Component';if(!didWarnAboutFindNodeInStrictMode[componentName]){didWarnAboutFindNodeInStrictMode[componentName]=true;varpreviousFiber=current;try{setCurrentFiber(hostFiber);if(fiber.mode&StrictMode){error('%s is deprecated in StrictMode. '+'%s was passed an instance of %s which is inside StrictMode. '+'Instead, add a ref directly to the element you want to reference. '+'Learn more about using refs safely here: '+'https://reactjs.org/link/strict-mode-find-node',methodName,methodName,componentName);}else{error('%s is deprecated in StrictMode. '+'%s was passed an instance of %s which renders StrictMode children. '+'Instead, add a ref directly to the element you want to reference. '+'Learn more about using refs safely here: '+'https://reactjs.org/link/strict-mode-find-node',methodName,methodName,componentName);}}finally{// Ideally this should reset to previous but this shouldn't be called in
// render and there's another warning for that anyway.
if(previousFiber){setCurrentFiber(previousFiber);}else{resetCurrentFiber();}}}}returnhostFiber.stateNode;}}functioncreateContainer(containerInfo,tag,hydrate,hydrationCallbacks){returncreateFiberRoot(containerInfo,tag,hydrate);}functionupdateContainer(element,container,parentComponent,callback){{onScheduleRoot(container,element);}varcurrent$1=container.current;vareventTime=requestEventTime();{// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if('undefined'!==typeofjest){warnIfUnmockedScheduler(current$1);warnIfNotScopedWithMatchingAct(current$1);}}varlane=requestUpdateLane(current$1);varcontext=getContextForSubtree(parentComponent);if(container.context===null){container.context=context;}else{container.pendingContext=context;}{if(isRendering&¤t!==null&&!didWarnAboutNestedUpdates){didWarnAboutNestedUpdates=true;error('Render methods should be a pure function of props and state; '+'triggering nested component updates from render is not allowed. '+'If necessary, trigger nested updates in componentDidUpdate.\n\n'+'Check the render method of %s.',getComponentName(current.type)||'Unknown');}}varupdate=createUpdate(eventTime,lane);// Caution: React DevTools currently depends on this property
// being called "element".
update.payload={element:element};callback=callback===undefined?null:callback;if(callback!==null){{if(typeofcallback!=='function'){error('render(...): Expected the last optional `callback` argument to be a '+'function. Instead received: %s.',callback);}}update.callback=callback;}enqueueUpdate(current$1,update);scheduleUpdateOnFiber(current$1,lane,eventTime);returnlane;}functiongetPublicRootInstance(container){varcontainerFiber=container.current;if(!containerFiber.child){returnnull;}switch(containerFiber.child.tag){caseHostComponent:returngetPublicInstance(containerFiber.child.stateNode);default:returncontainerFiber.child.stateNode;}}functionmarkRetryLaneImpl(fiber,retryLane){varsuspenseState=fiber.memoizedState;if(suspenseState!==null&&suspenseState.dehydrated!==null){suspenseState.retryLane=higherPriorityLane(suspenseState.retryLane,retryLane);}}// Increases the priority of thennables when they resolve within this boundary.
functionmarkRetryLaneIfNotHydrated(fiber,retryLane){markRetryLaneImpl(fiber,retryLane);varalternate=fiber.alternate;if(alternate){markRetryLaneImpl(alternate,retryLane);}}functionattemptUserBlockingHydration$1(fiber){if(fiber.tag!==SuspenseComponent){// We ignore HostRoots here because we can't increase
// their priority and they should not suspend on I/O,
// since you have to wrap anything that might suspend in
// Suspense.
return;}vareventTime=requestEventTime();varlane=InputDiscreteHydrationLane;scheduleUpdateOnFiber(fiber,lane,eventTime);markRetryLaneIfNotHydrated(fiber,lane);}functionattemptContinuousHydration$1(fiber){if(fiber.tag!==SuspenseComponent){// We ignore HostRoots here because we can't increase
// their priority and they should not suspend on I/O,
// since you have to wrap anything that might suspend in
// Suspense.
return;}vareventTime=requestEventTime();varlane=SelectiveHydrationLane;scheduleUpdateOnFiber(fiber,lane,eventTime);markRetryLaneIfNotHydrated(fiber,lane);}functionattemptHydrationAtCurrentPriority$1(fiber){if(fiber.tag!==SuspenseComponent){// We ignore HostRoots here because we can't increase
// their priority other than synchronously flush it.
return;}vareventTime=requestEventTime();varlane=requestUpdateLane(fiber);scheduleUpdateOnFiber(fiber,lane,eventTime);markRetryLaneIfNotHydrated(fiber,lane);}functionrunWithPriority$2(priority,fn){try{setCurrentUpdateLanePriority(priority);returnfn();}finally{}}functionfindHostInstanceWithNoPortals(fiber){varhostFiber=findCurrentHostFiberWithNoPortals(fiber);if(hostFiber===null){returnnull;}if(hostFiber.tag===FundamentalComponent){returnhostFiber.stateNode.instance;}returnhostFiber.stateNode;}varshouldSuspendImpl=function(fiber){returnfalse;};functionshouldSuspend(fiber){returnshouldSuspendImpl(fiber);}varoverrideHookState=null;varoverrideHookStateDeletePath=null;varoverrideHookStateRenamePath=null;varoverrideProps=null;varoverridePropsDeletePath=null;varoverridePropsRenamePath=null;varscheduleUpdate=null;varsetSuspenseHandler=null;{varcopyWithDeleteImpl=function(obj,path,index){varkey=path[index];varupdated=Array.isArray(obj)?obj.slice():_assign({},obj);if(index+1===path.length){if(Array.isArray(updated)){updated.splice(key,1);}else{deleteupdated[key];}returnupdated;}// $FlowFixMe number or string is fine here
updated[key]=copyWithDeleteImpl(obj[key],path,index+1);returnupdated;};varcopyWithDelete=function(obj,path){returncopyWithDeleteImpl(obj,path,0);};varcopyWithRenameImpl=function(obj,oldPath,newPath,index){varoldKey=oldPath[index];varupdated=Array.isArray(obj)?obj.slice():_assign({},obj);if(index+1===oldPath.length){varnewKey=newPath[index];// $FlowFixMe number or string is fine here
updated[newKey]=updated[oldKey];if(Array.isArray(updated)){updated.splice(oldKey,1);}else{deleteupdated[oldKey];}}else{// $FlowFixMe number or string is fine here
updated[oldKey]=copyWithRenameImpl(// $FlowFixMe number or string is fine here
obj[oldKey],oldPath,newPath,index+1);}returnupdated;};varcopyWithRename=function(obj,oldPath,newPath){if(oldPath.length!==newPath.length){warn('copyWithRename() expects paths of the same length');return;}else{for(vari=0;i<newPath.length-1;i++){if(oldPath[i]!==newPath[i]){warn('copyWithRename() expects paths to be the same except for the deepest key');return;}}}returncopyWithRenameImpl(obj,oldPath,newPath,0);};varcopyWithSetImpl=function(obj,path,index,value){if(index>=path.length){returnvalue;}varkey=path[index];varupdated=Array.isArray(obj)?obj.slice():_assign({},obj);// $FlowFixMe number or string is fine here
updated[key]=copyWithSetImpl(obj[key],path,index+1,value);returnupdated;};varcopyWithSet=function(obj,path,value){returncopyWithSetImpl(obj,path,0,value);};varfindHook=function(fiber,id){// For now, the "id" of stateful hooks is just the stateful hook index.
// This may change in the future with e.g. nested hooks.
varcurrentHook=fiber.memoizedState;while(currentHook!==null&&id>0){currentHook=currentHook.next;id--;}returncurrentHook;};// Support DevTools editable values for useState and useReducer.
overrideHookState=function(fiber,id,path,value){varhook=findHook(fiber,id);if(hook!==null){varnewState=copyWithSet(hook.memoizedState,path,value);hook.memoizedState=newState;hook.baseState=newState;// We aren't actually adding an update to the queue,
// because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps=_assign({},fiber.memoizedProps);scheduleUpdateOnFiber(fiber,SyncLane,NoTimestamp);}};overrideHookStateDeletePath=function(fiber,id,path){varhook=findHook(fiber,id);if(hook!==null){varnewState=copyWithDelete(hook.memoizedState,path);hook.memoizedState=newState;hook.baseState=newState;// We aren't actually adding an update to the queue,
// because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps=_assign({},fiber.memoizedProps);scheduleUpdateOnFiber(fiber,SyncLane,NoTimestamp);}};overrideHookStateRenamePath=function(fiber,id,oldPath,newPath){varhook=findHook(fiber,id);if(hook!==null){varnewState=copyWithRename(hook.memoizedState,oldPath,newPath);hook.memoizedState=newState;hook.baseState=newState;// We aren't actually adding an update to the queue,
// because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps=_assign({},fiber.memoizedProps);scheduleUpdateOnFiber(fiber,SyncLane,NoTimestamp);}};// Support DevTools props for function components, forwardRef, memo, host components, etc.
findHostInstancesForRefresh:findHostInstancesForRefresh,scheduleRefresh:scheduleRefresh,scheduleRoot:scheduleRoot,setRefreshHandler:setRefreshHandler,// Enables DevTools to append owner stacks to error messages in DEV mode.
getCurrentFiber:getCurrentFiberForDevTools});}functionReactDOMRoot(container,options){this._internalRoot=createRootImpl(container,ConcurrentRoot,options);}functionReactDOMBlockingRoot(container,tag,options){this._internalRoot=createRootImpl(container,tag,options);}ReactDOMRoot.prototype.render=ReactDOMBlockingRoot.prototype.render=function(children){varroot=this._internalRoot;{if(typeofarguments[1]==='function'){error('render(...): does not support the second callback argument. '+'To execute a side effect after rendering, declare it in a component body with useEffect().');}varcontainer=root.containerInfo;if(container.nodeType!==COMMENT_NODE){varhostInstance=findHostInstanceWithNoPortals(root.current);if(hostInstance){if(hostInstance.parentNode!==container){error('render(...): It looks like the React-rendered content of the '+'root container was removed without using React. This is not '+'supported and will cause errors. Instead, call '+"root.unmount() to empty a root's container.");}}}}updateContainer(children,root,null,null);};ReactDOMRoot.prototype.unmount=ReactDOMBlockingRoot.prototype.unmount=function(){{if(typeofarguments[0]==='function'){error('unmount(...): does not support a callback argument. '+'To execute a side effect after rendering, declare it in a component body with useEffect().');}}varroot=this._internalRoot;varcontainer=root.containerInfo;updateContainer(null,root,null,function(){unmarkContainerAsRoot(container);});};functioncreateRootImpl(container,tag,options){// Tag is either LegacyRoot or Concurrent Root
varhydrate=options!=null&&options.hydrate===true;varhydrationCallbacks=options!=null&&options.hydrationOptions||null;varmutableSources=options!=null&&options.hydrationOptions!=null&&options.hydrationOptions.mutableSources||null;varroot=createContainer(container,tag,hydrate);markContainerAsRoot(root.current,container);varcontainerNodeType=container.nodeType;{varrootContainerElement=container.nodeType===COMMENT_NODE?container.parentNode:container;listenToAllSupportedEvents(rootContainerElement);}if(mutableSources){for(vari=0;i<mutableSources.length;i++){varmutableSource=mutableSources[i];registerMutableSourceForHydration(root,mutableSource);}}returnroot;}functioncreateLegacyRoot(container,options){returnnewReactDOMBlockingRoot(container,LegacyRoot,options);}functionisValidContainer(node){return!!(node&&(node.nodeType===ELEMENT_NODE||node.nodeType===DOCUMENT_NODE||node.nodeType===DOCUMENT_FRAGMENT_NODE||node.nodeType===COMMENT_NODE&&node.nodeValue===' react-mount-point-unstable '));}varReactCurrentOwner$3=ReactSharedInternals.ReactCurrentOwner;vartopLevelUpdateWarnings;varwarnedAboutHydrateAPI=false;{topLevelUpdateWarnings=function(container){if(container._reactRootContainer&&container.nodeType!==COMMENT_NODE){varhostInstance=findHostInstanceWithNoPortals(container._reactRootContainer._internalRoot.current);if(hostInstance){if(hostInstance.parentNode!==container){error('render(...): It looks like the React-rendered content of this '+'container was removed without using React. This is not '+'supported and will cause errors. Instead, call '+'ReactDOM.unmountComponentAtNode to empty a container.');}}}varisRootRenderedBySomeReact=!!container._reactRootContainer;varrootEl=getReactRootElementInContainer(container);varhasNonRootReactChild=!!(rootEl&&getInstanceFromNode(rootEl));if(hasNonRootReactChild&&!isRootRenderedBySomeReact){error('render(...): Replacing React-rendered children with a new root '+'component. If you intended to update the children of this node, '+'you should instead have the existing children update their state '+'and render the new components instead of calling ReactDOM.render.');}if(container.nodeType===ELEMENT_NODE&&container.tagName&&container.tagName.toUpperCase()==='BODY'){error('render(): Rendering components directly into document.body is '+'discouraged, since its children are often manipulated by third-party '+'scripts and browser extensions. This may lead to subtle '+'reconciliation issues. Try rendering into a container element created '+'for your app.');}};}functiongetReactRootElementInContainer(container){if(!container){returnnull;}if(container.nodeType===DOCUMENT_NODE){returncontainer.documentElement;}else{returncontainer.firstChild;}}functionshouldHydrateDueToLegacyHeuristic(container){varrootElement=getReactRootElementInContainer(container);return!!(rootElement&&rootElement.nodeType===ELEMENT_NODE&&rootElement.hasAttribute(ROOT_ATTRIBUTE_NAME));}functionlegacyCreateRootFromDOMContainer(container,forceHydrate){varshouldHydrate=forceHydrate||shouldHydrateDueToLegacyHeuristic(container);// First clear any existing content.
if(!shouldHydrate){varwarned=false;varrootSibling;while(rootSibling=container.lastChild){{if(!warned&&rootSibling.nodeType===ELEMENT_NODE&&rootSibling.hasAttribute(ROOT_ATTRIBUTE_NAME)){warned=true;error('render(): Target node has markup rendered by React, but there '+'are unrelated nodes as well. This is most commonly caused by '+'white-space inserted around server-rendered markup.');}}container.removeChild(rootSibling);}}{if(shouldHydrate&&!forceHydrate&&!warnedAboutHydrateAPI){warnedAboutHydrateAPI=true;warn('render(): Calling ReactDOM.render() to hydrate server-rendered markup '+'will stop working in React v18. Replace the ReactDOM.render() call '+'with ReactDOM.hydrate() if you want React to attach to the server HTML.');}}returncreateLegacyRoot(container,shouldHydrate?{hydrate:true}:undefined);}functionwarnOnInvalidCallback$1(callback,callerName){{if(callback!==null&&typeofcallback!=='function'){error('%s(...): Expected the last optional `callback` argument to be a '+'function. Instead received: %s.',callerName,callback);}}}functionlegacyRenderSubtreeIntoContainer(parentComponent,children,container,forceHydrate,callback){{topLevelUpdateWarnings(container);warnOnInvalidCallback$1(callback===undefined?null:callback,'render');}// TODO: Without `any` type, Flow says "Property cannot be accessed on any
// member of intersection type." Whyyyyyy.
varroot=container._reactRootContainer;varfiberRoot;if(!root){// Initial mount
root=container._reactRootContainer=legacyCreateRootFromDOMContainer(container,forceHydrate);fiberRoot=root._internalRoot;if(typeofcallback==='function'){varoriginalCallback=callback;callback=function(){varinstance=getPublicRootInstance(fiberRoot);originalCallback.call(instance);};}// Initial mount should not be batched.
updateContainer(children,fiberRoot,parentComponent,callback);}returngetPublicRootInstance(fiberRoot);}functionfindDOMNode(componentOrElement){{varowner=ReactCurrentOwner$3.current;if(owner!==null&&owner.stateNode!==null){varwarnedAboutRefsInRender=owner.stateNode._warnedAboutRefsInRender;if(!warnedAboutRefsInRender){error('%s is accessing findDOMNode inside its render(). '+'render() should be a pure function of props and state. It should '+'never access something that requires stale data from the previous '+'render, such as refs. Move this logic to componentDidMount and '+'componentDidUpdate instead.',getComponentName(owner.type)||'A component');}owner.stateNode._warnedAboutRefsInRender=true;}}if(componentOrElement==null){returnnull;}if(componentOrElement.nodeType===ELEMENT_NODE){returncomponentOrElement;}{returnfindHostInstanceWithWarning(componentOrElement,'findDOMNode');}}functionhydrate(element,container,callback){if(!isValidContainer(container)){{throwError("Target container is not a DOM element.");}}{varisModernRoot=isContainerMarkedAsRoot(container)&&container._reactRootContainer===undefined;if(isModernRoot){error('You are calling ReactDOM.hydrate() on a container that was previously '+'passed to ReactDOM.createRoot(). This is not supported. '+'Did you mean to call createRoot(container, {hydrate: true}).render(element)?');}}// TODO: throw or warn if we couldn't hydrate?
returnlegacyRenderSubtreeIntoContainer(null,element,container,true,callback);}functionrender(element,container,callback){if(!isValidContainer(container)){{throwError("Target container is not a DOM element.");}}{varisModernRoot=isContainerMarkedAsRoot(container)&&container._reactRootContainer===undefined;if(isModernRoot){error('You are calling ReactDOM.render() on a container that was previously '+'passed to ReactDOM.createRoot(). This is not supported. '+'Did you mean to call root.render(element)?');}}returnlegacyRenderSubtreeIntoContainer(null,element,container,false,callback);}functionunstable_renderSubtreeIntoContainer(parentComponent,element,containerNode,callback){if(!isValidContainer(containerNode)){{throwError("Target container is not a DOM element.");}}if(!(parentComponent!=null&&has(parentComponent))){{throwError("parentComponent must be a valid React Component");}}returnlegacyRenderSubtreeIntoContainer(parentComponent,element,containerNode,false,callback);}functionunmountComponentAtNode(container){if(!isValidContainer(container)){{throwError("unmountComponentAtNode(...): Target container is not a DOM element.");}}{varisModernRoot=isContainerMarkedAsRoot(container)&&container._reactRootContainer===undefined;if(isModernRoot){error('You are calling ReactDOM.unmountComponentAtNode() on a container that was previously '+'passed to ReactDOM.createRoot(). This is not supported. Did you mean to call root.unmount()?');}}if(container._reactRootContainer){{varrootEl=getReactRootElementInContainer(container);varrenderedByDifferentReact=rootEl&&!getInstanceFromNode(rootEl);if(renderedByDifferentReact){error("unmountComponentAtNode(): The node you're attempting to unmount "+'was rendered by another copy of React.');}}// Unmount should not be batched.
unbatchedUpdates(function(){legacyRenderSubtreeIntoContainer(null,null,container,false,function(){// $FlowFixMe This should probably use `delete container._reactRootContainer`
container._reactRootContainer=null;unmarkContainerAsRoot(container);});});// If you call unmountComponentAtNode twice in quick succession, you'll
// get `true` twice. That's probably fine?
returntrue;}else{{var_rootEl=getReactRootElementInContainer(container);varhasNonRootReactChild=!!(_rootEl&&getInstanceFromNode(_rootEl));// Check if the container itself is a React root node.
varisContainerReactRoot=container.nodeType===ELEMENT_NODE&&isValidContainer(container.parentNode)&&!!container.parentNode._reactRootContainer;if(hasNonRootReactChild){error("unmountComponentAtNode(): The node you're attempting to unmount "+'was rendered by React and is not a top-level container. %s',isContainerReactRoot?'You may have accidentally passed in a React root node instead '+'of its container.':'Instead, have the parent component update its state and '+'rerender in order to remove this component.');}}returnfalse;}}setAttemptUserBlockingHydration(attemptUserBlockingHydration$1);setAttemptContinuousHydration(attemptContinuousHydration$1);setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority$1);setAttemptHydrationAtPriority(runWithPriority$2);vardidWarnAboutUnstableCreatePortal=false;{if(typeofMap!=='function'||// $FlowIssue Flow incorrectly thinks Map has no prototype
Map.prototype==null||typeofMap.prototype.forEach!=='function'||typeofSet!=='function'||// $FlowIssue Flow incorrectly thinks Set has no prototype
Set.prototype==null||typeofSet.prototype.clear!=='function'||typeofSet.prototype.forEach!=='function'){error('React depends on Map and Set built-in types. Make sure that you load a '+'polyfill in older browsers. https://reactjs.org/link/react-polyfills');}}setRestoreImplementation(restoreControlledState$3);setBatchingImplementation(batchedUpdates$1,discreteUpdates$1,flushDiscreteUpdates,batchedEventUpdates$1);functioncreatePortal$1(children,container){varkey=arguments.length>2&&arguments[2]!==undefined?arguments[2]:null;if(!isValidContainer(container)){{throwError("Target container is not a DOM element.");}}// TODO: pass ReactDOM portal implementation as third argument
// $FlowFixMe The Flow type is opaque but there's no way to actually create it.
returncreatePortal(children,container,null,key);}functionrenderSubtreeIntoContainer(parentComponent,element,containerNode,callback){returnunstable_renderSubtreeIntoContainer(parentComponent,element,containerNode,callback);}functionunstable_createPortal(children,container){varkey=arguments.length>2&&arguments[2]!==undefined?arguments[2]:null;{if(!didWarnAboutUnstableCreatePortal){didWarnAboutUnstableCreatePortal=true;warn('The ReactDOM.unstable_createPortal() alias has been deprecated, '+'and will be removed in React 18+. Update your code to use '+'ReactDOM.createPortal() instead. It has the exact same API, '+'but without the "unstable_" prefix.');}}returncreatePortal$1(children,container,key);}varInternals={// Keep in sync with ReactTestUtils.js, and ReactTestUtilsAct.js.
// This is an array for better minification.
Events:[getInstanceFromNode,getNodeFromInstance,getFiberCurrentPropsFromNode,enqueueStateRestore,restoreStateIfNeeded,flushPassiveEffects,// TODO: This is related to `act`, not events. Move to separate key?
IsThisRendererActing]};varfoundDevTools=injectIntoDevTools({findFiberByHostInstance:getClosestInstanceFromNode,bundleType:1,version:ReactVersion,rendererPackageName:'react-dom'});{if(!foundDevTools&&canUseDOM&&window.top===window.self){// If we're in Chrome or Firefox, provide a download link if not installed.
if(navigator.userAgent.indexOf('Chrome')>-1&&navigator.userAgent.indexOf('Edge')===-1||navigator.userAgent.indexOf('Firefox')>-1){varprotocol=window.location.protocol;// Don't warn in exotic cases like chrome-extension://.
console.info('%cDownload the React DevTools '+'for a better development experience: '+'https://reactjs.org/link/react-devtools'+(protocol==='file:'?'\nYou might need to use a local HTTP server (instead of file://): '+'https://reactjs.org/link/react-devtools-faq':''),'font-weight:bold');}}}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=Internals;exports.createPortal=createPortal$1;exports.findDOMNode=findDOMNode;exports.flushSync=flushSync;exports.hydrate=hydrate;exports.render=render;exports.unmountComponentAtNode=unmountComponentAtNode;exports.unstable_batchedUpdates=batchedUpdates$1;exports.unstable_createPortal=unstable_createPortal;exports.unstable_renderSubtreeIntoContainer=renderSubtreeIntoContainer;exports.version=ReactVersion;})();}
.setDesc('Include the dollar amount on the final line of a transaction. This value is optional, and is alway equal to the sum of the previous lines * -1.')
text:"Ledger uses accounts to group expense types. Accounts are grouped into a hierarchy by separating with a colon. For example 'expenses:food:grocery' and 'expenses:food:restaurants",
.setDesc('The account prefix used for grouping asset accounts. If you use aliases in your Ledger file, this must be the **unaliased** account prefix. e.g. "Assets" instead of "a"')
.setDesc('The account prefix used for grouping expense accounts. If you use aliases in your Ledger file, this must be the **unaliased** account prefix. e.g. "Expenses" instead of "e"')
.setDesc('The account prefix used for grouping income accounts. If you use aliases in your Ledger file, this must be the **unaliased** account prefix. e.g. "Income" instead of "i"')
.setDesc('The account prefix used for grouping liability accounts. If you use aliases in your Ledger file, this must be the **unaliased** account prefix. e.g. "Liabilities" instead of "l"')
functionisBoolean(value){returnvalue===true||value===false||isObjectLike(value)&&getTag(value)=='[object Boolean]';}functionisObject(value){returntypeofvalue==='object';}// Checks if `value` is object-like.
functionisObjectLike(value){returnisObject(value)&&value!==null;}functionisDefined(value){returnvalue!==undefined&&value!==null;}functionisBlank(value){return!value.trim().length;}// Gets the `toStringTag` of `value`.
functiongetTag(value){returnvalue==null?value===undefined?'[object Undefined]':'[object Null]':Object.prototype.toString.call(value);}constEXTENDED_SEARCH_UNAVAILABLE='Extended search is not available';constINCORRECT_INDEX_TYPE="Incorrect 'index' type";constLOGICAL_SEARCH_INVALID_QUERY_FOR_KEY=key=>`Invalid value for key ${key}`;constPATTERN_LENGTH_TOO_LARGE=max=>`Pattern length exceeds max of ${max}.`;constMISSING_KEY_PROPERTY=name=>`Missing ${name} property in key`;constINVALID_KEY_WEIGHT_VALUE=key=>`Property 'weight' in key '${key}' must be a positive integer`;consthasOwn=Object.prototype.hasOwnProperty;classKeyStore{constructor(keys){this._keys=[];this._keyMap={};lettotalWeight=0;keys.forEach(key=>{letobj=createKey(key);totalWeight+=obj.weight;this._keys.push(obj);this._keyMap[obj.id]=obj;totalWeight+=obj.weight;});// Normalize weights so that their sum is equal to 1
this._keys.forEach(key=>{key.weight/=totalWeight;});}get(keyId){returnthis._keyMap[keyId];}keys(){returnthis._keys;}toJSON(){returnJSON.stringify(this._keys);}}functioncreateKey(key){letpath=null;letid=null;letsrc=null;letweight=1;if(isString(key)||isArray(key)){src=key;path=createKeyPath(key);id=createKeyId(key);}else{if(!hasOwn.call(key,'name')){thrownewError(MISSING_KEY_PROPERTY('name'));}constname=key.name;src=name;if(hasOwn.call(key,'weight')){weight=key.weight;if(weight<=0){thrownewError(INVALID_KEY_WEIGHT_VALUE(name));}}path=createKeyPath(name);id=createKeyId(name);}return{path,id,weight,src};}functioncreateKeyPath(key){returnisArray(key)?key:key.split('.');}functioncreateKeyId(key){returnisArray(key)?key.join('.'):key;}functionget(obj,path){letlist=[];letarr=false;constdeepGet=(obj,path,index)=>{if(!isDefined(obj)){return;}if(!path[index]){// If there's no path left, we've arrived at the object we care about.
list.push(obj);}else{letkey=path[index];constvalue=obj[key];if(!isDefined(value)){return;}// If we're at the last value in the path, and if it's a string/number/bool,
// add it to the list
if(index===path.length-1&&(isString(value)||isNumber(value)||isBoolean(value))){list.push(toString(value));}elseif(isArray(value)){arr=true;// Search each item in the array.
for(leti=0,len=value.length;i<len;i+=1){deepGet(value[i],path,index+1);}}elseif(path.length){// An object. Recurse further.
deepGet(value,path,index+1);}}};// Backwards compatibility (since path used to be a string)
deepGet(obj,isString(path)?path.split('.'):path,0);returnarr?list:list[0];}constMatchOptions={// Whether the matches should be included in the result set. When `true`, each record in the result
// set will include the indices of the matched characters.
// These can consequently be used for highlighting purposes.
includeMatches:false,// When `true`, the matching function will continue to the end of a search pattern even if
// a perfect match has already been located in the string.
findAllMatches:false,// Minimum number of characters that must be matched before a result is considered a match
minMatchCharLength:1};constBasicOptions={// When `true`, the algorithm continues searching to the end of the input even if a perfect
// match is found before the end of the same input.
isCaseSensitive:false,// When true, the matching function will continue to the end of a search pattern even if
includeScore:false,// List of properties that will be searched. This also supports nested properties.
keys:[],// Whether to sort the result list, by score
shouldSort:true,// Default sort function: sort by ascending score, ascending index
sortFn:(a,b)=>a.score===b.score?a.idx<b.idx?-1:1:a.score<b.score?-1:1};constFuzzyOptions={// Approximately where in the text is the pattern expected to be found?
location:0,// At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
// (of both letters and location), a threshold of '1.0' would match anything.
threshold:0.6,// Determines how close the match must be to the fuzzy location (specified above).
// An exact letter match which is 'distance' characters away from the fuzzy location
// would score as a complete mismatch. A distance of '0' requires the match be at
// the exact location specified, a threshold of '1000' would require a perfect match
// to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
distance:100};constAdvancedOptions={// When `true`, it enables the use of unix-like search commands
useExtendedSearch:false,// The get function to use when fetching an object's properties.
// The default will search nested paths *ie foo.bar.baz*
// More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
ignoreLocation:false,// When `true`, the calculation for the relevance score (used for sorting) will
// ignore the field-length norm.
// More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
ignoreFieldNorm:false};varConfig={...BasicOptions,...MatchOptions,...FuzzyOptions,...AdvancedOptions};constSPACE=/[^ ]+/g;// Field-length norm: the shorter the field, the higher the weight.
// Set to 3 decimals to reduce index size.
functionnorm(mantissa=3){constcache=newMap();constm=Math.pow(10,mantissa);return{get(value){constnumTokens=value.match(SPACE).length;if(cache.has(numTokens)){returncache.get(numTokens);}constnorm=1/Math.sqrt(numTokens);// In place of `toFixed(mantissa)`, for faster computation
constn=parseFloat(Math.round(norm*m)/m);cache.set(numTokens,n);returnn;},clear(){cache.clear();}};}classFuseIndex{constructor({getFn=Config.getFn}={}){this.norm=norm(3);this.getFn=getFn;this.isCreated=false;this.setIndexRecords();}setSources(docs=[]){this.docs=docs;}setIndexRecords(records=[]){this.records=records;}setKeys(keys=[]){this.keys=keys;this._keysMap={};keys.forEach((key,idx)=>{this._keysMap[key.id]=idx;});}create(){if(this.isCreated||!this.docs.length){return;}this.isCreated=true;// List is Array<String>
if(isString(this.docs[0])){this.docs.forEach((doc,docIndex)=>{this._addString(doc,docIndex);});}else{// List is Array<Object>
this.docs.forEach((doc,docIndex)=>{this._addObject(doc,docIndex);});}this.norm.clear();}// Adds a doc to the end of the index
add(doc){constidx=this.size();if(isString(doc)){this._addString(doc,idx);}else{this._addObject(doc,idx);}}// Removes the doc at the specified index of the index
removeAt(idx){this.records.splice(idx,1);// Change ref index of every subsquent doc
for(leti=idx,len=this.size();i<len;i+=1){this.records[i].i-=1;}}getValueForItemAtKeyId(item,keyId){returnitem[this._keysMap[keyId]];}size(){returnthis.records.length;}_addString(doc,docIndex){if(!isDefined(doc)||isBlank(doc)){return;}letrecord={v:doc,i:docIndex,n:this.norm.get(doc)};this.records.push(record);}_addObject(doc,docIndex){letrecord={i:docIndex,$:{}};// Iterate over every key (i.e, path), and fetch the value at that key
letvalue=this.getFn(doc,key.path);if(!isDefined(value)){return;}if(isArray(value)){letsubRecords=[];conststack=[{nestedArrIndex:-1,value}];while(stack.length){const{nestedArrIndex,value}=stack.pop();if(!isDefined(value)){continue;}if(isString(value)&&!isBlank(value)){letsubRecord={v:value,i:nestedArrIndex,n:this.norm.get(value)};subRecords.push(subRecord);}elseif(isArray(value)){value.forEach((item,k)=>{stack.push({nestedArrIndex:k,value:item});});}}record.$[keyIndex]=subRecords;}elseif(!isBlank(value)){letsubRecord={v:value,n:this.norm.get(value)};record.$[keyIndex]=subRecord;}});this.records.push(record);}toJSON(){return{keys:this.keys,records:this.records};}}functioncreateIndex(keys,docs,{getFn=Config.getFn}={}){constmyIndex=newFuseIndex({getFn});myIndex.setKeys(keys.map(createKey));myIndex.setSources(docs);myIndex.create();returnmyIndex;}functionparseIndex(data,{getFn=Config.getFn}={}){const{keys,records}=data;constmyIndex=newFuseIndex({getFn});myIndex.setKeys(keys);myIndex.setIndexRecords(records);returnmyIndex;}functioncomputeScore(pattern,{errors=0,currentLocation=0,expectedLocation=0,distance=Config.distance,ignoreLocation=Config.ignoreLocation}={}){constaccuracy=errors/pattern.length;if(ignoreLocation){returnaccuracy;}constproximity=Math.abs(expectedLocation-currentLocation);if(!distance){// Dodge divide by zero error.
returnproximity?1.0:accuracy;}returnaccuracy+proximity/distance;}functionconvertMaskToIndices(matchmask=[],minMatchCharLength=Config.minMatchCharLength){letindices=[];letstart=-1;letend=-1;leti=0;for(letlen=matchmask.length;i<len;i+=1){letmatch=matchmask[i];if(match&&start===-1){start=i;}elseif(!match&&start!==-1){end=i-1;if(end-start+1>=minMatchCharLength){indices.push([start,end]);}start=-1;}}// (i-1 - start) + 1 => i - start
if(matchmask[i-1]&&i-start>=minMatchCharLength){indices.push([start,i-1]);}returnindices;}// Machine word size
constMAX_BITS=32;functionsearch(text,pattern,patternAlphabet,{location=Config.location,distance=Config.distance,threshold=Config.threshold,findAllMatches=Config.findAllMatches,minMatchCharLength=Config.minMatchCharLength,includeMatches=Config.includeMatches,ignoreLocation=Config.ignoreLocation}={}){if(pattern.length>MAX_BITS){thrownewError(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));}constpatternLen=pattern.length;// Set starting location at beginning text and initialize the alphabet.
consttextLen=text.length;// Handle the case when location > text.length
constexpectedLocation=Math.max(0,Math.min(location,textLen));// Highest score beyond which we give up.
letcurrentThreshold=threshold;// Is there a nearby exact match? (speedup)
letbestLocation=expectedLocation;// Performance: only computer matches when the minMatchCharLength > 1
// OR if `includeMatches` is true.
constcomputeMatches=minMatchCharLength>1||includeMatches;// A mask of the matches, used for building the indices
constmatchMask=computeMatches?Array(textLen):[];letindex;// Get all exact matches, here for speed up
while((index=text.indexOf(pattern,bestLocation))>-1){letscore=computeScore(pattern,{currentLocation:index,expectedLocation,distance,ignoreLocation});currentThreshold=Math.min(score,currentThreshold);bestLocation=index+patternLen;if(computeMatches){leti=0;while(i<patternLen){matchMask[index+i]=1;i+=1;}}}// Reset the best location
bestLocation=-1;letlastBitArr=[];letfinalScore=1;letbinMax=patternLen+textLen;constmask=1<<patternLen-1;for(leti=0;i<patternLen;i+=1){// Scan for the best match; each iteration allows for one more error.
// Run a binary search to determine how far from the match location we can stray
// at this error level.
letbinMin=0;letbinMid=binMax;while(binMin<binMid){constscore=computeScore(pattern,{errors:i,currentLocation:expectedLocation+binMid,expectedLocation,distance,ignoreLocation});if(score<=currentThreshold){binMin=binMid;}else{binMax=binMid;}binMid=Math.floor((binMax-binMin)/2+binMin);}// Use the result from this iteration as the maximum for the next.
binMax=binMid;letstart=Math.max(1,expectedLocation-binMid+1);letfinish=findAllMatches?textLen:Math.min(expectedLocation+binMid,textLen)+patternLen;// Initialize the bit array
letbitArr=Array(finish+2);bitArr[finish+1]=(1<<i)-1;for(letj=finish;j>=start;j-=1){letcurrentLocation=j-1;letcharMatch=patternAlphabet[text.charAt(currentLocation)];if(computeMatches){// Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)
matchMask[currentLocation]=+!!charMatch;}// First pass: exact match
bitArr[j]=(bitArr[j+1]<<1|1)&charMatch;// Subsequent passes: fuzzy match
if(i){bitArr[j]|=(lastBitArr[j+1]|lastBitArr[j])<<1|1|lastBitArr[j+1];}if(bitArr[j]&mask){finalScore=computeScore(pattern,{errors:i,currentLocation,expectedLocation,distance,ignoreLocation});// This match will almost certainly be better than any existing match.
// But check anyway.
if(finalScore<=currentThreshold){// Indeed it is
currentThreshold=finalScore;bestLocation=currentLocation;// Already passed `loc`, downhill from here on in.
if(bestLocation<=expectedLocation){break;}// When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.
start=Math.max(1,2*expectedLocation-bestLocation);}}}// No hope for a (better) match at greater error levels.
constscore=computeScore(pattern,{errors:i+1,currentLocation:expectedLocation,expectedLocation,distance,ignoreLocation});if(score>currentThreshold){break;}lastBitArr=bitArr;}constresult={isMatch:bestLocation>=0,// Count exact matches (those with a score of 0) to be "almost" exact
score:Math.max(0.001,finalScore)};if(computeMatches){constindices=convertMaskToIndices(matchMask,minMatchCharLength);if(!indices.length){result.isMatch=false;}elseif(includeMatches){result.indices=indices;}}returnresult;}functioncreatePatternAlphabet(pattern){letmask={};for(leti=0,len=pattern.length;i<len;i+=1){constchar=pattern.charAt(i);mask[char]=(mask[char]||0)|1<<len-i-1;}returnmask;}classBitapSearch{constructor(pattern,{location=Config.location,threshold=Config.threshold,distance=Config.distance,includeMatches=Config.includeMatches,findAllMatches=Config.findAllMatches,minMatchCharLength=Config.minMatchCharLength,isCaseSensitive=Config.isCaseSensitive,ignoreLocation=Config.ignoreLocation}={}){this.options={location,threshold,distance,includeMatches,findAllMatches,minMatchCharLength,isCaseSensitive,ignoreLocation};this.pattern=isCaseSensitive?pattern:pattern.toLowerCase();this.chunks=[];if(!this.pattern.length){return;}constaddChunk=(pattern,startIndex)=>{this.chunks.push({pattern,alphabet:createPatternAlphabet(pattern),startIndex});};constlen=this.pattern.length;if(len>MAX_BITS){leti=0;constremainder=len%MAX_BITS;constend=len-remainder;while(i<end){addChunk(this.pattern.substr(i,MAX_BITS),i);i+=MAX_BITS;}if(remainder){conststartIndex=len-MAX_BITS;addChunk(this.pattern.substr(startIndex),startIndex);}}else{addChunk(this.pattern,0);}}searchIn(text){const{isCaseSensitive,includeMatches}=this.options;if(!isCaseSensitive){text=text.toLowerCase();}// Exact match
if(this.pattern===text){letresult={isMatch:true,score:0};if(includeMatches){result.indices=[[0,text.length-1]];}returnresult;}// Otherwise, use Bitap algorithm
classIncludeMatchextendsBaseMatch{constructor(pattern){super(pattern);}staticgettype(){return'include';}staticgetmultiRegex(){return/^'"(.*)"$/;}staticgetsingleRegex(){return/^'(.*)$/;}search(text){letlocation=0;letindex;constindices=[];constpatternLen=this.pattern.length;// Get all exact matches
while((index=text.indexOf(this.pattern,location))>-1){location=index+patternLen;indices.push([index,location-1]);}constisMatch=!!indices.length;return{isMatch,score:isMatch?0:1,indices};}}// ❗Order is important. DO NOT CHANGE.
constsearchers=[ExactMatch,IncludeMatch,PrefixExactMatch,InversePrefixExactMatch,InverseSuffixExactMatch,SuffixExactMatch,InverseExactMatch,FuzzyMatch];constsearchersLen=searchers.length;// Regex to split by spaces, but keep anything in quotes together
constSPACE_RE=/ +(?=([^\"]*\"[^\"]*\")*[^\"]*$)/;constOR_TOKEN='|';// Return a 2D array representation of the query, for simpler parsing.
functionparseQuery(pattern,options={}){returnpattern.split(OR_TOKEN).map(item=>{letquery=item.trim().split(SPACE_RE).filter(item=>item&&!!item.trim());letresults=[];for(leti=0,len=query.length;i<len;i+=1){constqueryItem=query[i];// 1. Handle multiple query match (i.e, once that are quoted, like `"hello world"`)
letfound=false;letidx=-1;while(!found&&++idx<searchersLen){constsearcher=searchers[idx];lettoken=searcher.isMultiMatch(queryItem);if(token){results.push(newsearcher(token,options));found=true;}}if(found){continue;}// 2. Handle single query matches (i.e, once that are *not* quoted)
idx=-1;while(++idx<searchersLen){constsearcher=searchers[idx];lettoken=searcher.isSingleMatch(queryItem);if(token){results.push(newsearcher(token,options));break;}}}returnresults;});}// These extended matchers can return an array of matches, as opposed
for(leti=0,qLen=query.length;i<qLen;i+=1){constsearchers=query[i];// Reset indices
allIndices.length=0;numMatches=0;// ANDs
for(letj=0,pLen=searchers.length;j<pLen;j+=1){constsearcher=searchers[j];const{isMatch,indices,score}=searcher.search(text);if(isMatch){numMatches+=1;totalScore+=score;if(includeMatches){consttype=searcher.constructor.type;if(MultiMatchSet.has(type)){allIndices=[...allIndices,...indices];}else{allIndices.push(indices);}}}else{totalScore=0;numMatches=0;allIndices.length=0;break;}}// OR condition, so if TRUE, return
if(numMatches){letresult={isMatch:true,score:totalScore/numMatches};if(includeMatches){result.indices=allIndices;}returnresult;}}// Nothing was matched
return{isMatch:false,score:1};}}constregisteredSearchers=[];functionregister(...args){registeredSearchers.push(...args);}functioncreateSearcher(pattern,options){for(leti=0,len=registeredSearchers.length;i<len;i+=1){letsearcherClass=registeredSearchers[i];if(searcherClass.condition(pattern,options)){returnnewsearcherClass(pattern,options);}}returnnewBitapSearch(pattern,options);}constLogicalOperator={AND:'$and',OR:'$or'};constKeyType={PATH:'$path',PATTERN:'$val'};constisExpression=query=>!!(query[LogicalOperator.AND]||query[LogicalOperator.OR]);constisPath=query=>!!query[KeyType.PATH];constisLeaf=query=>!isArray(query)&&isObject(query)&&!isExpression(query);constconvertToExplicit=query=>({[LogicalOperator.AND]:Object.keys(query).map(key=>({[key]:query[key]}))});// When `auto` is `true`, the parse function will infer and initialize and add
// the appropriate `Searcher` instance
functionparse$1(query,options,{auto=true}={}){constnext=query=>{letkeys=Object.keys(query);constisQueryPath=isPath(query);if(!isQueryPath&&keys.length>1&&!isExpression(query)){returnnext(convertToExplicit(query));}if(isLeaf(query)){constkey=isQueryPath?query[KeyType.PATH]:keys[0];constpattern=isQueryPath?query[KeyType.PATTERN]:query[key];if(!isString(pattern)){thrownewError(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));}constobj={keyId:createKeyId(key),pattern};if(auto){obj.searcher=createSearcher(pattern,options);}returnobj;}letnode={children:[],operator:keys[0]};keys.forEach(key=>{constvalue=query[key];if(isArray(value)){value.forEach(item=>{node.children.push(next(item));});}});returnnode;};if(!isExpression(query)){query=convertToExplicit(query);}returnnext(query);}// Practical scoring function
functioncomputeScore$1(results,{ignoreFieldNorm=Config.ignoreFieldNorm}){results.forEach(result=>{lettotalScore=1;result.matches.forEach(({key,norm,score})=>{constweight=key?key.weight:null;totalScore*=Math.pow(score===0&&weight?Number.EPSILON:score,(weight||1)*(ignoreFieldNorm?1:norm));});result.score=totalScore;});}functiontransformMatches(result,data){constmatches=result.matches;data.matches=[];if(!isDefined(matches)){return;}matches.forEach(match=>{if(!isDefined(match.indices)||!match.indices.length){return;}const{indices,value}=match;letobj={indices,value};if(match.key){obj.key=match.key.src;}if(match.idx>-1){obj.refIndex=match.idx;}data.matches.push(obj);});}functiontransformScore(result,data){data.score=result.score;}functionformat(results,docs,{includeMatches=Config.includeMatches,includeScore=Config.includeScore}={}){consttransformers=[];if(includeMatches)transformers.push(transformMatches);if(includeScore)transformers.push(transformScore);returnresults.map(result=>{const{idx}=result;constdata={item:docs[idx],refIndex:idx};if(transformers.length){transformers.forEach(transformer=>{transformer(result,data);});}returndata;});}classFuse{constructor(docs,options={},index){this.options={...Config,...options};if(this.options.useExtendedSearch&&!true){thrownewError(EXTENDED_SEARCH_UNAVAILABLE);}this._keyStore=newKeyStore(this.options.keys);this.setCollection(docs,index);}setCollection(docs,index){this._docs=docs;if(index&&!(indexinstanceofFuseIndex)){thrownewError(INCORRECT_INDEX_TYPE);}this._myIndex=index||createIndex(this.options.keys,this._docs,{getFn:this.options.getFn});}add(doc){if(!isDefined(doc)){return;}this._docs.push(doc);this._myIndex.add(doc);}remove(predicate=()=>false){constresults=[];for(leti=0,len=this._docs.length;i<len;i+=1){constdoc=this._docs[i];if(predicate(doc,i)){this.removeAt(i);i-=1;len-=1;results.push(doc);}}returnresults;}removeAt(idx){this._docs.splice(idx,1);this._myIndex.removeAt(idx);}getIndex(){returnthis._myIndex;}search(query,{limit=-1}={}){const{includeMatches,includeScore,shouldSort,sortFn,ignoreFieldNorm}=this.options;letresults=isString(query)?isString(this._docs[0])?this._searchStringList(query):this._searchObjectList(query):this._searchLogical(query);computeScore$1(results,{ignoreFieldNorm});if(shouldSort){results.sort(sortFn);}if(isNumber(limit)&&limit>-1){results=results.slice(0,limit);}returnformat(results,this._docs,{includeMatches,includeScore});}_searchStringList(query){constsearcher=createSearcher(query,this.options);const{records}=this._myIndex;constresults=[];// Iterate over every string in the index
records.forEach(({v:text,i:idx,n:norm})=>{if(!isDefined(text)){return;}const{isMatch,score,indices}=searcher.searchIn(text);if(isMatch){results.push({item:text,idx,matches:[{score,value:text,norm,indices}]});}});returnresults;}_searchLogical(query){constexpression=parse$1(query,this.options);constevaluate=(node,item,idx)=>{if(!node.children){const{keyId,searcher}=node;constmatches=this._findMatches({key:this._keyStore.get(keyId),value:this._myIndex.getValueForItemAtKeyId(item,keyId),searcher});if(matches&&matches.length){return[{idx,item,matches}];}return[];}/*eslint indent: [2, 2, {"SwitchCase": 1}]*/switch(node.operator){caseLogicalOperator.AND:{constres=[];for(leti=0,len=node.children.length;i<len;i+=1){constchild=node.children[i];constresult=evaluate(child,item,idx);if(result.length){res.push(...result);}else{return[];}}returnres;}caseLogicalOperator.OR:{constres=[];for(leti=0,len=node.children.length;i<len;i+=1){constchild=node.children[i];constresult=evaluate(child,item,idx);if(result.length){res.push(...result);break;}}returnres;}}};constrecords=this._myIndex.records;constresultMap={};constresults=[];records.forEach(({$:item,i:idx})=>{if(isDefined(item)){letexpResults=evaluate(expression,item,idx);if(expResults.length){// Dedupe when adding
if(!resultMap[idx]){resultMap[idx]={idx,item,matches:[]};results.push(resultMap[idx]);}expResults.forEach(({matches})=>{resultMap[idx].matches.push(...matches);});}}});returnresults;}_searchObjectList(query){constsearcher=createSearcher(query,this.options);const{keys,records}=this._myIndex;constresults=[];// List is Array<Object>
records.forEach(({$:item,i:idx})=>{if(!isDefined(item)){return;}letmatches=[];// Iterate over every key (i.e, path), and fetch the value at that key
vartop='top';varbottom='bottom';varright='right';varleft='left';varauto='auto';varbasePlacements=[top,bottom,right,left];varstart='start';varend='end';varclippingParents='clippingParents';varviewport='viewport';varpopper='popper';varreference='reference';varvariationPlacements=/*#__PURE__*/basePlacements.reduce(function(acc,placement){returnacc.concat([placement+"-"+start,placement+"-"+end]);},[]);varplacements=/*#__PURE__*/[].concat(basePlacements,[auto]).reduce(function(acc,placement){returnacc.concat([placement,placement+"-"+start,placement+"-"+end]);},[]);// modifiers that need to read the DOM
functionisElement(node){varOwnElement=getWindow(node).Element;returnnodeinstanceofOwnElement||nodeinstanceofElement;}functionisHTMLElement(node){varOwnElement=getWindow(node).HTMLElement;returnnodeinstanceofOwnElement||nodeinstanceofHTMLElement;}functionisShadowRoot(node){// IE 11 has no ShadowRoot
// and applies them to the HTMLElements such as popper and arrow
functionapplyStyles(_ref){varstate=_ref.state;Object.keys(state.elements).forEach(function(name){varstyle=state.styles[name]||{};varattributes=state.attributes[name]||{};varelement=state.elements[name];// arrow is optional + virtual elements
if(!isHTMLElement(element)||!getNodeName(element)){return;}// Flow doesn't support to extend this property, but it's the most
// effective way to apply styles to an HTMLElement
// $FlowFixMe[cannot-write]
Object.assign(element.style,style);Object.keys(attributes).forEach(function(name){varvalue=attributes[name];if(value===false){element.removeAttribute(name);}else{element.setAttribute(name,value===true?'':value);}});});}functioneffect(_ref2){varstate=_ref2.state;varinitialStyles={popper:{position:state.options.strategy,left:'0',top:'0',margin:'0'},arrow:{position:'absolute'},reference:{}};Object.assign(state.elements.popper.style,initialStyles.popper);state.styles=initialStyles;if(state.elements.arrow){Object.assign(state.elements.arrow.style,initialStyles.arrow);}returnfunction(){Object.keys(state.elements).forEach(function(name){varelement=state.elements[name];varattributes=state.attributes[name]||{};varstyleProperties=Object.keys(state.styles.hasOwnProperty(name)?state.styles[name]:initialStyles[name]);// Set all values to an empty string to unset them
varstyle=styleProperties.reduce(function(style,property){style[property]='';returnstyle;},{});// arrow is optional + virtual elements
functioncontains(parent,child){varrootNode=child.getRootNode&&child.getRootNode();// First, attempt with faster native method
if(parent.contains(child)){returntrue;}// then fallback to custom implementation with Shadow DOM support
elseif(rootNode&&isShadowRoot(rootNode)){varnext=child;do{if(next&&parent.isSameNode(next)){returntrue;}// $FlowFixMe[prop-missing]: need a better way to handle this...
next=next.parentNode||next.host;}while(next);}// Give up, the result is false
functiongetParentNode(element){if(getNodeName(element)==='html'){returnelement;}return(// this is a quicker (but less type safe) way to save quite some bytes from the bundle
// $FlowFixMe[incompatible-return]
// $FlowFixMe[prop-missing]
element.assignedSlot||// step into the shadow DOM of the parent of a slotted node
getComputedStyle(element).position==='fixed'){returnnull;}returnelement.offsetParent;}// `.offsetParent` reports `null` for fixed elements, while absolute elements
// return the containing block
functiongetContainingBlock(element){varisFirefox=navigator.userAgent.toLowerCase().indexOf('firefox')!==-1;varisIE=navigator.userAgent.indexOf('Trident')!==-1;if(isIE&&isHTMLElement(element)){// In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
varelementCss=getComputedStyle(element);if(elementCss.position==='fixed'){returnnull;}}varcurrentNode=getParentNode(element);while(isHTMLElement(currentNode)&&['html','body'].indexOf(getNodeName(currentNode))<0){varcss=getComputedStyle(currentNode);// This is non-exhaustive but covers the most common CSS properties that
vartoPaddingObject=functiontoPaddingObject(padding,state){padding=typeofpadding==='function'?padding(Object.assign({},state.rects,{placement:state.placement})):padding;returnmergePaddingObject(typeofpadding!=='number'?padding:expandToHashMap(padding,basePlacements));};functionarrow(_ref){var_state$modifiersData$;varstate=_ref.state,name=_ref.name,options=_ref.options;vararrowElement=state.elements.arrow;varpopperOffsets=state.modifiersData.popperOffsets;varbasePlacement=getBasePlacement(state.placement);varaxis=getMainAxisFromPlacement(basePlacement);varisVertical=[left,right].indexOf(basePlacement)>=0;varlen=isVertical?'height':'width';if(!arrowElement||!popperOffsets){return;}varpaddingObject=toPaddingObject(options.padding,state);vararrowRect=getLayoutRect(arrowElement);varminProp=axis==='y'?top:left;varmaxProp=axis==='y'?bottom:right;varendDiff=state.rects.reference[len]+state.rects.reference[axis]-popperOffsets[axis]-state.rects.popper[len];varstartDiff=popperOffsets[axis]-state.rects.reference[axis];vararrowOffsetParent=getOffsetParent(arrowElement);varclientSize=arrowOffsetParent?axis==='y'?arrowOffsetParent.clientHeight||0:arrowOffsetParent.clientWidth||0:0;varcenterToReference=endDiff/2-startDiff/2;// Make sure the arrow doesn't overflow the popper if the center point is
if(typeofarrowElement==='string'){arrowElement=state.elements.popper.querySelector(arrowElement);if(!arrowElement){return;}}{if(!isHTMLElement(arrowElement)){console.error(['Popper: "arrow" element must be an HTMLElement (not an SVGElement).','To use an SVG arrow, wrap it in an HTMLElement that will be used as','the arrow.'].join(' '));}}if(!contains(state.elements.popper,arrowElement)){{console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper','element.'].join(' '));}return;}state.elements.arrow=arrowElement;}// eslint-disable-next-line import/no-unused-modules
varunsetSides={top:'auto',right:'auto',bottom:'auto',left:'auto'};// Round the offsets to the nearest suitable subpixel based on the DPR.
// Zooming can change the DPR, but it seems to report a value that will
// cleanly divide the values into the appropriate subpixels.
functionroundOffsetsByDPR(_ref){varx=_ref.x,y=_ref.y;varwin=window;vardpr=win.devicePixelRatio||1;return{x:round(round(x*dpr)/dpr)||0,y:round(round(y*dpr)/dpr)||0};}functionmapToStyles(_ref2){var_Object$assign2;varpopper=_ref2.popper,popperRect=_ref2.popperRect,placement=_ref2.placement,offsets=_ref2.offsets,position=_ref2.position,gpuAcceleration=_ref2.gpuAcceleration,adaptive=_ref2.adaptive,roundOffsets=_ref2.roundOffsets;var_ref3=roundOffsets===true?roundOffsetsByDPR(offsets):typeofroundOffsets==='function'?roundOffsets(offsets):offsets,_ref3$x=_ref3.x,x=_ref3$x===void0?0:_ref3$x,_ref3$y=_ref3.y,y=_ref3$y===void0?0:_ref3$y;varhasX=offsets.hasOwnProperty('x');varhasY=offsets.hasOwnProperty('y');varsideX=left;varsideY=top;varwin=window;if(adaptive){varoffsetParent=getOffsetParent(popper);varheightProp='clientHeight';varwidthProp='clientWidth';if(offsetParent===getWindow(popper)){offsetParent=getDocumentElement(popper);if(getComputedStyle(offsetParent).position!=='static'){heightProp='scrollHeight';widthProp='scrollWidth';}}// $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
x-=offsetParent[widthProp]-popperRect.width;x*=gpuAcceleration?1:-1;}}varcommonStyles=Object.assign({position:position},adaptive&&unsetSides);if(gpuAcceleration){var_Object$assign;returnObject.assign({},commonStyles,(_Object$assign={},_Object$assign[sideY]=hasY?'0':'',_Object$assign[sideX]=hasX?'0':'',_Object$assign.transform=(win.devicePixelRatio||1)<2?"translate("+x+"px, "+y+"px)":"translate3d("+x+"px, "+y+"px, 0)",_Object$assign));}returnObject.assign({},commonStyles,(_Object$assign2={},_Object$assign2[sideY]=hasY?y+"px":'',_Object$assign2[sideX]=hasX?x+"px":'',_Object$assign2.transform='',_Object$assign2));}functioncomputeStyles(_ref4){varstate=_ref4.state,options=_ref4.options;var_options$gpuAccelerat=options.gpuAcceleration,gpuAcceleration=_options$gpuAccelerat===void0?true:_options$gpuAccelerat,_options$adaptive=options.adaptive,adaptive=_options$adaptive===void0?true:_options$adaptive,_options$roundOffsets=options.roundOffsets,roundOffsets=_options$roundOffsets===void0?true:_options$roundOffsets;{vartransitionProperty=getComputedStyle(state.elements.popper).transitionProperty||'';if(adaptive&&['transform','top','right','bottom','left'].some(function(property){returntransitionProperty.indexOf(property)>=0;})){console.warn(['Popper: Detected CSS transitions on at least one of the following','CSS properties: "transform", "top", "right", "bottom", "left".','\n\n','Disable the "computeStyles" modifier\'s `adaptive` option to allow','for smooth transitions, or remove these properties from the CSS','transition declaration on the popper element if only transitioning','opacity or background-color for example.','\n\n','We recommend using the popper element as a wrapper around an inner','element that can have any CSS property transitioned for animations.'].join(' '));}}varcommonStyles={placement:getBasePlacement(state.placement),popper:state.elements.popper,popperRect:state.rects.popper,gpuAcceleration:gpuAcceleration};if(state.modifiersData.popperOffsets!=null){state.styles.popper=Object.assign({},state.styles.popper,mapToStyles(Object.assign({},commonStyles,{offsets:state.modifiersData.popperOffsets,position:state.options.strategy,adaptive:adaptive,roundOffsets:roundOffsets})));}if(state.modifiersData.arrow!=null){state.styles.arrow=Object.assign({},state.styles.arrow,mapToStyles(Object.assign({},commonStyles,{offsets:state.modifiersData.arrow,position:'absolute',adaptive:false,roundOffsets:roundOffsets})));}state.attributes.popper=Object.assign({},state.attributes.popper,{'data-popper-placement':state.placement});}// eslint-disable-next-line import/no-unused-modules
functiongetViewportRect(element){varwin=getWindow(element);varhtml=getDocumentElement(element);varvisualViewport=win.visualViewport;varwidth=html.clientWidth;varheight=html.clientHeight;varx=0;vary=0;// NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
// can be obscured underneath it.
// Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
// if it isn't open, so if this isn't available, the popper will be detected
// to overflow the bottom of the screen too early.
if(visualViewport){width=visualViewport.width;height=visualViewport.height;// Uses Layout Viewport (like Chrome; Safari does not currently)
// In Chrome, it returns a value very close to 0 (+/-) but contains rounding
// errors due to floating point numbers, so we need to check precision.
// Safari returns a number <= 0, usually < -1 when pinch-zoomed
// Feature detection fails in mobile emulation mode in Chrome.
functiongetScrollParent(node){if(['html','body','#document'].indexOf(getNodeName(node))>=0){// $FlowFixMe[incompatible-return]: assume body is always available
functiongetInnerBoundingClientRect(element){varrect=getBoundingClientRect(element);rect.top=rect.top+element.clientTop;rect.left=rect.left+element.clientLeft;rect.bottom=rect.top+element.clientHeight;rect.right=rect.left+element.clientWidth;rect.width=element.clientWidth;rect.height=element.clientHeight;rect.x=rect.left;rect.y=rect.top;returnrect;}functiongetClientRectFromMixedType(element,clippingParent){returnclippingParent===viewport?rectToClientRect(getViewportRect(element)):isHTMLElement(clippingParent)?getInnerBoundingClientRect(clippingParent):rectToClientRect(getDocumentRect(getDocumentElement(element)));}// A "clipping parent" is an overflowable container with the characteristic of
// clipping (or hiding) overflowing elements with a position different from
returnclippingParents.filter(function(clippingParent){returnisElement(clippingParent)&&contains(clippingParent,clipperElement)&&getNodeName(clippingParent)!=='body';});}// Gets the maximum area that the element is visible in due to any number of
functiondetectOverflow(state,options){if(options===void0){options={};}var_options=options,_options$placement=_options.placement,placement=_options$placement===void0?state.placement:_options$placement,_options$boundary=_options.boundary,boundary=_options$boundary===void0?clippingParents:_options$boundary,_options$rootBoundary=_options.rootBoundary,rootBoundary=_options$rootBoundary===void0?viewport:_options$rootBoundary,_options$elementConte=_options.elementContext,elementContext=_options$elementConte===void0?popper:_options$elementConte,_options$altBoundary=_options.altBoundary,altBoundary=_options$altBoundary===void0?false:_options$altBoundary,_options$padding=_options.padding,padding=_options$padding===void0?0:_options$padding;varpaddingObject=mergePaddingObject(typeofpadding!=='number'?padding:expandToHashMap(padding,basePlacements));varaltContext=elementContext===popper?reference:popper;varreferenceElement=state.elements.reference;varpopperRect=state.rects.popper;varelement=state.elements[altBoundary?altContext:elementContext];varclippingClientRect=getClippingRect(isElement(element)?element:element.contextElement||getDocumentElement(state.elements.popper),boundary,rootBoundary);varreferenceClientRect=getBoundingClientRect(referenceElement);varpopperOffsets=computeOffsets({reference:referenceClientRect,element:popperRect,strategy:'absolute',placement:placement});varpopperClientRect=rectToClientRect(Object.assign({},popperRect,popperOffsets));varelementClientRect=elementContext===popper?popperClientRect:referenceClientRect;// positive = overflowing the clipping rect
// 0 or negative = within the clipping rect
varoverflowOffsets={top:clippingClientRect.top-elementClientRect.top+paddingObject.top,bottom:elementClientRect.bottom-clippingClientRect.bottom+paddingObject.bottom,left:clippingClientRect.left-elementClientRect.left+paddingObject.left,right:elementClientRect.right-clippingClientRect.right+paddingObject.right};varoffsetData=state.modifiersData.offset;// Offsets can be applied only to the popper element
functioncomputeAutoPlacement(state,options){if(options===void0){options={};}var_options=options,placement=_options.placement,boundary=_options.boundary,rootBoundary=_options.rootBoundary,padding=_options.padding,flipVariations=_options.flipVariations,_options$allowedAutoP=_options.allowedAutoPlacements,allowedAutoPlacements=_options$allowedAutoP===void0?placements:_options$allowedAutoP;varvariation=getVariation(placement);varplacements$1=variation?flipVariations?variationPlacements:variationPlacements.filter(function(placement){returngetVariation(placement)===variation;}):basePlacements;varallowedPlacements=placements$1.filter(function(placement){returnallowedAutoPlacements.indexOf(placement)>=0;});if(allowedPlacements.length===0){allowedPlacements=placements$1;{console.error(['Popper: The `allowedAutoPlacements` option did not allow any','placements. Ensure the `placement` option matches the variation','of the allowed placements.','For example, "auto" cannot be used to allow "bottom-start".','Use "auto-start" instead.'].join(' '));}}// $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
functiongetExpandedFallbackPlacements(placement){if(getBasePlacement(placement)===auto){return[];}varoppositePlacement=getOppositePlacement(placement);return[getOppositeVariationPlacement(placement),oppositePlacement,getOppositeVariationPlacement(oppositePlacement)];}functionflip(_ref){varstate=_ref.state,options=_ref.options,name=_ref.name;if(state.modifiersData[name]._skip){return;}var_options$mainAxis=options.mainAxis,checkMainAxis=_options$mainAxis===void0?true:_options$mainAxis,_options$altAxis=options.altAxis,checkAltAxis=_options$altAxis===void0?true:_options$altAxis,specifiedFallbackPlacements=options.fallbackPlacements,padding=options.padding,boundary=options.boundary,rootBoundary=options.rootBoundary,altBoundary=options.altBoundary,_options$flipVariatio=options.flipVariations,flipVariations=_options$flipVariatio===void0?true:_options$flipVariatio,allowedAutoPlacements=options.allowedAutoPlacements;varpreferredPlacement=state.options.placement;varbasePlacement=getBasePlacement(preferredPlacement);varisBasePlacement=basePlacement===preferredPlacement;varfallbackPlacements=specifiedFallbackPlacements||(isBasePlacement||!flipVariations?[getOppositePlacement(preferredPlacement)]:getExpandedFallbackPlacements(preferredPlacement));varplacements=[preferredPlacement].concat(fallbackPlacements).reduce(function(acc,placement){returnacc.concat(getBasePlacement(placement)===auto?computeAutoPlacement(state,{placement:placement,boundary:boundary,rootBoundary:rootBoundary,padding:padding,flipVariations:flipVariations,allowedAutoPlacements:allowedAutoPlacements}):placement);},[]);varreferenceRect=state.rects.reference;varpopperRect=state.rects.popper;varchecksMap=newMap();varmakeFallbackChecks=true;varfirstFittingPlacement=placements[0];for(vari=0;i<placements.length;i++){varplacement=placements[i];var_basePlacement=getBasePlacement(placement);varisStartVariation=getVariation(placement)===start;varisVertical=[top,bottom].indexOf(_basePlacement)>=0;varlen=isVertical?'width':'height';varoverflow=detectOverflow(state,{placement:placement,boundary:boundary,rootBoundary:rootBoundary,altBoundary:altBoundary,padding:padding});varmainVariationSide=isVertical?isStartVariation?right:left:isStartVariation?bottom:top;if(referenceRect[len]>popperRect[len]){mainVariationSide=getOppositePlacement(mainVariationSide);}varaltVariationSide=getOppositePlacement(mainVariationSide);varchecks=[];if(checkMainAxis){checks.push(overflow[_basePlacement]<=0);}if(checkAltAxis){checks.push(overflow[mainVariationSide]<=0,overflow[altVariationSide]<=0);}if(checks.every(function(check){returncheck;})){firstFittingPlacement=placement;makeFallbackChecks=false;break;}checksMap.set(placement,checks);}if(makeFallbackChecks){// `2` may be desired in some cases – research later
functionpreventOverflow(_ref){varstate=_ref.state,options=_ref.options,name=_ref.name;var_options$mainAxis=options.mainAxis,checkMainAxis=_options$mainAxis===void0?true:_options$mainAxis,_options$altAxis=options.altAxis,checkAltAxis=_options$altAxis===void0?false:_options$altAxis,boundary=options.boundary,rootBoundary=options.rootBoundary,altBoundary=options.altBoundary,padding=options.padding,_options$tether=options.tether,tether=_options$tether===void0?true:_options$tether,_options$tetherOffset=options.tetherOffset,tetherOffset=_options$tetherOffset===void0?0:_options$tetherOffset;varoverflow=detectOverflow(state,{boundary:boundary,rootBoundary:rootBoundary,padding:padding,altBoundary:altBoundary});varbasePlacement=getBasePlacement(state.placement);varvariation=getVariation(state.placement);varisBasePlacement=!variation;varmainAxis=getMainAxisFromPlacement(basePlacement);varaltAxis=getAltAxis(mainAxis);varpopperOffsets=state.modifiersData.popperOffsets;varreferenceRect=state.rects.reference;varpopperRect=state.rects.popper;vartetherOffsetValue=typeoftetherOffset==='function'?tetherOffset(Object.assign({},state.rects,{placement:state.placement})):tetherOffset;vardata={x:0,y:0};if(!popperOffsets){return;}if(checkMainAxis||checkAltAxis){varmainSide=mainAxis==='y'?top:left;varaltSide=mainAxis==='y'?bottom:right;varlen=mainAxis==='y'?'height':'width';varoffset=popperOffsets[mainAxis];varmin$1=popperOffsets[mainAxis]+overflow[mainSide];varmax$1=popperOffsets[mainAxis]-overflow[altSide];varadditive=tether?-popperRect[len]/2:0;varminLen=variation===start?referenceRect[len]:popperRect[len];varmaxLen=variation===start?-popperRect[len]:-referenceRect[len];// We need to include the arrow in the calculation so the arrow doesn't go
vararrowElement=state.elements.arrow;vararrowRect=tether&&arrowElement?getLayoutRect(arrowElement):{width:0,height:0};vararrowPaddingObject=state.modifiersData['arrow#persistent']?state.modifiersData['arrow#persistent'].padding:getFreshSideObject();vararrowPaddingMin=arrowPaddingObject[mainSide];vararrowPaddingMax=arrowPaddingObject[altSide];// If the reference length is smaller than the arrow length, we don't want
// to include its full size in the calculation. If the reference is small
// and near the edge of a boundary, the popper can overflow even if the
// reference is not overflowing as well (e.g. virtual elements with no
functionorder(modifiers){varmap=newMap();varvisited=newSet();varresult=[];modifiers.forEach(function(modifier){map.set(modifier.name,modifier);});// On visiting object, check for its dependencies and visit them recursively
functionsort(modifier){visited.add(modifier.name);varrequires=[].concat(modifier.requires||[],modifier.requiresIfExists||[]);requires.forEach(function(dep){if(!visited.has(dep)){vardepModifier=map.get(dep);if(depModifier){sort(depModifier);}}});result.push(modifier);}modifiers.forEach(function(modifier){if(!visited.has(modifier.name)){// check for visited object
sort(modifier);}});returnresult;}functionorderModifiers(modifiers){// order based on dependencies
varorderedModifiers=order(modifiers);// order based on phase
varINVALID_MODIFIER_ERROR='Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';varMISSING_DEPENDENCY_ERROR='Popper: modifier "%s" requires "%s", but "%s" modifier is not available';varVALID_PROPERTIES=['name','enabled','phase','fn','effect','requires','options'];functionvalidateModifiers(modifiers){modifiers.forEach(function(modifier){Object.keys(modifier).forEach(function(key){switch(key){case'name':if(typeofmodifier.name!=='string'){console.error(format$1(INVALID_MODIFIER_ERROR,String(modifier.name),'"name"','"string"',"\""+String(modifier.name)+"\""));}break;case'enabled':if(typeofmodifier.enabled!=='boolean'){console.error(format$1(INVALID_MODIFIER_ERROR,modifier.name,'"enabled"','"boolean"',"\""+String(modifier.enabled)+"\""));}case'phase':if(modifierPhases.indexOf(modifier.phase)<0){console.error(format$1(INVALID_MODIFIER_ERROR,modifier.name,'"phase"',"either "+modifierPhases.join(', '),"\""+String(modifier.phase)+"\""));}break;case'fn':if(typeofmodifier.fn!=='function'){console.error(format$1(INVALID_MODIFIER_ERROR,modifier.name,'"fn"','"function"',"\""+String(modifier.fn)+"\""));}break;case'effect':if(typeofmodifier.effect!=='function'){console.error(format$1(INVALID_MODIFIER_ERROR,modifier.name,'"effect"','"function"',"\""+String(modifier.fn)+"\""));}break;case'requires':if(!Array.isArray(modifier.requires)){console.error(format$1(INVALID_MODIFIER_ERROR,modifier.name,'"requires"','"array"',"\""+String(modifier.requires)+"\""));}break;case'requiresIfExists':if(!Array.isArray(modifier.requiresIfExists)){console.error(format$1(INVALID_MODIFIER_ERROR,modifier.name,'"requiresIfExists"','"array"',"\""+String(modifier.requiresIfExists)+"\""));}break;case'options':case'data':break;default:console.error("PopperJS: an invalid property has been provided to the \""+modifier.name+"\" modifier, valid properties are "+VALID_PROPERTIES.map(function(s){return"\""+s+"\"";}).join(', ')+"; but \""+key+"\" was provided.");}modifier.requires&&modifier.requires.forEach(function(requirement){if(modifiers.find(function(mod){returnmod.name===requirement;})==null){console.error(format$1(MISSING_DEPENDENCY_ERROR,String(modifier.name),requirement,requirement));}});});});}
functionmergeByName(modifiers){varmerged=modifiers.reduce(function(merged,current){varexisting=merged[current.name];merged[current.name]=existing?Object.assign({},existing,current,{options:Object.assign({},existing.options,current.options),data:Object.assign({},existing.data,current.data)}):current;returnmerged;},{});// IE11 does not support Object.values
varINVALID_ELEMENT_ERROR='Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.';varINFINITE_LOOP_ERROR='Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';varDEFAULT_OPTIONS={placement:'bottom',modifiers:[],strategy:'absolute'};functionareValidElements(){for(var_len=arguments.length,args=newArray(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}return!args.some(function(element){return!(element&&typeofelement.getBoundingClientRect==='function');});}functionpopperGenerator(generatorOptions){if(generatorOptions===void0){generatorOptions={};}var_generatorOptions=generatorOptions,_generatorOptions$def=_generatorOptions.defaultModifiers,defaultModifiers=_generatorOptions$def===void0?[]:_generatorOptions$def,_generatorOptions$def2=_generatorOptions.defaultOptions,defaultOptions=_generatorOptions$def2===void0?DEFAULT_OPTIONS:_generatorOptions$def2;returnfunctioncreatePopper(reference,popper,options){if(options===void0){options=defaultOptions;}varstate={placement:'bottom',orderedModifiers:[],options:Object.assign({},DEFAULT_OPTIONS,defaultOptions),modifiersData:{},elements:{reference:reference,popper:popper},attributes:{},styles:{}};vareffectCleanupFns=[];varisDestroyed=false;varinstance={state:state,setOptions:functionsetOptions(options){cleanupModifierEffects();state.options=Object.assign({},defaultOptions,state.options,options);state.scrollParents={reference:isElement(reference)?listScrollParents(reference):reference.contextElement?listScrollParents(reference.contextElement):[],popper:listScrollParents(popper)};// Orders the modifiers based on their dependencies and `phase`
// properties
varorderedModifiers=orderModifiers(mergeByName([].concat(defaultModifiers,state.options.modifiers)));// Strip out disabled modifiers
state.orderedModifiers=orderedModifiers.filter(function(m){returnm.enabled;});// Validate the provided modifiers so that the consumer will get warned
// if one of the modifiers is invalid for any reason
{varmodifiers=uniqueBy([].concat(orderedModifiers,state.options.modifiers),function(_ref){varname=_ref.name;returnname;});validateModifiers(modifiers);if(getBasePlacement(state.options.placement)===auto){varflipModifier=state.orderedModifiers.find(function(_ref2){varname=_ref2.name;returnname==='flip';});if(!flipModifier){console.error(['Popper: "auto" placements require the "flip" modifier be','present and enabled to work.'].join(' '));}}var_getComputedStyle=getComputedStyle(popper),marginTop=_getComputedStyle.marginTop,marginRight=_getComputedStyle.marginRight,marginBottom=_getComputedStyle.marginBottom,marginLeft=_getComputedStyle.marginLeft;// We no longer take into account `margins` on the popper, and it can
// cause bugs with positioning, so we'll warn the consumer
if([marginTop,marginRight,marginBottom,marginLeft].some(function(margin){returnparseFloat(margin);})){console.warn(['Popper: CSS "margin" styles cannot be used to apply padding','between the popper and its reference element or boundary.','To replicate margin, use the `offset` modifier, as well as','the `padding` option in the `preventOverflow` and `flip`','modifiers.'].join(' '));}}runModifierEffects();returninstance.update();},// Sync update – it will always be executed, even if not necessary. This
// is useful for low frequency updates where sync behavior simplifies the
// logic.
// For high frequency updates (e.g. `resize` and `scroll` events), always
// prefer the async Popper#update method
forceUpdate:functionforceUpdate(){if(isDestroyed){return;}var_state$elements=state.elements,reference=_state$elements.reference,popper=_state$elements.popper;// Don't proceed if `reference` or `popper` are not valid elements
// anymore
if(!areValidElements(reference,popper)){{console.error(INVALID_ELEMENT_ERROR);}return;}// Store the reference and popper rects to be read by modifiers
state.rects={reference:getCompositeRect(reference,getOffsetParent(popper),state.options.strategy==='fixed'),popper:getLayoutRect(popper)};// Modifiers have the ability to reset the current update cycle. The
// most common use case for this is the `flip` modifier changing the
// placement, which then needs to re-run all the modifiers, because the
// logic was previously ran for the previous placement and is therefore
// stale/incorrect
state.reset=false;state.placement=state.options.placement;// On each update cycle, the `modifiersData` property for each modifier
// is filled with the initial data specified by the modifier. This means
// it doesn't persist and is fresh on each update.
// To ensure persistent data, use `${name}#persistent`
state.orderedModifiers.forEach(function(modifier){returnstate.modifiersData[modifier.name]=Object.assign({},modifier.data);});var__debug_loops__=0;for(varindex=0;index<state.orderedModifiers.length;index++){{__debug_loops__+=1;if(__debug_loops__>100){console.error(INFINITE_LOOP_ERROR);break;}}if(state.reset===true){state.reset=false;index=-1;continue;}var_state$orderedModifie=state.orderedModifiers[index],fn=_state$orderedModifie.fn,_state$orderedModifie2=_state$orderedModifie.options,_options=_state$orderedModifie2===void0?{}:_state$orderedModifie2,name=_state$orderedModifie.name;if(typeoffn==='function'){state=fn({state:state,options:_options,name:name,instance:instance})||state;}}},// Async and optimistically optimized update – it will not be executed if
// not necessary (debounced to run at most once-per-tick)
update:debounce(function(){returnnewPromise(function(resolve){instance.forceUpdate();resolve(state);});}),destroy:functiondestroy(){cleanupModifierEffects();isDestroyed=true;}};if(!areValidElements(reference,popper)){{console.error(INVALID_ELEMENT_ERROR);}returninstance;}instance.setOptions(options).then(function(state){if(!isDestroyed&&options.onFirstUpdate){options.onFirstUpdate(state);}});// Modifiers have the ability to execute arbitrary code before the first
// update cycle runs. They will be executed in the same order as the update
// cycle. This is useful when a modifier adds some persistent data that
// other modifiers need to use, but the modifier is run after the dependent
/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */
varhasElementType=typeofElement!=='undefined';varhasMap=typeofMap==='function';varhasSet=typeofSet==='function';varhasArrayBuffer=typeofArrayBuffer==='function'&&!!ArrayBuffer.isView;// Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js
(function(global,factory){module.exports=factory();})(commonjsGlobal,function(){varhookCallback;functionhooks(){returnhookCallback.apply(null,arguments);}// This is done to register the method called with moment()
// without creating circular dependencies.
functionsetHookCallback(callback){hookCallback=callback;}functionisArray(input){returninputinstanceofArray||Object.prototype.toString.call(input)==='[object Array]';}functionisObject(input){// IE8 will treat undefined and null as object if it wasn't for
// input != null
returninput!=null&&Object.prototype.toString.call(input)==='[object Object]';}functionhasOwnProp(a,b){returnObject.prototype.hasOwnProperty.call(a,b);}functionisObjectEmpty(obj){if(Object.getOwnPropertyNames){returnObject.getOwnPropertyNames(obj).length===0;}else{vark;for(kinobj){if(hasOwnProp(obj,k)){returnfalse;}}returntrue;}}functionisUndefined(input){returninput===void0;}functionisNumber(input){returntypeofinput==='number'||Object.prototype.toString.call(input)==='[object Number]';}functionisDate(input){returninputinstanceofDate||Object.prototype.toString.call(input)==='[object Date]';}functionmap(arr,fn){varres=[],i;for(i=0;i<arr.length;++i){res.push(fn(arr[i],i));}returnres;}functionextend(a,b){for(variinb){if(hasOwnProp(b,i)){a[i]=b[i];}}if(hasOwnProp(b,'toString')){a.toString=b.toString;}if(hasOwnProp(b,'valueOf')){a.valueOf=b.valueOf;}returna;}functioncreateUTC(input,format,locale,strict){returncreateLocalOrUTC(input,format,locale,strict,true).utc();}functiondefaultParsingFlags(){// We need to deep clone this object.
return{empty:false,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:false,invalidEra:null,invalidMonth:null,invalidFormat:false,userInvalidated:false,iso:false,parsedDateParts:[],era:null,meridiem:null,rfc2822:false,weekdayMismatch:false};}functiongetParsingFlags(m){if(m._pf==null){m._pf=defaultParsingFlags();}returnm._pf;}varsome;if(Array.prototype.some){some=Array.prototype.some;}else{some=function(fun){vart=Object(this),len=t.length>>>0,i;for(i=0;i<len;i++){if(iint&&fun.call(this,t[i],i,t)){returntrue;}}returnfalse;};}functionisValid(m){if(m._isValid==null){varflags=getParsingFlags(m),parsedParts=some.call(flags.parsedDateParts,function(i){returni!=null;}),isNowValid=!isNaN(m._d.getTime())&&flags.overflow<0&&!flags.empty&&!flags.invalidEra&&!flags.invalidMonth&&!flags.invalidWeekday&&!flags.weekdayMismatch&&!flags.nullInput&&!flags.invalidFormat&&!flags.userInvalidated&&(!flags.meridiem||flags.meridiem&&parsedParts);if(m._strict){isNowValid=isNowValid&&flags.charsLeftOver===0&&flags.unusedTokens.length===0&&flags.bigHour===undefined;}if(Object.isFrozen==null||!Object.isFrozen(m)){m._isValid=isNowValid;}else{returnisNowValid;}}returnm._isValid;}functioncreateInvalid(flags){varm=createUTC(NaN);if(flags!=null){extend(getParsingFlags(m),flags);}else{getParsingFlags(m).userInvalidated=true;}returnm;}// Plugins that add properties should also add the key here (null value),
// so we can properly clone ourselves.
varmomentProperties=hooks.momentProperties=[],updateInProgress=false;functioncopyConfig(to,from){vari,prop,val;if(!isUndefined(from._isAMomentObject)){to._isAMomentObject=from._isAMomentObject;}if(!isUndefined(from._i)){to._i=from._i;}if(!isUndefined(from._f)){to._f=from._f;}if(!isUndefined(from._l)){to._l=from._l;}if(!isUndefined(from._strict)){to._strict=from._strict;}if(!isUndefined(from._tzm)){to._tzm=from._tzm;}if(!isUndefined(from._isUTC)){to._isUTC=from._isUTC;}if(!isUndefined(from._offset)){to._offset=from._offset;}if(!isUndefined(from._pf)){to._pf=getParsingFlags(from);}if(!isUndefined(from._locale)){to._locale=from._locale;}if(momentProperties.length>0){for(i=0;i<momentProperties.length;i++){prop=momentProperties[i];val=from[prop];if(!isUndefined(val)){to[prop]=val;}}}returnto;}// Moment prototype object
functionMoment(config){copyConfig(this,config);this._d=newDate(config._d!=null?config._d.getTime():NaN);if(!this.isValid()){this._d=newDate(NaN);}// Prevent infinite loop in case updateOffset creates new moment
// objects.
if(updateInProgress===false){updateInProgress=true;hooks.updateOffset(this);updateInProgress=false;}}functionisMoment(obj){returnobjinstanceofMoment||obj!=null&&obj._isAMomentObject!=null;}functionwarn(msg){if(hooks.suppressDeprecationWarnings===false&&typeofconsole!=='undefined'&&console.warn){console.warn('Deprecation warning: '+msg);}}functiondeprecate(msg,fn){varfirstTime=true;returnextend(function(){if(hooks.deprecationHandler!=null){hooks.deprecationHandler(null,msg);}if(firstTime){varargs=[],arg,i,key;for(i=0;i<arguments.length;i++){arg='';if(typeofarguments[i]==='object'){arg+='\n['+i+'] ';for(keyinarguments[0]){if(hasOwnProp(arguments[0],key)){arg+=key+': '+arguments[0][key]+', ';}}arg=arg.slice(0,-2);// Remove trailing comma and space
}else{arg=arguments[i];}args.push(arg);}warn(msg+'\nArguments: '+Array.prototype.slice.call(args).join('')+'\n'+newError().stack);firstTime=false;}returnfn.apply(this,arguments);},fn);}vardeprecations={};functiondeprecateSimple(name,msg){if(hooks.deprecationHandler!=null){hooks.deprecationHandler(name,msg);}if(!deprecations[name]){warn(msg);deprecations[name]=true;}}hooks.suppressDeprecationWarnings=false;hooks.deprecationHandler=null;functionisFunction(input){returntypeofFunction!=='undefined'&&inputinstanceofFunction||Object.prototype.toString.call(input)==='[object Function]';}functionset(config){varprop,i;for(iinconfig){if(hasOwnProp(config,i)){prop=config[i];if(isFunction(prop)){this[i]=prop;}else{this['_'+i]=prop;}}}this._config=config;// Lenient ordinal parsing accepts just a number in addition to
// number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
// TODO: Remove "ordinalParse" fallback in next major release.
this._dayOfMonthOrdinalParseLenient=newRegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+'|'+/\d{1,2}/.source);}functionmergeConfigs(parentConfig,childConfig){varres=extend({},parentConfig),prop;for(propinchildConfig){if(hasOwnProp(childConfig,prop)){if(isObject(parentConfig[prop])&&isObject(childConfig[prop])){res[prop]={};extend(res[prop],parentConfig[prop]);extend(res[prop],childConfig[prop]);}elseif(childConfig[prop]!=null){res[prop]=childConfig[prop];}else{deleteres[prop];}}}for(propinparentConfig){if(hasOwnProp(parentConfig,prop)&&!hasOwnProp(childConfig,prop)&&isObject(parentConfig[prop])){// make sure changes to properties don't modify parent config
functionaddFormatToken(token,padded,ordinal,callback){varfunc=callback;if(typeofcallback==='string'){func=function(){returnthis[callback]();};}if(token){formatTokenFunctions[token]=func;}if(padded){formatTokenFunctions[padded[0]]=function(){returnzeroFill(func.apply(this,arguments),padded[1],padded[2]);};}if(ordinal){formatTokenFunctions[ordinal]=function(){returnthis.localeData().ordinal(func.apply(this,arguments),token);};}}functionremoveFormattingTokens(input){if(input.match(/\[[\s\S]/)){returninput.replace(/^\[|\]$/g,'');}returninput.replace(/\\/g,'');}functionmakeFormatFunction(format){vararray=format.match(formattingTokens),i,length;for(i=0,length=array.length;i<length;i++){if(formatTokenFunctions[array[i]]){array[i]=formatTokenFunctions[array[i]];}else{array[i]=removeFormattingTokens(array[i]);}}returnfunction(mom){varoutput='',i;for(i=0;i<length;i++){output+=isFunction(array[i])?array[i].call(mom,format):array[i];}returnoutput;};}// format date using native date object
// any word (or two) characters or numbers including two/three word month in arabic.
// includes scottish gaelic two word and hyphenated months
matchWord=/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,regexes;regexes={};functionaddRegexToken(token,regex,strictRegex){regexes[token]=isFunction(regex)?regex:function(isStrict,localeData){returnisStrict&&strictRegex?strictRegex:regex;};}functiongetParseRegexForToken(token,config){if(!hasOwnProp(regexes,token)){returnnewRegExp(unescapeFormat(token));}returnregexes[token](config._strict,config._locale);}// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
functionunescapeFormat(s){returnregexEscape(s.replace('\\','').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(matched,p1,p2,p3,p4){returnp1||p2||p3||p4;}));}functionregexEscape(s){returns.replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&');}vartokens={};functionaddParseToken(token,callback){vari,func=callback;if(typeoftoken==='string'){token=[token];}if(isNumber(callback)){func=function(input,array){array[callback]=toInt(input);};}for(i=0;i<token.length;i++){tokens[token[i]]=func;}}functionaddWeekParseToken(token,callback){addParseToken(token,function(input,array,config,token){config._w=config._w||{};callback(input,config._w,config,token);});}functionaddTimeToArrayFromToken(token,input,config){if(input!=null&&hasOwnProp(tokens,token)){tokens[token](input,config._a,config,token);}}varYEAR=0,MONTH=1,DATE=2,HOUR=3,MINUTE=4,SECOND=5,MILLISECOND=6,WEEK=7,WEEKDAY=8;functionmod(n,x){return(n%x+x)%x;}varindexOf;if(Array.prototype.indexOf){indexOf=Array.prototype.indexOf;}else{indexOf=function(o){// I know
addRegexToken('M',match1to2);addRegexToken('MM',match1to2,match2);addRegexToken('MMM',function(isStrict,locale){returnlocale.monthsShortRegex(isStrict);});addRegexToken('MMMM',function(isStrict,locale){returnlocale.monthsRegex(isStrict);});addParseToken(['M','MM'],function(input,array){array[MONTH]=toInt(input)-1;});addParseToken(['MMM','MMMM'],function(input,array,config,token){varmonth=config._locale.monthsParse(input,token,config._strict);// if we didn't find a month name, mark the date as invalid.
vardefaultLocaleMonths='January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),defaultLocaleMonthsShort='Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),MONTHS_IN_FORMAT=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,defaultMonthsShortRegex=matchWord,defaultMonthsRegex=matchWord;functionlocaleMonths(m,format){if(!m){returnisArray(this._months)?this._months:this._months['standalone'];}returnisArray(this._months)?this._months[m.month()]:this._months[(this._months.isFormat||MONTHS_IN_FORMAT).test(format)?'format':'standalone'][m.month()];}functionlocaleMonthsShort(m,format){if(!m){returnisArray(this._monthsShort)?this._monthsShort:this._monthsShort['standalone'];}returnisArray(this._monthsShort)?this._monthsShort[m.month()]:this._monthsShort[MONTHS_IN_FORMAT.test(format)?'format':'standalone'][m.month()];}functionhandleStrictParse(monthName,format,strict){vari,ii,mom,llc=monthName.toLocaleLowerCase();if(!this._monthsParse){// this is not used
// Sorting makes sure if one month (or abbr) is a prefix of another
// see sorting in computeMonthsParse
for(i=0;i<12;i++){// make the regex if we don't have it already
mom=createUTC([2000,i]);if(strict&&!this._longMonthsParse[i]){this._longMonthsParse[i]=newRegExp('^'+this.months(mom,'').replace('.','')+'$','i');this._shortMonthsParse[i]=newRegExp('^'+this.monthsShort(mom,'').replace('.','')+'$','i');}if(!strict&&!this._monthsParse[i]){regex='^'+this.months(mom,'')+'|^'+this.monthsShort(mom,'');this._monthsParse[i]=newRegExp(regex.replace('.',''),'i');}// test the regex
functionsetMonth(mom,value){vardayOfMonth;if(!mom.isValid()){// No op
returnmom;}if(typeofvalue==='string'){if(/^\d+$/.test(value)){value=toInt(value);}else{value=mom.localeData().monthsParse(value);// TODO: Another silent failure?
if(!isNumber(value)){returnmom;}}}dayOfMonth=Math.min(mom.date(),daysInMonth(mom.year(),value));mom._d['set'+(mom._isUTC?'UTC':'')+'Month'](value,dayOfMonth);returnmom;}functiongetSetMonth(value){if(value!=null){setMonth(this,value);hooks.updateOffset(this,true);returnthis;}else{returnget(this,'Month');}}functiongetDaysInMonth(){returndaysInMonth(this.year(),this.month());}functionmonthsShortRegex(isStrict){if(this._monthsParseExact){if(!hasOwnProp(this,'_monthsRegex')){computeMonthsParse.call(this);}if(isStrict){returnthis._monthsShortStrictRegex;}else{returnthis._monthsShortRegex;}}else{if(!hasOwnProp(this,'_monthsShortRegex')){this._monthsShortRegex=defaultMonthsShortRegex;}returnthis._monthsShortStrictRegex&&isStrict?this._monthsShortStrictRegex:this._monthsShortRegex;}}functionmonthsRegex(isStrict){if(this._monthsParseExact){if(!hasOwnProp(this,'_monthsRegex')){computeMonthsParse.call(this);}if(isStrict){returnthis._monthsStrictRegex;}else{returnthis._monthsRegex;}}else{if(!hasOwnProp(this,'_monthsRegex')){this._monthsRegex=defaultMonthsRegex;}returnthis._monthsStrictRegex&&isStrict?this._monthsStrictRegex:this._monthsRegex;}}functioncomputeMonthsParse(){functioncmpLenRev(a,b){returnb.length-a.length;}varshortPieces=[],longPieces=[],mixedPieces=[],i,mom;for(i=0;i<12;i++){// make the regex if we don't have it already
mom=createUTC([2000,i]);shortPieces.push(this.monthsShort(mom,''));longPieces.push(this.months(mom,''));mixedPieces.push(this.months(mom,''));mixedPieces.push(this.monthsShort(mom,''));}// Sorting makes sure if one month (or abbr) is a prefix of another it
vargetSetYear=makeGetSet('FullYear',true);functiongetIsLeapYear(){returnisLeapYear(this.year());}functioncreateDate(y,m,d,h,M,s,ms){// can't just apply() to create a date:
// https://stackoverflow.com/q/181348
vardate;// the date constructor remaps years 0-99 to 1900-1999
if(y<100&&y>=0){// preserve leap years using a full 400 year cycle, then reset
date=newDate(y+400,m,d,h,M,s,ms);if(isFinite(date.getFullYear())){date.setFullYear(y);}}else{date=newDate(y,m,d,h,M,s,ms);}returndate;}functioncreateUTCDate(y){vardate,args;// the Date.UTC function remaps years 0-99 to 1900-1999
if(y<100&&y>=0){args=Array.prototype.slice.call(arguments);// preserve leap years using a full 400 year cycle, then reset
addRegexToken('d',match1to2);addRegexToken('e',match1to2);addRegexToken('E',match1to2);addRegexToken('dd',function(isStrict,locale){returnlocale.weekdaysMinRegex(isStrict);});addRegexToken('ddd',function(isStrict,locale){returnlocale.weekdaysShortRegex(isStrict);});addRegexToken('dddd',function(isStrict,locale){returnlocale.weekdaysRegex(isStrict);});addWeekParseToken(['dd','ddd','dddd'],function(input,week,config,token){varweekday=config._locale.weekdaysParse(input,token,config._strict);// if we didn't get a weekday name, mark the date as invalid
functionshiftWeekdays(ws,n){returnws.slice(n,7).concat(ws.slice(0,n));}vardefaultLocaleWeekdays='Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),defaultLocaleWeekdaysShort='Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),defaultLocaleWeekdaysMin='Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),defaultWeekdaysRegex=matchWord,defaultWeekdaysShortRegex=matchWord,defaultWeekdaysMinRegex=matchWord;functionlocaleWeekdays(m,format){varweekdays=isArray(this._weekdays)?this._weekdays:this._weekdays[m&&m!==true&&this._weekdays.isFormat.test(format)?'format':'standalone'];returnm===true?shiftWeekdays(weekdays,this._week.dow):m?weekdays[m.day()]:weekdays;}functionlocaleWeekdaysShort(m){returnm===true?shiftWeekdays(this._weekdaysShort,this._week.dow):m?this._weekdaysShort[m.day()]:this._weekdaysShort;}functionlocaleWeekdaysMin(m){returnm===true?shiftWeekdays(this._weekdaysMin,this._week.dow):m?this._weekdaysMin[m.day()]:this._weekdaysMin;}functionhandleStrictParse$1(weekdayName,format,strict){vari,ii,mom,llc=weekdayName.toLocaleLowerCase();if(!this._weekdaysParse){this._weekdaysParse=[];this._shortWeekdaysParse=[];this._minWeekdaysParse=[];for(i=0;i<7;++i){mom=createUTC([2000,1]).day(i);this._minWeekdaysParse[i]=this.weekdaysMin(mom,'').toLocaleLowerCase();this._shortWeekdaysParse[i]=this.weekdaysShort(mom,'').toLocaleLowerCase();this._weekdaysParse[i]=this.weekdays(mom,'').toLocaleLowerCase();}}if(strict){if(format==='dddd'){ii=indexOf.call(this._weekdaysParse,llc);returnii!==-1?ii:null;}elseif(format==='ddd'){ii=indexOf.call(this._shortWeekdaysParse,llc);returnii!==-1?ii:null;}else{ii=indexOf.call(this._minWeekdaysParse,llc);returnii!==-1?ii:null;}}else{if(format==='dddd'){ii=indexOf.call(this._weekdaysParse,llc);if(ii!==-1){returnii;}ii=indexOf.call(this._shortWeekdaysParse,llc);if(ii!==-1){returnii;}ii=indexOf.call(this._minWeekdaysParse,llc);returnii!==-1?ii:null;}elseif(format==='ddd'){ii=indexOf.call(this._shortWeekdaysParse,llc);if(ii!==-1){returnii;}ii=indexOf.call(this._weekdaysParse,llc);if(ii!==-1){returnii;}ii=indexOf.call(this._minWeekdaysParse,llc);returnii!==-1?ii:null;}else{ii=indexOf.call(this._minWeekdaysParse,llc);if(ii!==-1){returnii;}ii=indexOf.call(this._weekdaysParse,llc);if(ii!==-1){returnii;}ii=indexOf.call(this._shortWeekdaysParse,llc);returnii!==-1?ii:null;}}}functionlocaleWeekdaysParse(weekdayName,format,strict){vari,mom,regex;if(this._weekdaysParseExact){returnhandleStrictParse$1.call(this,weekdayName,format,strict);}if(!this._weekdaysParse){this._weekdaysParse=[];this._minWeekdaysParse=[];this._shortWeekdaysParse=[];this._fullWeekdaysParse=[];}for(i=0;i<7;i++){// make the regex if we don't have it already
mom=createUTC([2000,1]).day(i);if(strict&&!this._fullWeekdaysParse[i]){this._fullWeekdaysParse[i]=newRegExp('^'+this.weekdays(mom,'').replace('.','\\.?')+'$','i');this._shortWeekdaysParse[i]=newRegExp('^'+this.weekdaysShort(mom,'').replace('.','\\.?')+'$','i');this._minWeekdaysParse[i]=newRegExp('^'+this.weekdaysMin(mom,'').replace('.','\\.?')+'$','i');}if(!this._weekdaysParse[i]){regex='^'+this.weekdays(mom,'')+'|^'+this.weekdaysShort(mom,'')+'|^'+this.weekdaysMin(mom,'');this._weekdaysParse[i]=newRegExp(regex.replace('.',''),'i');}// test the regex
functiongetSetDayOfWeek(input){if(!this.isValid()){returninput!=null?this:NaN;}varday=this._isUTC?this._d.getUTCDay():this._d.getDay();if(input!=null){input=parseWeekday(input,this.localeData());returnthis.add(input-day,'d');}else{returnday;}}functiongetSetLocaleDayOfWeek(input){if(!this.isValid()){returninput!=null?this:NaN;}varweekday=(this.day()+7-this.localeData()._week.dow)%7;returninput==null?weekday:this.add(input-weekday,'d');}functiongetSetISODayOfWeek(input){if(!this.isValid()){returninput!=null?this:NaN;}// behaves the same as moment#day except
// as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
// as a setter, sunday should belong to the previous week.
if(input!=null){varweekday=parseIsoWeekday(input,this.localeData());returnthis.day(this.day()%7?weekday:weekday-7);}else{returnthis.day()||7;}}functionweekdaysRegex(isStrict){if(this._weekdaysParseExact){if(!hasOwnProp(this,'_weekdaysRegex')){computeWeekdaysParse.call(this);}if(isStrict){returnthis._weekdaysStrictRegex;}else{returnthis._weekdaysRegex;}}else{if(!hasOwnProp(this,'_weekdaysRegex')){this._weekdaysRegex=defaultWeekdaysRegex;}returnthis._weekdaysStrictRegex&&isStrict?this._weekdaysStrictRegex:this._weekdaysRegex;}}functionweekdaysShortRegex(isStrict){if(this._weekdaysParseExact){if(!hasOwnProp(this,'_weekdaysRegex')){computeWeekdaysParse.call(this);}if(isStrict){returnthis._weekdaysShortStrictRegex;}else{returnthis._weekdaysShortRegex;}}else{if(!hasOwnProp(this,'_weekdaysShortRegex')){this._weekdaysShortRegex=defaultWeekdaysShortRegex;}returnthis._weekdaysShortStrictRegex&&isStrict?this._weekdaysShortStrictRegex:this._weekdaysShortRegex;}}functionweekdaysMinRegex(isStrict){if(this._weekdaysParseExact){if(!hasOwnProp(this,'_weekdaysRegex')){computeWeekdaysParse.call(this);}if(isStrict){returnthis._weekdaysMinStrictRegex;}else{returnthis._weekdaysMinRegex;}}else{if(!hasOwnProp(this,'_weekdaysMinRegex')){this._weekdaysMinRegex=defaultWeekdaysMinRegex;}returnthis._weekdaysMinStrictRegex&&isStrict?this._weekdaysMinStrictRegex:this._weekdaysMinRegex;}}functioncomputeWeekdaysParse(){functioncmpLenRev(a,b){returnb.length-a.length;}varminPieces=[],shortPieces=[],longPieces=[],mixedPieces=[],i,mom,minp,shortp,longp;for(i=0;i<7;i++){// make the regex if we don't have it already
mom=createUTC([2000,1]).day(i);minp=regexEscape(this.weekdaysMin(mom,''));shortp=regexEscape(this.weekdaysShort(mom,''));longp=regexEscape(this.weekdays(mom,''));minPieces.push(minp);shortPieces.push(shortp);longPieces.push(longp);mixedPieces.push(minp);mixedPieces.push(shortp);mixedPieces.push(longp);}// Sorting makes sure if one weekday (or abbr) is a prefix of another it
functionlocaleIsPM(input){// IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
// Using charAt should be more compatible.
return(input+'').toLowerCase().charAt(0)==='p';}vardefaultLocaleMeridiemParse=/[ap]\.?m?\.?/i,// Setting the hour should keep the time, because the user explicitly
// specified which hour they want. So trying to maintain the same hour (in
// a new timezone) makes sense. Adding/subtracting hours does not follow
// this rule.
getSetHour=makeGetSet('Hours',true);functionlocaleMeridiem(hours,minutes,isLower){if(hours>11){returnisLower?'pm':'PM';}else{returnisLower?'am':'AM';}}varbaseConfig={calendar:defaultCalendar,longDateFormat:defaultLongDateFormat,invalidDate:defaultInvalidDate,ordinal:defaultOrdinal,dayOfMonthOrdinalParse:defaultDayOfMonthOrdinalParse,relativeTime:defaultRelativeTime,months:defaultLocaleMonths,monthsShort:defaultLocaleMonthsShort,week:defaultLocaleWeek,weekdays:defaultLocaleWeekdays,weekdaysMin:defaultLocaleWeekdaysMin,weekdaysShort:defaultLocaleWeekdaysShort,meridiemParse:defaultLocaleMeridiemParse};// internal storage for locale config files
varlocales={},localeFamilies={},globalLocale;functioncommonPrefix(arr1,arr2){vari,minl=Math.min(arr1.length,arr2.length);for(i=0;i<minl;i+=1){if(arr1[i]!==arr2[i]){returni;}}returnminl;}functionnormalizeLocale(key){returnkey?key.toLowerCase().replace('_','-'):key;}// pick the locale from the array
// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
functionchooseLocale(names){vari=0,j,next,locale,split;while(i<names.length){split=normalizeLocale(names[i]).split('-');j=split.length;next=normalizeLocale(names[i+1]);next=next?next.split('-'):null;while(j>0){locale=loadLocale(split.slice(0,j).join('-'));if(locale){returnlocale;}if(next&&next.length>=j&&commonPrefix(split,next)>=j-1){//the next array item is better than a shallower substring of this one
break;}j--;}i++;}returnglobalLocale;}functionloadLocale(name){varoldLocale=null,aliasedRequire;// TODO: Find a better way to register and load all the locales in Node
if(locales[name]===undefined&&'object'!=='undefined'&&module&&module.exports){try{oldLocale=globalLocale._abbr;aliasedRequire=commonjsRequire;aliasedRequire('./locale/'+name);getSetGlobalLocale(oldLocale);}catch(e){// mark as not found to avoid repeating expensive file require call causing high CPU
// when trying to find en-US, en_US, en-us for every format call
locales[name]=null;// null means not found
}}returnlocales[name];}// This function will load locale and then set the global locale. If
// no arguments are passed in, it will simply return the current global
globalLocale=data;}else{if(typeofconsole!=='undefined'&&console.warn){//warn user if arguments are passed but the locale could not be set
console.warn('Locale '+key+' not found. Did you forget to load it?');}}}returnglobalLocale._abbr;}functiondefineLocale(name,config){if(config!==null){varlocale,parentConfig=baseConfig;config.abbr=name;if(locales[name]!=null){deprecateSimple('defineLocaleOverride','use moment.updateLocale(localeName, config) to change '+'an existing locale. moment.defineLocale(localeName, '+'config) should only be used for creating a new locale '+'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');parentConfig=locales[name]._config;}elseif(config.parentLocale!=null){if(locales[config.parentLocale]!=null){parentConfig=locales[config.parentLocale]._config;}else{locale=loadLocale(config.parentLocale);if(locale!=null){parentConfig=locale._config;}else{if(!localeFamilies[config.parentLocale]){localeFamilies[config.parentLocale]=[];}localeFamilies[config.parentLocale].push({name:name,config:config});returnnull;}}}locales[name]=newLocale(mergeConfigs(parentConfig,config));if(localeFamilies[name]){localeFamilies[name].forEach(function(x){defineLocale(x.name,x.config);});}// backwards compat for now: also set the locale
// make sure we set the locale AFTER all child locales have been
// created, so we won't end up with the child locale set.
getSetGlobalLocale(name);returnlocales[name];}else{// useful for testing
deletelocales[name];returnnull;}}functionupdateLocale(name,config){if(config!=null){varlocale,tmpLocale,parentConfig=baseConfig;if(locales[name]!=null&&locales[name].parentLocale!=null){// Update existing child locale in-place to avoid memory-leaks
tmpLocale=loadLocale(name);if(tmpLocale!=null){parentConfig=tmpLocale._config;}config=mergeConfigs(parentConfig,config);if(tmpLocale==null){// updateLocale is called for creating a new locale
// Set abbr so it will have a name (getters return
// undefined otherwise).
config.abbr=name;}locale=newLocale(config);locale.parentLocale=locales[name];locales[name]=locale;}// backwards compat for now: also set the locale
getSetGlobalLocale(name);}else{// pass null for config to unupdate, useful for tests
if(locales[name]!=null){if(locales[name].parentLocale!=null){locales[name]=locales[name].parentLocale;if(name===getSetGlobalLocale()){getSetGlobalLocale(name);}}elseif(locales[name]!=null){deletelocales[name];}}}returnlocales[name];}// returns locale data
locale=loadLocale(key);if(locale){returnlocale;}key=[key];}returnchooseLocale(key);}functionlistLocales(){returnkeys(locales);}functioncheckOverflow(m){varoverflow,a=m._a;if(a&&getParsingFlags(m).overflow===-2){overflow=a[MONTH]<0||a[MONTH]>11?MONTH:a[DATE]<1||a[DATE]>daysInMonth(a[YEAR],a[MONTH])?DATE:a[HOUR]<0||a[HOUR]>24||a[HOUR]===24&&(a[MINUTE]!==0||a[SECOND]!==0||a[MILLISECOND]!==0)?HOUR:a[MINUTE]<0||a[MINUTE]>59?MINUTE:a[SECOND]<0||a[SECOND]>59?SECOND:a[MILLISECOND]<0||a[MILLISECOND]>999?MILLISECOND:-1;if(getParsingFlags(m)._overflowDayOfYear&&(overflow<YEAR||overflow>DATE)){overflow=DATE;}if(getParsingFlags(m)._overflowWeeks&&overflow===-1){overflow=WEEK;}if(getParsingFlags(m)._overflowWeekday&&overflow===-1){overflow=WEEKDAY;}getParsingFlags(m).overflow=overflow;}returnm;}// iso 8601 regex
// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
varextendedIsoRegex=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,basicIsoRegex=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,tzRegex=/Z|[+-]\d\d(?::?\d\d)?/,isoDates=[['YYYYYY-MM-DD',/[+-]\d{6}-\d\d-\d\d/],['YYYY-MM-DD',/\d{4}-\d\d-\d\d/],['GGGG-[W]WW-E',/\d{4}-W\d\d-\d/],['GGGG-[W]WW',/\d{4}-W\d\d/,false],['YYYY-DDD',/\d{4}-\d{3}/],['YYYY-MM',/\d{4}-\d\d/,false],['YYYYYYMMDD',/[+-]\d{10}/],['YYYYMMDD',/\d{8}/],['GGGG[W]WWE',/\d{4}W\d{3}/],['GGGG[W]WW',/\d{4}W\d{2}/,false],['YYYYDDD',/\d{7}/],['YYYYMM',/\d{6}/,false],['YYYY',/\d{4}/,false]],// iso time formats and regexes
isoTimes=[['HH:mm:ss.SSSS',/\d\d:\d\d:\d\d\.\d+/],['HH:mm:ss,SSSS',/\d\d:\d\d:\d\d,\d+/],['HH:mm:ss',/\d\d:\d\d:\d\d/],['HH:mm',/\d\d:\d\d/],['HHmmss.SSSS',/\d\d\d\d\d\d\.\d+/],['HHmmss,SSSS',/\d\d\d\d\d\d,\d+/],['HHmmss',/\d\d\d\d\d\d/],['HHmm',/\d\d\d\d/],['HH',/\d\d/]],aspNetJsonRegex=/^\/?Date\((-?\d+)/i,// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
rfc2822=/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,obsOffsets={UT:0,GMT:0,EDT:-4*60,EST:-5*60,CDT:-5*60,CST:-6*60,MDT:-6*60,MST:-7*60,PDT:-7*60,PST:-8*60};// date from iso format
functionconfigFromISO(config){vari,l,string=config._i,match=extendedIsoRegex.exec(string)||basicIsoRegex.exec(string),allowTime,dateFormat,timeFormat,tzFormat;if(match){getParsingFlags(config).iso=true;for(i=0,l=isoDates.length;i<l;i++){if(isoDates[i][1].exec(match[1])){dateFormat=isoDates[i][0];allowTime=isoDates[i][2]!==false;break;}}if(dateFormat==null){config._isValid=false;return;}if(match[3]){for(i=0,l=isoTimes.length;i<l;i++){if(isoTimes[i][1].exec(match[3])){// match[2] should be 'T' or space
timeFormat=(match[2]||' ')+isoTimes[i][0];break;}}if(timeFormat==null){config._isValid=false;return;}}if(!allowTime&&timeFormat!=null){config._isValid=false;return;}if(match[4]){if(tzRegex.exec(match[4])){tzFormat='Z';}else{config._isValid=false;return;}}config._f=dateFormat+(timeFormat||'')+(tzFormat||'');configFromStringAndFormat(config);}else{config._isValid=false;}}functionextractFromRFC2822Strings(yearStr,monthStr,dayStr,hourStr,minuteStr,secondStr){varresult=[untruncateYear(yearStr),defaultLocaleMonthsShort.indexOf(monthStr),parseInt(dayStr,10),parseInt(hourStr,10),parseInt(minuteStr,10)];if(secondStr){result.push(parseInt(secondStr,10));}returnresult;}functionuntruncateYear(yearStr){varyear=parseInt(yearStr,10);if(year<=49){return2000+year;}elseif(year<=999){return1900+year;}returnyear;}functionpreprocessRFC2822(s){// Remove comments and folding whitespace and replace multiple-spaces with a single space
returns.replace(/\([^)]*\)|[\n\t]/g,' ').replace(/(\s\s+)/g,' ').replace(/^\s\s*/,'').replace(/\s\s*$/,'');}functioncheckWeekday(weekdayStr,parsedInput,config){if(weekdayStr){// TODO: Replace the vanilla JS Date object with an independent day-of-week check.
varweekdayProvided=defaultLocaleWeekdaysShort.indexOf(weekdayStr),weekdayActual=newDate(parsedInput[0],parsedInput[1],parsedInput[2]).getDay();if(weekdayProvided!==weekdayActual){getParsingFlags(config).weekdayMismatch=true;config._isValid=false;returnfalse;}}returntrue;}functioncalculateOffset(obsOffset,militaryOffset,numOffset){if(obsOffset){returnobsOffsets[obsOffset];}elseif(militaryOffset){// the only allowed military tz is Z
return0;}else{varhm=parseInt(numOffset,10),m=hm%100,h=(hm-m)/100;returnh*60+m;}}// date and time from ref 2822 format
functionconfigFromRFC2822(config){varmatch=rfc2822.exec(preprocessRFC2822(config._i)),parsedArray;if(match){parsedArray=extractFromRFC2822Strings(match[4],match[3],match[2],match[5],match[6],match[7]);if(!checkWeekday(match[1],parsedArray,config)){return;}config._a=parsedArray;config._tzm=calculateOffset(match[8],match[9],match[10]);config._d=createUTCDate.apply(null,config._a);config._d.setUTCMinutes(config._d.getUTCMinutes()-config._tzm);getParsingFlags(config).rfc2822=true;}else{config._isValid=false;}}// date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
functionconfigFromString(config){varmatched=aspNetJsonRegex.exec(config._i);if(matched!==null){config._d=newDate(+matched[1]);return;}configFromISO(config);if(config._isValid===false){deleteconfig._isValid;}else{return;}configFromRFC2822(config);if(config._isValid===false){deleteconfig._isValid;}else{return;}if(config._strict){config._isValid=false;}else{// Final attempt, use Input Fallback
hooks.createFromInputFallback(config);}}hooks.createFromInputFallback=deprecate('value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), '+'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are '+'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.',function(config){config._d=newDate(config._i+(config._useUTC?' UTC':''));});// Pick the first defined of two or three arguments.
functiondefaults(a,b,c){if(a!=null){returna;}if(b!=null){returnb;}returnc;}functioncurrentDateArray(config){// hooks is actually the exported moment object
varnowValue=newDate(hooks.now());if(config._useUTC){return[nowValue.getUTCFullYear(),nowValue.getUTCMonth(),nowValue.getUTCDate()];}return[nowValue.getFullYear(),nowValue.getMonth(),nowValue.getDate()];}// convert an array to a date.
// the array should mirror the parameters below
// note: all values past the year are optional and will default to the lowest possible value.
// [year, month, day , hour, minute, second, millisecond]
functionconfigFromArray(config){vari,date,input=[],currentDate,expectedWeekday,yearToUse;if(config._d){return;}currentDate=currentDateArray(config);//compute day of the year from weeks and weekdays
if(config._w&&config._a[DATE]==null&&config._a[MONTH]==null){dayOfYearFromWeekInfo(config);}//if the day of the year is set, figure out what it is
if(config._dayOfYear!=null){yearToUse=defaults(config._a[YEAR],currentDate[YEAR]);if(config._dayOfYear>daysInYear(yearToUse)||config._dayOfYear===0){getParsingFlags(config)._overflowDayOfYear=true;}date=createUTCDate(yearToUse,0,config._dayOfYear);config._a[MONTH]=date.getUTCMonth();config._a[DATE]=date.getUTCDate();}// Default to current date.
// * if no year, month, day of month are given, default to today
// * if day of month is given, default month and year
// * if month is given, default only year
// * if year is given, don't default anything
for(i=0;i<3&&config._a[i]==null;++i){config._a[i]=input[i]=currentDate[i];}// Zero out whatever was not defaulted, including time
for(;i<7;i++){config._a[i]=input[i]=config._a[i]==null?i===2?1:0:config._a[i];}// Check for 24:00:00.000
if(config._a[HOUR]===24&&config._a[MINUTE]===0&&config._a[SECOND]===0&&config._a[MILLISECOND]===0){config._nextDay=true;config._a[HOUR]=0;}config._d=(config._useUTC?createUTCDate:createDate).apply(null,input);expectedWeekday=config._useUTC?config._d.getUTCDay():config._d.getDay();// Apply timezone offset from input. The actual utcOffset can be changed
// with parseZone.
if(config._tzm!=null){config._d.setUTCMinutes(config._d.getUTCMinutes()-config._tzm);}if(config._nextDay){config._a[HOUR]=24;}// check for mismatching day of week
if(config._w&&typeofconfig._w.d!=='undefined'&&config._w.d!==expectedWeekday){getParsingFlags(config).weekdayMismatch=true;}}functiondayOfYearFromWeekInfo(config){varw,weekYear,week,weekday,dow,doy,temp,weekdayOverflow,curWeek;w=config._w;if(w.GG!=null||w.W!=null||w.E!=null){dow=1;doy=4;// TODO: We need to take the current isoWeekYear, but that depends on
// how we interpret now (local, utc, fixed offset). So create
// a now version of current config (take local/utc/offset flags, and
// create now).
weekYear=defaults(w.GG,config._a[YEAR],weekOfYear(createLocal(),1,4).year);week=defaults(w.W,1);weekday=defaults(w.E,1);if(weekday<1||weekday>7){weekdayOverflow=true;}}else{dow=config._locale._week.dow;doy=config._locale._week.doy;curWeek=weekOfYear(createLocal(),dow,doy);weekYear=defaults(w.gg,config._a[YEAR],curWeek.year);// Default to current week.
week=defaults(w.w,curWeek.week);if(w.d!=null){// weekday -- low day numbers are considered next week
weekday=w.d;if(weekday<0||weekday>6){weekdayOverflow=true;}}elseif(w.e!=null){// local weekday -- counting starts from beginning of week
weekday=w.e+dow;if(w.e<0||w.e>6){weekdayOverflow=true;}}else{// default to beginning of week
weekday=dow;}}if(week<1||week>weeksInYear(weekYear,dow,doy)){getParsingFlags(config)._overflowWeeks=true;}elseif(weekdayOverflow!=null){getParsingFlags(config)._overflowWeekday=true;}else{temp=dayOfYearFromWeeks(weekYear,week,weekday,dow,doy);config._a[YEAR]=temp.year;config._dayOfYear=temp.dayOfYear;}}// constant that refers to the ISO standard
hooks.ISO_8601=function(){};// constant that refers to the RFC 2822 form
hooks.RFC_2822=function(){};// date from string and format string
functionconfigFromStringAndFormat(config){// TODO: Move this to another part of the creation flow to prevent circular deps
if(config._f===hooks.ISO_8601){configFromISO(config);return;}if(config._f===hooks.RFC_2822){configFromRFC2822(config);return;}config._a=[];getParsingFlags(config).empty=true;// This array is used to make a Date, either with `new Date` or `Date.UTC`
varstring=''+config._i,i,parsedInput,tokens,token,skipped,stringLength=string.length,totalParsedInputLength=0,era;tokens=expandFormat(config._f,config._locale).match(formattingTokens)||[];for(i=0;i<tokens.length;i++){token=tokens[i];parsedInput=(string.match(getParseRegexForToken(token,config))||[])[0];if(parsedInput){skipped=string.substr(0,string.indexOf(parsedInput));if(skipped.length>0){getParsingFlags(config).unusedInput.push(skipped);}string=string.slice(string.indexOf(parsedInput)+parsedInput.length);totalParsedInputLength+=parsedInput.length;}// don't parse if it's not a known token
if(formatTokenFunctions[token]){if(parsedInput){getParsingFlags(config).empty=false;}else{getParsingFlags(config).unusedTokens.push(token);}addTimeToArrayFromToken(token,parsedInput,config);}elseif(config._strict&&!parsedInput){getParsingFlags(config).unusedTokens.push(token);}}// add remaining unparsed input length to the string
getParsingFlags(config).charsLeftOver=stringLength-totalParsedInputLength;if(string.length>0){getParsingFlags(config).unusedInput.push(string);}// clear _12h flag if hour is <= 12
if(config._a[HOUR]<=12&&getParsingFlags(config).bigHour===true&&config._a[HOUR]>0){getParsingFlags(config).bigHour=undefined;}getParsingFlags(config).parsedDateParts=config._a.slice(0);getParsingFlags(config).meridiem=config._meridiem;// handle meridiem
config._a[HOUR]=meridiemFixWrap(config._locale,config._a[HOUR],config._meridiem);// handle era
era=getParsingFlags(config).era;if(era!==null){config._a[YEAR]=config._locale.erasConvertYear(era,config._a[YEAR]);}configFromArray(config);checkOverflow(config);}functionmeridiemFixWrap(locale,hour,meridiem){varisPm;if(meridiem==null){// nothing to do
isPm=locale.isPM(meridiem);if(isPm&&hour<12){hour+=12;}if(!isPm&&hour===12){hour=0;}returnhour;}else{// this is not supposed to happen
returnhour;}}// date from string and array of format strings
functionconfigFromStringAndArray(config){vartempConfig,bestMoment,scoreToBeat,i,currentScore,validFormatFound,bestFormatIsValid=false;if(config._f.length===0){getParsingFlags(config).invalidFormat=true;config._d=newDate(NaN);return;}for(i=0;i<config._f.length;i++){currentScore=0;validFormatFound=false;tempConfig=copyConfig({},config);if(config._useUTC!=null){tempConfig._useUTC=config._useUTC;}tempConfig._f=config._f[i];configFromStringAndFormat(tempConfig);if(isValid(tempConfig)){validFormatFound=true;}// if there is any input that was not parsed add a penalty for that format
currentScore+=getParsingFlags(tempConfig).unusedTokens.length*10;getParsingFlags(tempConfig).score=currentScore;if(!bestFormatIsValid){if(scoreToBeat==null||currentScore<scoreToBeat||validFormatFound){scoreToBeat=currentScore;bestMoment=tempConfig;if(validFormatFound){bestFormatIsValid=true;}}}else{if(currentScore<scoreToBeat){scoreToBeat=currentScore;bestMoment=tempConfig;}}}extend(config,bestMoment||tempConfig);}functionconfigFromObject(config){if(config._d){return;}vari=normalizeObjectUnits(config._i),dayOrDate=i.day===undefined?i.date:i.day;config._a=map([i.year,i.month,dayOrDate,i.hour,i.minute,i.second,i.millisecond],function(obj){returnobj&&parseInt(obj,10);});configFromArray(config);}functioncreateFromConfig(config){varres=newMoment(checkOverflow(prepareConfig(config)));if(res._nextDay){// Adding is smart enough around DST
res.add(1,'d');res._nextDay=undefined;}returnres;}functionprepareConfig(config){varinput=config._i,format=config._f;config._locale=config._locale||getLocale(config._l);if(input===null||format===undefined&&input===''){returncreateInvalid({nullInput:true});}if(typeofinput==='string'){config._i=input=config._locale.preparse(input);}if(isMoment(input)){returnnewMoment(checkOverflow(input));}elseif(isDate(input)){config._d=input;}elseif(isArray(format)){configFromStringAndArray(config);}elseif(format){configFromStringAndFormat(config);}else{configFromInput(config);}if(!isValid(config)){config._d=null;}returnconfig;}functionconfigFromInput(config){varinput=config._i;if(isUndefined(input)){config._d=newDate(hooks.now());}elseif(isDate(input)){config._d=newDate(input.valueOf());}elseif(typeofinput==='string'){configFromString(config);}elseif(isArray(input)){config._a=map(input.slice(0),function(obj){returnparseInt(obj,10);});configFromArray(config);}elseif(isObject(input)){configFromObject(config);}elseif(isNumber(input)){// from milliseconds
config._d=newDate(input);}else{hooks.createFromInputFallback(config);}}functioncreateLocalOrUTC(input,format,locale,strict,isUTC){varc={};if(format===true||format===false){strict=format;format=undefined;}if(locale===true||locale===false){strict=locale;locale=undefined;}if(isObject(input)&&isObjectEmpty(input)||isArray(input)&&input.length===0){input=undefined;}// object construction must be done this way.
// https://github.com/moment/moment/issues/1423
c._isAMomentObject=true;c._useUTC=c._isUTC=isUTC;c._l=locale;c._i=input;c._f=format;c._strict=strict;returncreateFromConfig(c);}functioncreateLocal(input,format,locale,strict){returncreateLocalOrUTC(input,format,locale,strict,false);}varprototypeMin=deprecate('moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',function(){varother=createLocal.apply(null,arguments);if(this.isValid()&&other.isValid()){returnother<this?this:other;}else{returncreateInvalid();}}),prototypeMax=deprecate('moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',function(){varother=createLocal.apply(null,arguments);if(this.isValid()&&other.isValid()){returnother>this?this:other;}else{returncreateInvalid();}});// Pick a moment m from moments so that m[fn](other) is true for all
// other. This relies on the function fn to be transitive.
// moments should either be an array of moment objects or an array, whose
// first element is an array of moment objects.
functionpickBy(fn,moments){varres,i;if(moments.length===1&&isArray(moments[0])){moments=moments[0];}if(!moments.length){returncreateLocal();}res=moments[0];for(i=1;i<moments.length;++i){if(!moments[i].isValid()||moments[i][fn](res)){res=moments[i];}}returnres;}// TODO: Use [].sort instead?
functionmin(){varargs=[].slice.call(arguments,0);returnpickBy('isBefore',args);}functionmax(){varargs=[].slice.call(arguments,0);returnpickBy('isAfter',args);}varnow=function(){returnDate.now?Date.now():+newDate();};varordering=['year','quarter','month','week','day','hour','minute','second','millisecond'];functionisDurationValid(m){varkey,unitHasDecimal=false,i;for(keyinm){if(hasOwnProp(m,key)&&!(indexOf.call(ordering,key)!==-1&&(m[key]==null||!isNaN(m[key])))){returnfalse;}}for(i=0;i<ordering.length;++i){if(m[ordering[i]]){if(unitHasDecimal){returnfalse;// only allow non-integers for smallest unit
}if(parseFloat(m[ordering[i]])!==toInt(m[ordering[i]])){unitHasDecimal=true;}}}returntrue;}functionisValid$1(){returnthis._isValid;}functioncreateInvalid$1(){returncreateDuration(NaN);}functionDuration(duration){varnormalizedInput=normalizeObjectUnits(duration),years=normalizedInput.year||0,quarters=normalizedInput.quarter||0,months=normalizedInput.month||0,weeks=normalizedInput.week||normalizedInput.isoWeek||0,days=normalizedInput.day||0,hours=normalizedInput.hour||0,minutes=normalizedInput.minute||0,seconds=normalizedInput.second||0,milliseconds=normalizedInput.millisecond||0;this._isValid=isDurationValid(normalizedInput);// representation for dateAddRemove
hours*1000*60*60;//using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
// Because of dateAddRemove treats 24 hours as different from a
// day when working around DST, we need to store them separately
this._days=+days+weeks*7;// It is impossible to translate months into days without knowing
// which months you are are talking about, so we have to store
// it separately.
this._months=+months+quarters*3+years*12;this._data={};this._locale=getLocale();this._bubble();}functionisDuration(obj){returnobjinstanceofDuration;}functionabsRound(number){if(number<0){returnMath.round(-1*number)*-1;}else{returnMath.round(number);}}// compare two arrays, return the number of differences
varchunkOffset=/([\+\-]|\d\d)/gi;functionoffsetFromString(matcher,string){varmatches=(string||'').match(matcher),chunk,parts,minutes;if(matches===null){returnnull;}chunk=matches[matches.length-1]||[];parts=(chunk+'').match(chunkOffset)||['-',0,0];minutes=+(parts[1]*60)+toInt(parts[2]);returnminutes===0?0:parts[0]==='+'?minutes:-minutes;}// Return a moment from input, that is local/utc/zone equivalent to model.
functioncloneWithOffset(input,model){varres,diff;if(model._isUTC){res=model.clone();diff=(isMoment(input)||isDate(input)?input.valueOf():createLocal(input).valueOf())-res.valueOf();// Use low-level api, because this fn is low-level api.
res._d.setTime(res._d.valueOf()+diff);hooks.updateOffset(res,false);returnres;}else{returncreateLocal(input).local();}}functiongetDateOffset(m){// On Firefox.24 Date#getTimezoneOffset returns a floating point.
// Keeping the time actually adds/subtracts (one hour)
// from the actual represented time. That is why we call updateOffset
// a second time. In case it wants us to change the offset again
// _changeInProgress == true case, then we have to adjust, because
// there is no such time in the given timezone.
functiongetSetOffset(input,keepLocalTime,keepMinutes){varoffset=this._offset||0,localAdjust;if(!this.isValid()){returninput!=null?this:NaN;}if(input!=null){if(typeofinput==='string'){input=offsetFromString(matchShortOffset,input);if(input===null){returnthis;}}elseif(Math.abs(input)<16&&!keepMinutes){input=input*60;}if(!this._isUTC&&keepLocalTime){localAdjust=getDateOffset(this);}this._offset=input;this._isUTC=true;if(localAdjust!=null){this.add(localAdjust,'m');}if(offset!==input){if(!keepLocalTime||this._changeInProgress){addSubtract(this,createDuration(input-offset,'m'),1,false);}elseif(!this._changeInProgress){this._changeInProgress=true;hooks.updateOffset(this,true);this._changeInProgress=null;}}returnthis;}else{returnthis._isUTC?offset:getDateOffset(this);}}functiongetSetZone(input,keepLocalTime){if(input!=null){if(typeofinput!=='string'){input=-input;}this.utcOffset(input,keepLocalTime);returnthis;}else{return-this.utcOffset();}}functionsetOffsetToUTC(keepLocalTime){returnthis.utcOffset(0,keepLocalTime);}functionsetOffsetToLocal(keepLocalTime){if(this._isUTC){this.utcOffset(0,keepLocalTime);this._isUTC=false;if(keepLocalTime){this.subtract(getDateOffset(this),'m');}}returnthis;}functionsetOffsetToParsedOffset(){if(this._tzm!=null){this.utcOffset(this._tzm,false,true);}elseif(typeofthis._i==='string'){vartZone=offsetFromString(matchOffset,this._i);if(tZone!=null){this.utcOffset(tZone);}else{this.utcOffset(0,true);}}returnthis;}functionhasAlignedHourOffset(input){if(!this.isValid()){returnfalse;}input=input?createLocal(input).utcOffset():0;return(this.utcOffset()-input)%60===0;}functionisDaylightSavingTime(){returnthis.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset();}functionisDaylightSavingTimeShifted(){if(!isUndefined(this._isDSTShifted)){returnthis._isDSTShifted;}varc={},other;copyConfig(c,this);c=prepareConfig(c);if(c._a){other=c._isUTC?createUTC(c._a):createLocal(c._a);this._isDSTShifted=this.isValid()&&compareArrays(c._a,other.toArray())>0;}else{this._isDSTShifted=false;}returnthis._isDSTShifted;}functionisLocal(){returnthis.isValid()?!this._isUTC:false;}functionisUtcOffset(){returnthis.isValid()?this._isUTC:false;}functionisUtc(){returnthis.isValid()?this._isUTC&&this._offset===0:false;}// ASP.NET json date format regex
varaspNetRegex=/^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
// and further modified to allow for strings containing both week and day
isoRegex=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;functioncreateDuration(input,key){varduration=input,// matching against regexp is expensive, do it on demand
match=null,sign,ret,diffRes;if(isDuration(input)){duration={ms:input._milliseconds,d:input._days,M:input._months};}elseif(isNumber(input)||!isNaN(+input)){duration={};if(key){duration[key]=+input;}else{duration.milliseconds=+input;}}elseif(match=aspNetRegex.exec(input)){sign=match[1]==='-'?-1:1;duration={y:0,d:toInt(match[DATE])*sign,h:toInt(match[HOUR])*sign,m:toInt(match[MINUTE])*sign,s:toInt(match[SECOND])*sign,ms:toInt(absRound(match[MILLISECOND]*1000))*sign// the millisecond decimal point is included in the match
};}elseif(match=isoRegex.exec(input)){sign=match[1]==='-'?-1:1;duration={y:parseIso(match[2],sign),M:parseIso(match[3],sign),w:parseIso(match[4],sign),d:parseIso(match[5],sign),h:parseIso(match[6],sign),m:parseIso(match[7],sign),s:parseIso(match[8],sign)};}elseif(duration==null){// checks for null or undefined
duration={};}elseif(typeofduration==='object'&&('from'induration||'to'induration)){diffRes=momentsDifference(createLocal(duration.from),createLocal(duration.to));duration={};duration.ms=diffRes.milliseconds;duration.M=diffRes.months;}ret=newDuration(duration);if(isDuration(input)&&hasOwnProp(input,'_locale')){ret._locale=input._locale;}if(isDuration(input)&&hasOwnProp(input,'_isValid')){ret._isValid=input._isValid;}returnret;}createDuration.fn=Duration.prototype;createDuration.invalid=createInvalid$1;functionparseIso(inp,sign){// We'd normally use ~~inp for this, but unfortunately it also
// converts floats to ints.
// inp may be undefined, so careful calling replace on it.
varres=inp&&parseFloat(inp.replace(',','.'));// apply sign while we're at it
return(isNaN(res)?0:res)*sign;}functionpositiveMomentsDifference(base,other){varres={};res.months=other.month()-base.month()+(other.year()-base.year())*12;if(base.clone().add(res.months,'M').isAfter(other)){--res.months;}res.milliseconds=+other-+base.clone().add(res.months,'M');returnres;}functionmomentsDifference(base,other){varres;if(!(base.isValid()&&other.isValid())){return{milliseconds:0,months:0};}other=cloneWithOffset(other,base);if(base.isBefore(other)){res=positiveMomentsDifference(base,other);}else{res=positiveMomentsDifference(other,base);res.milliseconds=-res.milliseconds;res.months=-res.months;}returnres;}// TODO: remove 'name' arg after deprecation is removed
functioncreateAdder(direction,name){returnfunction(val,period){vardur,tmp;//invert the arguments, but complain about it
if(period!==null&&!isNaN(+period)){deprecateSimple(name,'moment().'+name+'(period, number) is deprecated. Please use moment().'+name+'(number, period). '+'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');tmp=val;val=period;period=tmp;}dur=createDuration(val,period);addSubtract(this,dur,direction);returnthis;};}functionaddSubtract(mom,duration,isAdding,updateOffset){varmilliseconds=duration._milliseconds,days=absRound(duration._days),months=absRound(duration._months);if(!mom.isValid()){// No op
return;}updateOffset=updateOffset==null?true:updateOffset;if(months){setMonth(mom,get(mom,'Month')+months*isAdding);}if(days){set$1(mom,'Date',get(mom,'Date')+days*isAdding);}if(milliseconds){mom._d.setTime(mom._d.valueOf()+milliseconds*isAdding);}if(updateOffset){hooks.updateOffset(mom,days||months);}}varadd=createAdder(1,'add'),subtract=createAdder(-1,'subtract');functionisString(input){returntypeofinput==='string'||inputinstanceofString;}// type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined
functionisMomentInput(input){returnisMoment(input)||isDate(input)||isString(input)||isNumber(input)||isNumberOrStringArray(input)||isMomentInputObject(input)||input===null||input===undefined;}functionisMomentInputObject(input){varobjectTest=isObject(input)&&!isObjectEmpty(input),propertyTest=false,properties=['years','year','y','months','month','M','days','day','d','dates','date','D','hours','hour','h','minutes','minute','m','seconds','second','s','milliseconds','millisecond','ms'],i,property;for(i=0;i<properties.length;i+=1){property=properties[i];propertyTest=propertyTest||hasOwnProp(input,property);}returnobjectTest&&propertyTest;}functionisNumberOrStringArray(input){vararrayTest=isArray(input),dataTypeTest=false;if(arrayTest){dataTypeTest=input.filter(function(item){return!isNumber(item)&&isString(input);}).length===0;}returnarrayTest&&dataTypeTest;}functionisCalendarSpec(input){varobjectTest=isObject(input)&&!isObjectEmpty(input),propertyTest=false,properties=['sameDay','nextDay','lastDay','nextWeek','lastWeek','sameElse'],i,property;for(i=0;i<properties.length;i+=1){property=properties[i];propertyTest=propertyTest||hasOwnProp(input,property);}returnobjectTest&&propertyTest;}functiongetCalendarFormat(myMoment,now){vardiff=myMoment.diff(now,'days',true);returndiff<-6?'sameElse':diff<-1?'lastWeek':diff<0?'lastDay':diff<1?'sameDay':diff<2?'nextDay':diff<7?'nextWeek':'sameElse';}functioncalendar$1(time,formats){// Support for single parameter, formats only overload to the calendar function
if(arguments.length===1){if(!arguments[0]){time=undefined;formats=undefined;}elseif(isMomentInput(arguments[0])){time=arguments[0];formats=undefined;}elseif(isCalendarSpec(arguments[0])){formats=arguments[0];time=undefined;}}// We want to compare the start of today, vs this.
// Getting start-of-today depends on whether we're local/utc/offset or not.
default:output=this-that;}returnasFloat?output:absFloor(output);}functionmonthDiff(a,b){if(a.date()<b.date()){// end-of-month calculations work correct when the start month has more
// days than the end month.
return-monthDiff(b,a);}// difference in months
varwholeMonthDiff=(b.year()-a.year())*12+(b.month()-a.month()),// b is in (anchor - 1 month, anchor + 1 month)
anchor=a.clone().add(wholeMonthDiff,'months'),anchor2,adjust;if(b-anchor<0){anchor2=a.clone().add(wholeMonthDiff-1,'months');// linear across the month
adjust=(b-anchor)/(anchor-anchor2);}else{anchor2=a.clone().add(wholeMonthDiff+1,'months');// linear across the month
adjust=(b-anchor)/(anchor2-anchor);}//check for negative zero, return zero if negative zero
return-(wholeMonthDiff+adjust)||0;}hooks.defaultFormat='YYYY-MM-DDTHH:mm:ssZ';hooks.defaultFormatUtc='YYYY-MM-DDTHH:mm:ss[Z]';functiontoString(){returnthis.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');}functiontoISOString(keepOffset){if(!this.isValid()){returnnull;}varutc=keepOffset!==true,m=utc?this.clone().utc():this;if(m.year()<0||m.year()>9999){returnformatMoment(m,utc?'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]':'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');}if(isFunction(Date.prototype.toISOString)){// native implementation is ~50x faster, use it when we can
// instance. Otherwise, it will return the locale configuration
// variables for this instance.
functionlocale(key){varnewLocaleData;if(key===undefined){returnthis._locale._abbr;}else{newLocaleData=getLocale(key);if(newLocaleData!=null){this._locale=newLocaleData;}returnthis;}}varlang=deprecate('moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',function(key){if(key===undefined){returnthis.localeData();}else{returnthis.locale(key);}});functionlocaleData(){returnthis._locale;}varMS_PER_SECOND=1000,MS_PER_MINUTE=60*MS_PER_SECOND,MS_PER_HOUR=60*MS_PER_MINUTE,MS_PER_400_YEARS=(365*400+97)*24*MS_PER_HOUR;// actual modulo - handles negative numbers (for dates before 1970):
functionmod$1(dividend,divisor){return(dividend%divisor+divisor)%divisor;}functionlocalStartOfDate(y,m,d){// the date constructor remaps years 0-99 to 1900-1999
if(y<100&&y>=0){// preserve leap years using a full 400 year cycle, then reset
returnnewDate(y+400,m,d)-MS_PER_400_YEARS;}else{returnnewDate(y,m,d).valueOf();}}functionutcStartOfDate(y,m,d){// Date.UTC remaps years 0-99 to 1900-1999
if(y<100&&y>=0){// preserve leap years using a full 400 year cycle, then reset
returnDate.UTC(y+400,m,d)-MS_PER_400_YEARS;}else{returnDate.UTC(y,m,d);}}functionstartOf(units){vartime,startOfDate;units=normalizeUnits(units);if(units===undefined||units==='millisecond'||!this.isValid()){returnthis;}startOfDate=this._isUTC?utcStartOfDate:localStartOfDate;switch(units){case'year':time=startOfDate(this.year(),0,1);break;case'quarter':time=startOfDate(this.year(),this.month()-this.month()%3,1);break;case'month':time=startOfDate(this.year(),this.month(),1);break;case'week':time=startOfDate(this.year(),this.month(),this.date()-this.weekday());break;case'isoWeek':time=startOfDate(this.year(),this.month(),this.date()-(this.isoWeekday()-1));break;case'day':case'date':time=startOfDate(this.year(),this.month(),this.date());break;case'hour':time=this._d.valueOf();time-=mod$1(time+(this._isUTC?0:this.utcOffset()*MS_PER_MINUTE),MS_PER_HOUR);break;case'minute':time=this._d.valueOf();time-=mod$1(time,MS_PER_MINUTE);break;case'second':time=this._d.valueOf();time-=mod$1(time,MS_PER_SECOND);break;}this._d.setTime(time);hooks.updateOffset(this,true);returnthis;}functionendOf(units){vartime,startOfDate;units=normalizeUnits(units);if(units===undefined||units==='millisecond'||!this.isValid()){returnthis;}startOfDate=this._isUTC?utcStartOfDate:localStartOfDate;switch(units){case'year':time=startOfDate(this.year()+1,0,1)-1;break;case'quarter':time=startOfDate(this.year(),this.month()-this.month()%3+3,1)-1;break;case'month':time=startOfDate(this.year(),this.month()+1,1)-1;break;case'week':time=startOfDate(this.year(),this.month(),this.date()-this.weekday()+7)-1;break;case'isoWeek':time=startOfDate(this.year(),this.month(),this.date()-(this.isoWeekday()-1)+7)-1;break;case'day':case'date':time=startOfDate(this.year(),this.month(),this.date()+1)-1;break;case'hour':time=this._d.valueOf();time+=MS_PER_HOUR-mod$1(time+(this._isUTC?0:this.utcOffset()*MS_PER_MINUTE),MS_PER_HOUR)-1;break;case'minute':time=this._d.valueOf();time+=MS_PER_MINUTE-mod$1(time,MS_PER_MINUTE)-1;break;case'second':time=this._d.valueOf();time+=MS_PER_SECOND-mod$1(time,MS_PER_SECOND)-1;break;}this._d.setTime(time);hooks.updateOffset(this,true);returnthis;}functionvalueOf(){returnthis._d.valueOf()-(this._offset||0)*60000;}functionunix(){returnMath.floor(this.valueOf()/1000);}functiontoDate(){returnnewDate(this.valueOf());}functiontoArray(){varm=this;return[m.year(),m.month(),m.date(),m.hour(),m.minute(),m.second(),m.millisecond()];}functiontoObject(){varm=this;return{years:m.year(),months:m.month(),date:m.date(),hours:m.hours(),minutes:m.minutes(),seconds:m.seconds(),milliseconds:m.milliseconds()};}functiontoJSON(){// new Date(NaN).toJSON() === null
returnthis.isValid()?this.toISOString():null;}functionisValid$2(){returnisValid(this);}functionparsingFlags(){returnextend({},getParsingFlags(this));}functioninvalidAt(){returngetParsingFlags(this).overflow;}functioncreationData(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict};}addFormatToken('N',0,0,'eraAbbr');addFormatToken('NN',0,0,'eraAbbr');addFormatToken('NNN',0,0,'eraAbbr');addFormatToken('NNNN',0,0,'eraName');addFormatToken('NNNNN',0,0,'eraNarrow');addFormatToken('y',['y',1],'yo','eraYear');addFormatToken('y',['yy',2],0,'eraYear');addFormatToken('y',['yyy',3],0,'eraYear');addFormatToken('y',['yyyy',4],0,'eraYear');addRegexToken('N',matchEraAbbr);addRegexToken('NN',matchEraAbbr);addRegexToken('NNN',matchEraAbbr);addRegexToken('NNNN',matchEraName);addRegexToken('NNNNN',matchEraNarrow);addParseToken(['N','NN','NNN','NNNN','NNNNN'],function(input,array,config,token){varera=config._locale.erasParse(input,token,config._strict);if(era){getParsingFlags(config).era=era;}else{getParsingFlags(config).invalidEra=input;}});addRegexToken('y',matchUnsigned);addRegexToken('yy',matchUnsigned);addRegexToken('yyy',matchUnsigned);addRegexToken('yyyy',matchUnsigned);addRegexToken('yo',matchEraYearOrdinal);addParseToken(['y','yy','yyy','yyyy'],YEAR);addParseToken(['yo'],function(input,array,config,token){varmatch;if(config._locale._eraYearOrdinalRegex){match=input.match(config._locale._eraYearOrdinalRegex);}if(config._locale.eraYearOrdinalParse){array[YEAR]=config._locale.eraYearOrdinalParse(input,match);}else{array[YEAR]=parseInt(input,10);}});functionlocaleEras(m,format){vari,l,date,eras=this._eras||getLocale('en')._eras;for(i=0,l=eras.length;i<l;++i){switch(typeoferas[i].since){case'string':// truncate time
date=hooks(eras[i].since).startOf('day');eras[i].since=date.valueOf();break;}switch(typeoferas[i].until){case'undefined':eras[i].until=+Infinity;break;case'string':// truncate time
date=hooks(eras[i].until).startOf('day').valueOf();eras[i].until=date.valueOf();break;}}returneras;}functionlocaleErasParse(eraName,format,strict){vari,l,eras=this.eras(),name,abbr,narrow;eraName=eraName.toUpperCase();for(i=0,l=eras.length;i<l;++i){name=eras[i].name.toUpperCase();abbr=eras[i].abbr.toUpperCase();narrow=eras[i].narrow.toUpperCase();if(strict){switch(format){case'N':case'NN':case'NNN':if(abbr===eraName){returneras[i];}break;case'NNNN':if(name===eraName){returneras[i];}break;case'NNNNN':if(narrow===eraName){returneras[i];}break;}}elseif([name,abbr,narrow].indexOf(eraName)>=0){returneras[i];}}}functionlocaleErasConvertYear(era,year){vardir=era.since<=era.until?+1:-1;if(year===undefined){returnhooks(era.since).year();}else{returnhooks(era.since).year()+(year-era.offset)*dir;}}functiongetEraName(){vari,l,val,eras=this.localeData().eras();for(i=0,l=eras.length;i<l;++i){// truncate time
val=this.clone().startOf('day').valueOf();if(eras[i].since<=val&&val<=eras[i].until){returneras[i].name;}if(eras[i].until<=val&&val<=eras[i].since){returneras[i].name;}}return'';}functiongetEraNarrow(){vari,l,val,eras=this.localeData().eras();for(i=0,l=eras.length;i<l;++i){// truncate time
val=this.clone().startOf('day').valueOf();if(eras[i].since<=val&&val<=eras[i].until){returneras[i].narrow;}if(eras[i].until<=val&&val<=eras[i].since){returneras[i].narrow;}}return'';}functiongetEraAbbr(){vari,l,val,eras=this.localeData().eras();for(i=0,l=eras.length;i<l;++i){// truncate time
val=this.clone().startOf('day').valueOf();if(eras[i].since<=val&&val<=eras[i].until){returneras[i].abbr;}if(eras[i].until<=val&&val<=eras[i].since){returneras[i].abbr;}}return'';}functiongetEraYear(){vari,l,dir,val,eras=this.localeData().eras();for(i=0,l=eras.length;i<l;++i){dir=eras[i].since<=eras[i].until?+1:-1;// truncate time
addRegexToken('D',match1to2);addRegexToken('DD',match1to2,match2);addRegexToken('Do',function(isStrict,locale){// TODO: Remove "ordinalParse" fallback in next major release.
functiongetZoneAbbr(){returnthis._isUTC?'UTC':'';}functiongetZoneName(){returnthis._isUTC?'Coordinated Universal Time':'';}varproto=Moment.prototype;proto.add=add;proto.calendar=calendar$1;proto.clone=clone;proto.diff=diff;proto.endOf=endOf;proto.format=format;proto.from=from;proto.fromNow=fromNow;proto.to=to;proto.toNow=toNow;proto.get=stringGet;proto.invalidAt=invalidAt;proto.isAfter=isAfter;proto.isBefore=isBefore;proto.isBetween=isBetween;proto.isSame=isSame;proto.isSameOrAfter=isSameOrAfter;proto.isSameOrBefore=isSameOrBefore;proto.isValid=isValid$2;proto.lang=lang;proto.locale=locale;proto.localeData=localeData;proto.max=prototypeMax;proto.min=prototypeMin;proto.parsingFlags=parsingFlags;proto.set=stringSet;proto.startOf=startOf;proto.subtract=subtract;proto.toArray=toArray;proto.toObject=toObject;proto.toDate=toDate;proto.toISOString=toISOString;proto.inspect=inspect;if(typeofSymbol!=='undefined'&&Symbol.for!=null){proto[Symbol.for('nodejs.util.inspect.custom')]=function(){return'Moment<'+this.format()+'>';};}proto.toJSON=toJSON;proto.toString=toString;proto.unix=unix;proto.valueOf=valueOf;proto.creationData=creationData;proto.eraName=getEraName;proto.eraNarrow=getEraNarrow;proto.eraAbbr=getEraAbbr;proto.eraYear=getEraYear;proto.year=getSetYear;proto.isLeapYear=getIsLeapYear;proto.weekYear=getSetWeekYear;proto.isoWeekYear=getSetISOWeekYear;proto.quarter=proto.quarters=getSetQuarter;proto.month=getSetMonth;proto.daysInMonth=getDaysInMonth;proto.week=proto.weeks=getSetWeek;proto.isoWeek=proto.isoWeeks=getSetISOWeek;proto.weeksInYear=getWeeksInYear;proto.weeksInWeekYear=getWeeksInWeekYear;proto.isoWeeksInYear=getISOWeeksInYear;proto.isoWeeksInISOWeekYear=getISOWeeksInISOWeekYear;proto.date=getSetDayOfMonth;proto.day=proto.days=getSetDayOfWeek;proto.weekday=getSetLocaleDayOfWeek;proto.isoWeekday=getSetISODayOfWeek;proto.dayOfYear=getSetDayOfYear;proto.hour=proto.hours=getSetHour;proto.minute=proto.minutes=getSetMinute;proto.second=proto.seconds=getSetSecond;proto.millisecond=proto.milliseconds=getSetMillisecond;proto.utcOffset=getSetOffset;proto.utc=setOffsetToUTC;proto.local=setOffsetToLocal;proto.parseZone=setOffsetToParsedOffset;proto.hasAlignedHourOffset=hasAlignedHourOffset;proto.isDST=isDaylightSavingTime;proto.isLocal=isLocal;proto.isUtcOffset=isUtcOffset;proto.isUtc=isUtc;proto.isUTC=isUtc;proto.zoneAbbr=getZoneAbbr;proto.zoneName=getZoneName;proto.dates=deprecate('dates accessor is deprecated. Use date instead.',getSetDayOfMonth);proto.months=deprecate('months accessor is deprecated. Use month instead',getSetMonth);proto.years=deprecate('years accessor is deprecated. Use year instead',getSetYear);proto.zone=deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',getSetZone);proto.isDSTShifted=deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',isDaylightSavingTimeShifted);functioncreateUnix(input){returncreateLocal(input*1000);}functioncreateInZone(){returncreateLocal.apply(null,arguments).parseZone();}functionpreParsePostFormat(string){returnstring;}varproto$1=Locale.prototype;proto$1.calendar=calendar;proto$1.longDateFormat=longDateFormat;proto$1.invalidDate=invalidDate;proto$1.ordinal=ordinal;proto$1.preparse=preParsePostFormat;proto$1.postformat=preParsePostFormat;proto$1.relativeTime=relativeTime;proto$1.pastFuture=pastFuture;proto$1.set=set;proto$1.eras=localeEras;proto$1.erasParse=localeErasParse;proto$1.erasConvertYear=localeErasConvertYear;proto$1.erasAbbrRegex=erasAbbrRegex;proto$1.erasNameRegex=erasNameRegex;proto$1.erasNarrowRegex=erasNarrowRegex;proto$1.months=localeMonths;proto$1.monthsShort=localeMonthsShort;proto$1.monthsParse=localeMonthsParse;proto$1.monthsRegex=monthsRegex;proto$1.monthsShortRegex=monthsShortRegex;proto$1.week=localeWeek;proto$1.firstDayOfYear=localeFirstDayOfYear;proto$1.firstDayOfWeek=localeFirstDayOfWeek;proto$1.weekdays=localeWeekdays;proto$1.weekdaysMin=localeWeekdaysMin;proto$1.weekdaysShort=localeWeekdaysShort;proto$1.weekdaysPar
// (5)
// (fmt, 5)
// (fmt)
// (true)
// (true, 5)
// (true, fmt, 5)
// (true, fmt)
functionlistWeekdaysImpl(localeSorted,format,index,field){if(typeoflocaleSorted==='boolean'){if(isNumber(format)){index=format;format=undefined;}format=format||'';}else{format=localeSorted;index=format;localeSorted=false;if(isNumber(format)){index=format;format=undefined;}format=format||'';}varlocale=getLocale(),shift=localeSorted?locale._week.dow:0,i,out=[];if(index!=null){returnget$1(format,(index+shift)%7,field,'day');}for(i=0;i<7;i++){out[i]=get$1(format,(i+shift)%7,field,'day');}returnout;}functionlistMonths(format,index){returnlistMonthsImpl(format,index,'months');}functionlistMonthsShort(format,index){returnlistMonthsImpl(format,index,'monthsShort');}functionlistWeekdays(localeSorted,format,index){returnlistWeekdaysImpl(localeSorted,format,index,'weekdays');}functionlistWeekdaysShort(localeSorted,format,index){returnlistWeekdaysImpl(localeSorted,format,index,'weekdaysShort');}functionlistWeekdaysMin(localeSorted,format,index){returnlistWeekdaysImpl(localeSorted,format,index,'weekdaysMin');}getSetGlobalLocale('en',{eras:[{since:'0001-01-01',until:+Infinity,offset:1,name:'Anno Domini',narrow:'AD',abbr:'AD'},{since:'0000-12-31',until:-Infinity,offset:1,name:'Before Christ',narrow:'BC',abbr:'BC'}],dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(number){varb=number%10,output=toInt(number%100/10)===1?'th':b===1?'st':b===2?'nd':b===3?'rd':'th';returnnumber+output;}});// Side effect imports
hooks.lang=deprecate('moment.lang is deprecated. Use moment.locale instead.',getSetGlobalLocale);hooks.langData=deprecate('moment.langData is deprecated. Use moment.localeData instead.',getLocale);varmathAbs=Math.abs;functionabs(){vardata=this._data;this._milliseconds=mathAbs(this._milliseconds);this._days=mathAbs(this._days);this._months=mathAbs(this._months);data.milliseconds=mathAbs(data.milliseconds);data.seconds=mathAbs(data.seconds);data.minutes=mathAbs(data.minutes);data.hours=mathAbs(data.hours);data.months=mathAbs(data.months);data.years=mathAbs(data.years);returnthis;}functionaddSubtract$1(duration,input,value,direction){varother=createDuration(input,value);duration._milliseconds+=direction*other._milliseconds;duration._days+=direction*other._days;duration._months+=direction*other._months;returnduration._bubble();}// supports only 2.0-style add(1, 's') or add(duration)
functionadd$1(input,value){returnaddSubtract$1(this,input,value,1);}// supports only 2.0-style subtract(1, 's') or subtract(duration)
functionsubtract$1(input,value){returnaddSubtract$1(this,input,value,-1);}functionabsCeil(number){if(number<0){returnMath.floor(number);}else{returnMath.ceil(number);}}functionbubble(){varmilliseconds=this._milliseconds,days=this._days,months=this._months,data=this._data,seconds,minutes,hours,years,monthsFromDays;// if we have a mix of positive and negative values, bubble down first
if(!(milliseconds>=0&&days>=0&&months>=0||milliseconds<=0&&days<=0&&months<=0)){milliseconds+=absCeil(monthsToDays(months)+days)*864e5;days=0;months=0;}// The following code bubbles up values, see the tests for
// examples of what that means.
data.milliseconds=milliseconds%1000;seconds=absFloor(milliseconds/1000);data.seconds=seconds%60;minutes=absFloor(seconds/60);data.minutes=minutes%60;hours=absFloor(minutes/60);data.hours=hours%24;days+=absFloor(hours/24);// convert days to months
monthsFromDays=absFloor(daysToMonths(days));months+=monthsFromDays;days-=absCeil(monthsToDays(monthsFromDays));// 12 months -> 1 year
years=absFloor(months/12);months%=12;data.days=days;data.months=months;data.years=years;returnthis;}functiondaysToMonths(days){// 400 years have 146097 days (taking into account leap year rules)
// 400 years have 12 months === 4800
returndays*4800/146097;}functionmonthsToDays(months){// the reverse of daysToMonths
returnmonths*146097/4800;}functionas(units){if(!this.isValid()){returnNaN;}vardays,months,milliseconds=this._milliseconds;units=normalizeUnits(units);if(units==='month'||units==='quarter'||units==='year'){days=this._days+milliseconds/864e5;months=this._months+daysToMonths(days);switch(units){case'month':returnmonths;case'quarter':returnmonths/3;case'year':returnmonths/12;}}else{// handle milliseconds separately because of floating point math errors (issue #1867)
days=this._days+Math.round(monthsToDays(this._months));switch(units){case'week':returndays/7+milliseconds/6048e5;case'day':returndays+milliseconds/864e5;case'hour':returndays*24+milliseconds/36e5;case'minute':returndays*1440+milliseconds/6e4;case'second':returndays*86400+milliseconds/1000;// Math.floor prevents floating point math errors here
case'millisecond':returnMath.floor(days*864e5)+milliseconds;default:thrownewError('Unknown unit '+units);}}}// TODO: Use this.as('ms')?
functionvalueOf$1(){if(!this.isValid()){returnNaN;}returnthis._milliseconds+this._days*864e5+this._months%12*2592e6+toInt(this._months/12)*31536e6;}functionmakeAs(alias){returnfunction(){returnthis.as(alias);};}varasMilliseconds=makeAs('ms'),asSeconds=makeAs('s'),asMinutes=makeAs('m'),asHours=makeAs('h'),asDays=makeAs('d'),asWeeks=makeAs('w'),asMonths=makeAs('M'),asQuarters=makeAs('Q'),asYears=makeAs('y');functionclone$1(){returncreateDuration(this);}functionget$2(units){units=normalizeUnits(units);returnthis.isValid()?this[units+'s']():NaN;}functionmakeGetter(name){returnfunction(){returnthis.isValid()?this._data[name]:NaN;};}varmilliseconds=makeGetter('milliseconds'),seconds=makeGetter('seconds'),minutes=makeGetter('minutes'),hours=makeGetter('hours'),days=makeGetter('days'),months=makeGetter('months'),years=makeGetter('years');functionweeks(){returnabsFloor(this.days()/7);}varround=Math.round,thresholds={ss:44,// a few seconds to seconds
s:45,// seconds to minute
m:45,// minutes to hour
h:22,// hours to day
d:26,// days to month/week
w:null,// weeks to month
M:11// months to year
};// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
functionsubstituteTimeAgo(string,number,withoutSuffix,isFuture,locale){returnlocale.relativeTime(number||1,!!withoutSuffix,string,isFuture);}functionrelativeTime$1(posNegDuration,withoutSuffix,thresholds,locale){varduration=createDuration(posNegDuration).abs(),seconds=round(duration.as('s')),minutes=round(duration.as('m')),hours=round(duration.as('h')),days=round(duration.as('d')),months=round(duration.as('M')),weeks=round(duration.as('w')),years=round(duration.as('y')),a=seconds<=thresholds.ss&&['s',seconds]||seconds<thresholds.s&&['ss',seconds]||minutes<=1&&['m']||minutes<thresholds.m&&['mm',minutes]||hours<=1&&['h']||hours<thresholds.h&&['hh',hours]||days<=1&&['d']||days<thresholds.d&&['dd',days];if(thresholds.w!=null){a=a||weeks<=1&&['w']||weeks<thresholds.w&&['ww',weeks];}a=a||months<=1&&['M']||months<thresholds.M&&['MM',months]||years<=1&&['y']||['yy',years];a[2]=withoutSuffix;a[3]=+posNegDuration>0;a[4]=locale;returnsubstituteTimeAgo.apply(null,a);}// This function allows you to set the rounding function for relative time strings
functiongetSetRelativeTimeRounding(roundingFunction){if(roundingFunction===undefined){returnround;}if(typeofroundingFunction==='function'){round=roundingFunction;returntrue;}returnfalse;}// This function allows you to set a threshold for relative time strings
functiongetSetRelativeTimeThreshold(threshold,limit){if(thresholds[threshold]===undefined){returnfalse;}if(limit===undefined){returnthresholds[threshold];}thresholds[threshold]=limit;if(threshold==='s'){thresholds.ss=limit-1;}returntrue;}functionhumanize(argWithSuffix,argThresholds){if(!this.isValid()){returnthis.localeData().invalidDate();}varwithSuffix=false,th=thresholds,locale,output;if(typeofargWithSuffix==='object'){argThresholds=argWithSuffix;argWithSuffix=false;}if(typeofargWithSuffix==='boolean'){withSuffix=argWithSuffix;}if(typeofargThresholds==='object'){th=Object.assign({},thresholds,argThresholds);if(argThresholds.s!=null&&argThresholds.ss==null){th.ss=argThresholds.s-1;}}locale=this.localeData();output=relativeTime$1(this,!withSuffix,th,locale);if(withSuffix){output=locale.pastFuture(+this,output);}returnlocale.postformat(output);}varabs$1=Math.abs;functionsign(x){return(x>0)-(x<0)||+x;}functiontoISOString$1(){// for ISO strings we do not use the normal bubbling rules:
// * milliseconds bubble up until they become hours
// * days do not bubble at all
// * months bubble up until they become years
// This is because there is no context-free conversion between hours and days
// (think of clock changes)
// and also not between days and months (28-31 days per month)
if(!this.isValid()){returnthis.localeData().invalidDate();}varseconds=abs$1(this._milliseconds)/1000,days=abs$1(this._days),months=abs$1(this._months),minutes,hours,years,s,total=this.asSeconds(),totalSign,ymSign,daysSign,hmsSign;if(!total){// this is the same as C#'s (Noda) and python (isodate)...
minutes=absFloor(seconds/60);hours=absFloor(minutes/60);seconds%=60;minutes%=60;// 12 months -> 1 year
years=absFloor(months/12);months%=12;// inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
s=seconds?seconds.toFixed(3).replace(/\.?0+$/,''):'';totalSign=total<0?'-':'';ymSign=sign(this._months)!==sign(total)?'-':'';daysSign=sign(this._days)!==sign(total)?'-':'';hmsSign=sign(this._milliseconds)!==sign(total)?'-':'';returntotalSign+'P'+(years?ymSign+years+'Y':'')+(months?ymSign+months+'M':'')+(days?daysSign+days+'D':'')+(hours||minutes||seconds?'T':'')+(hours?hmsSign+hours+'H':'')+(minutes?hmsSign+minutes+'M':'')+(seconds?hmsSign+s+'S':'');}varproto$2=Duration.prototype;proto$2.isValid=isValid$1;proto$2.abs=abs;proto$2.add=add$1;proto$2.subtract=subtract$1;proto$2.as=as;proto$2.asMilliseconds=asMilliseconds;proto$2.asSeconds=asSeconds;proto$2.asMinutes=asMinutes;proto$2.asHours=asHours;proto$2.asDays=asDays;proto$2.asWeeks=asWeeks;proto$2.asMonths=asMonths;proto$2.asQuarters=asQuarters;proto$2.asYears=asYears;proto$2.valueOf=valueOf$1;proto$2._bubble=bubble;proto$2.clone=clone$1;proto$2.get=get$2;proto$2.milliseconds=milliseconds;proto$2.seconds=seconds;proto$2.minutes=minutes;proto$2.hours=hours;proto$2.days=days;proto$2.weeks=weeks;proto$2.months=months;proto$2.years=years;proto$2.humanize=humanize;proto$2.toISOString=toISOString$1;proto$2.toString=toISOString$1;proto$2.toJSON=toISOString$1;proto$2.locale=locale;proto$2.localeData=localeData;proto$2.toIsoString=deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',toISOString$1);proto$2.lang=lang;// FORMATTING
hooks.version='2.29.1';setHookCallback(createLocal);hooks.fn=proto;hooks.min=min;hooks.max=max;hooks.now=now;hooks.utc=createUTC;hooks.unix=createUnix;hooks.months=listMonths;hooks.isDate=isDate;hooks.locale=getSetGlobalLocale;hooks.invalid=createInvalid;hooks.duration=createDuration;hooks.isMoment=isMoment;hooks.weekdays=listWeekdays;hooks.parseZone=createInZone;hooks.localeData=getLocale;hooks.isDuration=isDuration;hooks.monthsShort=listMonthsShort;hooks.weekdaysMin=listWeekdaysMin;hooks.defineLocale=defineLocale;hooks.updateLocale=updateLocale;hooks.locales=listLocales;hooks.weekdaysShort=listWeekdaysShort;hooks.normalizeUnits=normalizeUnits;hooks.relativeTimeRounding=getSetRelativeTimeRounding;hooks.relativeTimeThreshold=getSetRelativeTimeThreshold;hooks.calendarFormat=getCalendarFormat;hooks.prototype=proto;// currently HTML5 input type only supports 24-hour formats
displayFileWarning?(react.createElement(Warning,null,"Please rename your ledger file to end with the .ledger extension. Once renamed, please update the configuration option in the Ledger plugin settings.")):null,
functionaround(obj,factories){constremovers=Object.keys(factories).map(key=>around1(obj,key,factories[key]));returnremovers.length===1?removers[0]:function(){removers.forEach(r=>r());};}functionaround1(obj,method,createWrapper){constoriginal=obj[method],hadOwn=obj.hasOwnProperty(method);letcurrent=createWrapper(original);// Let our wrapper inherit static props from the wrapping method,
// and the wrapping method, props from the original method
if(original)Object.setPrototypeOf(current,original);Object.setPrototypeOf(wrapper,current);obj[method]=wrapper;// Return a callback to allow safe removal
returnremove;functionwrapper(...args){// If we have been deactivated and are no longer wrapped, remove ourselves
if(current===original&&obj[method]===wrapper)remove();returncurrent.apply(this,args);}functionremove(){// If no other patches, just do a direct removal
if(obj[method]===wrapper){if(hadOwn)obj[method]=original;elsedeleteobj[method];}if(current===original)return;// Else pass future calls through, and remove wrapper from the prototype chain
