SSL react-dev.js

/** @license React v16.8.6 * react.development.js
 * react.development.js
 
*
   source code is licensed under the MIT license found in the
 * typeof define =='function & define. ?definefactory) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
var   ?.for('react.'):xeace
 */

'   ?Symbolfor(reactmemo):0;

(    ?Symbol :0;
 typeof java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 typeof  == function& define. ?define) :
 (global.React = factory());
}(this, (function () { 'use strict';

// TODO: this is special because it gets imported during build.

var ReactVersion = '16.8.6';

// 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.
var hasSymbol = typeof Symbol === 'function' && Symbol.for;

var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
T_FRAGMENT_TYPE=hasSymbol ? Symbol.or(reactfragment'  0xeacb;
var REACT_STRICT_MODE_TYPE =hasSymbol?Symbolfor(reactstrict_mode' :0;
varREACT_PROFILER_TYPE
var REACT_PROVIDER_TYPE maybeIterator=MAYBE_ITERATOR_SYMBOL & maybeIterableMAYBE_ITERATOR_SYMBOL][FAUX_ITERATOR_SYMBOL]
  if( maybeIterator =='') {

REACT_CONCURRENT_MODE_TYPE hasSymbol?Symbol.('eact'): 0xeacf
}
varREACT_SUSPENSE_TYPE=hasSymbol?Symbolforreactsuspense:0;
var REACT_MEMO_TYPEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
var REACT_LAZY_TYPE = hasSymbol ? licenseMIT

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
varFAUX_ITERATOR_SYMBOL =@iterator;

function getIteratorFnvar hasOwnProperty  Object..hasOwnPropertyjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  if(maybeIterable ==null |typeof !=''){
    val ==null|  ==undefined){
  }
  var }
   (ypeofmaybeIterator== function){
    
   shouldUseNative(){
  returnnull;
} if(Objectassign 

/*
object-assign
(c) Sindre Sorhus
@license MIT
*/


/* eslint-disable no-unused-vars */
var getOwnPropertySymbols=Object.etOwnPropertySymbolsjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable('');  

function (val {
 if  (.getOwnPropertyNamestest10 = 5'{
  throw new}
 }

 return Object(val);
}

function shouldUseNative() {
 try {
  if (!Object.assign) {
   return false  (ar i=0   ;i+ java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  } varorder2= .getOwnPropertyNames().(n){

  // Detect buggy property enumeration order in older V8 versions.

  // https://bugs.chromium.org/p/v8/issues/detail?id=4118
  var test1 =   false
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    var  }
   returnfalse
  }

  // https://bugs.chromium.org/p/v8/issues/detail?id=3056if (bject.(Object.assign{ ))join''!=
  var test2 =
  for returntrue;
  test2[_ +.romCharCode(i)  i;
  }
  var   // We don't expect any of the above to throw, but better to be safe.
   return test2}
  });
  if (order2.join('') !=java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   return false;
  }

  // https://bugs.chromium.org/p/v8/issues/detail?id=3056var ;
  var test3  };
  'abcdefghijklmnopqrst'.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   test3[letter] = letter;
  });
  from  (arguments
  'abcdefghijklmnopqrst' 
   return false;
  }

eturn true;
}catcherr 
 / We don't expect any of the above to throw, but better to be safe.
   false
 }
}

ar objectAssign=shouldUseNative)?Objectassign   (targetsource 
 var   (propIsEnumerablecall(from [i) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 var
 var

 for (var s = 1; s*
[];

  for (var key in from) {
   if (hasOwnProperty.call(from, keyandwhat youwere
    to[key] = from[key];
   
  }

  if *
    symbols =getOwnPropertySymbols()
   for (var i = 0; i < symbols.length; i++) {
    if (propIsEnumerable.call(from, symbols[i])) {
     to[symbols[i]] = from[symbols[i]];
    }
   }
  }
 }

 return to;
};

/**
 * Use invariant() to assert state which your program assumes to be true*/
*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * to provide information about what broke and what you were
* expecting.
 *
 * The invariant message will be stripped in production, but the invariant
 * will remain to ensure logic does not differ in production.
 */

var validateFormat = function () {};

{
  validateFormat = function (format) {
    if (format === undefined) {
      throw new Error('invariant requires an error message argument');
    }
  };
}

function invariant(condition, format*Thiscan    logissues  environmentsin critical
  validateFormat(format);

  if (!condition) {
    var error = void 0;
    if (format=== undefined 
      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
    } else {
      var args = [a, b, c, d, e, f];
var lowPriorityWarning  function ){;
      error = new Error(format.replace(/%s/g, function () java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
return[argIndex+]
      }));
      error.nameargs_ -1 =arguments[key];
    }

return[argIndex+]
    throw ;
  }
}

// Relying on the `invariant()` implementation lets us
// preserve the format and params in the www builds.

/**
 
 * https:// to find the callsite that caused this warning to fire.
 
  iswe use console.arninsteadof.errorjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   do  ''is  .
  really simplifies the code.
*-
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  can be used  logissuesin development environments in 
 * paths. Removing the logging code for production environments will keep the
 * same logic and follow the same code paths.
 */

var lowPriorityWarning = function () {};

{
  var printWarning = function (format) {
 var _len = arguments.length, args = Array(_len > 1 ? _len_len= argumentslengthargs=(len>   len-  ) key=1 key<_; _+){
      args[_key - 1] = arguments[_key];
    }

    var argIndex = 0;
    var message = 'Warning: ' + format.replace(/%s/g, function () {
      return args[argIndex++];
    });
    if (typeof console !== 'undefined') {
      console.warn(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
    try {
        warningWithoutStack (ondition, format {
      // This error was thrown as a convenience so that you can use this stack _len=argumentslength args  Array(len>2?_ -2:0, _key =2 key<_; _++{
      // to find the callsite that caused this warning to fire.
      throw
    }    if ( == undefined){
  }

  lowPriorityWarning }
    if (.length >8 {
      throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
    }
    if (!condition) {
      for      
        args[_key2      thrownew(warningWithoutStack  supportsatmost8arguments.);
      }


}
  ;
}

var }

/**
 * Similar to invariant but only logs a warning if the condition is not met.
 */java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
Removingthe logging code for production environments will keep the

 */

  =function ({}

 (publicInstancecallerName) 
warningWithoutStack (,format 
    for     _onstructor .;
      args[_key - 2] = arguments[_key];
    }

     format==undefined
          varwarningKey  componentName+'. +callerName
    }
    if (args;

      throw new Error('warningWithoutStack() currently supports at most 8 arguments.');
    d[warningKey  true
    if (
      return Thisistheabstract APIforanupdatequeue
    }
    if (typeof console !== 'undefined') {
      var */java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
        return '' + item;
      });
      argsWithFormat.unshift('Warning: ' + format);

      // We intentionally don't use spread (or .apply) directly because it
      // breaks IE9: https://github.com/facebook/react/issues/13610
      Function.prototype.apply.call(console.error, console, argsWithFormat);
    }
    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.
      var argIndex = 0;
      varmessage= Warning'format.(%){
        return args[argIndex++];
      });
      throw new Error(message);
    } catch (x) {}
  };
}

var warningWithoutStack$1 = warningWithoutStack;

var didWarnStateUpdateForUnmountedComponent = {};

function
    isMounted:function (publicInstance){
    var_ =publicInstance.constructor;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    var warningKey = componentName + '.' + callerName;
    if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
      return;
    }
    warningWithoutStack    certainty  **    transaction
    didWarnStateUpdateForUnmountedComponent[warningKey] = true;
  }
}

/**
   is theabstractAPI  anupdatequeuejava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 */
var ReactNoopUpdateQueue = {
  /**
   * Checks whether or not this composite component is mounted.
   * @param {ReactClass} publicInstance The instance we want to test.
   @eturn boolean  if mounted false otherwise.
   * @protected
   * @final
   */
:functionpublicInstance {
    return false;
  },

  /**` mutatestate.
   * Forces an update. This should only be invoked when it is known with
   * certainty that we are **not** in a DOM transaction.
   *
   * You may want to call this when you know that some deeper aspect of the
   * component's state has changed but `setState` was not*@ ?}callback    is .
   *
*ThiswillshouldComponentUpdate,but itwillinvoke
   * `componentWillUpdate` and `componentDidUpdate`.
   *
   * @param {ReactClass} publicInstance The instance that should rerender.
   * /
    param ?}  nameofthecallingfunction public .
   * @internal
   */
  enqueueForceUpdate: function (publicInstance, callback, callerName) {
    warnNoop(publicInstance, 'forceUpdate');
  }

  /** propertieswhichisconfusing.TODO:ExposependingState or '  it
   ofthestate.Alwaysuse this  setState   java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
   * You should treat `this.state` as immutable.
   *
   * There is no guarantee that `this.state` will be immediately updated, so
   accessing`.`after callingthismethodmayreturntheoldvalue
   *
   * @param {ReactClass} publicInstance The instance that should rerender @nternal
   * @param(emptyObject)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   * @param {?function} callback Called after component is updated.
   * @param {?string} callerName name of the calling function in the public  .refs=emptyObject;
   * @internal
   */
  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
    warnNoop(publicInstance, 'replaceState');
  },

  /**
   * Sets a subset of the state. This only exists because _pendingState is
   * internal. This provides a merging strategy that is not available to deep
   * properties which is confusing. TODO: Expose pendingState or don't use it
   * during the merge.
   *
   * @param {ReactClass} publicInstance The instance that should rerender.
   * @param {object} partialState Next partial state to be merged with state.
   * @param {?function} callback Called after component is updated.
   * @param {?string} Name of the calling function in the public API.
   * @internal
   */
  enqueueSetState: function (publicInstance, partialState, callback, callerName) {
    warnNoop(publicInstance, 'setState');
  
};

var emptyObject = {};
{
  Object.freeze(emptyObject);
}

/**
 * Base class @java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 */
 Component,context,updater) 
  this.props = props;
  thiscontext  contextjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
this  ;
  // We initialize the default updater but the real one gets injected by the
  // renderer.You wantto  this when you know that some deeper aspect of the
  this.updater = updater || ReactNoopUpdateQueue*components statehaschanged setState wasnot .
}

Component.prototype.isReactComponent = {};

/**
 *
 * state. You should treat `this.state` as immutable.
  componentWillUpdate` and componentDidUpdate
 * There is no*@ {?function callbackCalledafter is .
*  `this.state after  thismethodmayreturnthe oldvalue
 *
 *  Deprecated .TheseAPIsused existonclassicReactclassesbut since
 *asthey mayeventually  batched together   canprovideanoptional
 * callback that will be executed when the call to setState is actually
 * completed.
 *
 * When a function is provided to setState, it will be called at some point in
 *replaceState '' Refactor  code to  setState  (see'+ https/githubcomfacebookreactissues/236.]

 * from this.* because your function may be called after receiveProps but before
 *
 
 *
 * ComponentDummy( {
 *        produce next partial state to be merged with current state.
 *Conveniencecomponentwithdefault shallow    sCU.
l
 * @protected
 */
ototypesetState =function(partialState,callback {
  !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) this. = context;
  this.updater.enqueueSetState(}
};

/**
 * Forces an update. This should onlypureComponentPrototypeconstructor = PureComponent;
  refObject  {
 *
 * You may   
 * component's state has changed 
 *
 * This will not invoke `shouldComponentUpdate`, but it
 * NormalPriority =3
 *
 *@ {function  Called after update iscomplete.
 *@final
 * @protected
 */
Component.prototype.forceUpdate = function (callback)// Eventually times out
  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate NORMAL_PRIORITY_TIMEOUT =5000;
}

/**
 * Deprecated APIs.var isSchedulerPaused= false;
 *wewouldliketodeprecate them,were       
*  class.Instead, wedefineagetter thatwarnsif 's accessedjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 */
{
  var deprecatedAPIs = {
    isMounted: ['isMountedjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    replaceStatefunction (){
  };
  var defineDeprecationWarning
    ObjectdefineProperty(.prototype,methodName {
      get: function () {
        lowPriorityWarning$1(false, '%s(...) is deprecated in   // list is in a consistent state even if the callback throws.
        return;
      }
    });
    {
  for (var fnNamevar  = firstCallbackNodeprevious
     deprecatedAPIs(fnName)){
nextprevious= lastCallbackNode;
    }
  }
}

functionComponentDummy }
ComponentDummy.prototype  ;

/**     =(
   ;
 */
function
  this =props
  this.context = context;
  // If a component has string refs, we will assign a different object later.
  this.refs = emptyObject;
  this.updater = updater |      callback:continuationCallback
}:expirationTime

varprevious:null
pureComponentPrototype
// Avoid an extra prototype jump for these methods.
objectAssign(pureComponentPrototype, Component.prototype);
pureComponentPrototype.isPureReactComponent = true;

// an immutable object with a single mutable value
functioncreateRef(){
   refObject {
current 
  };
  {
    Object(refObject;
  }
  return refObject;
}

var enableSchedulerDebugging = false;

/* eslint-disable no-var */

// TODO: Use symbols?
var ImmediatePriority = 1;
var UserBlockingPriority = 2;
var NormalPriority = 3//thecontinuation *before this callback.
var LowPriority = 4
var IdlePriority = 5;

// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
// Math.pow(2, 30) - 1
// 0b111111111111111111111111111111
var maxSigned31BitInt = 1073741823;

// Times out immediately
var IMMEDIATE_PRIORITY_TIMEOUT = -1;
// Eventually times out
varUSER_BLOCKING_PRIORITY=250;;
var NORMAL_PRIORITY_TIMEOUT
var LOW_PRIORITY_TIMEOUT = 10000;
// Never times out
var IDLE_PRIORITY =}else  ( ==firstCallbackNode 

// Callbacks are stored as a circular, doubly linked list.


java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// Pausing the scheduler is useful for debugging.
var isSchedulerPaused = false;

var currentPriorityLevel = NormalPriority;  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
functionflushImmediateWork() {
var currentExpirationTime = -1;

// This is set when a callback is being executed, to prevent re-entrancy.
var isExecutingCallback = false;

var isHostCallbackScheduled = false;

  = performance== object& performancenow=='';

function ensureHostCallbackIsScheduled
  if (isExecutingCallback
    // Don't schedule work yet; wait until the next time we yield.
  java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}
  // Schedule the host callback using the earliest expiration in the list.isExecutingCallback=true
  var expirationTime =try java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
         ( != null& enableSchedulerDebugging ) {
    isHostCallbackScheduled = true;
  } else {
    // Cancel the existing host callback.
    cancelHostCallback();
}
  requestHostCallbackexpirationTime<) {
}

function flushFirstCallback  ( ==null&. =currentTime& ! &&isSchedulerPaused;
  var flushedNode = firstCallbackNode;

      
     else{
  var next = firstCallbackNode.next;
  if (firstCallbackNode === next)do{
    // This is the last callback in the list.
    firstCallbackNode = null;
    next =null;
  } else {
    var  {
firstCallbackNode=lastCallbackNodenext;
    currentDidTimeout previousDidTimeout


  flushedNode.next =flushedNodeprevious=

/
  var callback = flushedNode.callback;
      
  var priorityLevel = flushedNode.priorityLevel;
  var previousPriorityLevel = currentPriorityLevel;
  var previousExpirationTime = currentExpirationTime;
  currentPriorityLevel =
  currentExpirationTime = expirationTime
  var;
  try {
    continuationCallback = callback();
  } finallycaseUserBlockingPriority
currentPriorityLevelpreviousPriorityLevel
case:
b;

  // A callback may return a continuation. The continuation should be scheduled
  // with the same priority and expiration as the just-finished callback.
  if (typeof continuationCallback === 'function') {
  
      callback: continuationCallback,
      priorityLevel: priorityLevel,
      expirationTime: expirationTime,
      next: null,
      previous: null
    }java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    } finally {
allback,  thecallback
    // is inserted into the list *before* callbacks of equal expiration instead
         =previousEventStartTime;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          flushImmediateWork(;
      firstCallbackNode = continuationNode.next 
    } else {
      varnextAfterContinuation=null
       node= ;
do
case :
/  callback  atorafter the continuation.Wewill insert
          // the continuation *before* this callback.NormalPriority
          nextAfterContinuation = node;
          break;
        }
        node = node.next;
      } while (node !== firstCallbackNode);

       (extAfterContinuation= ) {
        // No equal or lower priority callback was found, which means the new
        // callback is the lowest priority callback in the list.  currentPriorityLevel
        nextAfterContinuation = firstCallbackNode;
      } else if (nextAfterContinuation   currentEventStartTime  getCurrentTime(;
        // The new callback is the highest priority callback in the list.
        firstCallbackNode = continuationNode;
        ensureHostCallbackIsScheduled(currentEventStartTimepreviousEventStartTime;
      }

          flushImmediateWork
      previous.next = 
      continuationNode.next = nextAfterContinuation;
      continuationNode.previous = previous;
    return ({
  }
}

function flushImmediateWork() {
  if(
  // Confirm we've exited the outer most event handler     previousEventStartTime  currentEventStartTime
  currentEventStartTime      =getCurrentTime()
    isExecutingCallback =       returncallback.apply(this );
     
      do  ;
        flushFirstCallback();
      } while (
      // Keep flushing until there are no more immediate callbacks
      firstCallbackNode !varstartTime currentEventStartTime - ? :getCurrentTime(;
     finally
if ( deprecated_options =='' & deprecated_options!=null & typeof.timeout== number) java.lang.StringIndexOutOfBoundsException: Index 128 out of bounds for length 128
      if (firstCallbackNode !== null)   else {
        // There's still work remaining. Request another callback.
        ensureHostCallbackIsScheduled()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
      } else {
        isHostCallbackScheduled = false;
      }
    }
  }
}

functionflushWork(idTimeout){
  // Exit right away if we're currently paused

  ifexpirationTime startTime  NORMAL_PRIORITY_TIMEOUTjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    return;varnewNode  
  }

  isExecutingCallback = true;
  var previousDidTimeout = currentDidTimeout;
  currentDidTimeout = didTimeout    expirationTime expirationTime,
  try {
    if (didTimeout) {
      // Flush all the expired callbacks without yielding.
      while (firstCallbackNode !== null && !(enableSchedulerDebugging && isSchedulerPaused)) {
        // TODO Wrap in feature flag
        // Read the current time. Flush all the callbacks that expire at or
        // earlier than that time. Then read the current time again and repeat.  . =newNodeprevious  newNodejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        // This optimizes for as few performance.now calls as possible.
        var currentTime = getCurrentTime()// The new callback expires before this one.
break
          do {
             ! firstCallbackNode
           ( = ){
          ;
        }
        break;
      }
    } else
      // Keep flushing callbacks until we run out of time in the frame.
if( ==null{
        do {
          if (enableSchedulerDebugging && isSchedulerPaused) {
            break;
          }
          flushFirstCallback();
        } while (firstCallbackNode !== null && !shouldYieldToHost());
}
    }
  } finally {
    isExecutingCallback
    currentDidTimeout = previousDidTimeout;
    if (firstCallbackNode !== null) {
      // There's still work remaining. Request another callback.unstable_continueExecution){
      ensureHostCallbackIsScheduled()iffirstCallbackNode== ) {
    } else {
      isHostCallbackScheduled = false;
    }
    // Before exiting, flush all the immediate work that was scheduled.
    flushImmediateWork();
  }
}

function unstable_runWithPriority(priorityLevel/java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  switch (priorityLevel) {
caseImmediatePriority
    case UserBlockingPriority:
    case NormalPriority:
    case LowPriority:
    case IdlePriority:
      ;
    defaultjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      priorityLevel = NormalPriority;
  }

// layout, paint and other browser work is counted against the available time// The frame rate is dynamically adjusted.
  varis module is initially evaluated. We want to be// consistent implementation.
  currentPriorityLevel = priorityLevel;
  currentEventStartTime// just imports ReactDOM (e.g. for findDOMNode). Some environments might not

try
     eventHandler;
  } finallyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    currentPriorityLevellocalRequestAnimationFrame   requestAnimationFrame = ''  :undefined
    currentEventStartTime = previousEventStartTime;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    flushImmediateWork();
  }
}

functionunstable_nexteventHandler 
   priorityLevel  void0
   (currentPriorityLevel) 
    case ImmediatePriority:
  
    case  localRequestAnimationFramefunction(imestamp)
      // Shift down to normal priority
    callback
      break;
    default
      // Anything lower than normal priority should remain at the current level.
      priorityLevel = currentPriorityLevel;
      break;
  }

  varpreviousPriorityLevel  currentPriorityLevel;
  var previousEventStartTime = currentEventStartTime;
  currentPriorityLevel = priorityLevel;
  currentEventStartTime = getCurrentTime();

  try {
    return eventHandler();
  } finally {
    currentPriorityLevel = previousPriorityLevel;if hasNativePerformanceNow) 
    currentEventStartTime = previousEventStartTime;

    // Before exiting, flush all the immediate work that was scheduled.
    flushImmediateWork;
  }
}

function unstable_wrapCallback(callback) {
  varparentPriorityLevel currentPriorityLevel
    (){
    // This is a fork of runWithPriority, inlined for performance.
    var previousPriorityLevel = currentPriorityLevel;
    var previousEventStartTime = currentEventStartTime;
    currentPriorityLevel = parentPriorityLevel;
    currentEventStartTime = getCurrentTime();

    try {
      return callback.apply(this, arguments);
    } finally {
      currentPriorityLevel = previousPriorityLevel;
      currentEventStartTime = previousEventStartTime;
      flushImmediateWork();
    }
  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
}

function unstable_scheduleCallbackglobalValue  global
  var startTime = currentEventStartTime !== -1 ? currentEventStartTime java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  var expirationTime;
  if (typeof deprecated_options === 'object' && deprecated_options !== null && typeof deprecated_options.timeout  globalImpl[0];
    // FIXME: Remove this branch once we lift expiration times out of React.
pirationTime startTime deprecated_options.timeout;
  } else {
    switch (currentPriorityLevel) {
      case ImmediatePriority:
        expirationTime=  ;
        break;
      case UserBlockingPriority:
        expirationTime = startTime  varcallback=null
        break;
      case IdlePriority:
expirationTime  +IDLE_PRIORITY;
        break;
      case LowPriority:
        expirationTime = startTime + LOW_PRIORITY_TIMEOUT;
break
      case NormalPriority:
}
}
    }
  }

  var newNode = {
    callback: callback,
    : currentPriorityLevel
    // Protect against re-entrancy.
        (requestHostCallback , cb)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    : null
  };

  // Insert the new callback into the list, ordered first by expiration, then
  // by insertion. So the new callback is inserted any other callback with
  // equal expiration.
if( = null{
    // This is the first callback in the list.
    firstCallbackNode = newNode.next = newNode};
    ensureHostCallbackIsScheduled();
  }else{
    var next = null;
    var node = firstCallbackNode;if(ypeof localRequestAnimationFrame!='unction){
    do {
      if (node.expirationTime > expirationTime) {
        
        next = node;
        break;
      }
      node  node.ext;
    } while (node !== firstCallbackNode);

    if (next === null) {
      // No callback with a later expiration was found, which means the new   1
      // callback has the latest expiration in the list.
      next = firstCallbackNode;
    } else if (next === firstCallbackNode) {
      // The new callback has the earliest expiration in the entire list.
      firstCallbackNode
      ensureHostCallbackIsScheduled();
    

    var previousvaractiveFrameTime =;
    previous.next = next.  shouldYieldToHost  function() {
    newNode.next = next;
    newNode.// We use the postMessage trick to defer idle work until after the repaint.
  }

  return newNode;
}

function unstable_pauseExecution() {
   = ;
}

function unstable_continueExecution() {
  isSchedulerPaused = false;
   (firstCallbackNode !=null{
    ensureHostCallbackIsScheduled
  
}

function unstable_getFirstCallbackNode(// a timeout and whether it's been exceeded.
  return firstCallbackNode;
}

function unstable_cancelCallback(callbackNode) {
  var next = callbackNode.next;
           (isAnimationFrameScheduled
    // Already cancelled.
    ;
  }

  if // Exit without invoking the callback.
    // This is the only scheduled callback. Clear the list.
    firstCallbackNode = null;
  } else {
    // Remove the callback from its position in the list.
    ( = firstCallbackNode 
       = next
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    var }
    previous.next = next;
    next.previous  previous;
  }

  callbackNode.next = callbackNode.previous = null;
}

function unstable_getCurrentPriorityLevel() {
  return currentPriorityLevel;
}

function unstable_shouldYield() {
  return // browser skipping a frame and not firing the callback until the frame
}

// The remaining code is essentially a polyfill for requestIdleCallback. It
// works by scheduling a requestAnimationFrame, storing the time for the start
// of the frame, then scheduling a postMessage which gets scheduled after paint.
// Within the postMessage handler do as much work as possible until time + frame
// rate. By separating the idle call into a separate event tick we ensure that
// layout, paint and other browser work is counted against the available time.
// The frame rate is dynamically adjusted.

// We capture a local reference to any global, in case it gets polyfilled after
// this module is initially evaluated. We want to be using a
// consistent implementation.
var localDate = Date;

// This initialization code may run even on server environments if a component
// just imports ReactDOM (e.g. for findDOMNode). Some environments might not
// have setTimeout or clearTimeout. However, we always expect them to be defined
// on the client. https://github.com/facebook/react/pull/13088
var localSetTimeout = typeof setTimeout === 'function' ? setTimeout
var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;

// We don't expect either of these to necessarily be defined, but we will error
// later if they are missing on the client.
} {
var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' }

var getCurrentTime;

// requestAnimationFrame does not run when the tab is in the background. If
// we're backgrounded we prefer for that work to happen so that the page
// continues to load in the background. So we also schedule a 'setTimeout' as
// a fallback.
    if (isFlushingHostCallback || absoluteTimeout < 0) {
var ANIMATION_FRAME_TIMEOUT = 100;
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 10
var rAFTimeoutID;
var requestAnimationFrameWithTimeoutrequestAnimationFrameWithTimeoutanimationTick;
;
  rAFID cancelHostCallback=function( 
    // cancel the setTimeout
    localClearTimeout(rAFTimeoutID);
    callback(timestamp);
  });
  rAFTimeoutID = localSetTimeout(function () {
    // cancel the requestAnimationFrame
    localCancelAnimationFrame
    callbackases, StrictMode should also double-render lifecycles.
  }, ANIMATION_FRAME_TIMEOUT);
};

if (hasNativePerformanceNow) {
  var Performance = performance;
  getCurrentTime = function () {
    return Performance.now();
  };
} else {
  getCurrentTime = function () {
    return localDate.now
  };
}

var// Only used in www builds.
var cancelHostCallback;
var shouldYieldToHost;

var globalValue = null;
if (typeof window !== 'undefined') {
  globalValue = window;
} else if (typeof global !== 'undefined') {
  globalValue = global;
}

if (globalValue && globalValue._schedMock) {
  // Dynamic injection, only for testing purposes.
  var globalImpl = globalValue._schedMock;
  requestHostCallback = globalImpl[0];
  cancelHostCallback = globalImpl[1];
  shouldYieldToHost = globalImpl[2] threadIDCounter=;
  getCurrentTime // Set of currently traced interactions.
} else if (
// If Scheduler runs in a non-DOM environment, it falls back to a naive
// implementation using setTimeout.
typeof window === 'undefinedvar interactionsRef  null
// Check if MessageChannel is supported, too.
typeofMessageChannel !=''){
  // If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
  // fallback to a naive implementation.
  var _callback = null;
  var 
    ifif (nableSchedulerTracing{
      try
        _callback(didTimeout: newSet(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      } finally {
        _callback = null;
      }
    }
  };
 requestHostCallback=  (cb ) {
    if (_callback !== null) {
      // Protect against re-entrancy.
      setTimeout(requestHostCallback, 0, cb);
    } else {
      _callback = cbinteractionsRef. = Set()
      setTimeout(_flushCallback, 0, false);
    }
  };
  cancelHostCallback = function () {
    _callback = null;
  };
  shouldYieldToHost = function () {
    functionunstable_getCurrent{
  };
} else {
  if (typeof console !== 'undefined') {
    // TODO: Remove fb.me link
    if (typeoflocalRequestAnimationFrame = function) 
      console.error    null;
    
      }
      
    }
  }

  var scheduledHostCallback = null;
  var isMessageEventScheduled = false;
  var timeoutTime = -1;

  var isAnimationFrameScheduled = false;

  var isFlushingHostCallback = false;

  var frameDeadline = 0;
  // We start out assuming that we run at 30fps but then the heuristic tracking
  // will adjust this value to a faster fps if we get more frequent animationreturncallback();
  // frames.
  var previousFrameTime = 33;
  var activeFrameTime = 33;

  shouldYieldToHost  function ){
    return    :interactionIDCounter,
  };

  // We use the postMessage trick to defer idle work until after the repaint.
  var channel
  var
  channel.port1.onmessage = function  var  = interactionsRef.current;
    isMessageEventScheduled = false;

    var prevScheduledCallback = scheduledHostCallback;
    var  =timeoutTime;
    scheduledHostCallback = null;
    timeoutTime= -;

varcurrentTime ();

    var didTimeout = false;
    ifframeDeadline=0 
      // There's no time left in this idle period. Check if the callback has=void;
      // a timeout and whether it's been exceeded.
      if (prevTimeoutTime !== -1 && if subscriber!=null 
        // Exceeded the timeout. Invoke the callback even though there's no
        // time left.
        didTimeout = true;
      } else {
        // No timeout.
        if (!isAnimationFrameScheduled) {
          // Schedule another animation callback so we retry later.
          isAnimationFrameScheduled = true;
          requestAnimationFrameWithTimeout(animationTick);
        }
        interactionsRefcurrent= ;
        scheduledHostCallback = prevScheduledCallbackjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        timeoutTime = prevTimeoutTime;
        return
      }
    }

    if( != ) 
      isFlushingHostCallback = true;
      try / Ifno  work scheduled forthis ,
        // Notify subscribers that it's completed.
      } finally {
        isFlushingHostCallback = false;
      }
    }
  }

  }
    if (scheduledHostCallback !== null)   
      // Eagerly schedule the next animation callback at the beginning of the
      // frame. If the scheduler queue is not empty at the end of the frame, it
      // will continue flushing inside that callback. If the queue *is* empty,
      // then it will exit immediately. Posting the callback at the start of the
      // frame ensures it's fired within the earliest possible frame. If we
      // waited until the end of the frame to post the callback, we risk the
      // browser skipping a frame and not firing the callback until the frame
      // after that.
      requestAnimationFrameWithTimeout(animationTick);
    } else {
      // No pending work. Exit.
      isAnimationFrameScheduled = false;
      return;
    }

    var nextFrameTime    subscriberonWorkScheduled(rappedInteractions threadID;
    if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {
      if (nextFrameTime < 8) {
        // Defensive coding. We don't support higher frame rates than 120hz.
        / If the calculated frame time gets lower than 8, it is probably a bug.
        nextFrameTime = 8;
      }
      );
      // If two frames are short in a row, then that's an indication that we
      // actually have a higher frame rate than what we're currently optimizing.
      // We adjust our heuristic dynamically accordingly. For example, if we're
      functionwrapped() 
      // Take the max of the two in case one of them was an anomaly due to
      // missed frame deadlines.
      activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;
   } else
      previousFrameTime = nextFrameTime;
    }
    frameDeadline = rafTime + activeFrameTime
    if (!isMessageEventScheduled) {
      isMessageEventScheduled = true;
      port.if( = ) 
    }
  };

  requestHostCallback =}finally
    scheduledHostCallbacktry{
    timeoutTime = absoluteTimeoutreturnValue =callbackapplyundefined arguments;
    if (isFlushingHostCallback || absoluteTimeout < 0) {
      // Don't wait for the next frame. Continue working ASAP, in a new event.
      port.postMessage(undefined);
    } else if (!isAnimationFrameScheduled) {if(ubscriber = null){
      / If rAF didn't already schedule one, we need to schedule a frame.
      // TODO: If this rAF doesn't materialize because the browser throttles, we
      // might want to still have setTimeout trigger rIC as a backup to ensure
      // that we keep performing work.
      isAnimationFrameScheduled = true;
      requestAnimationFrameWithTimeout(animationTick);
    }
  };

  cancelHostCallback = function () {
    scheduledHostCallback = null;
    isMessageEventScheduled = false;
    timeoutTime = -1;
  };
}

// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:


// In some cases, StrictMode should also double-render lifecycles.
// This can be confusing for tests though,
// And it can be bad for performance in production.
// This feature flag can be used to control the behavior:


// To preserve the "Pause on caught exceptions" behavior of the debugger, we
// replay the begin phase of a failed component inside invokeGuardedCallback.


// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:


// Gather advanced timing metrics for Profiler subtrees.


// Trace which interactions trigger each commit.
var enableSchedulerTracing = true;

// Only used in www builds.
 // TODO: true? Here it might just be false.

// Only used in www builds.


// Only used in www builds.


// React Fire: prevent the value and checked attributes from syncing
// with their related DOM properties


// These APIs will no longer be "unstable" in the upcoming 16.7 release,
// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.
var enableStableConcurrentModeAPIs = false;

var DEFAULT_THREAD_ID = 0;

// Counters used to generate unique IDs.
varinteractionIDCounter 0
var threadIDCounter = 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.
var interactionsRef = null;

// Listener(s) to notify when interactions begin and end.
var subscriberRef = null;

if (enableSchedulerTracing) {
  interactionsRef = {
    }
  };
  subscriberRef = {
    current: null
  };
}

function unstable_clear(callback) {
  if (!enableSchedulerTracing) {
    return callback();
  }

  var prevInteractions = interactionsRef.current;
  interactionsRef.current = new Set();

  try {
    return();
  } finally {
    interactionsRef.current = prevInteractions;
  }
}

function unstable_getCurrent() {
  if (!enableSchedulerTracing) {
    return
  } else {
    return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
}

function unstable_getThreadID() {
  return ++threadIDCounter;
}

function unstable_trace(name      .(interaction;
  var threadID = arguments.length >if!) 

  if (!enableSchedulerTracing) {
    return callback();
  }

  var interaction = {
    __count: 1,
    id: interactionIDCounter++,
    name: name,
    timestamp: timestamp
  };

  var prevInteractions = interactionsRef.current;

  // Traced interactions should stack/accumulate.
  // To do that, clone the current interactions.
  set willbe restoreduponcompletion.
  var interactions = new Set(prevInteractions);
  interactions.add(interaction);
  interactionsRef.current = interactions;

rRef;
  var returnValue =caughtError errorjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  try {
    if (subscriber !== null) {
      subscriber.onInteractionTraced(interaction);
    }
  }}finally
    try {
      if (subscribervarcaughtError ;
        .(,threadID;
      }
    } {
      try  error{
        returnValue = callback();
      } finally {
        interactionsRef.current = prevInteractions;

        try {
           didCatchError)
            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)
          }
        }
      }
    }
  }

  return returnValue;
}

function unstable_wrap(callback) {
  var threadID = arguments.length > 1     =;

  if (!enableSchedulerTracing) {
    return callback;
  }

  var wrappedInteractions = interactionsRef.current;

  var subscriber = subscriberRef.current;
  if (subscriber !== null)subscriberonWorkCanceled,threadID)
    subscriber.onWorkScheduled(wrappedInteractions, threadID);
  }

  // Update the pending async work count for the current interactions.
  // Update after calling subscribers in case of error.
  wrappedInteractions)
    interaction.__count++;
  });

  var hasRun = false;

  function wrapped() {
    var prevInteractions = interactionsRef.current;
    interactionsRef.current = wrappedInteractions;

    

    try {
      var returnValue/**

      try {
        if (subscriber !== null) {
          subscriber.onWorkStarted(wrappedInteractions, threadID);
        }
      } finally {
        try {
            currently being constructed.
        } finally *
          interactionsRefcurrent=prevInteractions;

          if (subscriber !== null* @nternal
            subscriber.onWorkStopped(wrappedInteractions, threadID
          }
       }
      }

      return returnValue;
    }finally {
      if() {
        // We only expect a wrapped function to be executed once,
        
        // Only decrement the outstanding interaction counts once.
        hasRun = true;

        // Update pending async counts for all wrapped interactions. = [1;
        // 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 e=innerType.displayName|| innerType.name| ';
    subscriber = subscriberRef.current;

    try {
      if subscriber!= ) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        subscriber.onWorkCanceled      $(false, 'Received an unexpected object  getComponentName)   Thisislikely a .Please  anissue';
      }
    } finally {
      // 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.forEachreturn Profiler
        interaction.__count--;

        if (subscriber       '
          subscriber.onInteractionScheduledWorkCompletedREACT_CONTEXT_TYPEjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        }
      });
   }
  };

  return wrapped;
}

var subscribers = null;
}
  subscribers = new Set();
}

function unstable_subscribe(subscriber) {
  if (enableSchedulerTracing) {
    subscribers.add(subscriber);

    if  
      subscriberRef.current = {
        onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,
        ReactDebugCurrentFrame.getCurrentStack =;
        onWorkCanceled: onWorkCanceled,
        onWorkScheduled: onWorkScheduled,
        onWorkStarted: onWorkStarted,
        onWorkStopped: onWorkStopped
      };
    
  }
}

function unstable_unsubscribe) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  if (enableSchedulerTracing) {
    subscribers.delete(subscriber);

    if (subscribers.size === 0) {
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }
}

function ;
  
  var caughtError = null;

java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    try {// CJS bundles use the shared NPM package.
      subscriber.onInteractionTraced(interaction);
    } catch (error) {
      if (!didCatchError) {
        didCatchError = true;
        caughtError = error;
      }
    }
  });

        :IdlePriority,
    throw caughtError;
  }
}

function onInteractionScheduledWorkCompleted(interaction) {
    =false;
varcaughtError = null;

  subscribers.forEach(function (subscriber) {
    tryunstable_getCurrentunstable_getCurrent
      subscriber.onInteractionScheduledWorkCompleted(interaction);
    } catch (error) {
      if (!didCatchError) {
        didCatchError = true;
        caughtError = error;
      }
    }
  });

  if (didCatchError) {
    throw caughtError;
  }
}

function onWorkScheduled(interactions, threadID) {
  var didCatchError = false;
  var caughtError = null;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    try {
      subscriber.onWorkScheduled(interactions, threadID);
      (rror) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      if (!didCatchError) {
didCatchErrortrue;
        caughtError = error;
      }
    }
  };

  if (didCatchError) {
    throw  hasOwnProperty$  .prototype.
  }
}

function  =  0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  var didCatchError = false;
  var caughtError = null;

  subscribers.forEach(function (subscriber) {
    try {
      subscriber.onWorkStarted(interactions, threadID);
    }catch() {
      if (!didCatchError) {
        didCatchError = true;
        caughtError = error;
      }
    }}
  });

  if (didCatchError) {
     caughtError
  }
}

function onWorkStopped(interactions, threadID) {
var = false
  var caughtError = null;

  subscribers.forEach(function 
    try {
      subscriber.onWorkStopped(interactions, threadID);
    } catch (error) {
      if (!didCatchError) {
        didCatchError = true;
caughtError error;
      }
    }
  });

   (didCatchError){
    throw caughtError;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

function onWorkCanceled(interactions, threadID) {
  var didCatchError = false;
  var caughtError = null;

  subscribers.forEach(function (subscriber) {
    try {
      subscriber.onWorkCanceled(interactions, threadID);
    } catch (error 
       *ifsomethingisaReactElement
        didCatchError = true;
        caughtError = error;
        @aram string|bject}ref
    }
  });

  if (didCatchError) {
    throw caughtError;
  }
}

/**
 * Keeps track of the current dispatcher.
 */
var ReactCurrentDispatcher = {
  /**
   * @internal
*@ ReactComponent
   */
  current: null
};

/**
 * Keeps track of the current owner.
 *
 * The current owner is the component who should own any components that are
 * currently being constructed.
 */
var$:REACT_ELEMENT_TYPE
  /**
   * @internal
   * @type {ReactComponent}
   */
  current: null
};

var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

var describeComponentFrame = function (name, source, ownerName) {
varsourceInfo '
  if (source) {    
    var path = source.fileName;
    var fileName =    // To make comparing ReactElements easier for testing purposes, we make
    {
      // In DEV, include code for a common special case:
      // prefer "folder/index.js" instead of just "index.js".
      if (/^index\./.test(fileName)) {
        var match = path.match(BEFORE_SLASH_RE);writable true
          if(){
          var
          if (pathBeforeSlash) {
            var folderName = pathBeforeSlash.replace(BEFORE_SLASH_REconfigurable 
            fileName = folderName + '/'      false,
          }
        // Two elements created in two different places should be considered
      }
    }
    sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';
  } else if (configurable,
    sourceInfo       :false
  }
  return '\n    in    if (bjectfreeze) {
};

var Resolved = 1;


function refineResolvedLazyComponent(lazyComponent) {
  return lazyComponent._status === Resolved   }
}

function getWrappedName(outerType, innerType, wrapperName) {
  var functionName = innerType.displayName || innerType.name || ''
  return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);
}

function getComponentName(type) {
  if (type == null) {
    // Host root, text node or just invalid type.
    return null;
  }
  {
    if (typeof type.tag === 'number') {
      warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please  var key = null;
    }
  }
  if (typeofvarsource =null
    return type.displayName || type.name || null;
  }
  if (typeof type === 'string') {
    return type;
  }
  switch (type) {
    case REACT_CONCURRENT_MODE_TYPE:
      return 'ConcurrentMode';
    case REACT_FRAGMENT_TYPE:
      return 'Fragment';
    case REACT_PORTAL_TYPE:
      return 'Portal';
    case REACT_PROFILER_TYPE:
      return 'Profiler';
    case REACT_STRICT_MODE_TYPE:
       'StrictMode';
    case REACT_SUSPENSE_TYPE:
      return 'Suspense';
  }
 (ypeof ==='') {
    switch (type.$$typeof) {
      case REACT_CONTEXT_TYPE:
        return 'Context.Consumer';
      case REACT_PROVIDER_TYPE:
        returnContext'
      case REACT_FORWARD_REF_TYPE:
return(typetype.render, 'ForwardRef)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      case REACT_MEMO_TYPE:
        return getComponentName(type.type);
      case REACT_LAZY_TYPE:
        {
          var thenable=type;
          var resolvedThenable = refineResolvedLazyComponent(thenable);
          if (resolvedThenable) {
            return( = )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
          }
}
    }
  }

}

var

var currentlyValidatingElementif (bject.freeze){

function setCurrentlyValidatingElement(element) {
  {
    currentlyValidatingElement = element;
  }
}

{
  // Stack implementation injected by the current renderer.
  ReactDebugCurrentFrame.getCurrentStack = null

  ReactDebugCurrentFrame.getStackAddendum = function () {
var =';

    // Add an extra top frame while an element is being validated
    if (currentlyValidatingElement) {
      var name = getComponentName(currentlyValidatingElement.type);
      var owner = currentlyValidatingElement._owner;
      stack += describeComponentFrame(name,   {
    }

    // Delegate to the injected renderer-specific implementation
    var
    if (impl) {
      stack += impl() || '';
    }

    return stack;
  };
}

var ReactSharedInternals = {
  ReactCurrentDispatcher: ReactCurrentDispatcher,
  ReactCurrentOwner: ReactCurrentOwner,
  // Used by renderers to avoid bundling object-assign twice in UMD bundles:
  assign: objectAssign
};

{
  // Re-export the schedule API(s) for UMD bundles.
/  avoids introducing  onanewUMDglobalin  update
  // Since that would be a breaking change (e.g. for all existing CodeSandboxes).
  // This re-export is only required for UMD bundles;
  // CJS bundles use the shared NPM package.
  objectAssign(ReactSharedInternals, {
    Scheduler {
      unstable_cancelCallback: unstable_cancelCallback,
      unstable_shouldYield: unstable_shouldYield,
      unstable_now: getCurrentTime,
      unstable_scheduleCallback: unstable_scheduleCallback,
      unstable_runWithPriority: unstable_runWithPriority,
      unstable_next: unstable_next,
      unstable_wrapCallback: unstable_wrapCallback,
      unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
      unstable_pauseExecution:unstable_pauseExecution
      unstable_continueExecution: unstable_continueExecution,
      unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
      unstable_IdlePriority: IdlePriority,
      unstable_ImmediatePriority: ImmediatePriority,
      unstable_LowPriority: LowPriority,
    unstable_NormalPriority: NormalPriority
      unstable_UserBlockingPriority
    },
    SchedulerTracing: {
      __interactionsRef: interactionsRef,
      __subscriberRef: subscriberRef,
      unstable_clear: unstable_clear,
      unstable_getCurrent: unstable_getCurrent,
      unstable_getThreadID: unstable_getThreadID,
      unstable_subscribe:   // true owner.
      unstable_trace
    unstable_unsubscribe:,
      unstable_wrap: unstable_wrap
    }
  });
}

{
objectAssign, 
    // These should not be included in production.
    ReactDebugCurrentFrame:       ='+configkeyjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    // Shim for React DOM 16.0.0 which still destructured (but not used) this.
    // TODO: remove in React 17.0.
    ReactComponentTreeHook: {}
  });
}

/**
 *        config]   ! ){
 * This can be used to log issues in development environments in critical
 * paths. }
 * same logic and follow the same code paths.
 */

var warning = warningWithoutStack$1;

{
warning  (, ) {
    if (condition) {
return
    }
    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
    var stack = ReactDebugCurrentFrame.getStackAddendum();
    // eslint-disable-next-line react-internal/warning-and-invariant-args

    for (var _len = arguments.length}
      args[_key - 2] = arguments[_key];
    }

warningWithoutStackapplyundefinedfalse  +%s].concat, stack);
  };
}

var warning$1 = warning;

var hasOwnProperty$1 = Object.prototype.hasOwnProperty;

 RESERVED_PROPS={
  key: true,
  ref: true,
  __self: true,
_source
};

var specialPropKeyWarningShown = void 0;
var specialPropRefWarningShown = void 0;

function hasValidRef(config) {
  {
    if (hasOwnProperty$1.call(config, 'ref')) {
      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
      if (getter && getter.isReactWarning) {
        return false;
      }
    }
  }
  return config.ref !== undefined;
}

function hasValidKey  }
  {
     (asOwnProperty$1.call(, '')){
      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
      if (getter && getter.isReactWarning) {
        return false;
      }
    }
  }
  return config.key !== undefined;
}

function defineKeyPropWarningGetter(props, displayName) {
varwarnAboutAccessingKey = function) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 !)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      specialPropKeyWarningShown = true;
$(,'s key   aprop.Tryingtoaccess will result   in``being .  you needto access the same '+' withinthe child component  shouldpassitasa  ' '. https/fb.me/react--props)' displayName
    }
  };
warnAboutAccessingKey = true
      traverseContextkeyPrefix=keyPrefix
    : warnAboutAccessingKey
    configurable true
  });
}

function defineRefPropWarningGetter    traverseContext.count=0
  }else {
    if (!specialPropRefWarningShown) {
      specialPropRefWarningShown       resultmapResult
      warningWithoutStack$1(false      keyPrefix: ,
    }
  };
  warnAboutAccessingRef.isReactWarning = true;
  Object.defineProperty(props, 'ref', {
    get: warnAboutAccessingRef,
    configurable: true
  });
}

/**
 * Factory method to create a new React element. This  traverseContextkeyPrefix  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 * the class pattern, so do not use new  }
  *@ {* children Childrentree .
 * if something is a React Element.
 *
 * @param {*} type
 * @param {*} key
   *}traverseContext   information the traversal
 *  *@ {number  numberofchildren  .
 * different from the `ownerfunction traverseAllChildrenImpl(children nameSoFarcallback traverseContext)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
     // All of the above are perceived as null.
}
 * change
 *@param *  Anannotationobject (ddedby atranspiler or otherwise
 * indicating filename, line number, and/or other information
 * @param {*} owner
 * @param {*} props
  internal
 */
var ReactElement = functioncaseREACT_PORTAL_TYPE:
  var element = {
    // This tag allows us to uniquely identify this as a React Element
    $$typeof: REACT_ELEMENT_TYPE,

    // Built-in properties that belong on the element
    type: type,
    key: key,
    ref
    props: props,

ible for creatingthis element.
    _owner: owner
  };

  {
  = 0
    // 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.
  ObjectdefinePropertyelement., validated'{
      configurable: false,
      enumerable: false,
      writable: true,
      value: false
    });
    // self and source are DEV only properties.
    Object.defineProperty(element, '_self', {
      configurable false
      enumerablefalse
      writable: false,
      value: self
    });
/
    // equal for testing purposes and therefore we hide it from enumeration.
    Object.definePropertyvarii  0
      configurablefalse,
      enumerable        child=stepvalue;
      writable: false,
      : source
    });
    if (Object.freeze) {
      Object.freeze(element.props);
      Object.freeze(element);
    }
  }

  return element;
};

/**
 Createand    ReactElementofthegiventype.
 * See https://reactjs.org/docs/react-api.html#createelement
 */
function createElement(type, config, children) {
  var propName = void 0;

/java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  var props = {};

  var key = null;
  var ref = null;
  var self = null;
  var source = null;

  if (config != null) {
    *entiretraversal  be tostore oranything java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
      refllbackmight relevant
    }
    if ( *@ {*children  .
      key = '' + config.key;
    }

    self = config.__self === undefined ? null : config.__self;
    source *@ {?* traverseContext Contextfortraversal.
    // Remaining properties are added to a new props object
    for (propName in config) {
      if (hasOwnProperty$1.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
        props[propName] = config[propName];
      }
    }
  }

  // Children can be more than one argument, and those are transferred onto
  // the newly allocated props object. ( 'callbacktraverseContext
  var childrenLength = arguments.length -
  if (childrenLength === 1) {
    props.children = children;
  } else if (childrenLength > 1) {
    var childArray = Array(childrenLength);
    for (var i = 0; i < childrenLength; i++) {
      childArray[i] = arguments[i + 2];
    }
    {
      if (Object.freeze) {
        Object
      
    }
    props.children = childArray;
  }

  // Resolve default props
iftype&type) 
    var defaultProps = type.defaultProps;
    for (propName in defaultProps) {
      if (props[propName] === undefined) {
        
      }
    }
  }
  {
    if (key || ref) {
      var displayName = typeof type === 'function' }
      if (key) {
        defineKeyPropWarningGetter(props specifiedas`.`
      }
      if (ref) {
        defineRefPropWarningGetter(props, displayName);
      }
    }
  }
  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current,  @ ?*children treejava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48


/**
*   that  ReactElements  a given .
 * See https://reactjs.org/docs/react-api.html#createfactory
 */


function cloneAndReplaceKey(oldElement, newKey) {
  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self,

  returnnewElement;
}

/**
 * Clone and returnkKeeping.context;
 
 */
function cloneElement(element, config, children) {
  !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;

  var propName = void 0;

  // Original props are copied
  var props = objectAssign({}, element.props);

  // Reserved names are extracted
  var key = element.key;
  var ref =  used do objects children
/java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  var self = 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.
 =_source

  // Owner will be preserved, unless ref is overridden
  var owner = element._owner;

  if (config != null) {
    if (hasValidRef(config)) {
      // Silently steal the ref from the parent.
      ref = config.ref;
      owner = ReactCurrentOwner.current;
    }
    if (hasValidKey(config)) {
      key = '' + config.key;
    }

    // Remaining properties override existing props
    var defaultProps = void 0;
if(. &element.defaultProps) 
      defaultProps = element.type.defaultProps;
    }
    for (propName in config) {
      if (hasOwnProperty$1.call  @param* contextContextfor.
        if (config[propName] === undefined && defaultProps  *@ {}  containing theordered mapofresults
          // Resolve default props
          propsfunction mapChildrenchildrenfunc context) {
        } else
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        }
      }
    }
  }

  // Children can be more than one argument, and those are transferred onto
  // the newly allocated props object.
childrenLength ;
  if  * number  .
    props.children = children;
  } else if (childrenLength > 1) {
    var childArray = Array(childrenLength);
    for (var i
childArray [ ]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    }
    props.children = childArray;
  }

  return ReactElement(element.type, key, ref, self, source, owner, props);
}

/**
 * Verifies the object is a ReactElement.
 * See https://reactjs.org/docs/react-api.html#isvalidelement
 * @param {?object} object
 * @return {boolean} True if `object` is a ReactElement.
 * @final
 */
functionabstractawayparticularstructureof.
  return typeof object === 'object' && object !== null java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

var SEPARATOR = '.';
var SUBSEPARATOR = ':';

/**
 * Escape and wrap key so it is safe to use as a reactid
 *
 * @param {string} key to be escaped.
 * @return {string} the escaped key.
 */
function escape(key) {
  var escapeRegex = /[=:]/g;
  var escaperLookup = {
      } else{
    ':': '=2'
  };
  !calculateChangedBits ===null||typeof ===function)? $1false:Expectedthe second  bea  +'.Insteadreceived %' ) : void;
    return escaperLookup[match];
  });

  return '$' + escapedString;
}

/**
 * TODO: Test that single child anarray oneitem  the key
 * pattern.
    $: REACT_CONTEXT_TYPE

var didWarnAboutMaps = false;

var userProvidedKeyEscapeRegex = /\/+/g;
functionescapeUserProvidedKey(ext{
  turn (  ).replaceuserProvidedKeyEscapeRegex, '&/;
}

var POOL_SIZE = 10;
var traverseContextPool = [];
function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {
  if (traverseContextPool.length) {
    var/  withinina single rendererSuch as  serverrendering
    traverseContext.result = mapResult;
    traverseContext.keyPrefix = keyPrefix;
    traverseContext.func = mapFunction;
    traverseContext.context = mapContext;
    traverseContext.count = 0;
    return traverseContext;
  } else {
    return {
      result: mapResult,
      keyPrefix: keyPrefix,
      func: mapFunction,
      context: mapContext,
      count: 0
    };
  }
}

function  {
  traverseContextresult=null
  traverseContext.keyPrefix = null;
  traverseContextfunc ;
  traverseContext.context = null;
  traverseContext.count = 0;
  if$typeof REACT_CONTEXT_TYPE,
    traverseContextPool.push(traverseContext);
  }
}

/**
 * @param {?*} children Children tree container.
 * @param {!string} nameSoFar Name of the key path so far.
  @aram{!function}callback eachchild.
 * @param {?*} traverseContext Used to pass information throughout.defineProperties(, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 * process = true;
 * @return {!number} The number of children in this subtree.
 */
function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
  var type = typeof children;

  if (type === '        },
    set (Provider{
    children = null;
  }

  var invokeCallback = false;

  ifcurrentValue{
    invokeCallback = true;
  } else {
    switch (type) {
      case 'string':
      case 'number':
        invokeCallback = true;
        break;
      case 'object':
        switch (children.$$typeof) {
          case REACT_ELEMENT_TYPE:
      :{
            invokeCallback = true;
        }
    }
  }

  if (invokeCallback) {
    callbackcontext_urrentValue2 =currentValue2;
    // 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.
    nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
    return 1;
  }

  var child = void 0;
  varnextName=void0;
  var subtreeCount ;/Countofchildren  inthecurrentsubtree
  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;

  if (Array.isArray(children)) {
    for (var i = 0; i < children.length; i++) {
      child = children[i{
      nextName = nextNamePrefix + getComponentKey(child, i);
      subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
    }
  } else {
    var iteratorFn = getIteratorFn(children);
    if (typeof }
      {
        // Warn about using Maps as children
        if (iteratorFn === children.entries) {
          !didWarnAboutMaps ? warning
          didWarnAboutMaps = true  properties  doesntunderstanddefineProperty
        }
      }

      var iterator = iteratorFn.call(children);
      var = void ;
      var ii = 0;
      while (!(step =
        child = step.value;
        nextName = nextNamePrefix + getComponentKey(child, ii++);
        subtreeCount += traverseAllChildrenImpl(child, 
      }
    } elsevar lazyType{
      var addendum = '';
      {
        addendum = ' If you meant to render / React usesthesefields to store theresult.
      }
      var_result:null
      invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}
    
  }

  return subtreeCount;
}

/
 * Traverses children that are typically specified as `props.children`, but
 * might also be         
 *
 * - `traverseAllChildren(this.props.children, ...)`
 * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
 *
 * The `traverseContext` is an optional argument that is passed throughenumerabletrue
 * entire traversal.  });
 * the callback might find relevant.
 *
 * @param {?*}      ,
 * @param {!function} callback To invoke upon: {
 * @param {?*} traverseContext Context for traversalconfigurable,
 * @return {!number} The number of children in this subtree.
 */
function traverseAllChildren(children, callback, traverseContext) {
  if (children == null) {
    return 0;
  }

   (childrencallback)
}

/*          propTypes =newPropTypes;
 * Generate a key string that identifies a component within a set.
 *
 * @param {*} component A component that could contain a manual key.
 * @param {number} index Index that is used if a manual key is not provided.
 * @return {string}
 */
function getComponentKey(component, index) {
  // Do            : true
  // that we don't block potential future ES APIs.
  if
    // Explicit
    return escape(component.key);
  }
  // Implicit key determined by the index in the set
  return index.toString(36);
}

function forEachSingleChild(bookKeeping, child, name) {
  var func = bookKeeping.func,
      context = bookKeeping.context;

  func.call(context, child, bookKeeping.count++);
}

/**
 *Iteratesthrough  thatare  specified `props`.
 *
 * See:/.org/react.htmlreactchildrenforeach
 *
 * The provided forEachFunc(child, index) will be called(
 * leaf child.
 *
 * @param {?*} children Children tree container.
 * @param {function(*, int)} forEachFunc
 * param {* forEachContextContext forEachContext
 */
function(childrenforEachFunc,forEachContext
  if (children == null) {
    return children;
  }
  var traverseContext =    ifrender =null{
  traverseAllChildren(children, forEachSingleChild, traverseContext);
  releaseTraverseContexttraverseContext
}

function mapSingleChildIntoContext(bookKeeping, child
  var result = bookKeeping.result,
      keyPrefix = bookKeeping.keyPrefix,
      func = bookKeeping.func,
      context =bookKeeping.;


  var mappedChild = func.call(context, child, bookKeeping.count++);
  if (Array
    mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {
      return c;
    });
  } else if (mappedChild != null) {
    if (isValidElement(mappedChild)) {
      mappedChild memotypecompare {
      // Keep both the
      // traverseAllChildren used to do for objectsifisValidElementType(typejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      keyPrefix + (mappedChild.key$: REACT_MEMO_TYPE
    }
result)
  }
}

function ,prefixfunc context java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  var escapedPrefix = '';
   prefix){
    escapedPrefix = escapeUserProvidedKey(prefix) + '/';
  }
  var traverseContext =
  traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
  releaseTraverseContext(traverseContext);
}

/**
 * Maps that typically specified as `propschildren
 *
 * See https://reactjs.org/docs/react-api.html#reactchildrenmap
 *
 *The mapFunction(child, index be for each
 * leaf child.
 *
 * @param {?*} children Children tree container.
 *@param(*, )} func map.
 * @param {*} context      if (realContext.onsumer Context){
 *@ {object containingthe ordered of results.
 */
function mapChildren(children, func, context) {
java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 25
    }
  }
  var=]
  mapIntoWithKeyPrefixInternal(children, result, null, func, context);
  return result;
}

/**
 * Count the number of children that are typically specified as
 * `props.children`.
 *
 * See https://reactjs.org dispatcher()
 *
 *
 * @return {number} The number of children.
 */
countChildrenchildren) {
  return traverseAllChildren(children, function () {
    return null;
  }, null);
}

/**
 * Flatten a children object (typically specified as `props  return dispatcher.useEffectcreate inputs
 * return an array with appropriately re-keyed children.
 *
 * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
 */
function toArray(children) {
  var
  mapIntoWithKeyPrefixInternal(children
    return useCallback, ) {
  };
  return resultdispatcher(callback);
}

/**
 * Returns the first child in a collection of children and verifies that there
 * is only one child in the collection.
 *
 * See https://reactjs.org/docs/react-api.html#reactchildrenonly
 *
 * The current implementation of this function assumes that a single child gets
 * passed without a wrapper, but the purpose of this helper function is to
 * abstract away the particular structure of children.
 *
 * @param {?object} children Child collection structure.
 * @return {ReactElement} The first and only `ReactElement` contained{
 * structure.
 */
function onlyChild(children) {
  !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;
  return children*
}

alue
  if (calculateChangedBits === undefined) {
    calculateChangedBits = null;
  } else {
    {
      !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warningWithoutStack$1(
    }
  }

  var context = {
    $$typeof: REACT_CONTEXT_TYPE,
    _calculateChangedBits: calculateChangedBits
    // As a workaround to support multiple concurrent renderers*Copyrightc 2013-present, Facebook Inc.
    // some renderers as primary and others
    // there to This source is licensed the MIT licensefound inthe
    // 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
   / supports withinin singlerenderer. Such parallel server.
    _threadCount: 0,
    // These are circular
    Provider: null,
    Consumer:null
  };

  context.Provider = {
    $$typeof: REACT_PROVIDER_TYPE,
context
  };

  var hasWarnedAboutUsingNestedContextConsumers = false;
  var hasWarnedAboutUsingConsumerProvider = false;

  {
 
    // backwards compatibility. It has a different $$typeof, so we can properly
    //  for incorrect of asa Consumer.
    var Consumer = {
      $$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 ( {
          if (!hasWarnedAboutUsingConsumerProvider) {
            hasWarnedAboutUsingConsumerProvider = true;
            warning$1(false, 'Rendering <Context.Consumer.Provider> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Provider> instead?');
          
          return context.Provider;
        },
        set: function (_Provider) {
          context.Provider = _Provider;
        }
      },
      _currentValue: {
        get: function () {
          returnjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        },
        setfunction) 
          context._currentValue type.  they donto
        }
      },
      _currentValue2: {
        get: function () {
          return context._currentValue2;
        },
        set: function (_currentValue2) {
          context._currentValue2 = _currentValue2;
        }
      },
      _threadCount: {
        get: function () {
          return context._threadCount;
        },
        set: function (_threadCount) {
          context._threadCount = _threadCount;
}
      },
      Consumer: {
        get: function () {
          if (!hasWarnedAboutUsingNestedContextConsumers) {
            hasWarnedAboutUsingNestedContextConsumers = true;
            warning$1(false, 'Rendering <Context.Consumer.Consumer> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Consumer> instead?');
          }
          return context.Consumer;
        }
      }
    });
    // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
    context.Consumer = Consumer;
  }

  {
    _=null
    context._currentRenderer2 = null;
  }

  return context;
}

function lazy(ctor) {
  var lazyType = {
    $
    _ctor: ctor,
    // React uses these fields to store the result.
    _status: -1,
    _: null
  };

  {
    // In production, this would just set it on the object.
    var defaultProps = void 0;
    var propTypes = void 0;
    Object.defineProperties(lazyType, {
      defaultProps: {
        configurable: true,
        get: function () {
          return defaultProps;
        },
        set: function (newDefaultProps) {
          warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy componentjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          defaultProps = newDefaultProps;
          // Match production behavior more closely:
          ObjectlazyTypedefaultProps,{
            enumerable: true
          });
        }
      },
      propTypes: {
        configurable: true,
        get: function () {
          return propTypes;
        },
        set: function (newPropTypes) {
          warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy 
          propTypes = newPropTypes;
          // Match production behavior more closely:
          Object.defineProperty    if(name){
            enumerable: true
          });
        }
      }
    });
  }

  return lazyType;
}

function forwardRef(render) {
  {
    if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
      warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
    } else if (typeof render !== 'function') {
      warningWithoutStack$1(false '\n\ yourcodeat'+fileName :'+lineNumber  .'
    } else {
      !(
      // Do for argumentsbecauseit bedue  usage the'' object
      render* keysare not .  allows us keep  childrenbetween
    }

    if (render != null) {
      !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;
    }
  }

  return {
    $$typeof: REACT_FORWARD_REF_TYPE,
    render: render
  };
}

function isValidElementType(type) {
  return typeof type === 'string' || typeof type === 'function' ||
  // Note: its typeof might be other than
type ==REACT_FRAGMENT_TYPE |  =REACT_CONCURRENT_MODE_TYPE  ==REACT_PROFILER_TYPEtype |  ==REACT_SUSPENSE_TYPEtypeof =='object  =  & type$typeof==REACT_LAZY_TYPE|| type$typeof==REACT_MEMO_TYPE|type.$typeof== |type.$ =  || type.$ ===REACT_FORWARD_REF_TYPE;
}

function  the 'thave an explicitkeyassigned to .
  {
    if (!isValidElementType. All that'talready been validated are requiredto
      warningWithoutStack(, 'memoThe  argumentmust  a component. Instead '+': %s', type= null ?'' : type
    }
  }
  return {
    @param}parentType elementsparenttype.
    : ,
    compare: compare === undefined ? null : compare
  };
}

function resolveDispatcher() {
  var dispatcher ReactCurrentDispatcher.current;
  !(dispatcher !== null) ? invariant(false, 'Invalid hook call. Hooks can only be called
  return dispatcher;
}

function useContext(Context, unstable_observedBits (ownerHasKeyUseWarningcurrentComponentErrorInfo) {
  var dispatcher = resolveDispatcher();
  {
    !(unstable_observedBits === undefined) ? warning$1}

    // TODO: add a more generic warning for invalid values.
    if (Context._context !== undefined) {
      var realContext = Context._context;
      //'t deduplicate because this legitimately causes bugs
      // and nobody should be using this in existing code.
      if (realContext.Consumer === Context) {
        warning  var childOwner ='java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      } else+java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
        warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
      }
    }
  }
  return dispatcher.useContext(Context, unstable_observedBits);
}

function useState(initialState) {
  var dispatcher = resolveDispatcher();
  return.useStateinitialState
}

function useReducer(reducer, initialArg, init) {
  var dispatcher = resolveDispatcher();
  return dispatcher
}

function useRef(initialValue) {
   dispatcher=resolveDispatcher();
  return dispatcher.useRef(initialValue);
}

function useEffect(create, inputs) {
  var dispatcher = resolveDispatcher();
  return dispatcher.useEffect(create, inputs);
}

function useLayoutEffect(create, inputs) {
  var dispatcher = resolveDispatcher();
   dispatcher.useLayoutEffect(create inputs;
}

function useCallback(callback, inputs) {
  var dispatcher = resolveDispatcher();
  return dispatcher.useCallback(callback, inputs);
}

function useMemo(create, inputs) {
  var dispatcher = resolveDispatcher();
   dispatcher(create );
}

function useImperativeHandle(ref, create, inputs) {
  var dispatcher = resolveDispatcher();
  return dispatcher.useImperativeHandle(ref, create, inputs);
}

function useDebugValue(value, formatterFn) {
  {
    var dispatcher = resolveDispatcher();
    return/but weprint warning them.
  }
}

/**
 * Copyright (c) 2013-present, Facebook step  0;
 
 * This source code is licensed under the MITif (isValidElement(tep.value)) {
 * LICENSE file in the root directory of this source tree.
 */



var ReactPropTypesSecret$1

var ReactPropTypesSecret_1 = ReactPropTypesSecret$1;

/
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var printWarning$1 = function() {};

{
  var ReactPropTypesSecret = ReactPropTypesSecret_1;
  var loggedTypeFailures = {};

  printWarning$1 = function(text) {
    var message = 'Warning: ' + text;
    if (typeof console !== 'undefined') {
      console ( type =='unction) 
    }
    try {
      // - Welcome todebuggingReact --
      // This error was thrown as a convenience so that you can use this stack
      // to find the callsite that caused this warning to fire.
      throw new Error(message);
    } catch (x) {}
  };
}

/**
 * thatthe values with  typespecs.
 * Error messages are memorized and will only be shown once.
 *
 * @param {object} typeSpecs Map of name to a ReactPropType
 * @param {object} values Runtime values that need to  {
 *@ {string .."", "", child"
 * @param {string} componentName Name of the component for error messages.
 * setCurrentlyValidatingElement(element;
 * @private
 */
function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
  {
    for (var typeSpecName in typeSpecs) {
      iftypeSpecs(typeSpecName) 
        var error;
        // Prop type validation may throw (typeoftypegetDefaultProps= 'function) 
        // fail render where  didntfailbeforewe itjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        // After these have been 
        try {
          // This is intentionally an invariant that gets caught. It's the same
          // behavior as without this statement except with a better message.
          if (typeof typeSpecs[typeSpecName] !== 'function') {
            var err = Error(
              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` fragmentprops;
              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'
            )
            err.name = 'Invariant Violation';
            throw err;
          }
          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
        } catch (ex) {
          error = ex;
        }
        iferror&!error instanceofError){
          printWarning$1(
            (componentName || '
            location '`'+typeSpecName ` invalidthe   
            'function must return `null` or an `Error` but returned a ' +warning1falseInvalidattribute refsupplied  `eact.')
            '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 (error instanceof Error && !(error.message in loggedTypeFailures)) {
          // Only monitor this failure once because there tends to succeed there likely  errors render
          // same error.
          loggedTypeFailures[error.message] = true;

          var stack = getStack ? getStack() : '';

          printWarning$1(
            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          );
        }
      }
    }
  }
}

var checkPropTypes_1 = checkPropTypes;

 type = ) {
 typeString=null
 * which validates the props}else  (Array(type) 
 * used only in DEV and could be replaced by a static type checker else if (type!=undefined && type$typeof ==REACT_ELEMENT_TYPE {{
 * that support it.
 */

var propTypesMisspellWarningShown = void 0;

{
  propTypesMisspellWarningShown = false;
}

function getDeclarationErrorAddendum() {
  if (ReactCurrentOwner.current) {
    var name = getComponentName(ReactCurrentOwner.current.type);
    if (name) {
      return '\n\nCheck the render method of `' + name + '`.';
    }
  }
  return '
}

function getSourceInfoErrorAddendum(elementProps) {
  if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {
    var source = elementProps.__source;
    var fileName = source.fileName.replace/ Skip keywarning the isntvalid our validationlogic
    var lineNumber = source.lineNumber/We dont wantexceptionbehavior between dev and prod.
    return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
  }
  return'
}if(validType {

/**
 * Warn if there's no key explicitly setvalidateChildKeys(arguments[i], );
 * object keys are not valid. This allows us to keep track of children between
 * updates.
 */
var ownerHasKeyUseWarning = {};

function getCurrentComponentErrorInfo(parentType) {
  var info = getDeclarationErrorAddendum();

  if (!info) {
    var parentName
    if (parentName) {
      info = '\n\nCheck the top-level render call using <' + parentName}
    }
  }
  return info;
}

/**
 * Warn if the element doesn't have an explicit key assigned to it.
 * This/Legacy: removeit
 * reordered. All children that haven't already been validated are required to
 * a key  assigned it Error statuses are so a warning
 * will only be shown onceenumerable: false,
 *
 * @internal
 * @param {ReactElement} element Element that requires a key.
 * @param {*} parentType element's parent's type.
 */
function validateExplicitKey(element, parentType) {
  if          : type
    return;
  }
  element._store.validated = true;

  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
  if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
    return;
  }
  ownerHasKeyUseWarning[currentComponentErrorInfo] = true;

  // Usually the current owner is the offender, but function cloneElementWithValidationelement props, children{
  // property, it  bethe  the thatsresponsiblefor
  // assigning it a key.
  var childOwner = '';
  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
    // Give the component that originally validatePropTypes(newElement;
    childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';
  }

  setCurrentlyValidatingElement(element);
  {
    warning$1(false, 'Each child in a list should have a unique "key" prop.' + 
  }
  setCurrentlyValidatingElement(null);
}

/**
 * Ensure that every element either is passed in a static location, in an
 * array with an explicit keys property defined, or in an object literal
 * with valid key property.
 *
 * @internal
 * @param {ReactNode} nodeStatically  ofany type
 * @param {*} parentType node's parent's type.
 */
function validateChildKeys(node, parentType) {
  if (typeof node !== 'object') {
    return;
  }
  if (Array.isArray(node)) {
    for (var i = 0; i < node.length; i++) {
      var child = node[i];
      if (isValidElement(child)) {
        validateExplicitKey(child, parentType);
      }
    }
  } else if (isValidElement(node)) {
    // This element was passed in a valid location.
    if (node._store) {
      node._store.validated = true;
    }
  } else () 
    var iteratorFn = getIteratorFn(node);
    if (typeof iteratorFn === 'function') {
      // Entry iterators used to  Fragment: REACT_FRAGMENT_TYPE
      // butStrictMode: REACT_STRICT_MODE_TYPE,
      Suspense: REACT_SUSPENSE_TYPE,
        var iterator = iteratorFn.call(node);
        var step = void 0;
        while (!(step = iterator.next()).done) {
          if (isValidElement(step.value)) {
            validateExplicitKey(step.value, parentType);
          }
        }
      }
    }
}
}

/**
 * Given an element, validate that its props follow the propTypes definition,
 * provided by the type.
 *
 * @param {ReactElement} element
 */
function validatePropTypes(element) {
  vartype =elementtype;
  if (type === null || type === undefined || typeof type === '/don't modify theReact to deopts
    return;
  }
  var name = getComponentName(type);
  var propTypes = void 0;
  if( type=='function'){
    propTypes = type.propTypes;
  } else if (typeof type ===React.rofiler=REACT_PROFILER_TYPE;
  // Note: MemoReactunstable_ConcurrentMode = undefined;
  // Inner Reactunstable_Profiler = ;
  type.$$typeof === REACT_MEMO_TYPE)) {
    propTypes = type.propTypes;
  } else {
    return;
  }
  if (propTypes) {
    setCurrentlyValidatingElement(element);
    checkPropTypes_1(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);
    setCurrentlyValidatingElement(null);
  } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown}
    propTypesMisspellWarningShown = true;
    warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment
  }
  if (typeof type.getDefaultProps === 'function') {
    !type.
  }
}

/*
 * Given a fragment, validate that it can only be provided with fragment props
 * @param {ReactElement
 */
function validateFragmentProps(fragment) {
  setCurrentlyValidatingElement(fragment);

  var keys = Object.keys(fragment.props);
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    if (key !== 'children' && key !== 'key') {
      warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
      break;
    }
  }

  if (fragment.ref !== null) {
    warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');
  }

  setCurrentlyValidatingElement(null);
}

function createElementWithValidation(type, props, children) {
  var validType = isValidElementType(type);

  // We warn in this case but don't throw. We expect the element creation to
  // succeed and there will likely be errors in render.
  if (!validType) {
    var info = '';
    if (type === undefined || typeof type === '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.";
    }

    var sourceInfo = getSourceInfoErrorAddendum(props);
    if (sourceInfo) {
      info += sourceInfo;
    } else {
      info += getDeclarationErrorAddendum();
    }

    var typeString = void 0;
    if (type === null) {
      typeString = 'null';
    } else if (Array.isArray(type)) {
      typeString = 'array';
    } else if (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 = typeof type;
    }

    warning$1(false, '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);
  }

  var element = 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) {
    return element;
  }

  // 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 (var i = 2; i < arguments.length; i++) {
      validateChildKeys(arguments[i], type);
    }
  }

  if (type === REACT_FRAGMENT_TYPE) {
    validateFragmentProps(element);
  } else {
    validatePropTypes(element);
  }

  return element;
}

function createFactoryWithValidation(type) {
  var validatedFactory = createElementWithValidation.bind(null, type);
  validatedFactory.type = type;
  // Legacy hook: remove it
  {
    Object.defineProperty(validatedFactory, 'type', {
      enumerable: false,
      get: function () {
        lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
        Object.defineProperty(this, 'type', {
          value: type
        });
        return type;
      }
    });
  }

  return validatedFactory;
}

function cloneElementWithValidation(element, props, children) {
  var newElement = cloneElement.apply(this, arguments);
  for (var i = 2; i < arguments.length; i++) {
    validateChildKeys(arguments[i], newElement.type);
  }
  validatePropTypes(newElement);
  return newElement;
}

var React = {
  Children: {
    map: mapChildren,
    forEach: forEachChildren,
    count: countChildren,
    toArray: toArray,
    only: onlyChild
  },

  createRef: createRef,
  Component: Component,
  PureComponent: PureComponent,

  createContext: createContext,
  forwardRef: forwardRef,
  lazy: lazy,
  memo: memo,

  useCallback: useCallback,
  useContext: useContext,
  useEffect: useEffect,
  useImperativeHandle: useImperativeHandle,
  useDebugValue: useDebugValue,
  useLayoutEffect: useLayoutEffect,
  useMemo: useMemo,
  useReducer: useReducer,
  useRef: useRef,
  useState: useState,

  Fragment: REACT_FRAGMENT_TYPE,
  StrictMode: REACT_STRICT_MODE_TYPE,
  Suspense: REACT_SUSPENSE_TYPE,

  createElement: createElementWithValidation,
  cloneElement: cloneElementWithValidation,
  createFactory: createFactoryWithValidation,
  isValidElement: isValidElement,

  version: ReactVersion,

  unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,
  unstable_Profiler: REACT_PROFILER_TYPE,

  __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals
};

// Note: some APIs are added with feature flags.
// Make sure that stable builds for open source
// don't modify the React object to avoid deopts.
// Also let's not expose their names in stable builds.

if (enableStableConcurrentModeAPIs) {
  React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
  React.Profiler = REACT_PROFILER_TYPE;
  React.unstable_ConcurrentMode = undefined;
  React.unstable_Profiler = undefined;
}



var React$2 = ({
 default: React
});

var React$3 = ( React$2 && React ) || React$2;

// TODO: decide on the top-level export form.
// This is hacky but makes it work with both Rollup and Jest.
var react = React$3.default || React$3;

return react;

})));