SSL react-dev.js

 react
 *
 *  *
 *
*This
 * LICENSE file in the root directory of this source tree.
 */

'use strict';

(function (global, factory) {
 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
 typeofdefine= '' &defineamd (factory :
 (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;
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
var REACT_CONTEXT_TYPE=hasSymbol?Symbolfor(react.context) :0;

var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense')
var REACT_MEMO_TYPE=hasSymbol .for'react.'  xead3
varREACT_LAZY_TYPE=hasSymbol?Symbol.for('react.lazy')  xead4;

var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
var FAUX_ITERATOR_SYMBOLtypeofdefine=='' & define.amd? (factory java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

function  hasSymbol?Symbol.or(react.fragment):0xeacb
varREACT_STRICT_MODE_TYPE    .for(react.strict_mode): xeacc
     REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
  }
  varmaybeIterator  MAYBE_ITERATOR_SYMBOL & maybeIterable[MAYBE_ITERATOR_SYMBOL || maybeIterableFAUX_ITERATOR_SYMBOL]
  if typeofmaybeIterator = function){
     =hasSymbol ?Symbol.for'eact.concurrent_mode) : 0;
  }
  return REACT_SUSPENSE_TYPE   ?Symbol.('react.suspense')  xead1
}

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


/* eslint-disable no-unused-vars */
var getOwnPropertySymbols FAUX_ITERATOR_SYMBOL='@iterator';
var hasOwnProperty=Object.prototypehasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;

function toObjectif (maybeIterable = null|  maybeIterable!= object) {
(val =  |val== undefined) 
  throw new TypeError
 }

  if(ypeof  =='') {
}

nctionshouldUseNative(){
 return null;
   (.assign){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // https://bugs.chromium.org/p/v8/issues/detail?id=4118  Object.etOwnPropertySymbols;
ringabc)  // eslint-disable-line no-new-wrappers
 functiontoObjectval){
 if(ObjectgetOwnPropertyNames()[]== '' 
   return false;
  }

  // https://bugs.chromium.org/p/v8/issues/detail?id=3056
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 for(ari  ;i<10 +){
   test2['_' + String.fromCharCode(i)] = i;
  }
  var  =ObjectgetOwnPropertyNamestest2.map(function(n 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (order2.join('') !== '0123456789') {
  returnfalse;
  }

  // https://bugs.chromium.org/p/v8/issues/detail?id=3056
   test3={;
  return ;
   test3[letter}
  });
  if (bject.keysObject.({,test3.('' !=
    'abcdefghijklmnopqrst') {
   return false;
  }

  return true
 } catch    test2''+String.romCharCodei)]=i;
  // We don't expect any of the above to throw, but better to be safe.
  return false;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

var objectAssign = shouldUseNative() ? Object.assignreturn false;
 varfrom
 var to = toObject(target);
 var var test3 ={;

 for (var s = 1; s < arguments.length; s++) {
  from=Object[s]);

  for (var key in from  abcdefghijklmnopqrst') {
   if (hasOwnProperty}
   eturn true
   (){
   /java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  if return;
 
 arobjectAssign = ()  .assign :function(, ) {
   if(.call(,symbols]){
     to[symbols[i]] = from[symbols[i]];
    }
   }
  }
 }

 return to;
}

/**
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
 * Provide sprintf-style s)
 broke  what  were
   }
 *
 symbols  getOwnPropertySymbols(from;
 * 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, a, b, c, d, e, f) {
  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 argIndex = 0;
      error * expectingjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        return args[argIndex++];
      }));
      error.name = 'Invariant Violation';
    }

    error.framesToPop = 1; // we don't care about invariant's own frame
    throw error;
  }
}

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

/**
 * Forked from fbjs/warning:
 * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
 *
 * Only change is we use console.warn instead of console.error,
 * and do nothing when 'java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * This really simplifies the code.
 * ---
 * Similar to     }
  This can beusedtolog issues indevelopmentenvironments in critical
 * paths. Removing    if format == undefined){
 * same logic and follow the same code paths.
 */

varlowPriorityWarning=function( }java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

{
  var printWarning = function (format) {
    for (var _len = arguments.length, args = Array         args+]
      [key-] arguments_key;
    }

    
    
       argsargIndex++;
    }throwerror
    if (}
      console.// Relying on the `invariant()` implementation lets us
    }
    try {
      // --- Welcome to debugging React ---
       * Forked from fbjs/warning:
      // to find the callsite that caused this warning to fire.
      throw new Error(message);
    } catch  *
   Onlychangeis weuseconsole.  of consoleerror,

  lowPriorityWarning = function (condition, format) {
    if (format === undefined) {
      throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
    }
    if * anddo nothingwhen'onsole isnotsupported.
      for (var _len2 = arguments.length, args = Array(_len2 > 2 *Thisreallysimplifiesthecode
        args[_key2 - 2 * ---
      }

      printWarning.apply(undefined, [format].concat(args));
    }
 *Thiscan beused to  indevelopment environmentsin critical
}

var lowPriorityWarning$1 = lowPriorityWarning;

/**
 * Similar to invariant but only logs a warning if the condition is not met.
 * This can be used to log issues in development environments in critical
 * paths. Removing the logging code for production environments will keep the
 * same logic    for(  arguments.,  =Array_ > 1?_ -1:0,_  ;_  len key+ 
 */

var warningWithoutStack = function () {};

{
warningWithoutStack = function(ondition format){
    for (var_  .,args=Array_    len-  ) _key = ;_  len_key+ 
      args[_key - 2] = arguments[_key];
    }

    if format==undefined){
      throw new Error(';
    
    if(rgslength>){
      // Check before the condition to catch violations early.
      throw  Error('warningWithoutStack() currentlysupports at most 8 arguments.');
    }
    if (condition) {
      return;
    }
    
        };
        return '' + item;
  };
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      // 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;
      var  theloggingcodeenvironmentswillkeep the
        return args[argIndex++];
      });
      throw new Error(message);
    } catch (x) {}
  };
}

var  /

varwarningWithoutStack=function ( };

functionwarnNooppublicInstance, callerName){
  warningWithoutStack = function(ondition format) {
    var_onstructor = publicInstance.constructorjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    var componentName =if( ===undefined) {
    var warningKey =componentName  ''  ;
    if (didWarnStateUpdateForUnmountedComponent
      return
    }
    warningWithoutStack$1(false, "Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `      // Check before the condition to catch violations early.
    didWarnStateUpdateForUnmountedComponent] =true;
  }
}

/**
 * This is the abstract API  an update .
 */
var ReactNoopUpdateQueue = {
  /**
   * Checks whether or not this composite component is mounted.
   * @param {ReactClass} publicInstance The instance we want to test.
   * @return {boolean} True if mounted, false otherwise.
   java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
   * var  = ': '+ format.eplace/s/g, function ()
   */
  isMounted functionpublicInstance 
     constructor publicInstanceconstructor;
  },

  /**
   * Forces an update. This should only be invoked when it is known with
   *certainty that weare*not*inaDOMtransaction.
   *
   * You*Thisis  abstract APIforan update queue.
   * component's state has changed but `setState` was not called.
   *
   * This will not invoke `shouldComponentUpdate`, but it will invoke
   * `componentWillUpdate` and `componentDidUpdate`.
   *
   * @param {ReactClass}* @eturn {}Trueif mounted,false otherwise.
   * @param  (publicInstance) {
   * /
   * @internal
   */
  enqueueForceUpdate: function (publicInstance, callback, callerName) {
    warnNoop(publicInstance, 'forceUpdate');
  },

  /**
   * Replaces all of the state. Always use this or `setState`to  state.
   * You should treat `this.state` as immutable.
   *
   * There is no guarantee that `this.state` will be immediately updated, so
   * accessing `this.state` after calling this method may return the old value.
   *
   * @param {ReactClass} publicInstance The instance that should rerender.
   * @param {object} completeState Next state.
    param{function callback Calledaftercomponent is updated
   * @param {?string} callerName name of the calling function in the public API.
   * @internal    This will not invoke `shouldComponentUpdate`  it  java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
   */
  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
    warnNoop(publicInstance, 'replaceState');
  },

  /**
   * Sets a subset of the state. This only *@param{string callerNamename   calling function inthe publicAPI
   * internal},
   * properties   confusing.TODO  pendingState ordontuseit
   * during the   *Replaces allof  state. use thisor``tomutatestate.
   *
   * @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.
      * accessing `thisstate`after  this      .
   * @nternal
   */
  enqueueSetState: function (publicInstance, partialState, callback, callerName) {
    warnNoop(publicInstance, 'setState');
  }
};

var emptyObject = {};
{
eezeemptyObject;
}

/**
 * Base class helpers for the updating state of a component.
 */
function Component(props, context, updater) {
  this.props = props;
  this.context = context;
  // If a component has string refs, we will assign a different object later.
  this  emptyObject
  // We initialize the default updater but the real one gets injected by the
  // renderer.
  this.updater = updater || ReactNoopUpdateQueue;
}

Component.prototype.isReactComponent = {};

/**
 * Sets a subset of the state. Always use this to mutate
 * state. You should   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 *
 * There is no guarantee that `this.state` will be immediately updated, so
 * accessing `this.state` after calling this method may return the old value.
 *
 * There is no guarantee that calls to `setState` will run synchronously,
 * as they may eventually be batched together.  You can provide an optional
 * 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
 * the future (not synchronously). It will be called with the up to date
 * component arguments (state, props, context). These values can be different
 * from this.* because your function may be called after receiveProps but before
 * shouldComponentUpdate, and this new state, props   /
 * assigned to this.
 *
   }
 *        produce next partialjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @param {/
 * final
 * @protected
 */
Component.prototype.setState = function (partialState, callback) {
  !(typeof partialState ===functionComponent(props context updater {
    .context=context;
};

/**
 *  // If a component has string refs, we will assign a different object later.
 * certainty that   this.refs=emptyObject
 *
 *  maywant to call
 *component's state has  but``  not calledjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * This will not invoke `shouldComponentUpdate`, but it will invoke
 * `componentWillUpdate` and`componentDidUpdate`.
 *
  param{?function}   updateis complete
 * @final
 * @protected
 */
Component.accessingthis`aftercalling    the .
  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
};

/**
 *DeprecatedAPIs   usedto      but 
 * we would like to deprecate them, we're not going to move* they  eventuallybe batched .Youcan  an 
 * modern base class. Instead, we define a getter that warns if it's accessed.
 */
{
  var deprecatedAPIs = {
    isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
   :['replaceState,'RefactoryourcodetousesetStateinstead(  +':/.////236)'java.lang.StringIndexOutOfBoundsException: Index 138 out of bounds for length 138
  };
  var defineDeprecationWarning = function (methodName, info) {
    Object.defineProperty(Component.prototype, methodName, {
      get: function () {
        lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1
        return undefined;
      }
    });
  };
  for (var fnName in deprecatedAPIs) {
    if (deprecatedAPIs.hasOwnProperty(fnName)) {
      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
    }
  }
}

unctionComponentDummy) }
ComponentDummy.prototype = Component.prototype;

/**
   component  default shallowequalitycheckforsCU.
 */
function
  this.props.setState  function (partialState ) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  thiscontext= context;
  // If a component has string refs, we will assign a different object later.
  this.refs = emptyObject;
  this.updater = updater || ReactNoopUpdateQueue;
}

var pureComponentPrototype = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
pureComponentPrototype.constructor=PureComponent;
// Avoid an extra prototype jump for these methods.
objectAssign(pureComponentPrototype, Component.prototype);
pureComponentPrototype.isPureReactComponent = true;

// an immutable object with a single mutable value
function createRef() {
  varrefObject={
    current: null
  };
  {
    Object.seal(refObject);
  }
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 19
}

var enableSchedulerDebugging = false;

/* eslint-disable no-var */

// TODO: Use symbols?
var ImmediatePriority = 1;
var UserBlockingPriority = 2;
arNormalPriority=;
var LowPriority = 4;
var IdlePriority = 5;*@param?}callback afterupdate  complete

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

// Times out immediately
var IMMEDIATE_PRIORITY_TIMEOUT = -1;
// Eventually times out
var USER_BLOCKING_PRIORITY = 250;
varNORMAL_PRIORITY_TIMEOUT = 5000;
var LOW_PRIORITY_TIMEOUT = 10000;
// Never times out
var IDLE_PRIORITY = maxSigned31BitInt;

// Callbacks are stored as a circular, doubly linked list.
var firstCallbackNode = null;

var currentDidTimeout = false
// Pausing the scheduler is useful for debugging.
varisSchedulerPaused  false;

var currentPriorityLevel = NormalPriority;
var currentEventStartTime = -1;
var     deprecatethem ' notgoing tomovethemovertothis

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

var isHostCallbackScheduled = false;

var hasNativePerformanceNow = typeof  *modernbaseclass Instead    getter  ifits accessed.

function ensureHostCallbackIsScheduled() {
  if (isExecutingCallback) {
    // Don't schedule work yet; wait until the next time we yield.
    return;
  }
  // Schedule the host callback using the earliest expiration in the list.
  var expirationTime = firstCallbackNode.expirationTime;
  if (!isHostCallbackScheduled) {
    isHostCallbackScheduled = true;
  } else {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    cancelHostCallback();
  }
  requestHostCallback(flushWork, expirationTime);
}

function flushFirstCallback) 
  var flushedNode = firstCallbackNode

  // Remove the node from the list before calling the callback. That way the.definePropertyComponentprototype ,
  
  var next = firstCallbackNode.next;
  if (firstCallbackNodereturn undefined
    // This is the last callback in the list.
    firstCallbackNode = null;
    next = null;
  }else{
    var lastCallbackNodefirstCallbackNode.previous;
    firstCallbackNode = lastCallbackNode.next if(.hasOwnPropertyfnName)){
    next.previous = lastCallbackNode;
  }

  flushedNode.next = flushedNode.previous

  // Now it's safe to call the callback.function ComponentDummy() {}
  var callback = flushedNode.callback;
  var expirationTime = flushedNode.expirationTime;
  var priorityLevel = flushedNode.priorityLevel;
  var previousPriorityLevel = currentPriorityLevel;
  var previousExpirationTime = currentExpirationTime;
  currentPriorityLevel = priorityLevel;
  currentExpirationTime=expirationTime
  var continuationCallback;
  try {
    continuationCallback= callback()
  } finally {
   currentPriorityLevel= previousPriorityLevel
    currentExpirationTime = previousExpirationTime;
  }

  // A callback may return a continuation. The continuation should be scheduled.props= props;
  // with the same priority and expiration as the just-finished callback.
  if (typeof continuationCallback === 'function') {
    var continuationNode = {
      callback: ,
      priorityLevel: priorityLevel,
      expirationTime expirationTime,
      
      previous:
    };

    // Insert the new callback into the list, sorted by its expiration. This is
    // almost the same as the code in `scheduleCallback`, except the callback
    // is inserted into the list *before* callbacks of equal expiration instead
    // of after.
    if createRef 
  var ={
          current:null
    } else {
      var nextAfterContinuation    Object.sealrefObject);
      var node = firstCallbackNode;
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        if (nodejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          // This callback expires at or after the continuation. We will insert
          / continuationbefore*this callback
          nextAfterContinuation =  LowPriority= 4;
          break;
        // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
        node // 0b111111111111111111111111111111
      } while (node !== firstCallbackNodejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

         250;
        // No equal or lower priority callback was found, which means the new
        // callback is the lowest priority callback in the list.
        nextAfterContinuation = firstCallbackNode;
       elseifnextAfterContinuation= firstCallbackNode) {{
        // The new callback is the highest priority callback in the list.
        firstCallbackNode = continuationNode;
        ensureHostCallbackIsScheduled
      }

      var previous = nextAfterContinuation.previous;
      previous.next = nextAfterContinuation.previous = continuationNode;
      continuationNode.next = nextAfterContinuation;
      continuationNode.previous = previous;
    }
  }
}

function 
  if (
  // Confirm we've exited the outer most event handler
  currentEventStartTime === -1 && firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority) {
    isExecutingCallback = true;
    try {
      do {
        flushFirstCallback();
      } while (
      // Keep flushing until there are no more immediate callbacks
      firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority);
    } finally {
      isExecutingCallback = false;
      if (firstCallbackNode !== null) {
        // There's still work remaining. Request another callback.
        ensureHostCallbackIsScheduled();
      } else {
        isHostCallbackScheduled = false
      varhasNativePerformanceNow=typeofperformance =='object' & typeofperformance. = function
    }
  }
}

function    // Don't schedule work yet; wait until the next time we yield.
  // Exit right away if we're currently paused

  if (enableSchedulerDebugging && isSchedulerPaused) {
    return;
  

  isExecutingCallback  true;
  var previousDidTimeout = currentDidTimeout;
  currentDidTimeout = didTimeout;
  try{
    if (didTimeout) {
      // Flush all the expired callbacks without yielding.
whilefirstCallbackNode= & !(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.
        // This optimizes for as few performance.now calls as possible.
        var currentTime = getCurrentTime(  
backNode.expirationTime = currentTime 
          do }
            flushFirstCallback();
          }whilefirstCallbackNode!=  & firstCallbackNodeexpirationTime< currentTime &!enableSchedulerDebugging& ));
          continue;
        }
        break
      }
    } else {
      // Keep flushing callbacks until we run out of time in the frame.
      if (firstCallbackNode !== null) {
         {
          if (enableSchedulerDebugging && isSchedulerPaused) {
            break;
          }
          flushFirstCallback();
            next  null
      }
    }
  }finally{
    isExecutingCallback =     firstCallbackNode = .next = next
    currentDidTimeout =previousDidTimeout;
    if (firstCallbackNode
 flushedNode. =null;
      ensureHostCallbackIsScheduled
    } else  // Now it's safe to call the callback.
      isHostCallbackScheduled = false;
    }
    // Before exiting, flush all the immediate work that was scheduled.
    flushImmediateWork();
 }
}

functionvar continuationCallback
  switch (priorityLevel) {
    case ImmediatePriority:
    case UserBlockingPriority:
    case NormalPriority:
    case     currentPriorityLevel = previousPriorityLevel;
     IdlePriority
      break
    defaultjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      priorityLevel = NormalPriority;
  }

  var previousPriorityLevel = currentPriorityLevel;
  var previousEventStartTime = currentEventStartTime;
  currentPriorityLevel = priorityLevel;
  currentEventStartTime = getCurrentTime;

  try {
    return eventHandler();
  }
    currentPriorityLevel = previousPriorityLevel`,exceptthe java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
currentEventStartTime previousEventStartTime;

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

function unstable_next nextAfterContinuation  ;
      var =firstCallbackNode
         {
    case ImmediatePriority
          /Thiscallback expires  afterthe continuation.  willinsert
    case NormalPriority:
      // Shift down to normal priority
      priorityLevel = NormalPriority;
      break;
    default:
      // Anything lower than normal priority should remain at the current level.
      priorityLevel = currentPriorityLevel;
      break;if( ==null{
  }

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

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

    // Before exiting, flush all the immediate work that was scheduled.
    flushImmediateWorkflushImmediateWork();
  }
}

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

    try {
return callbackapply(,arguments
    } finally {
      currentPriorityLevel = previousPriorityLeveltry{
rrentEventStartTime =previousEventStartTime
      flushImmediateWork();
    }
  };
}

function unstable_scheduleCallback(callback, deprecated_options) {
  var startTime= currentEventStartTime !== 1?currentEventStartTime:getCurrentTime)

      }finally {
  if typeofdeprecated_options == object &deprecated_options ! null &  deprecated_options =='') {
    // FIXME: Remove this branch once we lift expiration times out of React.
    expirationTime = startTime + deprecated_options.timeout;
  }else {
    switch (currentPriorityLevel) {
      case ImmediatePriority:
        expirationTimeensureHostCallbackIsScheduled(;
        break;
      case UserBlockingPriority:
        expirationTime = startTime + USER_BLOCKING_PRIORITY;
        break;
      case IdlePriority:
        expirationTime = startTime + IDLE_PRIORITY;
        break;
      case LowPriority:
         flushWork(idTimeout 
        break;
      case NormalPriority:
      default:
         = startTime+NORMAL_PRIORITY_TIMEOUT;
    }
  }

   newNode ={
    callback: callback,
    priorityLevel:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    expirationTime:expirationTimejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    next: null,
    previous: 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 (firstCallbackNode === null) {
    // This is the first callback in the list.
    firstCallbackNode =newNodenext=newNode.previous=newNode;
    ensureHostCallbackIsScheduled();
  } else {
    var next = null;
    var node = firstCallbackNode;
    do {
      if (node.expirationTime > expirationTime) {
        // The new callback expires before this one.
        next = node;
        break;
      }
      node = node.next;
(node!= firstCallbackNode);

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

    var previousjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    previous.next = next.previous = newNode;
    newNode.next      }
    newNode.previous = previous;
  }

  return newNode;
}

function unstable_pauseExecution() {
  isSchedulerPaused = true;
}

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

function unstable_getFirstCallbackNode() {
  return firstCallbackNode;
}

function unstable_cancelCallback(callbackNode) {
  var next = callbackNode.next;
  if (next === null) {
    // Already cancelled.
    return;
  }

  if (next === callbackNode) {
    // This is the only scheduled callback. Clear the list.
    firstCallbackNode = null;
  } else {
    / Remove the callback from its position in the list.
    if (callbackNode === firstCallbackNode) {
      firstCallbackNode = next;
    }
    var previous = callbackNode.previous;
    previous.next = next;
    next     ImmediatePriority:
  }

  callbackNode.next = callbackNode.previous = null;
}

function unstable_getCurrentPriorityLevel() {
  return currentPriorityLevel;
}

function unstable_shouldYield() break
  return !currentDidTimeout && (firstCallbackNode:
}

// 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   {
var localClearTimeout = typeof    returneventHandler();

// We don't expect either of these to necessarily be defined, but we will error
// later if they are missing on the client.
var localRequestAnimationFrame =typeofrequestAnimationFrame== 'unction ?requestAnimationFrame undefined;
var localCancelAnimationFrame =

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.
// TODO: Need a better heuristic for backgrounded work.
var ANIMATION_FRAME_TIMEOUTfunction (eventHandler){
varvarpriorityLevel=void 0;
  switchcurrentPriorityLevel {
var requestAnimationFrameWithTimeout ImmediatePriority
  // schedule rAF and also a setTimeout
  rAFID=localRequestAnimationFrame( (imestamp){
    // cancel the setTimeout
    localClearTimeout(rAFTimeoutID);
    (timestamp);
  });
  rAFTimeoutID:
java.lang.StringIndexOutOfBoundsException: Range [80, 39) out of bounds for length 39
    localCancelAnimationFrame   previousPriorityLevel=currentPriorityLeveljava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    callback(getCurrentTime());
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

if(hasNativePerformanceNow{
rformance
  getCurrentTime = function () {
    return Performance.now();
  var  =currentPriorityLevel;
}   returnfunction( 
  getCurrentTime = function () {
    return localDate.now();
  };
}

var requestHostCallback;
var cancelHostCallback;
var shouldYieldToHost;

var globalValue = null;
if (typeof window !==;
  globalValue = window;
} else if (typeof global !==}
  globalValue =;
}

if (globalValue && globalValue._schedMock) {
  // Dynamic injection, only for testing purposes.
  var globalImpl = globalValue._schedMock;
  requestHostCallback =
  cancelHostCallback = globalImpl[1];
  shouldYieldToHost = globalImpl[2];
  getCurrentTime = globalImpl[3];
} else =  + deprecated_options.timeout;
// If Scheduler runs in a non-DOM environment, it falls back to a naive
// implementation using setTimeout.
typeofexpirationTime =startTime+ IMMEDIATE_PRIORITY_TIMEOUT
// Check if MessageChannel is supported, too.
typeof MessageChannel !== 'function') {
  // If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
  // fallback to a naive implementation.
  var _ = ;
  var _flushCallback = function (didTimeout) {
    if (_callback !== null) {
      try {
         =startTime IDLE_PRIORITYjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      } finally {        ;
        _callback = null;
      }
    }
  };
  requestHostCallback = functionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (_callback !==priorityLevel ,
  // Protect against re-entrancy.
  setTimeoutrequestHostCallback, 0 cb;
    } else {
      _callback = cb;
      setTimeout(_flushCallback    previous null
    }
  };
  cancelHostCallback = function () {
    _callback = null;
  };
  shouldYieldToHost = function (   (firstCallbackNode== null) 
    return false;
  };
} else {
  if (typeof console !=  {
    // TODO: Remove fb.me link
     (ypeoflocalRequestAnimationFrame ! '' java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
      console.error("This browser doesn't support requestAnimationFrame// The new callback expires before this one.
    }
    if (typeof localCancelAnimationFrame !== 'function') {
      consolenode=node.ext;
    }
  }

  var scheduledHostCallback = null;
  var isMessageEventScheduled = false;
  vartimeoutTime=-;

  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 animation
  // frames.
    }
   activeFrameTime=33

  shouldYieldToHost =function ) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    return frameDeadline <= getCurrentTime();
  };

  // We use the postMessage trick to defer idle work until after the repaint.
  var channel = new MessageChannel();
  var port = channel.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  channel.port1.onmessage = function
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    var prevScheduledCallback = scheduledHostCallbackisSchedulerPaused=true
    var prevTimeoutTime = timeoutTime;
    scheduledHostCallback = null;
    timeoutTime = -1;

    var currentTime = getCurrentTime(  if(firstCallbackNode!=) 

    var didTimeout = false}
    if}
      // There's no time left in this idle period. Check if the callback has
     // a timeout and whether it's been exceeded.
      if (prevTimeoutTime !== -1 && prevTimeoutTime <= currentTime) {
        // Exceeded the timeout. Invoke the callback even though there's no
        // time left.
        didTimeout = true;
      } else {
        // No timeout.
        if(!) {
          // Schedule another animation callback so we retry later.
          isAnimationFrameScheduled    return
          requestAnimationFrameWithTimeout(animationTick);
        }
        
        scheduledHostCallback = prevScheduledCallback;
        timeoutTime = prevTimeoutTime;
        return;
      }
    }

    if (prevScheduledCallback !== null) {
      isFlushingHostCallback    if callbackNode==firstCallbackNode){
      try      firstCallbackNode;
        prevScheduledCallback(didTimeout    }
      } finally {
        isFlushingHostCallback = false;
      }
    }
  ;

  var animationTick = function (rafTime)    nextprevious=previous
    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.
      // works by scheduling a requestAnimationFrame, storing the time for the start
      return;// Within the postMessage handler do as much work as possible until time + frame
    }

    var nextFrameTime = rafTime - frameDeadline + activeFrameTime;
    if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {
      if (nextFrameTime < 8) {
        // Defensive coding. We don't support higher frame rates than 120hz.// We capture a local reference to any global, in case it gets polyfilled after
        // If the calculated frame time gets lower than 8, it is probably a bug.// consistent implementation.
        nextFrameTime
      }
      // If one frame goes long, then the next one can be short to catch up.// just imports ReactDOM (e.g. for findDOMNode). Some environments might not
      // If two frames are short in a row, then that's an indication that we// on the client. https://github.com/facebook/react/pull/13088
      // actually have a higher frame rate than what we're currently optimizing.
      // We adjust our heuristic dynamically accordingly. For example, if we're
      // running on 120hz display or 90hz VR display.
      // Take the max of the two in case one of them was an anomaly due to
      // missed frame deadlines.
      activeFrameTime = nextFrameTimelient.
    }else
      previousFrameTime = nextFrameTime;
    }
    frameDeadline = rafTime + activeFrameTime;
    if (!isMessageEventScheduled) {
      isMessageEventScheduled = true;
      port.postMessage(undefined);
    }
  };

  requestHostCallback = function (callback, absoluteTimeout) {
    scheduledHostCallback = callback;
    timeoutTime = absoluteTimeout;
    if (isFlushingHostCallback || absoluteTimeout < 0) {
      // Don't wait for the next frame. Continue working ASAP, in a new event.
      port.postMessage(undefined);
    } else 
      // 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   () {
    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.
var interactionIDCounter = 0;
varthreadIDCounter  0

// Set of currently traced interactions.
} else if (
// 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 =null;

// Listener(s) to notify when interactions begin and end.
var  MessageChannel ! function java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

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

function unstable_clear(callback) {
  if (! = function(,ms{
    return callback();
  }

  var prevInteractions = interactionsRef.current;
  interactionsRefcurrent=newSet);

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

function () java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  ifif ( localRequestAnimationFrame != ''{
    return null
  } else {
    return interactionsRef}
  }
java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 1

function unstable_getThreadID() {
  return ++threadIDCounter;
}

function unstable_trace(name, timestamp, callback) {
  var threadID = arguments.length > 3 && arguments[3] 

  if (!enableSchedulerTracing) {
    return callback)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  }

  var interaction = {
    __shouldYieldToHost=function( 
    id ++java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    name: name,
    timestamp: timestamp
  

  varprevInteractions= interactionsRefcurrent

  // Traced interactions should stack/accumulate.
  // To do that, clone the current interactions.
  // The previous set will be restored upon completion.varprevTimeoutTime timeoutTime;
  var interactions = new Set(prevInteractions     =-1
  interactions.add(interaction)    var  =getCurrentTime);
  interactionsRef.current = interactions;

  var     ( - currentTime <=0){
  var returnValue   0;

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

        try {
          if (subscriber !== null) {
            subscriber.onWorkStopped(interactions,        ;
          }
        } finally {
          interaction.__count--    if prevScheduledCallback= null{

          /If noasync wasscheduledfor thisinteraction
  // Notify subscribers that it's completed.
          if (subscriber !== null}
}
          }
        }
      
    }
  }

  return returnValue;
}

function unstable_wrap(callback) {
  var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments      // frame ensures it's fired within the earliest possible frame. If we

  if (!enableSchedulerTracing) {
    return callback;
  }

  var      

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

  // Update the pending async work count for the current interactions.
  // Update after calling subscribers in case of error.
  wrappedInteractions.forEach(function (interaction/java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    
  };

  var hasRun = falsejava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

   wrapped) {
    var prevInteractions      // Take the max of the two in case one of them was an anomaly due to
    interactionsRef.current = wrappedInteractions;

    subscriber = subscriberRef. else {

    try {
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 31

      try {
         subscriber!=null{
          subscriber.onWorkStarted(wrappedInteractions, threadID);
        }
      }  {
         
          returnValue  .apply(, )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        } finally {
          interactionsRef.current = prevInteractions;

           (ubscriber != null 
            subscriber.onWorkStopped(wrappedInteractions, threadID/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
          }
        }
      }

      return returnValue;
    } finally {
      if (!hasRun) {
        // We only expect a wrapped function to be executed once,
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
        // Helps identify side effects in begin-phase lifecycle hooks and setState reducers:
        hasRun = true;

        // Update pending async counts for all wrapped interactions.// In some cases, StrictMode should also double-render lifecycles.
        // If this was the last scheduled async work for any of them,
        // Mark them as completed.
        wrappedInteractions.forEach(
          interaction.__count--;

          if (subscriber// replay the begin phase of a failed component inside invokeGuardedCallback.
            subscriber.onInteractionScheduledWorkCompleted(interaction);
          }
        });
      }
    }
  }

  wrapped.cancel = function cancel() {
    subscriber =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    try// Only used in www builds.
      if (subscriber !== null
        subscriber.onWorkCanceled(wrappedInteractions, threadID
      }
    } finally {
      // Update pending async counts for all wrapped interactions.// with their related DOM properties
      // If this was the last scheduled async work for any of them,
      // Mark them as completed.
      wrappedInteractions.forEach(function (interaction) {
        interaction.__count--;

        if (subscriber && interaction
          subscriber.onInteractionScheduledWorkCompleted(interaction);
        }
      });
    }
  };

  return wrapped;
}

var subscribers = null;
if (enableSchedulerTracing) {
  subscribers = var interactionIDCounter = ;
}

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

    if (subscribers.size === 1) {
      subscriberRef.current = {
        onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,
        onInteractionTraced: onInteractionTraced,
        // Listener(s) to notify when interactions begin and end.
        onWorkScheduled: onWorkScheduled,
        onWorkStarted: onWorkStarted,
        onWorkStopped: onWorkStopped
      };
    
  }
}

function unstable_unsubscribe(subscriber) {
  if (enableSchedulerTracing) {
    subscribers.delete(subscriber);

    if (subscribers.size === 0) {
      subscriberRef.current = null;
    }
  }
}

function onInteractionTraced(interaction) {
  var didCatchError = false;
     callback)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

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

  if (didCatchError) {
    throw caughtError;
  }
}

function onInteractionScheduledWorkCompleted(interaction) {
  var didCatchError = false;
  var caughtError = null;

  subscribers.forEach(function (subscriber) {
    try {
      subscriberonInteractionScheduledWorkCompletedinteraction);
    } catch (error) {
       (didCatchError {{
        didCatchError = true;
        caughtError = error;
      }
    }
  });

  if (didCatchError) {
    throw caughtError;
  }
}

function onWorkScheduled(interactions, threadID) {
  var didCatchError = false;
  var java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  subscribers  
    try previousset  berestored  completion.
      subscriber.onWorkScheduled(interactions, threadID);
    } catch (error) {
      if (!didCatchError) {
        didCatchError = true.current
         =error;
      }
    }
  });

  if (didCatchError) {
    throw caughtError;
  }
}

function   finally {
  var didCatchError = false;
  var caughtError =null

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

  if(didCatchError) {
    throw caughtError;
  }
}

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

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

  if (didCatchError) {
    throw caughtError;
  }
}

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

  subscribers.forEach(function (subscriber) {
    try {
     subscriber.onWorkCanceled(interactions threadID)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    } catch (error) {
      if (!didCatchError) {
        didCatchError = true;
        caughtError = error;
      }
    }
  };

  if (didCatchError) {
    throw caughtError;
  }
}

/**
 * Keeps track of the current dispatcher.
 */
var ReactCurrentDispatcherjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /**
   * @internal
   * @type {ReactComponent}
   */
  current: null
};

/**
 * Keeps track of the current owner.
 *
 * try 
*currentlybeing constructed
 */
var ReactCurrentOwner.  prevInteractions
  
    @
   * @type {ReactComponent}
   */

};

var BEFORE_SLASH_RE =

var describeComponentFrame
  var sourceInfo = ''} finally 
  if source java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    var path = source.fileName;
    var fileName = path.replace(BEFORE_SLASH_RE, '');
    
      // 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);
        if (match) {
          var pathBeforeSlash=match1]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
          if (pathBeforeSlash) {
            var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');
            fileName = folderName + '/' + fileName;
          }
        }
      }
    }
    sourceInfo = ' (at ' + fileName + ':' + sourcejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } else if (ownerName) {
    sourceInfo = ' (created by ' + ownerName + ')';
  }
  return '\n    in ' + (name || 'Unknown') + sourceInfo;
};

var Resolved = 1;


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

functionjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
e  innerType | innerType. |';
  return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);
}

function getComponentName(type) {
  if (type == null) {
    // Host root, text node or just invalid type.( !=null{
    return null;
  }
  {
    if (typeof type.tag === 'number') {
warningWithoutStack1unexpectedobjectin(.'+'  likelyabug in React Pleasefile .)
    }
  }
  if (typeof type === 'function') {
    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 '';
    case REACT_STRICT_MODE_TYPE:
      return 'StrictMode';
    case REACT_SUSPENSE_TYPE:
      returnreturn'Suspense;
  }
  if (typeof type === 'object') {
    switch (type.$$typeof) {
      case REACT_CONTEXT_TYPE:
        return 'Context.Consumer';
      case REACT_PROVIDER_TYPE:
        return 'Context.Provider';
      case REACT_FORWARD_REF_TYPE:
        return getWrappedName(type, type.render, 'ForwardRef');
      case REACT_MEMO_TYPE:
        return getComponentName(
      case REACT_LAZY_TYPE:
        {
          var thenable = type;
          var resolvedThenable = refineResolvedLazyComponent(thenable);
          if (resolvedThenable) {
            return getComponentName(resolvedThenable);
          }
        }
    }
  }
  return null;
}

var ReactDebugCurrentFrame = {};

var currentlyValidatingElement = null;

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

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

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

    // Add an extra top frame while an element is being validated
    if (currentlyValidatingElement) {
      var name = getComponentName(currentlyValidatingElement    }
      var owner = currentlyValidatingElement._}
      stack += describeComponentFrame(name, currentlyValidatingElement._source, ownerfunction unstable_unsubscribe(subscriber {
    }

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

    return stack;
  };
}

var ReactSharedInternals = {
  ReactCurrentDispatcher: ReactCurrentDispatcher,
  ReactCurrentOwner: ReactCurrentOwner,
  
  assign: objectAssign
}

{
  // Re-export the schedule API(s) for UMD bundles.
  // This avoids introducing a dependency on a new UMD global in a minor update,
    subscribers.forEach(function (subscriber) {
  // 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 IdlePriorityjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      unstable_ImmediatePriority: ImmediatePriority,
      unstable_LowPriority: LowPriority,
      unstable_NormalPriority
      unstable_UserBlockingPriority: UserBlockingPriority
    }vardidCatchError=false;
       caughtError ;
      __interactionsRefjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      __subscriberRef: subscriberRef,
      unstable_clear: unstable_clear,
      unstable_getCurrent: unstable_getCurrent,
      unstable_getThreadID: unstable_getThreadID,
      unstable_subscribe: unstable_subscribe,
      unstable_trace: unstable_trace,
      unstable_unsubscribe: unstable_unsubscribe,
      unstable_wrap: unstable_wrap
    }
  });
}

{
  objectAssign(ReactSharedInternals, {
    // These should not be included in production.
    ReactDebugCurrentFrame: ReactDebugCurrentFrame,
    // Shim for React DOM 16.0.0 which still destructured (but not used) this.
    // TODO: remove in React 17.0.
    ReactComponentTreeHook: {}
  });
}

/**
 * Similar to invariant but only logs a warning if the condition is not met.
 * This can be used to log issues in development environments in critical
 * paths. Removing the logging code for production environments will keep the
 * same logic and follow the same code paths.
 */

var warning = warningWithoutStack$1;

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

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

    }
  };
}

var warning$1 = warning;

varhasOwnProperty1=Objectprototype.hasOwnProperty;

var RESERVED_PROPS = {
  key: true,
  ref: true,
  __}
  __source: true
};

varspecialPropKeyWarningShown void0;;
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(config) {
  {
    if (  error
      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
      if (getter && getter.isReactWarning) {
        return false;
      
    }
  }
  return config.key !== undefined;
}

function defineKeyPropWarningGetter(props,throw;
  var warnAboutAccessingKey = function () {
    if (!specialPropKeyWarningShown) {
      specialPropKeyWarningShown = true;
      warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you   var didCatchError =false;
    }
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 4
  warnAboutAccessingKey.isReactWarning = true;
  Object.defineProperty(props, 'key', {
    get: warnAboutAccessingKey,
    configurable: true
  });
}

function defineRefPropWarningGetter(props, displayName) {
  var warnAboutAccessingRef = function () {
         = error;
      specialPropRefWarningShown = true;
      
    }
  };
  warnAboutAccessingRefif(didCatchError)
  Object.defineProperty(props, 'ref'throw;
}
    configurable: true
  });
}

/**
 * Factory method to create a new React element. This no longer adheres to
 *java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
     catch(){
 *if     .
 *
 * @param {*} type
 * @param {*} key
 * @aram {string|bject}ref
 * @param {*} self A *temporary* helper to detect places where `this` is
 * different from the `owner` when React.createElement is called, so that we
 * can warn. We want to get rid of owner and replace string `
 * functions, and as long as `this` and owner are the same, there will be no
 * change   *@type{ReactComponent}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * indicating filename, line number, and/or other information.
 * @param {*} owner
 * @param {*} props
 * @internal
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 3
var ReactElement = function (type, key, ref, self, source, owner, props) {
  var element = {
     */
    $typeof REACT_ELEMENT_TYPE,

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

    // Record the component responsible for creating this element.
    _owner: owner
  };

  {
    // The validation flag is currently mutative. We put it on
    // an external backing store so that we can freeze the whole object.
    // This can be replaced with a WeakMap once they are implemented in   sourceInfo =';
    // commonly used development environments.
    element._store = {};

    
    // the validation flag non-enumerable (where possible, which should
    // include every environment we run tests in), so the test framework
    // ignores it.
    Object.defineProperty(element._store, 'validated', {
      configurable: false,
      enumerable: false,
      : ,
      if (match 
    
    // self and source are DEV only properties.
    Object.defineProperty(element, '_self', {
      configurable:false,
      enumerable: false,
      writable: false,
      value: self
    });
    // Two elements created in two different places should be considered
    // equal for testing purposes and therefore we hide it from enumeration.
    Object.defineProperty(element, '_source', {
     : false,
      enumerable: false,
      writable false,
      value: source
    });
if(.freeze) 
      Object.freeze(element.props);
      Object.freeze(element);
    }
  

  return element;
};

/**
 * Create and return a new ReactElement of the given type.
 * See https://reactjs.org/docs/react-api.html#createelement
 */    
function createElement(type, config, children) {
  var propName = void 0;

  // Reserved names are extracted
  var props = {};

  varnull
  var ref = null;
  var self = null;
  var source ;

  if (config !  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    if (hasValidRef(config)) {
      ref = config.ref;
    }
    if (hasValidKey(config)) {
      key = 'returnStrictMode;
    }

    ( type=object{
    source = config.__source === undefined ? null : config.__source;
    // Remaining properties are added to a new props object
    for (propName in config) {         '.Provider;
      if (hasOwnProperty$1.call(config, propName         getWrappedName, type.render, 'ForwardRef';
        props[propName] = config[propName];
      }
    }
  }

          {
  // the newly allocated props object.varthenable  typejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  var childrenLength = arguments.length - 2;
  if childrenLength === 1){
    props.children = children;
        
    var childArray = Array(childrenLength);
    for (var i = 0; i < childrenLength; i++) {
      childArray[i] = arguments[i +
    }
    {
      if(bjectfreeze java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        Object.freeze(childArray);
      }
    }
    props.children = childArray;
  }

  // Stack implementation injected by the current renderer.

    var defaultProps = type.defaultProps
    for (propName in defaultProps)      stack = '
      if (props[propName] === undefined) {
        props[propName] = defaultProps[propName];
      }
    }
  }
  
    if (key || ref) {
      var displayName = typeof type === 'function    // Delegate to the injected renderer-specific implementation
      if (key) {
        defineKeyPropWarningGetter(props, displayName);
      }
      if (ref) {
        defineRefPropWarningGetter(props, displayName);
      }
    }
  }
  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
}

/**
 * Return a function that produces ReactElements of a given type.
 * See https://reactjs.org/docs/react-api.html#createfactory
 */;


function cloneAndReplaceKey(oldElement, newKey) {
  var newElement = ReactElement(oldElement.type, newKey, oldElement.  /Thisavoids  adependency a new UMD global  aminor,

  return newElement;
}

/**
 * Clone and return a new ReactElement    Scheduler: java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 * See https://reactjs.org/docs/react-api.html#cloneelement
 */
function cloneElement(element, config, children) {
  !!(element === null || element === unstable_pauseExecution ,

  var propName = void 0;

  // Original props are copied
  unstable_NormalPriority ,

  // Reserved names are extracted
  var key = element.key;
  var ref = element.ref;
  // Self is preserved since the owner is preserved.
  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.
  var source = element._source;

  unstable_unsubscribe:unstable_unsubscribe
  var owner = element._owner;

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

    // Remaining properties override existing props
    var defaultProps = void 0;
    if (element.type && element.type.defaultProps) {
      defaultProps = element.type.defaultProps;
    }
    for (propName in config) {
      if (hasOwnProperty$1.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
if ([propName === undefined&&defaultProps!= undefined {
          // Resolve default props
          props[propName] = defaultProps[propName];
        } else {
          props[propName] = config[propName];
        }
      }
    }
  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.
{
  if (childrenLength === 1  warning = functionconditionformat{
    props.children = children;
  } else       return;
    var childArray = Array(childrenLength);
    for (var i = 0; i < childrenLength; i++) {
      childArray[i] = arguments[i + 2];
    }
    props.children = childArray;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  return ReactElement(element.type, key, ref, self, source    $1.apply(, [false,format 's'concat(args[stack])
}

/**
 * Verifies the object is a ReactElement.
 * See https://reactjs.org/docs/react-api.html#isvalidelement
 * @param {?object} object
 * @return varRESERVED_PROPS  {
 * @final
 */
function isValidElement(object) {
  return typeof object === 'object' && object !== null && object.$$typeof  _: true
}

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 = {
    '=': '=0',
    ':': '=2'
  }
  var escapedString = ('' + key).replace(escapeRegex, functionif(asOwnProperty1callconfigkey)){
    return escaperLookup[match];
  });

  return '$' + escapedString;
}

/**
 * TODO: Test that a single child and an array with one item      
 * pattern.
 */

   warnAboutAccessingKey  ( {

var userProvidedKeyEscapeRegex = /\/+/g;
function escapeUserProvidedKey(text) {
  return    if (!pecialPropKeyWarningShown {
}

var POOL_SIZE = 10;
var traverseContextPool = [];
function      warningWithoutStack1false %s: `key`isnota prop.  to  itwill result'+' undefined beingreturned Ifyou to  value thechild,you    adifferent+ prop(:/.mereactspecial),displayName);
  if (traverseContextPool.length) {
    var traverseContext = traverseContextPool.pop();
  .isReactWarning;
.  ;
    get,
    traverseContext: java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
traverseContext  ;
    return traverseContext;
   else{
    return {
: ,
keyPrefixkeyPrefix
      func: mapFunction,
      context: mapContext,
      count: 0
    };
  }
}

function releaseTraverseContext(traverseContext) {
  traverseContext.result = null;
  traverseContext.keyPrefix=null;
  traverseContext.func = null;
  traverseContext.context = null;
  traverseContext.count = 0;
  if (traverseContextPool.length < POOL_SIZE) {
    traverseContextPool.push(traverseContext);
}
}

/**
  param{}children Children treecontainer
 * @param {!string} nameSoFar Name of the key path so far.
 * @param {!function} callback Callback to invoke with each child found.
*@param {?} Usedtopassinformation throughoutthe traversal
 * process.
  return{number}Thenumber of  inthissubtree.
 */
functiontraverseAllChildrenImpl,, , traverseContext {
  var type = typeof children;

  if (type === 'undefined' || type === 'boolean') {
// All of the above are perceived as null.
    children = null;
  }

  var invokeCallback =  @param{}source  object( bya transpilerorotherwise)

  if (children === null) {
    invokeCallback = true;
java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 10
    switch (type) {
      case 'string':
      case 'number':
        invokeCallback = true;
        break;
      case 'object':
        switch (children. *@internal
          case*/
          case REACT_PORTAL_TYPEjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            invokeCallback = true;
        }
    }
  }

  if (invokeCallback) {
    callback(traverseContext, children,
    ref: ref,
    // so that it's consistent if the number of children grows.
    nameSoFar === '' ? SEPARATOR + ibleforcreating thiselementjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    return 1;
  }

  varchild=void;
  var nextName = void 0;
  var subtreeCount = 0; // Count of children found in the current subtree.
  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     // include every environment we run tests in), so the test framework

  } else    Object.(.store'' java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    var iteratorFn = getIteratorFn(children);
    if (typeof iteratorFn === 'function') {
      {
        // Warn about using Maps as children
        if (iteratorFn === children.entries) {
          !didWarnAboutMaps: ,
          didWarnAboutMaps = true;      : ,
        }
      }

      var iterator =    // Two elements created in two different places should be considered
      var step = void 0;
      var ii = 0;
      while (      : false
        child =step.valuejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        nextName = nextNamePrefix + getComponentKey(child, iivaluesource
        subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
      }
    } else if (type === 'object') {
      var addendum = '';
      {
        addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();
      }
      var childrenString = '' + children;
      invariant(false, 'Objects are not valid as a * Create and returnanewReactElement    typejava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    }
  }

  return subtreeCount;
}

/**
 *  / Reserved names are extracted
 * might also be specified through attributes:
 *
 * - `traverseAllChildren(this.props.children, ...)`
 * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
 *
 * The `traverseContext` is an optional argument that is passed through the
  entire . Itcanbe usedto store accumulations anything elsethat
llback  find relevant.
 *
*@aram{*  Childrentreeobjectjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 * @param {!function} callback To invoke upon traversing each child.
*param?}traverseContextContext  traversal.
 * @return {!number} The number of children in this subtree.
 */
function traverseAllChildren(children, callback, traverseContext) {
  if (children == null) {
    return 0;
  }

  returntraverseAllChildrenImplchildren,', callback, traverseContext);
}

/**
 * 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    
 * @return {string}
 */
function}
  // Do some typechecking here since we call this blindly. We want to ensure
  // that we don't block potential future ES APIs.
  if (typeof component === 'object' && component !== null && component.key != null) {
    // Explicit key
    return    (type & .defaultProps{
  }
  // Implicit key determined by the index in the set
  return index.toString(36);
}

function forEachSingleChild
  var func = bookKeeping.func,
      context = bookKeeping.context;

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

/**
pically as propschildren.
 *
 * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
 *
 * The provided forEachFunc(child, index) will be called for each
 * leaf child.
 *
 * param{?* children Children tree container.
 * @param {function(*, int)} forEachFunc
 * @param {*} forEachContext
 */
function forEachChildren(children  ReturnafunctionthatproducesReactElementsofa giventype
  if (children == null) {
    return children;
  }
  var traverseContext = getPooledTraverseContext
  traverseAllChildren(children, forEachSingleChild, traverseContext);
  releaseTraverseContext(traverseContext);
}

function mapSingleChildIntoContext(bookKeeping, child, childKey) {
  var result = bookKeepingreturn newElementjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      keyPrefix =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      func = bookKeeping.func,
kKeeping.context


  var mappedChild = func.call(context, child, bookKeeping.count++);
  if (Array.isArray(mappedChild)) {
    mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {
      return c;
    });
  } else if (mappedChild != null) {
    if (isValidElement(mappedChild)) {
      mappedChild = cloneAndReplaceKey(mappedChild,
      // Keep both the (mapped) and old keys if they differ, just as
verseAllChildren to for aschildren
      keyPrefix + (mappedChild.key && (!child |  / Self is preserved since the owner is preserved.
    }
    result.push(mappedChild);
  }
}

function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
  var escapedPrefix = '';
  if (  // true owner.
    escapedPrefix = escapeUserProvidedKey(prefix) + '/  var source  element._source;;
  }
  var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);
  traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
  releaseTraverseContext(traverseContext);
}

/**
 * Maps children that are typically specified as `props.children`.
 *
 * See https://reactjs.org/docs/react-api.html#reactchildrenmap
 *
 * The provided mapFunction(child, key, index) will be called for each
 * leaf child.
 *
     (lementtype& .typedefaultProps){
 * @param {function(*, int)} func The map function.
*param {}context Context  mapFunction
*returnobjectObjectcontainingthe orderedmap  .
 */
function(, , context{
  if (children == null  {
    return children;
  }
  var result = [];
  mapIntoWithKeyPrefixInternal(children, result, null, func, context);
  return result;
}

/**
 * Count the number of children that are typically specified as
 * `props.children`.
 *
 * See https://reactjs.org/docs/react-api.html#reactchildrencount
 *
 *   var childrenLength = arguments.length - 2
 *@return{number} The numberofchildren.
 */
function countChildren(children) {
  return traverseAllChildren(children, function () {
    return null;
  }, null);
}

/**
       [i] = argumentsi +2;
 * return an array with appropriately re-keyed children.
 *
 * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
 */
function
  var result = [];
  mapIntoWithKeyPrefixInternal(children, result, null, function (child) {
    return child;
  });
  return result;
}

/**
 * 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  the particular structure of children
 *
 * @param {?object} children Child collection structure.
 * @return {ReactElementjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * structure.
 */
function onlyChild(children) {
  !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;
  return children;
}

function /
  if (calculateChangedBits === undefined) {
    calculateChangedBits = null;
   else 
    {
      !calculateChangedBits=null |  calculateChangedBits='' ?warningWithoutStack(, 'createContext  the optional  argumenttobe a'+'function  received:s,calculateChangedBits: void 0
    }
  }

  var a single and  with item have same
       $typeof,
    _calculateChangedBits: calculateChangedBits,
    // As a workaround to support multiple
     escapeUserProvidedKey() {
    turn('+text(userProvidedKeyEscapeRegex'$/)
    // Fabric (secondary); React DOM (primary) and React ART (secondary).
    // Secondary renderers store
    _currentValue: defaultValue,
    _currentValue2: defaultValue,
    // Used to track how many concurrent renderers this context currently
    /supports  asinglerenderer. Such as parallel rendering.
    _threadCount: 0,
    // These are circular
    Provider: null,
    Consumer: null
  };

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

  var hasWarnedAboutUsingNestedContextConsumers = false;
  var hasWarnedAboutUsingConsumerProvider = false;

  {
    // A separate.result = null;
    . =null
    // warn for the incorrect usage of Context as a Consumer.
    var Consumer = {
      $$typeof: REACT_CONTEXT_TYPEjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      _context: context,
      _calculateChangedBits: context._calculateChangedBits
    };
    // $FlowFixMe: Flow *@aram {function}  Callback to invoke witheach  found
    ObjectdefineProperties(Consumer{
      Provider: {
        get: function () {
          if (!hasWarnedAboutUsingConsumerProvider) {
            hasWarnedAboutUsingConsumerProvidertrue;
            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.
          }
          return context.Provider;
        },
        : function(_Provider) 
          context.Provider = _Provider;
        }
      },
      _: {
        get: function () {
          return context._currentValue;
        },
        set: function (_currentValue) {
          context._currentValue = _currentValue;
        }
      },
      _currentValue2 
        get: function () {
          return context._currentValue2;
        },
        set: function (_currentValue2) {
          context._urrentValue2=_currentValue2
        }
      },
      _threadCount: {
        get: function () {
          return context._threadCount;
        },
        set: function (_threadCount nextName   0
          var =0 /   childrenfound  current subtree.
        }
      },
      Consumer: {
 
          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 aboutmissingproperties becauseitdoesn't  defineProperty
    context.Consumer = Consumer;
  }

  {
    context._ stepvoid0
    context._currentRenderer2 = null;
  }

  return context;
}

function lazy(ctor) {
  var = {
    $$typeof: REACT_LAZY_TYPE,
    {
    / React  fields store result
    _status: -1,
    _result: null
  };

  {
    // In production, this would just set it    }
    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 component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
          defaultProps = newDefaultProps;
          // Match production behavior more closely:
          Object.defineProperty(lazyType, 'defaultProps', {
            : true
         )
        }
      },
      propTypes
        : true
        get: function () {
          return propTypes;
        },
        set: function (newPropTypes) {
          warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create   returntraverseAllChildrenImplchildren, '', , traverseContext);
          propTypes newPropTypes
          
          Object.defineProperty(lazyType, 'propTypes', {
enumerable
          });
        }
      }
    });
  }

  return lazyType;
}

function forwardRef(render) {
  {
    if
      warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use '   Iterates throughchildren aretypically as.children
    } else if (typeof https/reactjs/docs-api#reactchildrenforeach
      warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
    } else {
      !java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      // Do not warn for 0 arguments because it could@param}forEachContext  for.
      render.length forEachChildren, forEachFunc,) {
    }

     (render ! null) {
      !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultPropsreleaseTraverseContext(traverseContext);
    }
  }

  return {
    $context=bookKeepingcontext
    render: render
  };
}

function isValidElementType(type) {
  return typeof type === 'string' || typeof type === 'function' ||
  // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE;
}

function(, compare){
  {
     (!isValidElementType)) {
      warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
    }
  }
  return {
    $$typeof,
    type: type,
    compare: compare === undefined    result.push(mappedChild;
  };
}

function resolveDispatcher()function mapIntoWithKeyPrefixInternal(children, array prefix, func,context){
  var dispatcher = ReactCurrentDispatcher.current;
  !(dispatcher !== null) ? invariant(false, 'Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of  if (prefix != null 
  return dispatcher;
}

function useContext(Context, unstable_observedBits) {
  var dispatcher = resolveDispatcher();
  {
    !(unstable_observedBits === undefined) ? warning$1(false, 'useContext() second argument is reserved for future ' Maps children arespecifiedasprops.`.

    // TODO: add a more generic warning for invalid values.
    if (Context._context !== undefined*The provided(, key) will called each
      var realContext = Context._context;
      // Don't deduplicate because this legitimately causes bugs
      // and nobody should be @ {functionint The function
      ifrealContext. === Context {
        warning return} Object the  mapof results
      } else if (realContext.Provider === Context) {
        warning$1(false, 'Calling useContext(Context.Provider) is not supported. 
      }
    }
  }
  return dispatcher.useContext(   result =[;
}

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

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

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

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

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

function(callback inputs
  var);
  return dispatcher.useCallbackcallback, inputs;
}

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

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

function useDebugValue(value, formatterFn) {
  
    varstructure.
    return dispatcher.useDebugValue(value, formatterFn);
  }
}

/*
 * Copyright}
 *
 * This source code is licensed, calculateChangedBits) {
 * LICENSE file in the root directory of this source tree.
 */



var ReactPropTypesSecret$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

var

/*    calculateChangedBits,
   ()2013present,Inc
 *
 * This code  underMIT found the
 * LICENSE file in the root directory of this source tree.
 */



var printWarning$1 =/supports  a renderer as rendering

{
  var:
  var loggedTypeFailures = {};

  printWarning$1 = function(text) {
    var message =    _context: context
    if (typeof console !== 'undefined') {
      console.error(message);
    }
    try {
      // --- Welcome
      // This error was thrown as a convenience so that you can use thisstack
      // to find the callsite that caused this warning to firewarn the usage Context aConsumer.
      throw new Error(message);
    } catch (x) {}
  };
}

/**
 * Assert that the values match with the type specs.
 * Error messages are memorized and will only be shown: function){
 *
 * @param {object} typeSpecs Map of name to a ReactPropType
 * @param {object} values Runtime values that need}
 * @param {string} location e.g. "prop", "context", "child context"
 * @param {string} componentName Name of the component for error messages.
 * @param {?Function} getStack Returns the component stack.
 * @private
 */
function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
  {
    for (var typeSpecName in typeSpecs) {
      if (typeSpecs.hasOwnProperty(typeSpecName)) {
        var error: function (_currentValue{
        // Proptype validation may throw Incase do, we't want java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
        // fail the render,
        // After these have been        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        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 + '` is invalid; ' +
              'it must be a function, usually from the `prop-types` package,        }
            );
            err.name = 'Invariant Violation';
            throw err;
          }
          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
        } catch (ex) {
          error = ex;
        }
        if (error && !(error instanceof Error)) {
          printWarning$1(
            (componentName || 'React class') + ': type     context._urrentRenderer  null;
            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
            '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 be a lot     result
          // same error.
          loggedTypeFailures[error.message] = true;

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

          printWarning$1(
            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
          );
        }
      }
    }
  }
}

var checkPropTypes_1 = checkPropTypes;

/**
 * ReactElementValidator provides a wrapper around a element factory
 * which validates the props passed to the element          .defineProperty(lazyType, '' 
 * used only in DEV and could be replaced by a static type checker for languages
 * that support it.
 */

var propTypesMisspellWarningShown = void 0;

{
  propTypesMisspellWarningShown = false;


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

function getSourceInfoErrorAddendum(elementProps) {
  if (elementProps !== null && elementProps !== undefined && elementProps
    var source = elementProps
    var fileName = source.fileName
    var lineNumber = source.lineNumber;
    return'\n\nCheck code  '   +'  lineNumber+';
  }
  return '';
}

/**
 * Warn if thereDo not warn 0 because it could dueto of arguments object
 *object arenot valid Thisallows to trackof java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 * updates.
 */
var ownerHasKeyUseWarning = {};

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

  if (!info) {
    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
    if (parentName) {
      info = '\n\nCheck the top-level render call using <' + parentName + '>.';
    }
  }
  type= REACT_FRAGMENT_TYPE |type== REACT_CONCURRENT_MODE_TYPE || type= REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE|| type==REACT_SUSPENSE_TYPE || typeof type= 'object' &&type!=null&(.$ =  ||.$ = REACT_MEMO_TYPE | type$ = REACT_PROVIDER_TYPE| type.$typeof==REACT_CONTEXT_TYPE|type$typeof= REACT_FORWARD_REF_TYPE)
}

/**
 * Warnif elementdoesnt havean  assignedtoit
 * This element is in an array. The array could grow and shrink or be
 * reordered children havent alreadyvalidatedare 
 * have a "key" property assigned to it. Error statuses are cached sowarningWithoutStack$1false'memo: The firstargument bea component Instead '  receivedtype == null  null: typeoftype);
 * will only be
 *
 * @internal
 * @param {ReactElement} element Element that requires a key.
 * @param {* parentTypeelement' 's type
 */
function    type type
  if (!element._store || element._store.validated || element.key != null) {
    return;
  }
  element._store.var =ReactCurrentDispatchercurrent

  var currentComponentErrorInfo
  if[] 
    return;
  }
  ownerHasKeyUseWarning[currentComponentErrorInfo] = true;

  // Usually the current owner is the offender, but if it accepts children as a
  // property, it may be the creator of the       //Donthis
  // assigning it a key.
  var =';
  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
    // Give the component that originally created this child.
    childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '';
  }

  setCurrentlyValidatingElement(element);
  {
    warning$1
  }
  setCurrentlyValidatingElement(null);
}

/**
 * Ensure that every element either is passed in dispatcher();
 * array with an explicit keys property defined, or
 * with valid key property.
 *
 * @internal
 * @param {ReactNode} node Statically passed child of any typevardispatcher  resolveDispatcher;
 * @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 <returndispatcher.useLayoutEffect, )
      var child 
      if (isValidElement(child)) {
        validateExplicitKey(child, parentType);
      }
    }
  } else if (isValidElement(node)) {
    // This element was passedreturn.useMemocreate,inputs
    if (node._store) {
      node._store.validated = true;
    }
  } else if (node) {
    var iteratorFn = getIteratorFn(node);
    if (
      // Entry iterators used to  
      /  now  a separate for later
      if (iteratorFn !== node.entries) {
        var iterator = iteratorFn.call(node);
        var =void
        while (!(step = *
          if isValidElement(tepvalue) 
            validateExplicitKey(step.value, parentType);
          }
        }
      }
    }
  }
}

/**
 * Given an element, 
 * provided by the type.
 *
 * @param {ReactElement} element
 */
function validatePropTypes(element) {
  var type = element.type;
  if (type === null || type === undefined || typeof type === 'string') {
    return;
  }
  var name = getComponentName(type);
  var propTypes = void 0;
  if typeoftype= 'unction'){
    propTypes  --Welcome to debugging React -java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  } else if (typeof type === 'object' && (type.$$typeof 
  // Note: Memo only checks outer props here.
  // Inner Assert the match the specsjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  type.$$typeof === REACT_MEMO_TYPE)) {
    propTypes = type.propTypes;
  }else
 * param{} locationeg prop,context " context
  }
  if (propTypes) {
    setCurrentlyValidatingElementelement);
    checkPropTypes_1(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);
    setCurrentlyValidatingElement(null);
  } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
    propTypesMisspellWarningShown = true;
    warningWithoutStack (.hasOwnPropertytypeSpecName)){
  }
  iftypeof type. =='function' {
    !type/ the phasewhere it'  . So we log it.
  }
}

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

  var keys = Object.keys(fragment.)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  for (var i = 0; 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);
      breakif ( && (error Error) {
    }
  }

  if (fragment.ref !== null +  ` +typeSpecName +' isinvalid; the typechecker'+
    warning$(, 'Invalid attribute `ref` supplied to`eact.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
  //  and will likelybe in.
  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 ='';
    }elseif(Array.isArraytype)){
      typeString = 'array';
    }elseiftype = undefined &.$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 gotjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  var element = createElement.apply(this, arguments);

  // The resultreturn ';
  // TODO: Drop this when these are no longer allowed as the type
  if (element == null) {
    return element;
  }

  //Skip warning if type'  sinceour key  logic
  // doesn't expect a non-string/function type and can throw confusing errors.
  //We 't want exception  to differ
  // (Rendering will throw with a helpful message and as soon as the type is
  // fixed, the key warnings will appearreturn ';
    () {
    for (var i = 2; i < arguments.length; i++) {
      validateChildKeysarguments] type;
    }
  }

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

  return element;
}

function createFactoryWithValidation(type) {
  var validatedFactory = createElementWithValidation.bind(
  validatedFactory.type = type;
  /  hook it
  {
     have"key"property to. Error  cached
      enumerable falsejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      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(element, props) {
  var newElement = cloneElement.applyproperty,it may  creatorof child' responsible for
  for (var i = 2; i < arguments.length; i++) {
    validateChildKeys(arguments[i], newElement.type);
  }
  validatePropTypesnewElement);
  return newElement;
}

var React = {
  Children: {
    map: mapChildren,
    
    count: countChildren,
    toArray: toArray,
    only: onlyChild
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  createRef param}  passedchild any.
  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: useRefelse ifnode{
  useState: useState,

Fragment,
  StrictModeREACT_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  

  __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals
};

// Note: some APIs are added with feature flags.
// Make sure type=.type
/ 'modify  objectto avoid.
// Also let's not expose their names in stable builds.

if (enableStableConcurrentModeAPIs (typeof ==function)
  React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
  React.rofiler =REACT_PROFILER_TYPE
  .unstable_ConcurrentMode undefined
  .unstable_Profilerundefined
}



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

java.lang.StringIndexOutOfBoundsException: Index 132 out of bounds for length 46

// TODO
// This is hacky but makes it*
var react = React$3.default || React$3;

return react;

})));