{"version":3,"sources":["webpack://ReactDevToolsBackend/webpack/universalModuleDefinition","webpack://ReactDevToolsBackend/webpack/bootstrap","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/build/node_modules/react-is/index.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/object-assign/index.js","webpack://ReactDevToolsBackend/../react-devtools-shared/node_modules/semver/semver.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/lodash.throttle/index.js","webpack://ReactDevToolsBackend/(webpack)/buildin/global.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/process/browser.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/lru-cache/index.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/clipboard-js/clipboard.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/build/node_modules/react-debug-tools/index.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/devtools/views/root.css","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/lru-cache/node_modules/yallist/yallist.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/lru-cache/node_modules/yallist/iterator.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/build/node_modules/react-is/cjs/react-is.production.min.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/timers-browserify/main.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/setimmediate/setImmediate.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/build/node_modules/react-debug-tools/cjs/react-debug-tools.production.min.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/error-stack-parser/error-stack-parser.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/stackframe/stackframe.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/build/node_modules/react/index.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/build/node_modules/react/cjs/react.production.min.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/events.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/constants.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/storage.js","webpack://ReactDevToolsBackend//Users/bvaughn/Documents/git/react.alt2/node_modules/memoize-one/esm/index.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/views/utils.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/views/Highlighter/Overlay.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/views/Highlighter/Highlighter.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/views/Highlighter/index.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/views/TraceUpdates/canvas.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/views/TraceUpdates/index.js","webpack://ReactDevToolsBackend/../shared/ReactSymbols.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/hydration.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/utils.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/utils.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/renderer.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/ReactSymbols.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/types.js","webpack://ReactDevToolsBackend/../shared/ConsolePatchingDev.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/DevToolsComponentStackFrame.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/DevToolsFiberComponentStack.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/console.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/agent.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/bridge.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/legacy/utils.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/legacy/renderer.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/NativeStyleEditor/resolveBoxStyle.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/NativeStyleEditor/setupNativeStyleEditor.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/hook.js","webpack://ReactDevToolsBackend/./src/backend.js","webpack://ReactDevToolsBackend/../react-devtools-shared/src/backend/index.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","require","getOwnPropertySymbols","propIsEnumerable","propertyIsEnumerable","toObject","val","TypeError","assign","test1","String","getOwnPropertyNames","test2","fromCharCode","map","join","test3","split","forEach","letter","keys","err","shouldUseNative","target","source","from","symbols","to","arguments","length","debug","SemVer","process","env","NODE_DEBUG","test","args","Array","slice","unshift","console","log","apply","SEMVER_SPEC_VERSION","MAX_SAFE_INTEGER","Number","re","src","tokens","R","tok","NUMERICIDENTIFIER","NUMERICIDENTIFIERLOOSE","NONNUMERICIDENTIFIER","MAINVERSION","MAINVERSIONLOOSE","PRERELEASEIDENTIFIER","PRERELEASEIDENTIFIERLOOSE","PRERELEASE","PRERELEASELOOSE","BUILDIDENTIFIER","BUILD","FULLPLAIN","FULL","LOOSEPLAIN","LOOSE","GTLT","XRANGEIDENTIFIERLOOSE","XRANGEIDENTIFIER","XRANGEPLAIN","XRANGEPLAINLOOSE","XRANGE","XRANGELOOSE","COERCE","COERCERTL","RegExp","LONETILDE","TILDETRIM","TILDE","TILDELOOSE","LONECARET","CARETTRIM","CARET","CARETLOOSE","COMPARATORLOOSE","COMPARATOR","COMPARATORTRIM","HYPHENRANGE","HYPHENRANGELOOSE","STAR","parse","version","options","loose","includePrerelease","er","this","trim","match","raw","major","minor","patch","prerelease","id","num","build","format","valid","v","clean","replace","toString","compare","other","compareMain","comparePre","compareIdentifiers","a","b","undefined","compareBuild","inc","release","identifier","push","isNaN","Error","diff","version1","version2","eq","v1","v2","prefix","defaultResult","numeric","anum","bnum","gt","lt","neq","gte","lte","cmp","op","Comparator","comp","semver","ANY","operator","rcompareIdentifiers","compareLoose","versionA","versionB","rcompare","sort","list","rsort","Range","range","set","parseRange","filter","isSatisfiable","comparators","result","remainingComparators","testComparator","pop","every","otherComparator","intersects","isX","toLowerCase","hyphenReplace","$0","fM","fm","fp","fpr","fb","tM","tm","tp","tpr","tb","testSet","allowed","satisfies","outside","hilo","gtfn","ltefn","ltfn","ecomp","high","low","comparator","rangeTmp","sameDirectionIncreasing","sameDirectionDecreasing","sameSemVer","differentDirectionsInclusive","oppositeDirectionsLessThan","oppositeDirectionsGreaterThan","comps","hr","compRe","_","M","pr","ret","replaceCaret","replaceCarets","replaceTilde","replaceTildes","gtlt","xM","xm","xp","anyX","replaceXRange","replaceXRanges","replaceStars","parseComparator","some","thisComparators","rangeComparators","thisComparator","rangeComparator","toComparators","maxSatisfying","versions","max","maxSV","rangeObj","minSatisfying","min","minSV","minVersion","minver","compver","validRange","ltr","gtr","parsed","r1","r2","coerce","rtl","next","exec","index","lastIndex","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","global","freeSelf","self","Function","objectToString","nativeMax","Math","nativeMin","now","Date","debounce","func","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","time","thisArg","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","remainingWait","debounced","isInvoking","toNumber","isObject","cancel","clearTimeout","flush","type","isSymbol","isObjectLike","valueOf","isBinary","g","e","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","concat","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","title","browser","argv","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","Yallist","MAX","LENGTH","LENGTH_CALCULATOR","ALLOW_STALE","MAX_AGE","DISPOSE","NO_DISPOSE_ON_SET","LRU_LIST","CACHE","UPDATE_AGE_ON_GET","naiveLength","LRUCache","Infinity","lc","stale","maxAge","dispose","noDisposeOnSet","updateAgeOnGet","reset","fn","thisp","walker","tail","prev","forEachStep","head","toArray","k","hit","Map","isStale","h","has","del","item","Entry","node","arr","expiresAt","mL","allowStale","mA","lC","doUse","unshiftNode","delete","removeNode","document","addEventListener","_resolve","_dataType","_intercept","clipboard","copy","_data","_bogusSelection","cleanup","getSelection","removeAllRanges","clipboardData","setData","preventDefault","data","Promise","resolve","reject","Node","XMLSerializer","serializeToString","triggerCopy","tryBogusSelect","execCommand","sel","queryCommandEnabled","isCollapsed","createRange","selectNodeContents","body","addRange","bogusSelect","paste","getData","dataType","ClipboardEvent","_state","_value","_deferreds","f","j","onFulfilled","onRejected","then","immediateFn","setImmediate","isArray","all","constructor","race","strData","definition","insert","inserted","pushNode","res","shift","forEachReverse","getReverse","mapReverse","reduce","initial","acc","reduceReverse","toArrayReverse","sliceReverse","splice","start","deleteCount","reverse","iterator","q","u","for","w","x","$$typeof","y","z","A","B","C","D","E","F","G","H","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","getModuleId","typeOf","scope","Timeout","clearFn","_id","_clearFn","setInterval","clearInterval","close","unref","ref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","clearImmediate","registerImmediate","html","channel","messagePrefix","onGlobalMessage","nextHandle","tasksByHandle","currentlyRunningATask","doc","attachTo","getPrototypeOf","handle","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","canUsePostMessage","MessageChannel","port1","event","port2","createElement","documentElement","script","onreadystatechange","removeChild","appendChild","random","indexOf","attachEvent","callback","task","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","useContext","_currentValue","useState","useReducer","useRef","useLayoutEffect","useEffect","useImperativeHandle","useDebugValue","useCallback","useMemo","primitive","stackError","getCacheForType","encodeURIComponent","readContext","memoizedState","current","useTransition","useMutableSource","_source","useDeferredValue","useOpaqueIdentifier","lastIndexOf","I","substr","J","functionName","isStateEditable","subHooks","K","L","ReactCurrentDispatcher","inspectHooks","inspectHooksOfFiber","tag","memoizedProps","elementType","defaultProps","_context","return","render","StackFrame","FIREFOX_SAFARI_STACK_REGEXP","CHROME_IE_STACK_REGEXP","SAFARI_NATIVE_CODE_REGEXP","error","stacktrace","parseOpera","stack","parseV8OrIE","parseFFOrSafari","extractLocation","urlLike","parts","line","sanitizedLine","location","locationParts","fileName","lineNumber","columnNumber","functionNameRegex","matches","message","parseOpera9","parseOpera11","parseOpera10","lineRE","lines","argsRaw","functionCall","_capitalize","str","charAt","toUpperCase","substring","_getter","booleanProps","numericProps","stringProps","props","obj","getArgs","setArgs","getEvalOrigin","evalOrigin","setEvalOrigin","getFileName","getLineNumber","getColumnNumber","getFunctionName","getIsEval","fromString","argsStartIndex","argsEndIndex","locationString","Boolean","parseFloat","isFinite","unstable_SuspenseList","unstable_DebugTracingMode","unstable_LegacyHidden","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","context","refs","updater","isReactComponent","setState","forceUpdate","isPureReactComponent","__self","__source","children","_owner","N","escape","O","done","P","Q","_status","_result","default","S","T","transition","U","ReactCurrentBatchConfig","ReactCurrentOwner","IsSomeRendererActing","Children","count","only","Component","PureComponent","cloneElement","createContext","_calculateChangedBits","_currentValue2","_threadCount","Provider","Consumer","createFactory","createRef","forwardRef","isValidElement","lazy","_payload","_init","memo","unstable_createMutableSource","_getVersion","_workInProgressVersionPrimary","_workInProgressVersionSecondary","unstable_getCacheForType","unstable_startTransition","unstable_useDeferredValue","unstable_useMutableSource","unstable_useOpaqueIdentifier","unstable_useTransition","EventEmitter","listener","listenersMap","didThrow","caughtError","clonedListeners","clear","rawStyleString","extractVar","varName","regExp","sessionStorageGetItem","sessionStorage","getItem","sessionStorageRemoveItem","removeItem","sessionStorageSetItem","setItem","simpleIsEqual","getOwnerWindow","ownerDocument","defaultView","getOwnerIframe","nodeWindow","frameElement","getBoundingClientRectWithBorderOffset","dimensions","getElementDimensions","mergeRectOffsets","getBoundingClientRect","top","borderTop","left","borderLeft","bottom","borderBottom","right","borderRight","width","height","rects","previousRect","rect","getNestedBoundingClientRect","boundaryWindow","ownerIframe","currentIframe","onlyOneMore","domElement","calculatedStyle","getComputedStyle","borderLeftWidth","borderRightWidth","borderTopWidth","borderBottomWidth","marginLeft","marginRight","marginTop","marginBottom","paddingLeft","paddingRight","paddingTop","paddingBottom","OverlayRect","container","border","padding","content","style","borderColor","overlayStyles","backgroundColor","background","margin","pointerEvents","position","zIndex","parentNode","box","dims","boxWrap","OverlayTip","tip","display","flexFlow","borderRadius","fontFamily","fontWeight","fontSize","whiteSpace","nameSpan","color","dimSpan","textContent","round","bounds","tipRect","tipPos","tipSize","tipHeight","tipWidth","findTipPos","Overlay","currentWindow","__REACT_DEVTOOLS_TARGET_WINDOW__","tipBoundsWindow","remove","nodes","elements","nodeType","ELEMENT_NODE","outerBox","POSITIVE_INFINITY","NEGATIVE_INFINITY","element","update","nodeName","hook","__REACT_DEVTOOLS_GLOBAL_HOOK__","rendererInterfaces","ownerName","values","rendererInterface","getFiberIDForNative","getDisplayNameForFiberID","updateText","tipBounds","updatePosition","scrollY","scrollX","innerHeight","innerWidth","what","borderStyle","timeoutID","overlay","hideOverlay","showOverlay","componentName","hideAfterTimeout","inspect","iframesListeningTo","Set","setupHighlighter","bridge","agent","registerListenersOnWindow","onClick","onMouseEvent","onPointerDown","onPointerOver","onPointerUp","stopInspectingNative","removeListenersOnWindow","frame","contentWindow","removeEventListener","stopPropagation","send","selectFiberForNode","tagName","iframe","add","displayName","openNativeElementsPanel","rendererID","scrollIntoView","renderer","warn","findNativeNodesForFiberID","block","inline","throttle","resultFn","isEqual","lastResult","calledOnce","isNewArgEqualToLast","newArg","_len","newArgs","_key","memoize","getIDForNode","COLORS","canvas","draw","nodeToData","cssText","insertBefore","firstChild","initialize","canvasFlow","getContext","clearRect","colorIndex","lineWidth","strokeStyle","strokeRect","setLineDash","drawBorder","getCurrentTime","performance","drawAnimationFrameID","isEnabled","redrawTimeoutID","toggleEnabled","cancelAnimationFrame","traceUpdates","lastMeasuredAt","measureNode","expirationTime","requestAnimationFrame","prepareToDraw","earliestExpiration","MAX_VALUE","REACT_SUSPENSE_LIST_TYPE","symbolFor","meta","inspectable","inspected","preview_long","preview_short","readonly","size","unserializable","createDehydrated","cleaned","path","dehydrated","formatDataForPreview","dehydrate","isPathAllowed","isPathAllowedCheck","level","getDataType","getDisplayNameForReactElement","byteLength","unserializableValue","getAllEnumerableKeys","cachedDisplayNames","WeakMap","encodedStringCache","LRU","alphaSortKeys","currentKeys","descriptors","getOwnPropertyDescriptors","getDisplayName","fallbackName","nameFromCache","uidCounter","getUID","utfEncodeString","string","cached","encoded","codePointAt","getInObject","reduced","attr","deletePathInObject","last","parent","renamePathInObject","oldPath","newPath","lastOld","setInObject","HTMLElement","ArrayBuffer","isView","toStringValue","SuspenseList","truncateForDisplay","showFormattedValue","buffer","formatted","shortName","entryOrEntries","cleanForBridge","cleanedPaths","unserializablePaths","cleanedData","copyToClipboard","cache","safeToCopy","JSON","stringify","text","clipboardCopyText","catch","copyWithDelete","updated","copyWithRename","oldKey","newKey","copyWithSet","getFiberFlags","fiber","flags","effectTag","getInternalReactConstants","ReactTypeOfWork","getTypeSymbol","symbolOrNumber","ClassComponent","CoroutineComponent","CoroutineHandlerPhase","DehydratedSuspenseComponent","FunctionComponent","HostComponent","HostPortal","HostRoot","HostText","IncompleteClassComponent","IndeterminateComponent","LazyComponent","LegacyHiddenComponent","MemoComponent","Mode","OffscreenComponent","ScopeComponent","SimpleMemoComponent","SuspenseComponent","SuspenseListComponent","YieldComponent","getDisplayNameForFiber","resolvedType","resolveFiberType","resolvedContext","ReactPriorityLevels","ImmediatePriority","UserBlockingPriority","NormalPriority","LowPriority","IdlePriority","NoPriority","ReactTypeOfSideEffect","NoFlags","PerformedWork","Placement","attach","overrideHookState","overrideHookStateDeletePath","overrideHookStateRenamePath","overrideProps","overridePropsDeletePath","overridePropsRenamePath","setSuspenseHandler","scheduleUpdate","supportsTogglingSuspense","registerRendererWithConsole","appendComponentStack","__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__","breakOnConsoleErrors","__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__","patchConsole","hideElementsWithDisplayNames","hideElementsWithPaths","hideElementsWithTypes","traceUpdatesEnabled","traceUpdatesForNodes","applyComponentFilters","componentFilters","componentFilter","isValid","shouldFilterFiber","_debugSource","getElementTypeForFiber","getPrimaryFiber","primaryFibers","alternate","__REACT_DEVTOOLS_COMPONENT_FILTERS__","fiberToIDMap","idToFiberMap","idToTreeBaseDurationMap","idToRootMap","currentRootID","getFiberID","primaryFiber","updateContextsForFiber","idToContextsMap","contexts","getContextsForFiber","NO_CONTEXT","instance","stateNode","legacyContext","modernContext","contextType","getContextChangedKeys","prevContexts","nextContexts","prevLegacyContext","prevModernContext","nextLegacyContext","nextModernContext","getChangedKeys","didHooksChange","changedKeys","didFiberRender","prevFiber","nextFiber","pendingOperations","pendingRealUnmountedIDs","pendingSimulatedUnmountedIDs","pendingOperationsQueue","pendingStringTable","pendingStringTableLength","pendingUnmountedRootID","pushOperation","flushPendingEvents","isProfiling","numUnmountIDs","operations","encodedKey","getStringID","existingID","stringID","recordUnmount","isSimulated","trackedPathMatchFiber","setTrackedPath","isRoot","mountFiberRecursively","parentFiber","traverseSiblings","traceNearestHostComponentUpdate","mightSiblingsBeOnTrackedPath","trackedPath","mightBeOnTrackedPath","returnFiber","returnAlternate","actualFrame","getPathFrame","expectedFrame","trackedPathMatchDepth","updateTrackedPathStateBeforeMount","shouldIncludeInTree","hasOwnerMetadata","isProfilingSupported","displayNamesByRootID","getDisplayNameForRoot","_debugOwner","ownerID","parentID","displayNameStringID","keyStringID","recordProfilingDurations","recordMount","primaryChildFragment","child","fallbackChildFragment","sibling","fallbackChild","primaryChild","updateTrackedPathStateAfterMount","unmountFiberChildrenRecursively","isTimedOutSuspense","actualDuration","treeBaseDuration","convertedTreeBaseDuration","floor","selfDuration","metadata","currentCommitProfilingMetadata","durations","maxActualDuration","recordChangeDescriptions","changeDescription","isFirstMount","state","getChangeDescription","changeDescriptions","findReorderedChildrenRecursively","nextChildren","updateFiberRecursively","mostRecentlyInspectedElement","hasElementUpdatedSinceLastInspected","shouldResetChildren","prevDidTimeout","nextDidTimeOut","nextFiberChild","nextFallbackChildSet","prevFiberChild","prevFallbackChildSet","nextPrimaryChildSet","nextChild","prevChildAtSameIndex","prevChild","findAllCurrentHostFibers","hostFiber","nextChildSet","childSet","numChildren","recordResetChildren","fibers","findCurrentFiberUsingSlowPathById","maybeFallbackFiber","isFiberMountedImpl","parentA","parentB","nextParent","didFindChild","inspectElementRaw","dependencies","usesHooks","typeSymbol","canViewSource","contextTypes","consumerResolvedContext","currentType","currentTypeSymbol","hasLegacyContext","owners","owner","hooks","originalConsoleMethods","method","currentDispatcherRef","rootType","fiberRoot","_debugRootType","canEditHooks","canEditFunctionProps","canEditHooksAndDeletePaths","canEditHooksAndRenamePaths","canEditFunctionPropsDeletePaths","canEditFunctionPropsRenamePaths","canToggleSuspense","forceFallbackForSuspenseIDs","rendererPackageName","rendererVersion","currentlyInspectedPaths","isMostRecentlyInspectedElementCurrent","mergeInspectedPaths","createIsPathAllowed","secondaryCategory","initialTreeBaseDurationsMap","initialIDToRootMap","profilingStartTime","rootToCommitProfilingMetadataMap","startProfiling","shouldRecordChangeDescriptions","getFiberRoots","rootID","crawlToInitializeContextsMap","shouldSuspendFiberAlwaysFalse","shouldSuspendFiberAccordingToSet","rootPseudoKeys","rootDisplayNameCounter","setRootPseudoKey","counter","pseudoKey","preferredDisplayName","fallbackDisplayName","formatPriorityLevel","priorityLevel","copyElementPath","deletePath","hookID","pendingProps","flushInitialOperations","localPendingOperationsQueue","memoizedInteractions","commitTime","interactions","interaction","timestamp","getBestMatchForTrackedPath","isFullMatch","hostInstance","findNearestUnfilteredAncestor","findFiberByHostInstance","getInstanceAndStyle","getOwnersList","getPathForElement","keyPath","getProfilingData","dataForRoots","commitProfilingMetadata","commitData","initialTreeBaseDurations","allInteractions","interactionCommits","commitProfilingData","commitIndex","interactionIDs","commitIndices","fiberActualDurations","fiberSelfDurations","fiberID","entries","duration","handleCommitFiberRoot","wasMounted","removeRootPseudoKey","handleCommitFiberUnmount","inspectElement","inspectedElement","$r","updateSelectedElement","cleanedInspectedElement","logElementToConsole","supportsGroup","groupCollapsed","nativeNodes","chrome","navigator","userAgent","groupEnd","prepareViewAttributeSource","$attribute","prepareViewElementSource","$type","overrideSuspense","forceFallback","overrideValueAtPath","renamePath","setTraceUpdatesEnabled","stopProfiling","storeAsGlobal","updateComponentFilters","describeBuiltInComponentFrame","ownerFn","reentry","describeNativeComponentFrame","construct","control","previousPrepareStackTrace","prepareStackTrace","previousDispatcher","Fake","Reflect","sample","sampleLines","controlLines","describeFunctionComponentFrame","describeFiber","workTagMap","workInProgress","ctor","describeClassComponentFrame","getStackByFiberInDevAndProd","info","APPEND_STACK_TO_METHODS","PREFIX_REGEX","ROW_COLUMN_NUMBER_REGEX","injectedRenderers","targetConsole","targetConsoleMethods","unpatchFn","registerRenderer","getCurrentFiber","consoleSettingsRef","originalMethod","overrideMethod","latestAppendComponentStack","lastArg","alreadyHasComponentStack","componentStack","__REACT_DEVTOOLS_ORIGINAL_METHOD__","Agent","_rendererInterfaces","_bridge","_isProfiling","_persistedSelectionMatch","_persistedSelection","_throttledPersistSelection","wasForwarded","_traceUpdatesEnabled","selectNode","_recordChangeDescriptions","prevMatch","nextMatch","prevMatchID","nextMatchID","persistedSelectionString","getProfilingStatus","reloadAndProfile","syncSelectionFromNativeElementsPanel","shutdown","updateConsolePatchSettings","viewAttributeSource","viewElementSource","overrideContext","overrideState","injectedAgent","isBackendStorageAPISupported","localStorage","selection","Bridge","wall","_timeoutID","_messageQueue","_wall","_flush","_wallUnlisten","listen","payload","_isShutdown","wallUnlisten","decorate","old","restoreMany","olds","internalInstance","_currentElement","getElementType","getPublicInstance","getChildren","_renderedComponent","_renderedChildren","renderedChildren","findNativeNodeForInternalID","idToInternalInstanceMap","internalInstanceToIDMap","internalInstanceToRootIDMap","getInternalIDForNative","getID","areEqualArrays","ComponentTree","getClosestInstanceFromNode","getNodeFromInstance","Mount","getNode","parentIDStack","oldReconcilerMethods","recordReorder","nextChildIDs","crawlAndRecordInitialMounts","Reconciler","fns","decorateMany","mountComponent","hostContainerInfo","_topLevelWrapper","performUpdateIfNecessary","prevChildren","receiveComponent","unmountComponent","pendingUnmountedIDs","currentlyInspectedElementID","publicInstance","_instance","Mixin","roots","_instancesByReactRootID","_instancesByContainerID","nativeNode","enabled","resolveBoxStyle","hasParts","styleForAll","styleForHorizontal","styleForLeft","styleForRight","styleForEnd","styleForStart","styleForVertical","styleForBottom","styleForTop","setupNativeStyleEditor","resolveNativeStyle","validAttributes","measureStyle","oldName","newName","customStyle","newStyle","setNativeProps","styleOverrides","componentIDToStyleOverrides","shallowClone","renameStyle","lastLength","setStyle","isSupported","EMPTY_BOX_STYLE","resolvedStyle","measure","layout","cloned","hasDetectedBadDCE","fiberRoots","renderers","inject","reactBuildType","bundleType","_renderNewRootComponent","renderRootCode","detectReactBuildType","__REACT_DEVTOOLS_ATTACH__","sub","supportsFiber","checkDCE","onCommitFiberUnmount","onCommitFiberRoot","mountedRoots","isKnownRoot","isUnmounting","configurable","__DEV__","installHook","savedComponentFilters","connectToDevTools","host","nativeStyleEditorValidAttributes","useHttps","port","websocket","resolveRNStyle","retryConnectionDelay","isAppActive","protocol","retryTimeoutID","messageListeners","uri","ws","WebSocket","onclose","scheduleRetry","onerror","onopen","transferable","readyState","OPEN","subs","setRendererInterface","onUnsupportedRenderer","onHookOperations","onTraceUpdates","attachRenderer","attachLegacy","reactDevtoolsAgent","onAgentShutdown","initBackend","lazyResolveRNStyle","lazyNativeStyleEditorValidAttributes","initAfterTick"],"mappings":"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","file":"backend.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ReactDevToolsBackend\"] = factory();\n\telse\n\t\troot[\"ReactDevToolsBackend\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 20);\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","exports = module.exports = SemVer\n\nvar debug\n/* istanbul ignore next */\nif (typeof process === 'object' &&\n    process.env &&\n    process.env.NODE_DEBUG &&\n    /\\bsemver\\b/i.test(process.env.NODE_DEBUG)) {\n  debug = function () {\n    var args = Array.prototype.slice.call(arguments, 0)\n    args.unshift('SEMVER')\n    console.log.apply(console, args)\n  }\n} else {\n  debug = function () {}\n}\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nexports.SEMVER_SPEC_VERSION = '2.0.0'\n\nvar MAX_LENGTH = 256\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n  /* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nvar MAX_SAFE_COMPONENT_LENGTH = 16\n\n// The actual regexps go on exports.re\nvar re = exports.re = []\nvar src = exports.src = []\nvar t = exports.tokens = {}\nvar R = 0\n\nfunction tok (n) {\n  t[n] = R++\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ntok('NUMERICIDENTIFIER')\nsrc[t.NUMERICIDENTIFIER] = '0|[1-9]\\\\d*'\ntok('NUMERICIDENTIFIERLOOSE')\nsrc[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ntok('NONNUMERICIDENTIFIER')\nsrc[t.NONNUMERICIDENTIFIER] = '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*'\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ntok('MAINVERSION')\nsrc[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[t.NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[t.NUMERICIDENTIFIER] + ')'\n\ntok('MAINVERSIONLOOSE')\nsrc[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\ntok('PRERELEASEIDENTIFIER')\nsrc[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +\n                            '|' + src[t.NONNUMERICIDENTIFIER] + ')'\n\ntok('PRERELEASEIDENTIFIERLOOSE')\nsrc[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +\n                                 '|' + src[t.NONNUMERICIDENTIFIER] + ')'\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ntok('PRERELEASE')\nsrc[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +\n                  '(?:\\\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))'\n\ntok('PRERELEASELOOSE')\nsrc[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +\n                       '(?:\\\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ntok('BUILDIDENTIFIER')\nsrc[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ntok('BUILD')\nsrc[t.BUILD] = '(?:\\\\+(' + src[t.BUILDIDENTIFIER] +\n             '(?:\\\\.' + src[t.BUILDIDENTIFIER] + ')*))'\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ntok('FULL')\ntok('FULLPLAIN')\nsrc[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +\n                  src[t.PRERELEASE] + '?' +\n                  src[t.BUILD] + '?'\n\nsrc[t.FULL] = '^' + src[t.FULLPLAIN] + '$'\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ntok('LOOSEPLAIN')\nsrc[t.LOOSEPLAIN] = '[v=\\\\s]*' + src[t.MAINVERSIONLOOSE] +\n                  src[t.PRERELEASELOOSE] + '?' +\n                  src[t.BUILD] + '?'\n\ntok('LOOSE')\nsrc[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$'\n\ntok('GTLT')\nsrc[t.GTLT] = '((?:<|>)?=?)'\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ntok('XRANGEIDENTIFIERLOOSE')\nsrc[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\\\*'\ntok('XRANGEIDENTIFIER')\nsrc[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\\\*'\n\ntok('XRANGEPLAIN')\nsrc[t.XRANGEPLAIN] = '[v=\\\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[t.XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[t.XRANGEIDENTIFIER] + ')' +\n                   '(?:' + src[t.PRERELEASE] + ')?' +\n                   src[t.BUILD] + '?' +\n                   ')?)?'\n\ntok('XRANGEPLAINLOOSE')\nsrc[t.XRANGEPLAINLOOSE] = '[v=\\\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:' + src[t.PRERELEASELOOSE] + ')?' +\n                        src[t.BUILD] + '?' +\n                        ')?)?'\n\ntok('XRANGE')\nsrc[t.XRANGE] = '^' + src[t.GTLT] + '\\\\s*' + src[t.XRANGEPLAIN] + '$'\ntok('XRANGELOOSE')\nsrc[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\\\s*' + src[t.XRANGEPLAINLOOSE] + '$'\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ntok('COERCE')\nsrc[t.COERCE] = '(^|[^\\\\d])' +\n              '(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +\n              '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +\n              '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +\n              '(?:$|[^\\\\d])'\ntok('COERCERTL')\nre[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ntok('LONETILDE')\nsrc[t.LONETILDE] = '(?:~>?)'\n\ntok('TILDETRIM')\nsrc[t.TILDETRIM] = '(\\\\s*)' + src[t.LONETILDE] + '\\\\s+'\nre[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')\nvar tildeTrimReplace = '$1~'\n\ntok('TILDE')\nsrc[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$'\ntok('TILDELOOSE')\nsrc[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ntok('LONECARET')\nsrc[t.LONECARET] = '(?:\\\\^)'\n\ntok('CARETTRIM')\nsrc[t.CARETTRIM] = '(\\\\s*)' + src[t.LONECARET] + '\\\\s+'\nre[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')\nvar caretTrimReplace = '$1^'\n\ntok('CARET')\nsrc[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$'\ntok('CARETLOOSE')\nsrc[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ntok('COMPARATORLOOSE')\nsrc[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\\\s*(' + src[t.LOOSEPLAIN] + ')$|^$'\ntok('COMPARATOR')\nsrc[t.COMPARATOR] = '^' + src[t.GTLT] + '\\\\s*(' + src[t.FULLPLAIN] + ')$|^$'\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ntok('COMPARATORTRIM')\nsrc[t.COMPARATORTRIM] = '(\\\\s*)' + src[t.GTLT] +\n                      '\\\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'\n\n// this one has to use the /g flag\nre[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')\nvar comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ntok('HYPHENRANGE')\nsrc[t.HYPHENRANGE] = '^\\\\s*(' + src[t.XRANGEPLAIN] + ')' +\n                   '\\\\s+-\\\\s+' +\n                   '(' + src[t.XRANGEPLAIN] + ')' +\n                   '\\\\s*$'\n\ntok('HYPHENRANGELOOSE')\nsrc[t.HYPHENRANGELOOSE] = '^\\\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s+-\\\\s+' +\n                        '(' + src[t.XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s*$'\n\n// Star ranges basically just allow anything at all.\ntok('STAR')\nsrc[t.STAR] = '(<|>)?=?\\\\s*\\\\*'\n\n// Compile to actual regexp objects.\n// All are flag-free, unless they were created above with a flag.\nfor (var i = 0; i < R; i++) {\n  debug(i, src[i])\n  if (!re[i]) {\n    re[i] = new RegExp(src[i])\n  }\n}\n\nexports.parse = parse\nfunction parse (version, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  if (version.length > MAX_LENGTH) {\n    return null\n  }\n\n  var r = options.loose ? re[t.LOOSE] : re[t.FULL]\n  if (!r.test(version)) {\n    return null\n  }\n\n  try {\n    return new SemVer(version, options)\n  } catch (er) {\n    return null\n  }\n}\n\nexports.valid = valid\nfunction valid (version, options) {\n  var v = parse(version, options)\n  return v ? v.version : null\n}\n\nexports.clean = clean\nfunction clean (version, options) {\n  var s = parse(version.trim().replace(/^[=v]+/, ''), options)\n  return s ? s.version : null\n}\n\nexports.SemVer = SemVer\n\nfunction SemVer (version, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n  if (version instanceof SemVer) {\n    if (version.loose === options.loose) {\n      return version\n    } else {\n      version = version.version\n    }\n  } else if (typeof version !== 'string') {\n    throw new TypeError('Invalid Version: ' + version)\n  }\n\n  if (version.length > MAX_LENGTH) {\n    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')\n  }\n\n  if (!(this instanceof SemVer)) {\n    return new SemVer(version, options)\n  }\n\n  debug('SemVer', version, options)\n  this.options = options\n  this.loose = !!options.loose\n\n  var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])\n\n  if (!m) {\n    throw new TypeError('Invalid Version: ' + version)\n  }\n\n  this.raw = version\n\n  // these are actually numbers\n  this.major = +m[1]\n  this.minor = +m[2]\n  this.patch = +m[3]\n\n  if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n    throw new TypeError('Invalid major version')\n  }\n\n  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n    throw new TypeError('Invalid minor version')\n  }\n\n  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n    throw new TypeError('Invalid patch version')\n  }\n\n  // numberify any prerelease numeric ids\n  if (!m[4]) {\n    this.prerelease = []\n  } else {\n    this.prerelease = m[4].split('.').map(function (id) {\n      if (/^[0-9]+$/.test(id)) {\n        var num = +id\n        if (num >= 0 && num < MAX_SAFE_INTEGER) {\n          return num\n        }\n      }\n      return id\n    })\n  }\n\n  this.build = m[5] ? m[5].split('.') : []\n  this.format()\n}\n\nSemVer.prototype.format = function () {\n  this.version = this.major + '.' + this.minor + '.' + this.patch\n  if (this.prerelease.length) {\n    this.version += '-' + this.prerelease.join('.')\n  }\n  return this.version\n}\n\nSemVer.prototype.toString = function () {\n  return this.version\n}\n\nSemVer.prototype.compare = function (other) {\n  debug('SemVer.compare', this.version, this.options, other)\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options)\n  }\n\n  return this.compareMain(other) || this.comparePre(other)\n}\n\nSemVer.prototype.compareMain = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options)\n  }\n\n  return compareIdentifiers(this.major, other.major) ||\n         compareIdentifiers(this.minor, other.minor) ||\n         compareIdentifiers(this.patch, other.patch)\n}\n\nSemVer.prototype.comparePre = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options)\n  }\n\n  // NOT having a prerelease is > having one\n  if (this.prerelease.length && !other.prerelease.length) {\n    return -1\n  } else if (!this.prerelease.length && other.prerelease.length) {\n    return 1\n  } else if (!this.prerelease.length && !other.prerelease.length) {\n    return 0\n  }\n\n  var i = 0\n  do {\n    var a = this.prerelease[i]\n    var b = other.prerelease[i]\n    debug('prerelease compare', i, a, b)\n    if (a === undefined && b === undefined) {\n      return 0\n    } else if (b === undefined) {\n      return 1\n    } else if (a === undefined) {\n      return -1\n    } else if (a === b) {\n      continue\n    } else {\n      return compareIdentifiers(a, b)\n    }\n  } while (++i)\n}\n\nSemVer.prototype.compareBuild = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options)\n  }\n\n  var i = 0\n  do {\n    var a = this.build[i]\n    var b = other.build[i]\n    debug('prerelease compare', i, a, b)\n    if (a === undefined && b === undefined) {\n      return 0\n    } else if (b === undefined) {\n      return 1\n    } else if (a === undefined) {\n      return -1\n    } else if (a === b) {\n      continue\n    } else {\n      return compareIdentifiers(a, b)\n    }\n  } while (++i)\n}\n\n// preminor will bump the version up to the next minor release, and immediately\n// down to pre-release. premajor and prepatch work the same way.\nSemVer.prototype.inc = function (release, identifier) {\n  switch (release) {\n    case 'premajor':\n      this.prerelease.length = 0\n      this.patch = 0\n      this.minor = 0\n      this.major++\n      this.inc('pre', identifier)\n      break\n    case 'preminor':\n      this.prerelease.length = 0\n      this.patch = 0\n      this.minor++\n      this.inc('pre', identifier)\n      break\n    case 'prepatch':\n      // If this is already a prerelease, it will bump to the next version\n      // drop any prereleases that might already exist, since they are not\n      // relevant at this point.\n      this.prerelease.length = 0\n      this.inc('patch', identifier)\n      this.inc('pre', identifier)\n      break\n    // If the input is a non-prerelease version, this acts the same as\n    // prepatch.\n    case 'prerelease':\n      if (this.prerelease.length === 0) {\n        this.inc('patch', identifier)\n      }\n      this.inc('pre', identifier)\n      break\n\n    case 'major':\n      // If this is a pre-major version, bump up to the same major version.\n      // Otherwise increment major.\n      // 1.0.0-5 bumps to 1.0.0\n      // 1.1.0 bumps to 2.0.0\n      if (this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0) {\n        this.major++\n      }\n      this.minor = 0\n      this.patch = 0\n      this.prerelease = []\n      break\n    case 'minor':\n      // If this is a pre-minor version, bump up to the same minor version.\n      // Otherwise increment minor.\n      // 1.2.0-5 bumps to 1.2.0\n      // 1.2.1 bumps to 1.3.0\n      if (this.patch !== 0 || this.prerelease.length === 0) {\n        this.minor++\n      }\n      this.patch = 0\n      this.prerelease = []\n      break\n    case 'patch':\n      // If this is not a pre-release version, it will increment the patch.\n      // If it is a pre-release it will bump up to the same patch version.\n      // 1.2.0-5 patches to 1.2.0\n      // 1.2.0 patches to 1.2.1\n      if (this.prerelease.length === 0) {\n        this.patch++\n      }\n      this.prerelease = []\n      break\n    // This probably shouldn't be used publicly.\n    // 1.0.0 \"pre\" would become 1.0.0-0 which is the wrong direction.\n    case 'pre':\n      if (this.prerelease.length === 0) {\n        this.prerelease = [0]\n      } else {\n        var i = this.prerelease.length\n        while (--i >= 0) {\n          if (typeof this.prerelease[i] === 'number') {\n            this.prerelease[i]++\n            i = -2\n          }\n        }\n        if (i === -1) {\n          // didn't increment anything\n          this.prerelease.push(0)\n        }\n      }\n      if (identifier) {\n        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n        if (this.prerelease[0] === identifier) {\n          if (isNaN(this.prerelease[1])) {\n            this.prerelease = [identifier, 0]\n          }\n        } else {\n          this.prerelease = [identifier, 0]\n        }\n      }\n      break\n\n    default:\n      throw new Error('invalid increment argument: ' + release)\n  }\n  this.format()\n  this.raw = this.version\n  return this\n}\n\nexports.inc = inc\nfunction inc (version, release, loose, identifier) {\n  if (typeof (loose) === 'string') {\n    identifier = loose\n    loose = undefined\n  }\n\n  try {\n    return new SemVer(version, loose).inc(release, identifier).version\n  } catch (er) {\n    return null\n  }\n}\n\nexports.diff = diff\nfunction diff (version1, version2) {\n  if (eq(version1, version2)) {\n    return null\n  } else {\n    var v1 = parse(version1)\n    var v2 = parse(version2)\n    var prefix = ''\n    if (v1.prerelease.length || v2.prerelease.length) {\n      prefix = 'pre'\n      var defaultResult = 'prerelease'\n    }\n    for (var key in v1) {\n      if (key === 'major' || key === 'minor' || key === 'patch') {\n        if (v1[key] !== v2[key]) {\n          return prefix + key\n        }\n      }\n    }\n    return defaultResult // may be undefined\n  }\n}\n\nexports.compareIdentifiers = compareIdentifiers\n\nvar numeric = /^[0-9]+$/\nfunction compareIdentifiers (a, b) {\n  var anum = numeric.test(a)\n  var bnum = numeric.test(b)\n\n  if (anum && bnum) {\n    a = +a\n    b = +b\n  }\n\n  return a === b ? 0\n    : (anum && !bnum) ? -1\n    : (bnum && !anum) ? 1\n    : a < b ? -1\n    : 1\n}\n\nexports.rcompareIdentifiers = rcompareIdentifiers\nfunction rcompareIdentifiers (a, b) {\n  return compareIdentifiers(b, a)\n}\n\nexports.major = major\nfunction major (a, loose) {\n  return new SemVer(a, loose).major\n}\n\nexports.minor = minor\nfunction minor (a, loose) {\n  return new SemVer(a, loose).minor\n}\n\nexports.patch = patch\nfunction patch (a, loose) {\n  return new SemVer(a, loose).patch\n}\n\nexports.compare = compare\nfunction compare (a, b, loose) {\n  return new SemVer(a, loose).compare(new SemVer(b, loose))\n}\n\nexports.compareLoose = compareLoose\nfunction compareLoose (a, b) {\n  return compare(a, b, true)\n}\n\nexports.compareBuild = compareBuild\nfunction compareBuild (a, b, loose) {\n  var versionA = new SemVer(a, loose)\n  var versionB = new SemVer(b, loose)\n  return versionA.compare(versionB) || versionA.compareBuild(versionB)\n}\n\nexports.rcompare = rcompare\nfunction rcompare (a, b, loose) {\n  return compare(b, a, loose)\n}\n\nexports.sort = sort\nfunction sort (list, loose) {\n  return list.sort(function (a, b) {\n    return exports.compareBuild(a, b, loose)\n  })\n}\n\nexports.rsort = rsort\nfunction rsort (list, loose) {\n  return list.sort(function (a, b) {\n    return exports.compareBuild(b, a, loose)\n  })\n}\n\nexports.gt = gt\nfunction gt (a, b, loose) {\n  return compare(a, b, loose) > 0\n}\n\nexports.lt = lt\nfunction lt (a, b, loose) {\n  return compare(a, b, loose) < 0\n}\n\nexports.eq = eq\nfunction eq (a, b, loose) {\n  return compare(a, b, loose) === 0\n}\n\nexports.neq = neq\nfunction neq (a, b, loose) {\n  return compare(a, b, loose) !== 0\n}\n\nexports.gte = gte\nfunction gte (a, b, loose) {\n  return compare(a, b, loose) >= 0\n}\n\nexports.lte = lte\nfunction lte (a, b, loose) {\n  return compare(a, b, loose) <= 0\n}\n\nexports.cmp = cmp\nfunction cmp (a, op, b, loose) {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object')\n        a = a.version\n      if (typeof b === 'object')\n        b = b.version\n      return a === b\n\n    case '!==':\n      if (typeof a === 'object')\n        a = a.version\n      if (typeof b === 'object')\n        b = b.version\n      return a !== b\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose)\n\n    case '!=':\n      return neq(a, b, loose)\n\n    case '>':\n      return gt(a, b, loose)\n\n    case '>=':\n      return gte(a, b, loose)\n\n    case '<':\n      return lt(a, b, loose)\n\n    case '<=':\n      return lte(a, b, loose)\n\n    default:\n      throw new TypeError('Invalid operator: ' + op)\n  }\n}\n\nexports.Comparator = Comparator\nfunction Comparator (comp, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  if (comp instanceof Comparator) {\n    if (comp.loose === !!options.loose) {\n      return comp\n    } else {\n      comp = comp.value\n    }\n  }\n\n  if (!(this instanceof Comparator)) {\n    return new Comparator(comp, options)\n  }\n\n  debug('comparator', comp, options)\n  this.options = options\n  this.loose = !!options.loose\n  this.parse(comp)\n\n  if (this.semver === ANY) {\n    this.value = ''\n  } else {\n    this.value = this.operator + this.semver.version\n  }\n\n  debug('comp', this)\n}\n\nvar ANY = {}\nComparator.prototype.parse = function (comp) {\n  var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n  var m = comp.match(r)\n\n  if (!m) {\n    throw new TypeError('Invalid comparator: ' + comp)\n  }\n\n  this.operator = m[1] !== undefined ? m[1] : ''\n  if (this.operator === '=') {\n    this.operator = ''\n  }\n\n  // if it literally is just '>' or '' then allow anything.\n  if (!m[2]) {\n    this.semver = ANY\n  } else {\n    this.semver = new SemVer(m[2], this.options.loose)\n  }\n}\n\nComparator.prototype.toString = function () {\n  return this.value\n}\n\nComparator.prototype.test = function (version) {\n  debug('Comparator.test', version, this.options.loose)\n\n  if (this.semver === ANY || version === ANY) {\n    return true\n  }\n\n  if (typeof version === 'string') {\n    try {\n      version = new SemVer(version, this.options)\n    } catch (er) {\n      return false\n    }\n  }\n\n  return cmp(version, this.operator, this.semver, this.options)\n}\n\nComparator.prototype.intersects = function (comp, options) {\n  if (!(comp instanceof Comparator)) {\n    throw new TypeError('a Comparator is required')\n  }\n\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  var rangeTmp\n\n  if (this.operator === '') {\n    if (this.value === '') {\n      return true\n    }\n    rangeTmp = new Range(comp.value, options)\n    return satisfies(this.value, rangeTmp, options)\n  } else if (comp.operator === '') {\n    if (comp.value === '') {\n      return true\n    }\n    rangeTmp = new Range(this.value, options)\n    return satisfies(comp.semver, rangeTmp, options)\n  }\n\n  var sameDirectionIncreasing =\n    (this.operator === '>=' || this.operator === '>') &&\n    (comp.operator === '>=' || comp.operator === '>')\n  var sameDirectionDecreasing =\n    (this.operator === '<=' || this.operator === '<') &&\n    (comp.operator === '<=' || comp.operator === '<')\n  var sameSemVer = this.semver.version === comp.semver.version\n  var differentDirectionsInclusive =\n    (this.operator === '>=' || this.operator === '<=') &&\n    (comp.operator === '>=' || comp.operator === '<=')\n  var oppositeDirectionsLessThan =\n    cmp(this.semver, '<', comp.semver, options) &&\n    ((this.operator === '>=' || this.operator === '>') &&\n    (comp.operator === '<=' || comp.operator === '<'))\n  var oppositeDirectionsGreaterThan =\n    cmp(this.semver, '>', comp.semver, options) &&\n    ((this.operator === '<=' || this.operator === '<') &&\n    (comp.operator === '>=' || comp.operator === '>'))\n\n  return sameDirectionIncreasing || sameDirectionDecreasing ||\n    (sameSemVer && differentDirectionsInclusive) ||\n    oppositeDirectionsLessThan || oppositeDirectionsGreaterThan\n}\n\nexports.Range = Range\nfunction Range (range, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  if (range instanceof Range) {\n    if (range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease) {\n      return range\n    } else {\n      return new Range(range.raw, options)\n    }\n  }\n\n  if (range instanceof Comparator) {\n    return new Range(range.value, options)\n  }\n\n  if (!(this instanceof Range)) {\n    return new Range(range, options)\n  }\n\n  this.options = options\n  this.loose = !!options.loose\n  this.includePrerelease = !!options.includePrerelease\n\n  // First, split based on boolean or ||\n  this.raw = range\n  this.set = range.split(/\\s*\\|\\|\\s*/).map(function (range) {\n    return this.parseRange(range.trim())\n  }, this).filter(function (c) {\n    // throw out any that are not relevant for whatever reason\n    return c.length\n  })\n\n  if (!this.set.length) {\n    throw new TypeError('Invalid SemVer Range: ' + range)\n  }\n\n  this.format()\n}\n\nRange.prototype.format = function () {\n  this.range = this.set.map(function (comps) {\n    return comps.join(' ').trim()\n  }).join('||').trim()\n  return this.range\n}\n\nRange.prototype.toString = function () {\n  return this.range\n}\n\nRange.prototype.parseRange = function (range) {\n  var loose = this.options.loose\n  range = range.trim()\n  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n  var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]\n  range = range.replace(hr, hyphenReplace)\n  debug('hyphen replace', range)\n  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n  range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)\n  debug('comparator trim', range, re[t.COMPARATORTRIM])\n\n  // `~ 1.2.3` => `~1.2.3`\n  range = range.replace(re[t.TILDETRIM], tildeTrimReplace)\n\n  // `^ 1.2.3` => `^1.2.3`\n  range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n\n  // normalize spaces\n  range = range.split(/\\s+/).join(' ')\n\n  // At this point, the range is completely trimmed and\n  // ready to be split into comparators.\n\n  var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n  var set = range.split(' ').map(function (comp) {\n    return parseComparator(comp, this.options)\n  }, this).join(' ').split(/\\s+/)\n  if (this.options.loose) {\n    // in loose mode, throw out any that are not valid comparators\n    set = set.filter(function (comp) {\n      return !!comp.match(compRe)\n    })\n  }\n  set = set.map(function (comp) {\n    return new Comparator(comp, this.options)\n  }, this)\n\n  return set\n}\n\nRange.prototype.intersects = function (range, options) {\n  if (!(range instanceof Range)) {\n    throw new TypeError('a Range is required')\n  }\n\n  return this.set.some(function (thisComparators) {\n    return (\n      isSatisfiable(thisComparators, options) &&\n      range.set.some(function (rangeComparators) {\n        return (\n          isSatisfiable(rangeComparators, options) &&\n          thisComparators.every(function (thisComparator) {\n            return rangeComparators.every(function (rangeComparator) {\n              return thisComparator.intersects(rangeComparator, options)\n            })\n          })\n        )\n      })\n    )\n  })\n}\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nfunction isSatisfiable (comparators, options) {\n  var result = true\n  var remainingComparators = comparators.slice()\n  var testComparator = remainingComparators.pop()\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every(function (otherComparator) {\n      return testComparator.intersects(otherComparator, options)\n    })\n\n    testComparator = remainingComparators.pop()\n  }\n\n  return result\n}\n\n// Mostly just for testing and legacy API reasons\nexports.toComparators = toComparators\nfunction toComparators (range, options) {\n  return new Range(range, options).set.map(function (comp) {\n    return comp.map(function (c) {\n      return c.value\n    }).join(' ').trim().split(' ')\n  })\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nfunction parseComparator (comp, options) {\n  debug('comp', comp, options)\n  comp = replaceCarets(comp, options)\n  debug('caret', comp)\n  comp = replaceTildes(comp, options)\n  debug('tildes', comp)\n  comp = replaceXRanges(comp, options)\n  debug('xrange', comp)\n  comp = replaceStars(comp, options)\n  debug('stars', comp)\n  return comp\n}\n\nfunction isX (id) {\n  return !id || id.toLowerCase() === 'x' || id === '*'\n}\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0\nfunction replaceTildes (comp, options) {\n  return comp.trim().split(/\\s+/).map(function (comp) {\n    return replaceTilde(comp, options)\n  }).join(' ')\n}\n\nfunction replaceTilde (comp, options) {\n  var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n  return comp.replace(r, function (_, M, m, p, pr) {\n    debug('tilde', comp, _, M, m, p, pr)\n    var ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n            ' <' + M + '.' + (+m + 1) + '.0'\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0\n      ret = '>=' + M + '.' + m + '.' + p +\n            ' <' + M + '.' + (+m + 1) + '.0'\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0\n// ^1.2.3 --> >=1.2.3 <2.0.0\n// ^1.2.0 --> >=1.2.0 <2.0.0\nfunction replaceCarets (comp, options) {\n  return comp.trim().split(/\\s+/).map(function (comp) {\n    return replaceCaret(comp, options)\n  }).join(' ')\n}\n\nfunction replaceCaret (comp, options) {\n  debug('caret', comp, options)\n  var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n  return comp.replace(r, function (_, M, m, p, pr) {\n    debug('caret', comp, _, M, m, p, pr)\n    var ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'\n      } else {\n        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n                ' <' + M + '.' + m + '.' + (+p + 1)\n        } else {\n          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n                ' <' + M + '.' + (+m + 1) + '.0'\n        }\n      } else {\n        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n              ' <' + (+M + 1) + '.0.0'\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + m + '.' + (+p + 1)\n        } else {\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + (+m + 1) + '.0'\n        }\n      } else {\n        ret = '>=' + M + '.' + m + '.' + p +\n              ' <' + (+M + 1) + '.0.0'\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nfunction replaceXRanges (comp, options) {\n  debug('replaceXRanges', comp, options)\n  return comp.split(/\\s+/).map(function (comp) {\n    return replaceXRange(comp, options)\n  }).join(' ')\n}\n\nfunction replaceXRange (comp, options) {\n  comp = comp.trim()\n  var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    var xM = isX(M)\n    var xm = xM || isX(m)\n    var xp = xm || isX(p)\n    var anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n    pr = options.includePrerelease ? '-0' : ''\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0-0'\n      } else {\n        // nothing is forbidden\n        ret = '*'\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0\n      }\n      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        // >1.2.3 => >= 1.2.4\n        gtlt = '>='\n        if (xm) {\n          M = +M + 1\n          m = 0\n          p = 0\n        } else {\n          m = +m + 1\n          p = 0\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      ret = gtlt + M + '.' + m + '.' + p + pr\n    } else if (xm) {\n      ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr\n    } else if (xp) {\n      ret = '>=' + M + '.' + m + '.0' + pr +\n        ' <' + M + '.' + (+m + 1) + '.0' + pr\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nfunction replaceStars (comp, options) {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[t.STAR], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0\nfunction hyphenReplace ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr, tb) {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = '>=' + fM + '.0.0'\n  } else if (isX(fp)) {\n    from = '>=' + fM + '.' + fm + '.0'\n  } else {\n    from = '>=' + from\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = '<' + (+tM + 1) + '.0.0'\n  } else if (isX(tp)) {\n    to = '<' + tM + '.' + (+tm + 1) + '.0'\n  } else if (tpr) {\n    to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr\n  } else {\n    to = '<=' + to\n  }\n\n  return (from + ' ' + to).trim()\n}\n\n// if ANY of the sets match ALL of its comparators, then pass\nRange.prototype.test = function (version) {\n  if (!version) {\n    return false\n  }\n\n  if (typeof version === 'string') {\n    try {\n      version = new SemVer(version, this.options)\n    } catch (er) {\n      return false\n    }\n  }\n\n  for (var i = 0; i < this.set.length; i++) {\n    if (testSet(this.set[i], version, this.options)) {\n      return true\n    }\n  }\n  return false\n}\n\nfunction testSet (set, version, options) {\n  for (var i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        var allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n\nexports.satisfies = satisfies\nfunction satisfies (version, range, options) {\n  try {\n    range = new Range(range, options)\n  } catch (er) {\n    return false\n  }\n  return range.test(version)\n}\n\nexports.maxSatisfying = maxSatisfying\nfunction maxSatisfying (versions, range, options) {\n  var max = null\n  var maxSV = null\n  try {\n    var rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v\n        maxSV = new SemVer(max, options)\n      }\n    }\n  })\n  return max\n}\n\nexports.minSatisfying = minSatisfying\nfunction minSatisfying (versions, range, options) {\n  var min = null\n  var minSV = null\n  try {\n    var rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v\n        minSV = new SemVer(min, options)\n      }\n    }\n  })\n  return min\n}\n\nexports.minVersion = minVersion\nfunction minVersion (range, loose) {\n  range = new Range(range, loose)\n\n  var minver = new SemVer('0.0.0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = new SemVer('0.0.0-0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = null\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i]\n\n    comparators.forEach(function (comparator) {\n      // Clone to avoid manipulating the comparator's semver object.\n      var compver = new SemVer(comparator.semver.version)\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++\n          } else {\n            compver.prerelease.push(0)\n          }\n          compver.raw = compver.format()\n          /* fallthrough */\n        case '':\n        case '>=':\n          if (!minver || gt(minver, compver)) {\n            minver = compver\n          }\n          break\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break\n        /* istanbul ignore next */\n        default:\n          throw new Error('Unexpected operation: ' + comparator.operator)\n      }\n    })\n  }\n\n  if (minver && range.test(minver)) {\n    return minver\n  }\n\n  return null\n}\n\nexports.validRange = validRange\nfunction validRange (range, options) {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*'\n  } catch (er) {\n    return null\n  }\n}\n\n// Determine if version is less than all the versions possible in the range\nexports.ltr = ltr\nfunction ltr (version, range, options) {\n  return outside(version, range, '<', options)\n}\n\n// Determine if version is greater than all the versions possible in the range.\nexports.gtr = gtr\nfunction gtr (version, range, options) {\n  return outside(version, range, '>', options)\n}\n\nexports.outside = outside\nfunction outside (version, range, hilo, options) {\n  version = new SemVer(version, options)\n  range = new Range(range, options)\n\n  var gtfn, ltefn, ltfn, comp, ecomp\n  switch (hilo) {\n    case '>':\n      gtfn = gt\n      ltefn = lte\n      ltfn = lt\n      comp = '>'\n      ecomp = '>='\n      break\n    case '<':\n      gtfn = lt\n      ltefn = gte\n      ltfn = gt\n      comp = '<'\n      ecomp = '<='\n      break\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n  }\n\n  // If it satisifes the range it is not outside\n  if (satisfies(version, range, options)) {\n    return false\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i]\n\n    var high = null\n    var low = null\n\n    comparators.forEach(function (comparator) {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator\n      low = low || comparator\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator\n      }\n    })\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false\n    }\n  }\n  return true\n}\n\nexports.prerelease = prerelease\nfunction prerelease (version, options) {\n  var parsed = parse(version, options)\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\n\nexports.intersects = intersects\nfunction intersects (r1, r2, options) {\n  r1 = new Range(r1, options)\n  r2 = new Range(r2, options)\n  return r1.intersects(r2)\n}\n\nexports.coerce = coerce\nfunction coerce (version, options) {\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version === 'number') {\n    version = String(version)\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  options = options || {}\n\n  var match = null\n  if (!options.rtl) {\n    match = version.match(re[t.COERCE])\n  } else {\n    // Find the right-most coercible string that does not share\n    // a terminus with a more left-ward coercible string.\n    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n    //\n    // Walk through the string checking with a /g regexp\n    // Manually set the index so as to pick up overlapping matches.\n    // Stop when we get a match that ends at the string end, since no\n    // coercible string can be more right-ward without the same terminus.\n    var next\n    while ((next = re[t.COERCERTL].exec(version)) &&\n      (!match || match.index + match[0].length !== version.length)\n    ) {\n      if (!match ||\n          next.index + next[0].length !== match.index + match[0].length) {\n        match = next\n      }\n      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length\n    }\n    // leave it in a clean state\n    re[t.COERCERTL].lastIndex = -1\n  }\n\n  if (match === null) {\n    return null\n  }\n\n  return parse(match[2] +\n    '.' + (match[3] || '0') +\n    '.' + (match[4] || '0'), options)\n}\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = throttle;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","'use strict'\n\n// A linked list to keep track of recently-used-ness\nconst Yallist = require('yallist')\n\nconst MAX = Symbol('max')\nconst LENGTH = Symbol('length')\nconst LENGTH_CALCULATOR = Symbol('lengthCalculator')\nconst ALLOW_STALE = Symbol('allowStale')\nconst MAX_AGE = Symbol('maxAge')\nconst DISPOSE = Symbol('dispose')\nconst NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')\nconst LRU_LIST = Symbol('lruList')\nconst CACHE = Symbol('cache')\nconst UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')\n\nconst naiveLength = () => 1\n\n// lruList is a yallist where the head is the youngest\n// item, and the tail is the oldest.  the list contains the Hit\n// objects as the entries.\n// Each Hit object has a reference to its Yallist.Node.  This\n// never changes.\n//\n// cache is a Map (or PseudoMap) that matches the keys to\n// the Yallist.Node object.\nclass LRUCache {\n  constructor (options) {\n    if (typeof options === 'number')\n      options = { max: options }\n\n    if (!options)\n      options = {}\n\n    if (options.max && (typeof options.max !== 'number' || options.max < 0))\n      throw new TypeError('max must be a non-negative number')\n    // Kind of weird to have a default max of Infinity, but oh well.\n    const max = this[MAX] = options.max || Infinity\n\n    const lc = options.length || naiveLength\n    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc\n    this[ALLOW_STALE] = options.stale || false\n    if (options.maxAge && typeof options.maxAge !== 'number')\n      throw new TypeError('maxAge must be a number')\n    this[MAX_AGE] = options.maxAge || 0\n    this[DISPOSE] = options.dispose\n    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false\n    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false\n    this.reset()\n  }\n\n  // resize the cache when the max changes.\n  set max (mL) {\n    if (typeof mL !== 'number' || mL < 0)\n      throw new TypeError('max must be a non-negative number')\n\n    this[MAX] = mL || Infinity\n    trim(this)\n  }\n  get max () {\n    return this[MAX]\n  }\n\n  set allowStale (allowStale) {\n    this[ALLOW_STALE] = !!allowStale\n  }\n  get allowStale () {\n    return this[ALLOW_STALE]\n  }\n\n  set maxAge (mA) {\n    if (typeof mA !== 'number')\n      throw new TypeError('maxAge must be a non-negative number')\n\n    this[MAX_AGE] = mA\n    trim(this)\n  }\n  get maxAge () {\n    return this[MAX_AGE]\n  }\n\n  // resize the cache when the lengthCalculator changes.\n  set lengthCalculator (lC) {\n    if (typeof lC !== 'function')\n      lC = naiveLength\n\n    if (lC !== this[LENGTH_CALCULATOR]) {\n      this[LENGTH_CALCULATOR] = lC\n      this[LENGTH] = 0\n      this[LRU_LIST].forEach(hit => {\n        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)\n        this[LENGTH] += hit.length\n      })\n    }\n    trim(this)\n  }\n  get lengthCalculator () { return this[LENGTH_CALCULATOR] }\n\n  get length () { return this[LENGTH] }\n  get itemCount () { return this[LRU_LIST].length }\n\n  rforEach (fn, thisp) {\n    thisp = thisp || this\n    for (let walker = this[LRU_LIST].tail; walker !== null;) {\n      const prev = walker.prev\n      forEachStep(this, fn, walker, thisp)\n      walker = prev\n    }\n  }\n\n  forEach (fn, thisp) {\n    thisp = thisp || this\n    for (let walker = this[LRU_LIST].head; walker !== null;) {\n      const next = walker.next\n      forEachStep(this, fn, walker, thisp)\n      walker = next\n    }\n  }\n\n  keys () {\n    return this[LRU_LIST].toArray().map(k => k.key)\n  }\n\n  values () {\n    return this[LRU_LIST].toArray().map(k => k.value)\n  }\n\n  reset () {\n    if (this[DISPOSE] &&\n        this[LRU_LIST] &&\n        this[LRU_LIST].length) {\n      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))\n    }\n\n    this[CACHE] = new Map() // hash of items by key\n    this[LRU_LIST] = new Yallist() // list of items in order of use recency\n    this[LENGTH] = 0 // length of items in the list\n  }\n\n  dump () {\n    return this[LRU_LIST].map(hit =>\n      isStale(this, hit) ? false : {\n        k: hit.key,\n        v: hit.value,\n        e: hit.now + (hit.maxAge || 0)\n      }).toArray().filter(h => h)\n  }\n\n  dumpLru () {\n    return this[LRU_LIST]\n  }\n\n  set (key, value, maxAge) {\n    maxAge = maxAge || this[MAX_AGE]\n\n    if (maxAge && typeof maxAge !== 'number')\n      throw new TypeError('maxAge must be a number')\n\n    const now = maxAge ? Date.now() : 0\n    const len = this[LENGTH_CALCULATOR](value, key)\n\n    if (this[CACHE].has(key)) {\n      if (len > this[MAX]) {\n        del(this, this[CACHE].get(key))\n        return false\n      }\n\n      const node = this[CACHE].get(key)\n      const item = node.value\n\n      // dispose of the old one before overwriting\n      // split out into 2 ifs for better coverage tracking\n      if (this[DISPOSE]) {\n        if (!this[NO_DISPOSE_ON_SET])\n          this[DISPOSE](key, item.value)\n      }\n\n      item.now = now\n      item.maxAge = maxAge\n      item.value = value\n      this[LENGTH] += len - item.length\n      item.length = len\n      this.get(key)\n      trim(this)\n      return true\n    }\n\n    const hit = new Entry(key, value, len, now, maxAge)\n\n    // oversized objects fall out of cache automatically.\n    if (hit.length > this[MAX]) {\n      if (this[DISPOSE])\n        this[DISPOSE](key, value)\n\n      return false\n    }\n\n    this[LENGTH] += hit.length\n    this[LRU_LIST].unshift(hit)\n    this[CACHE].set(key, this[LRU_LIST].head)\n    trim(this)\n    return true\n  }\n\n  has (key) {\n    if (!this[CACHE].has(key)) return false\n    const hit = this[CACHE].get(key).value\n    return !isStale(this, hit)\n  }\n\n  get (key) {\n    return get(this, key, true)\n  }\n\n  peek (key) {\n    return get(this, key, false)\n  }\n\n  pop () {\n    const node = this[LRU_LIST].tail\n    if (!node)\n      return null\n\n    del(this, node)\n    return node.value\n  }\n\n  del (key) {\n    del(this, this[CACHE].get(key))\n  }\n\n  load (arr) {\n    // reset the cache\n    this.reset()\n\n    const now = Date.now()\n    // A previous serialized cache has the most recent items first\n    for (let l = arr.length - 1; l >= 0; l--) {\n      const hit = arr[l]\n      const expiresAt = hit.e || 0\n      if (expiresAt === 0)\n        // the item was created without expiration in a non aged cache\n        this.set(hit.k, hit.v)\n      else {\n        const maxAge = expiresAt - now\n        // dont add already expired items\n        if (maxAge > 0) {\n          this.set(hit.k, hit.v, maxAge)\n        }\n      }\n    }\n  }\n\n  prune () {\n    this[CACHE].forEach((value, key) => get(this, key, false))\n  }\n}\n\nconst get = (self, key, doUse) => {\n  const node = self[CACHE].get(key)\n  if (node) {\n    const hit = node.value\n    if (isStale(self, hit)) {\n      del(self, node)\n      if (!self[ALLOW_STALE])\n        return undefined\n    } else {\n      if (doUse) {\n        if (self[UPDATE_AGE_ON_GET])\n          node.value.now = Date.now()\n        self[LRU_LIST].unshiftNode(node)\n      }\n    }\n    return hit.value\n  }\n}\n\nconst isStale = (self, hit) => {\n  if (!hit || (!hit.maxAge && !self[MAX_AGE]))\n    return false\n\n  const diff = Date.now() - hit.now\n  return hit.maxAge ? diff > hit.maxAge\n    : self[MAX_AGE] && (diff > self[MAX_AGE])\n}\n\nconst trim = self => {\n  if (self[LENGTH] > self[MAX]) {\n    for (let walker = self[LRU_LIST].tail;\n      self[LENGTH] > self[MAX] && walker !== null;) {\n      // We know that we're about to delete this one, and also\n      // what the next least recently used key will be, so just\n      // go ahead and set it now.\n      const prev = walker.prev\n      del(self, walker)\n      walker = prev\n    }\n  }\n}\n\nconst del = (self, node) => {\n  if (node) {\n    const hit = node.value\n    if (self[DISPOSE])\n      self[DISPOSE](hit.key, hit.value)\n\n    self[LENGTH] -= hit.length\n    self[CACHE].delete(hit.key)\n    self[LRU_LIST].removeNode(node)\n  }\n}\n\nclass Entry {\n  constructor (key, value, length, now, maxAge) {\n    this.key = key\n    this.value = value\n    this.length = length\n    this.now = now\n    this.maxAge = maxAge || 0\n  }\n}\n\nconst forEachStep = (self, fn, node, thisp) => {\n  let hit = node.value\n  if (isStale(self, hit)) {\n    del(self, node)\n    if (!self[ALLOW_STALE])\n      hit = undefined\n  }\n  if (hit)\n    fn.call(thisp, hit.value, hit.key, self)\n}\n\nmodule.exports = LRUCache\n","//  Import support https://stackoverflow.com/questions/13673346/supporting-both-commonjs-and-amd\n(function(name, definition) {\n    if (typeof module !== \"undefined\") { module.exports = definition(); }\n    else if (typeof define === \"function\" && typeof define.amd === \"object\") { define(definition); }\n    else { this[name] = definition(); }\n}(\"clipboard\", function() {\n  if (typeof document === 'undefined' || !document.addEventListener) {\n    return null;\n  }\n\n  var clipboard = {};\n\n  clipboard.copy = (function() {\n    var _intercept = false;\n    var _data = null; // Map from data type (e.g. \"text/html\") to value.\n    var _bogusSelection = false;\n\n    function cleanup() {\n      _intercept = false;\n      _data = null;\n      if (_bogusSelection) {\n        window.getSelection().removeAllRanges();\n      }\n      _bogusSelection = false;\n    }\n\n    document.addEventListener(\"copy\", function(e) {\n      if (_intercept) {\n        for (var key in _data) {\n          e.clipboardData.setData(key, _data[key]);\n        }\n        e.preventDefault();\n      }\n    });\n\n    // Workaround for Safari: https://bugs.webkit.org/show_bug.cgi?id=156529\n    function bogusSelect() {\n      var sel = document.getSelection();\n      // If \"nothing\" is selected...\n      if (!document.queryCommandEnabled(\"copy\") && sel.isCollapsed) {\n        // ... temporarily select the entire body.\n        //\n        // We select the entire body because:\n        // - it's guaranteed to exist,\n        // - it works (unlike, say, document.head, or phantom element that is\n        //   not inserted into the DOM),\n        // - it doesn't seem to flicker (due to the synchronous copy event), and\n        // - it avoids modifying the DOM (can trigger mutation observers).\n        //\n        // Because we can't do proper feature detection (we already checked\n        // document.queryCommandEnabled(\"copy\") , which actually gives a false\n        // negative for Blink when nothing is selected) and UA sniffing is not\n        // reliable (a lot of UA strings contain \"Safari\"), this will also\n        // happen for some browsers other than Safari. :-()\n        var range = document.createRange();\n        range.selectNodeContents(document.body);\n        sel.removeAllRanges();\n        sel.addRange(range);\n        _bogusSelection = true;\n      }\n    };\n\n    return function(data) {\n      return new Promise(function(resolve, reject) {\n        _intercept = true;\n        if (typeof data === \"string\") {\n          _data = {\"text/plain\": data};\n        } else if (data instanceof Node) {\n          _data = {\"text/html\": new XMLSerializer().serializeToString(data)};\n        } else if (data instanceof Object){\n          _data = data;\n        } else {\n          reject(\"Invalid data type. Must be string, DOM node, or an object mapping MIME types to strings.\")\n        }\n\n        function triggerCopy(tryBogusSelect) {\n          try {\n            if (document.execCommand(\"copy\")) {\n              // document.execCommand is synchronous: http://www.w3.org/TR/2015/WD-clipboard-apis-20150421/#integration-with-rich-text-editing-apis\n              // So we can call resolve() back here.\n              cleanup();\n              resolve();\n            }\n            else {\n              if (!tryBogusSelect) {\n                bogusSelect();\n                triggerCopy(true);\n              } else {\n                cleanup();\n                throw new Error(\"Unable to copy. Perhaps it's not available in your browser?\");\n              }\n            }\n          } catch (e) {\n            cleanup();\n            reject(e);\n          }\n        }\n        triggerCopy(false);\n\n      });\n    };\n  })();\n\n  clipboard.paste = (function() {\n    var _intercept = false;\n    var _resolve;\n    var _dataType;\n\n    document.addEventListener(\"paste\", function(e) {\n      if (_intercept) {\n        _intercept = false;\n        e.preventDefault();\n        var resolve = _resolve;\n        _resolve = null;\n        resolve(e.clipboardData.getData(_dataType));\n      }\n    });\n\n    return function(dataType) {\n      return new Promise(function(resolve, reject) {\n        _intercept = true;\n        _resolve = resolve;\n        _dataType = dataType || \"text/plain\";\n        try {\n          if (!document.execCommand(\"paste\")) {\n            _intercept = false;\n            reject(new Error(\"Unable to paste. Pasting only works in Internet Explorer at the moment.\"));\n          }\n        } catch (e) {\n          _intercept = false;\n          reject(new Error(e));\n        }\n      });\n    };\n  })();\n\n  // Handle IE behaviour.\n  if (typeof ClipboardEvent === \"undefined\" &&\n      typeof window.clipboardData !== \"undefined\" &&\n      typeof window.clipboardData.setData !== \"undefined\") {\n\n    /*! promise-polyfill 2.0.1 */\n    (function(a){function b(a,b){return function(){a.apply(b,arguments)}}function c(a){if(\"object\"!=typeof this)throw new TypeError(\"Promises must be constructed via new\");if(\"function\"!=typeof a)throw new TypeError(\"not a function\");this._state=null,this._value=null,this._deferreds=[],i(a,b(e,this),b(f,this))}function d(a){var b=this;return null===this._state?void this._deferreds.push(a):void j(function(){var c=b._state?a.onFulfilled:a.onRejected;if(null===c)return void(b._state?a.resolve:a.reject)(b._value);var d;try{d=c(b._value)}catch(e){return void a.reject(e)}a.resolve(d)})}function e(a){try{if(a===this)throw new TypeError(\"A promise cannot be resolved with itself.\");if(a&&(\"object\"==typeof a||\"function\"==typeof a)){var c=a.then;if(\"function\"==typeof c)return void i(b(c,a),b(e,this),b(f,this))}this._state=!0,this._value=a,g.call(this)}catch(d){f.call(this,d)}}function f(a){this._state=!1,this._value=a,g.call(this)}function g(){for(var a=0,b=this._deferreds.length;b>a;a++)d.call(this,this._deferreds[a]);this._deferreds=null}function h(a,b,c,d){this.onFulfilled=\"function\"==typeof a?a:null,this.onRejected=\"function\"==typeof b?b:null,this.resolve=c,this.reject=d}function i(a,b,c){var d=!1;try{a(function(a){d||(d=!0,b(a))},function(a){d||(d=!0,c(a))})}catch(e){if(d)return;d=!0,c(e)}}var j=c.immediateFn||\"function\"==typeof setImmediate&&setImmediate||function(a){setTimeout(a,1)},k=Array.isArray||function(a){return\"[object Array]\"===Object.prototype.toString.call(a)};c.prototype[\"catch\"]=function(a){return this.then(null,a)},c.prototype.then=function(a,b){var e=this;return new c(function(c,f){d.call(e,new h(a,b,c,f))})},c.all=function(){var a=Array.prototype.slice.call(1===arguments.length&&k(arguments[0])?arguments[0]:arguments);return new c(function(b,c){function d(f,g){try{if(g&&(\"object\"==typeof g||\"function\"==typeof g)){var h=g.then;if(\"function\"==typeof h)return void h.call(g,function(a){d(f,a)},c)}a[f]=g,0===--e&&b(a)}catch(i){c(i)}}if(0===a.length)return b([]);for(var e=a.length,f=0;f<a.length;f++)d(f,a[f])})},c.resolve=function(a){return a&&\"object\"==typeof a&&a.constructor===c?a:new c(function(b){b(a)})},c.reject=function(a){return new c(function(b,c){c(a)})},c.race=function(a){return new c(function(b,c){for(var d=0,e=a.length;e>d;d++)a[d].then(b,c)})},\"undefined\"!=typeof module&&module.exports?module.exports=c:a.Promise||(a.Promise=c)})(this);\n\n    clipboard.copy = function(data) {\n      return new Promise(function(resolve, reject) {\n        // IE supports string and URL types: https://msdn.microsoft.com/en-us/library/ms536744(v=vs.85).aspx\n        // We only support the string type for now.\n        if (typeof data !== \"string\" && !(\"text/plain\" in data)) {\n          throw new Error(\"You must provide a text/plain type.\");\n        }\n\n        var strData = (typeof data === \"string\" ? data : data[\"text/plain\"]);\n        var copySucceeded = window.clipboardData.setData(\"Text\", strData);\n        if (copySucceeded) {\n          resolve();\n        } else {\n          reject(new Error(\"Copying was rejected.\"));\n        }\n      });\n    };\n\n    clipboard.paste = function() {\n      return new Promise(function(resolve, reject) {\n        var strData = window.clipboardData.getData(\"Text\");\n        if (strData) {\n          resolve(strData);\n        } else {\n          // The user rejected the paste request.\n          reject(new Error(\"Pasting was rejected.\"));\n        }\n      });\n    };\n  }\n\n  return clipboard;\n}));\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-debug-tools.production.min.js');\n} else {\n  module.exports = require('./cjs/react-debug-tools.development.js');\n}\n","export default \":root {\\n  /**\\n   * IMPORTANT: When new theme variables are added below– also add them to SettingsContext updateThemeVariables()\\n   */\\n\\n  /* Light theme */\\n  --light-color-attribute-name: #ef6632;\\n  --light-color-attribute-name-not-editable: #23272f;\\n  --light-color-attribute-name-inverted: rgba(255, 255, 255, 0.7);\\n  --light-color-attribute-value: #1a1aa6;\\n  --light-color-attribute-value-inverted: #ffffff;\\n  --light-color-attribute-editable-value: #1a1aa6;\\n  --light-color-background: #ffffff;\\n  --light-color-background-hover: rgba(0, 136, 250, 0.1);\\n  --light-color-background-inactive: #e5e5e5;\\n  --light-color-background-invalid: #fff0f0;\\n  --light-color-background-selected: #0088fa;\\n  --light-color-button-background: #ffffff;\\n  --light-color-button-background-focus: #ededed;\\n  --light-color-button: #5f6673;\\n  --light-color-button-disabled: #cfd1d5;\\n  --light-color-button-active: #0088fa;\\n  --light-color-button-focus: #23272f;\\n  --light-color-button-hover: #23272f;\\n  --light-color-border: #eeeeee;\\n  --light-color-commit-did-not-render-fill: #cfd1d5;\\n  --light-color-commit-did-not-render-fill-text: #000000;\\n  --light-color-commit-did-not-render-pattern: #cfd1d5;\\n  --light-color-commit-did-not-render-pattern-text: #333333;\\n  --light-color-commit-gradient-0: #37afa9;\\n  --light-color-commit-gradient-1: #63b19e;\\n  --light-color-commit-gradient-2: #80b393;\\n  --light-color-commit-gradient-3: #97b488;\\n  --light-color-commit-gradient-4: #abb67d;\\n  --light-color-commit-gradient-5: #beb771;\\n  --light-color-commit-gradient-6: #cfb965;\\n  --light-color-commit-gradient-7: #dfba57;\\n  --light-color-commit-gradient-8: #efbb49;\\n  --light-color-commit-gradient-9: #febc38;\\n  --light-color-commit-gradient-text: #000000;\\n  --light-color-component-name: #6a51b2;\\n  --light-color-component-name-inverted: #ffffff;\\n  --light-color-component-badge-background: rgba(0, 0, 0, 0.1);\\n  --light-color-component-badge-background-inverted: rgba(255, 255, 255, 0.25);\\n  --light-color-component-badge-count: #777d88;\\n  --light-color-component-badge-count-inverted: rgba(255, 255, 255, 0.7);\\n  --light-color-context-background: rgba(0,0,0,.9);\\n  --light-color-context-background-hover: rgba(255, 255, 255, 0.1);\\n  --light-color-context-background-selected: #178fb9;\\n  --light-color-context-border: #3d424a;\\n  --light-color-context-text: #ffffff;\\n  --light-color-context-text-selected: #ffffff;\\n  --light-color-dim: #777d88;\\n  --light-color-dimmer: #cfd1d5;\\n  --light-color-dimmest: #eff0f1;\\n  --light-color-error-background: hsl(0, 100%, 97%);\\n  --light-color-error-border: hsl(0, 100%, 92%);\\n  --light-color-error-text: #ff0000;\\n  --light-color-expand-collapse-toggle: #777d88;\\n  --light-color-link: #0000ff;\\n  --light-color-modal-background: rgba(255, 255, 255, 0.75);\\n  --light-color-record-active: #fc3a4b;\\n  --light-color-record-hover: #3578e5;\\n  --light-color-record-inactive: #0088fa;\\n  --light-color-scroll-thumb: #c2c2c2;\\n  --light-color-scroll-track: #fafafa;\\n  --light-color-search-match: yellow;\\n  --light-color-search-match-current: #f7923b;\\n  --light-color-selected-tree-highlight-active: rgba(0, 136, 250, 0.1);\\n  --light-color-selected-tree-highlight-inactive: rgba(0, 0, 0, 0.05);\\n  --light-color-shadow: rgba(0, 0, 0, 0.25);\\n  --light-color-tab-selected-border: #0088fa;\\n  --light-color-text: #000000;\\n  --light-color-text-invalid: #ff0000;\\n  --light-color-text-selected: #ffffff;\\n  --light-color-toggle-background-invalid: #fc3a4b;\\n  --light-color-toggle-background-on: #0088fa;\\n  --light-color-toggle-background-off: #cfd1d5;\\n  --light-color-toggle-text: #ffffff;\\n  --light-color-tooltip-background: rgba(0, 0, 0, 0.9);\\n  --light-color-tooltip-text: #ffffff;\\n\\n  /* Dark theme */\\n  --dark-color-attribute-name: #9d87d2;\\n  --dark-color-attribute-name-not-editable: #ededed;\\n  --dark-color-attribute-name-inverted: #282828;\\n  --dark-color-attribute-value: #cedae0;\\n  --dark-color-attribute-value-inverted: #ffffff;\\n  --dark-color-attribute-editable-value: yellow;\\n  --dark-color-background: #282c34;\\n  --dark-color-background-hover: rgba(255, 255, 255, 0.1);\\n  --dark-color-background-inactive: #3d424a;\\n  --dark-color-background-invalid: #5c0000;\\n  --dark-color-background-selected: #178fb9;\\n  --dark-color-button-background: #282c34;\\n  --dark-color-button-background-focus: #3d424a;\\n  --dark-color-button: #afb3b9;\\n  --dark-color-button-active: #61dafb;\\n  --dark-color-button-disabled: #4f5766;\\n  --dark-color-button-focus: #a2e9fc;\\n  --dark-color-button-hover: #ededed;\\n  --dark-color-border: #3d424a;\\n  --dark-color-commit-did-not-render-fill: #777d88;\\n  --dark-color-commit-did-not-render-fill-text: #000000;\\n  --dark-color-commit-did-not-render-pattern: #666c77;\\n  --dark-color-commit-did-not-render-pattern-text: #ffffff;\\n  --dark-color-commit-gradient-0: #37afa9;\\n  --dark-color-commit-gradient-1: #63b19e;\\n  --dark-color-commit-gradient-2: #80b393;\\n  --dark-color-commit-gradient-3: #97b488;\\n  --dark-color-commit-gradient-4: #abb67d;\\n  --dark-color-commit-gradient-5: #beb771;\\n  --dark-color-commit-gradient-6: #cfb965;\\n  --dark-color-commit-gradient-7: #dfba57;\\n  --dark-color-commit-gradient-8: #efbb49;\\n  --dark-color-commit-gradient-9: #febc38;\\n  --dark-color-commit-gradient-text: #000000;\\n  --dark-color-component-name: #61dafb;\\n  --dark-color-component-name-inverted: #282828;\\n  --dark-color-component-badge-background: rgba(255, 255, 255, 0.25);\\n  --dark-color-component-badge-background-inverted: rgba(0, 0, 0, 0.25);\\n  --dark-color-component-badge-count: #8f949d;\\n  --dark-color-component-badge-count-inverted: rgba(255, 255, 255, 0.7);\\n  --dark-color-context-background: rgba(255,255,255,.9);\\n  --dark-color-context-background-hover: rgba(0, 136, 250, 0.1);\\n  --dark-color-context-background-selected: #0088fa;\\n  --dark-color-context-border: #eeeeee;\\n  --dark-color-context-text: #000000;\\n  --dark-color-context-text-selected: #ffffff;\\n  --dark-color-dim: #8f949d;\\n  --dark-color-dimmer: #777d88;\\n  --dark-color-dimmest: #4f5766;\\n  --dark-color-error-background: #200;\\n  --dark-color-error-border: #900;\\n  --dark-color-error-text: #f55;\\n  --dark-color-expand-collapse-toggle: #8f949d;\\n  --dark-color-link: #61dafb;\\n  --dark-color-modal-background: rgba(0, 0, 0, 0.75);\\n  --dark-color-record-active: #fc3a4b;\\n  --dark-color-record-hover: #a2e9fc;\\n  --dark-color-record-inactive: #61dafb;\\n  --dark-color-scroll-thumb: #afb3b9;\\n  --dark-color-scroll-track: #313640;\\n  --dark-color-search-match: yellow;\\n  --dark-color-search-match-current: #f7923b;\\n  --dark-color-selected-tree-highlight-active: rgba(23, 143, 185, 0.15);\\n  --dark-color-selected-tree-highlight-inactive: rgba(255, 255, 255, 0.05);\\n  --dark-color-shadow: rgba(0, 0, 0, 0.5);\\n  --dark-color-tab-selected-border: #178fb9;\\n  --dark-color-text: #ffffff;\\n  --dark-color-text-invalid: #ff8080;\\n  --dark-color-text-selected: #ffffff;\\n  --dark-color-toggle-background-invalid: #fc3a4b;\\n  --dark-color-toggle-background-on: #178fb9;\\n  --dark-color-toggle-background-off: #777d88;\\n  --dark-color-toggle-text: #ffffff;\\n  --dark-color-tooltip-background: rgba(255, 255, 255, 0.9);\\n  --dark-color-tooltip-text: #000000;\\n\\n  /* Font smoothing */\\n  --light-font-smoothing: auto;\\n  --dark-font-smoothing: antialiased;\\n  --font-smoothing: auto;\\n\\n  /* Compact density */\\n  --compact-font-size-monospace-small: 9px;\\n  --compact-font-size-monospace-normal: 11px;\\n  --compact-font-size-monospace-large: 15px;\\n  --compact-font-size-sans-small: 10px;\\n  --compact-font-size-sans-normal: 12px;\\n  --compact-font-size-sans-large: 14px;\\n  --compact-line-height-data: 18px;\\n  --compact-root-font-size: 16px;\\n\\n  /* Comfortable density */\\n  --comfortable-font-size-monospace-small: 10px;\\n  --comfortable-font-size-monospace-normal: 13px;\\n  --comfortable-font-size-monospace-large: 17px;\\n  --comfortable-font-size-sans-small: 12px;\\n  --comfortable-font-size-sans-normal: 14px;\\n  --comfortable-font-size-sans-large: 16px;\\n  --comfortable-line-height-data: 22px;\\n  --comfortable-root-font-size: 20px;\\n\\n  /* GitHub.com system fonts */\\n  --font-family-monospace: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo,\\n    Courier, monospace;\\n  --font-family-sans: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica,\\n    Arial, sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol;\\n\\n  /* Constant values shared between JS and CSS */\\n  --interaction-commit-size: 10px;\\n  --interaction-label-width: 200px;\\n}\\n\"","'use strict'\nmodule.exports = Yallist\n\nYallist.Node = Node\nYallist.create = Yallist\n\nfunction Yallist (list) {\n  var self = this\n  if (!(self instanceof Yallist)) {\n    self = new Yallist()\n  }\n\n  self.tail = null\n  self.head = null\n  self.length = 0\n\n  if (list && typeof list.forEach === 'function') {\n    list.forEach(function (item) {\n      self.push(item)\n    })\n  } else if (arguments.length > 0) {\n    for (var i = 0, l = arguments.length; i < l; i++) {\n      self.push(arguments[i])\n    }\n  }\n\n  return self\n}\n\nYallist.prototype.removeNode = function (node) {\n  if (node.list !== this) {\n    throw new Error('removing node which does not belong to this list')\n  }\n\n  var next = node.next\n  var prev = node.prev\n\n  if (next) {\n    next.prev = prev\n  }\n\n  if (prev) {\n    prev.next = next\n  }\n\n  if (node === this.head) {\n    this.head = next\n  }\n  if (node === this.tail) {\n    this.tail = prev\n  }\n\n  node.list.length--\n  node.next = null\n  node.prev = null\n  node.list = null\n\n  return next\n}\n\nYallist.prototype.unshiftNode = function (node) {\n  if (node === this.head) {\n    return\n  }\n\n  if (node.list) {\n    node.list.removeNode(node)\n  }\n\n  var head = this.head\n  node.list = this\n  node.next = head\n  if (head) {\n    head.prev = node\n  }\n\n  this.head = node\n  if (!this.tail) {\n    this.tail = node\n  }\n  this.length++\n}\n\nYallist.prototype.pushNode = function (node) {\n  if (node === this.tail) {\n    return\n  }\n\n  if (node.list) {\n    node.list.removeNode(node)\n  }\n\n  var tail = this.tail\n  node.list = this\n  node.prev = tail\n  if (tail) {\n    tail.next = node\n  }\n\n  this.tail = node\n  if (!this.head) {\n    this.head = node\n  }\n  this.length++\n}\n\nYallist.prototype.push = function () {\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    push(this, arguments[i])\n  }\n  return this.length\n}\n\nYallist.prototype.unshift = function () {\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    unshift(this, arguments[i])\n  }\n  return this.length\n}\n\nYallist.prototype.pop = function () {\n  if (!this.tail) {\n    return undefined\n  }\n\n  var res = this.tail.value\n  this.tail = this.tail.prev\n  if (this.tail) {\n    this.tail.next = null\n  } else {\n    this.head = null\n  }\n  this.length--\n  return res\n}\n\nYallist.prototype.shift = function () {\n  if (!this.head) {\n    return undefined\n  }\n\n  var res = this.head.value\n  this.head = this.head.next\n  if (this.head) {\n    this.head.prev = null\n  } else {\n    this.tail = null\n  }\n  this.length--\n  return res\n}\n\nYallist.prototype.forEach = function (fn, thisp) {\n  thisp = thisp || this\n  for (var walker = this.head, i = 0; walker !== null; i++) {\n    fn.call(thisp, walker.value, i, this)\n    walker = walker.next\n  }\n}\n\nYallist.prototype.forEachReverse = function (fn, thisp) {\n  thisp = thisp || this\n  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {\n    fn.call(thisp, walker.value, i, this)\n    walker = walker.prev\n  }\n}\n\nYallist.prototype.get = function (n) {\n  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {\n    // abort out of the list early if we hit a cycle\n    walker = walker.next\n  }\n  if (i === n && walker !== null) {\n    return walker.value\n  }\n}\n\nYallist.prototype.getReverse = function (n) {\n  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {\n    // abort out of the list early if we hit a cycle\n    walker = walker.prev\n  }\n  if (i === n && walker !== null) {\n    return walker.value\n  }\n}\n\nYallist.prototype.map = function (fn, thisp) {\n  thisp = thisp || this\n  var res = new Yallist()\n  for (var walker = this.head; walker !== null;) {\n    res.push(fn.call(thisp, walker.value, this))\n    walker = walker.next\n  }\n  return res\n}\n\nYallist.prototype.mapReverse = function (fn, thisp) {\n  thisp = thisp || this\n  var res = new Yallist()\n  for (var walker = this.tail; walker !== null;) {\n    res.push(fn.call(thisp, walker.value, this))\n    walker = walker.prev\n  }\n  return res\n}\n\nYallist.prototype.reduce = function (fn, initial) {\n  var acc\n  var walker = this.head\n  if (arguments.length > 1) {\n    acc = initial\n  } else if (this.head) {\n    walker = this.head.next\n    acc = this.head.value\n  } else {\n    throw new TypeError('Reduce of empty list with no initial value')\n  }\n\n  for (var i = 0; walker !== null; i++) {\n    acc = fn(acc, walker.value, i)\n    walker = walker.next\n  }\n\n  return acc\n}\n\nYallist.prototype.reduceReverse = function (fn, initial) {\n  var acc\n  var walker = this.tail\n  if (arguments.length > 1) {\n    acc = initial\n  } else if (this.tail) {\n    walker = this.tail.prev\n    acc = this.tail.value\n  } else {\n    throw new TypeError('Reduce of empty list with no initial value')\n  }\n\n  for (var i = this.length - 1; walker !== null; i--) {\n    acc = fn(acc, walker.value, i)\n    walker = walker.prev\n  }\n\n  return acc\n}\n\nYallist.prototype.toArray = function () {\n  var arr = new Array(this.length)\n  for (var i = 0, walker = this.head; walker !== null; i++) {\n    arr[i] = walker.value\n    walker = walker.next\n  }\n  return arr\n}\n\nYallist.prototype.toArrayReverse = function () {\n  var arr = new Array(this.length)\n  for (var i = 0, walker = this.tail; walker !== null; i++) {\n    arr[i] = walker.value\n    walker = walker.prev\n  }\n  return arr\n}\n\nYallist.prototype.slice = function (from, to) {\n  to = to || this.length\n  if (to < 0) {\n    to += this.length\n  }\n  from = from || 0\n  if (from < 0) {\n    from += this.length\n  }\n  var ret = new Yallist()\n  if (to < from || to < 0) {\n    return ret\n  }\n  if (from < 0) {\n    from = 0\n  }\n  if (to > this.length) {\n    to = this.length\n  }\n  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {\n    walker = walker.next\n  }\n  for (; walker !== null && i < to; i++, walker = walker.next) {\n    ret.push(walker.value)\n  }\n  return ret\n}\n\nYallist.prototype.sliceReverse = function (from, to) {\n  to = to || this.length\n  if (to < 0) {\n    to += this.length\n  }\n  from = from || 0\n  if (from < 0) {\n    from += this.length\n  }\n  var ret = new Yallist()\n  if (to < from || to < 0) {\n    return ret\n  }\n  if (from < 0) {\n    from = 0\n  }\n  if (to > this.length) {\n    to = this.length\n  }\n  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {\n    walker = walker.prev\n  }\n  for (; walker !== null && i > from; i--, walker = walker.prev) {\n    ret.push(walker.value)\n  }\n  return ret\n}\n\nYallist.prototype.splice = function (start, deleteCount /*, ...nodes */) {\n  if (start > this.length) {\n    start = this.length - 1\n  }\n  if (start < 0) {\n    start = this.length + start;\n  }\n\n  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {\n    walker = walker.next\n  }\n\n  var ret = []\n  for (var i = 0; walker && i < deleteCount; i++) {\n    ret.push(walker.value)\n    walker = this.removeNode(walker)\n  }\n  if (walker === null) {\n    walker = this.tail\n  }\n\n  if (walker !== this.head && walker !== this.tail) {\n    walker = walker.prev\n  }\n\n  for (var i = 2; i < arguments.length; i++) {\n    walker = insert(this, walker, arguments[i])\n  }\n  return ret;\n}\n\nYallist.prototype.reverse = function () {\n  var head = this.head\n  var tail = this.tail\n  for (var walker = head; walker !== null; walker = walker.prev) {\n    var p = walker.prev\n    walker.prev = walker.next\n    walker.next = p\n  }\n  this.head = tail\n  this.tail = head\n  return this\n}\n\nfunction insert (self, node, value) {\n  var inserted = node === self.head ?\n    new Node(value, null, node, self) :\n    new Node(value, node, node.next, self)\n\n  if (inserted.next === null) {\n    self.tail = inserted\n  }\n  if (inserted.prev === null) {\n    self.head = inserted\n  }\n\n  self.length++\n\n  return inserted\n}\n\nfunction push (self, item) {\n  self.tail = new Node(item, self.tail, null, self)\n  if (!self.head) {\n    self.head = self.tail\n  }\n  self.length++\n}\n\nfunction unshift (self, item) {\n  self.head = new Node(item, null, self.head, self)\n  if (!self.tail) {\n    self.tail = self.head\n  }\n  self.length++\n}\n\nfunction Node (value, prev, next, list) {\n  if (!(this instanceof Node)) {\n    return new Node(value, prev, next, list)\n  }\n\n  this.list = list\n  this.value = value\n\n  if (prev) {\n    prev.next = this\n    this.prev = prev\n  } else {\n    this.prev = null\n  }\n\n  if (next) {\n    next.prev = this\n    this.next = next\n  } else {\n    this.next = null\n  }\n}\n\ntry {\n  // add if support for Symbol.iterator is present\n  require('./iterator.js')(Yallist)\n} catch (er) {}\n","'use strict'\nmodule.exports = function (Yallist) {\n  Yallist.prototype[Symbol.iterator] = function* () {\n    for (let walker = this.head; walker; walker = walker.next) {\n      yield walker.value\n    }\n  }\n}\n","/** @license React v0.0.0-experimental-9b8060041\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var b=60103,c=60106,d=60107,e=60108,f=60114,g=60109,h=60110,k=60112,l=60113,m=60120,n=60115,p=60116,q=60117,r=60129,u=60131;\nif(\"function\"===typeof Symbol&&Symbol.for){var v=Symbol.for;b=v(\"react.element\");c=v(\"react.portal\");d=v(\"react.fragment\");e=v(\"react.strict_mode\");f=v(\"react.profiler\");g=v(\"react.provider\");h=v(\"react.context\");k=v(\"react.forward_ref\");l=v(\"react.suspense\");m=v(\"react.suspense_list\");n=v(\"react.memo\");p=v(\"react.lazy\");q=v(\"react.fundamental\");r=v(\"react.debug_trace_mode\");u=v(\"react.legacy_hidden\")}var w=0;\"function\"===typeof Symbol&&(w=Symbol.for(\"react.module.reference\"));\nfunction x(a){if(\"object\"===typeof a&&null!==a){var t=a.$$typeof;switch(t){case b:switch(a=a.type,a){case d:case f:case e:case l:case m:return a;default:switch(a=a&&a.$$typeof,a){case h:case k:case p:case n:case g:return a;default:return t}}case c:return t}}}var y=g,z=b,A=k,B=d,C=p,D=n,E=c,F=f,G=e,H=l;exports.ContextConsumer=h;exports.ContextProvider=y;exports.Element=z;exports.ForwardRef=A;exports.Fragment=B;exports.Lazy=C;exports.Memo=D;exports.Portal=E;exports.Profiler=F;exports.StrictMode=G;\nexports.Suspense=H;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return x(a)===h};exports.isContextProvider=function(a){return x(a)===g};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return x(a)===k};exports.isFragment=function(a){return x(a)===d};exports.isLazy=function(a){return x(a)===p};exports.isMemo=function(a){return x(a)===n};\nexports.isPortal=function(a){return x(a)===c};exports.isProfiler=function(a){return x(a)===f};exports.isStrictMode=function(a){return x(a)===e};exports.isSuspense=function(a){return x(a)===l};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===d||a===f||a===r||a===e||a===l||a===m||a===u||\"object\"===typeof a&&null!==a&&(a.$$typeof===p||a.$$typeof===n||a.$$typeof===g||a.$$typeof===h||a.$$typeof===k||a.$$typeof===q||a.$$typeof===w||void 0!==a.getModuleId)?!0:!1};exports.typeOf=x;\n","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","/** @license React v0.0.0-experimental-9b8060041\n * react-debug-tools.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var g=require(\"object-assign\"),k=require(\"error-stack-parser\");function p(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}var v=require(\"react\").__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,w=60128;\nif(\"function\"===typeof Symbol&&Symbol.for){var x=Symbol.for;w=x(\"react.opaque.id\")}var y=[],z=null,A=null;\nfunction B(){if(null===z){var a=new Map;try{C.useContext({_currentValue:null}),C.useState(null),C.useReducer(function(a){return a},null),C.useRef(null),C.useLayoutEffect(function(){}),C.useEffect(function(){}),C.useImperativeHandle(void 0,function(){return null}),C.useDebugValue(null),C.useCallback(function(){}),C.useMemo(function(){return null})}finally{var b=y;y=[]}for(var c=0;c<b.length;c++){var d=b[c];a.set(d.primitive,k.parse(d.stackError))}z=a}return z}var D=null;\nfunction E(){var a=D;null!==a&&(D=a.next);return a}\nvar C={getCacheForType:function(){throw Error(p(248));},readContext:function(a){return a._currentValue},useCallback:function(a){var b=E();y.push({primitive:\"Callback\",stackError:Error(),value:null!==b?b.memoizedState[0]:a});return a},useContext:function(a){y.push({primitive:\"Context\",stackError:Error(),value:a._currentValue});return a._currentValue},useEffect:function(a){E();y.push({primitive:\"Effect\",stackError:Error(),value:a})},useImperativeHandle:function(a){E();var b=void 0;null!==a&&\"object\"===\ntypeof a&&(b=a.current);y.push({primitive:\"ImperativeHandle\",stackError:Error(),value:b})},useDebugValue:function(a,b){y.push({primitive:\"DebugValue\",stackError:Error(),value:\"function\"===typeof b?b(a):a})},useLayoutEffect:function(a){E();y.push({primitive:\"LayoutEffect\",stackError:Error(),value:a})},useMemo:function(a){var b=E();a=null!==b?b.memoizedState[0]:a();y.push({primitive:\"Memo\",stackError:Error(),value:a});return a},useReducer:function(a,b,c){a=E();b=null!==a?a.memoizedState:void 0!==c?\nc(b):b;y.push({primitive:\"Reducer\",stackError:Error(),value:b});return[b,function(){}]},useRef:function(a){var b=E();a=null!==b?b.memoizedState:{current:a};y.push({primitive:\"Ref\",stackError:Error(),value:a.current});return a},useState:function(a){var b=E();a=null!==b?b.memoizedState:\"function\"===typeof a?a():a;y.push({primitive:\"State\",stackError:Error(),value:a});return[a,function(){}]},useTransition:function(){E();E();y.push({primitive:\"Transition\",stackError:Error(),value:void 0});return[function(){},\n!1]},useMutableSource:function(a,b){E();E();E();E();a=b(a._source);y.push({primitive:\"MutableSource\",stackError:Error(),value:a});return a},useDeferredValue:function(a){E();E();y.push({primitive:\"DeferredValue\",stackError:Error(),value:a});return a},useOpaqueIdentifier:function(){var a=E();A&&0===A.mode&&E();(a=null===a?void 0:a.memoizedState)&&a.$$typeof===w&&(a=void 0);y.push({primitive:\"OpaqueIdentifier\",stackError:Error(),value:a});return a}},F=0;\nfunction G(a,b,c){var d=b[c].source,e=0;a:for(;e<a.length;e++)if(a[e].source===d){for(var n=c+1,q=e+1;n<b.length&&q<a.length;n++,q++)if(a[q].source!==b[n].source)continue a;return e}return-1}function H(a,b){if(!a)return!1;b=\"use\"+b;return a.length<b.length?!1:a.lastIndexOf(b)===a.length-b.length}function I(a){if(!a)return\"\";var b=a.lastIndexOf(\".\");-1===b&&(b=0);\"use\"===a.substr(b,3)&&(b+=3);return a.substr(b)}\nfunction J(a,b){for(var c=[],d=null,e=c,n=0,q=[],u=0;u<b.length;u++){var t=b[u];var f=a;var h=k.parse(t.stackError);b:{var m=h,r=G(m,f,F);if(-1!==r)f=r;else{for(var l=0;l<f.length&&5>l;l++)if(r=G(m,f,l),-1!==r){F=l;f=r;break b}f=-1}}b:{m=h;r=B().get(t.primitive);if(void 0!==r)for(l=0;l<r.length&&l<m.length;l++)if(r[l].source!==m[l].source){l<m.length-1&&H(m[l].functionName,t.primitive)&&l++;l<m.length-1&&H(m[l].functionName,t.primitive)&&l++;m=l;break b}m=-1}h=-1===f||-1===m||2>f-m?null:h.slice(m,\nf-1);if(null!==h){f=0;if(null!==d){for(;f<h.length&&f<d.length&&h[h.length-f-1].source===d[d.length-f-1].source;)f++;for(d=d.length-1;d>f;d--)e=q.pop()}for(d=h.length-f-1;1<=d;d--)f=[],e.push({id:null,isStateEditable:!1,name:I(h[d-1].functionName),value:void 0,subHooks:f}),q.push(e),e=f;d=h}h=t.primitive;f=\"Context\"===h||\"DebugValue\"===h?null:n++;e.push({id:f,isStateEditable:\"Reducer\"===h||\"State\"===h,name:h,value:t.value,subHooks:[]})}K(c,null);return c}\nfunction K(a,b){for(var c=[],d=0;d<a.length;d++){var e=a[d];\"DebugValue\"===e.name&&0===e.subHooks.length?(a.splice(d,1),d--,c.push(e)):K(e.subHooks,e)}null!==b&&(1===c.length?b.value=c[0].value:1<c.length&&(b.value=c.map(function(a){return a.value})))}function L(a,b,c){null==c&&(c=v.ReactCurrentDispatcher);var d=c.current;c.current=C;try{var e=Error();a(b)}finally{a=y,y=[],c.current=d}c=k.parse(e);return J(c,a)}function M(a){a.forEach(function(a,c){return c._currentValue=a})}\nexports.inspectHooks=L;\nexports.inspectHooksOfFiber=function(a,b){null==b&&(b=v.ReactCurrentDispatcher);A=a;if(0!==a.tag&&15!==a.tag&&11!==a.tag)throw Error(\"Unknown Fiber. Needs to be a function component to inspect hooks.\");B();var c=a.type,d=a.memoizedProps;if(c!==a.elementType&&c&&c.defaultProps){d=g({},d);var e=c.defaultProps;for(n in e)void 0===d[n]&&(d[n]=e[n])}D=a.memoizedState;var n=new Map;try{for(e=a;e;){if(10===e.tag){var q=e.type._context;n.has(q)||(n.set(q,q._currentValue),q._currentValue=e.memoizedProps.value)}e=\ne.return}if(11===a.tag){var u=c.render;c=d;var t=a.ref;a=b;var f=a.current;a.current=C;try{var h=Error();u(c,t)}finally{var m=y;y=[];a.current=f}var r=k.parse(h);return J(r,m)}return L(c,d,b)}finally{D=null,M(n)}};\n","(function(root, factory) {\n    'use strict';\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.\n\n    /* istanbul ignore next */\n    if (typeof define === 'function' && define.amd) {\n        define('error-stack-parser', ['stackframe'], factory);\n    } else if (typeof exports === 'object') {\n        module.exports = factory(require('stackframe'));\n    } else {\n        root.ErrorStackParser = factory(root.StackFrame);\n    }\n}(this, function ErrorStackParser(StackFrame) {\n    'use strict';\n\n    var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\\S+:\\d+/;\n    var CHROME_IE_STACK_REGEXP = /^\\s*at .*(\\S+:\\d+|\\(native\\))/m;\n    var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\\[native code])?$/;\n\n    return {\n        /**\n         * Given an Error object, extract the most information from it.\n         *\n         * @param {Error} error object\n         * @return {Array} of StackFrames\n         */\n        parse: function ErrorStackParser$$parse(error) {\n            if (typeof error.stacktrace !== 'undefined' || typeof error['opera#sourceloc'] !== 'undefined') {\n                return this.parseOpera(error);\n            } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {\n                return this.parseV8OrIE(error);\n            } else if (error.stack) {\n                return this.parseFFOrSafari(error);\n            } else {\n                throw new Error('Cannot parse given Error object');\n            }\n        },\n\n        // Separate line and column numbers from a string of the form: (URI:Line:Column)\n        extractLocation: function ErrorStackParser$$extractLocation(urlLike) {\n            // Fail-fast but return locations like \"(native)\"\n            if (urlLike.indexOf(':') === -1) {\n                return [urlLike];\n            }\n\n            var regExp = /(.+?)(?::(\\d+))?(?::(\\d+))?$/;\n            var parts = regExp.exec(urlLike.replace(/[()]/g, ''));\n            return [parts[1], parts[2] || undefined, parts[3] || undefined];\n        },\n\n        parseV8OrIE: function ErrorStackParser$$parseV8OrIE(error) {\n            var filtered = error.stack.split('\\n').filter(function(line) {\n                return !!line.match(CHROME_IE_STACK_REGEXP);\n            }, this);\n\n            return filtered.map(function(line) {\n                if (line.indexOf('(eval ') > -1) {\n                    // Throw away eval information until we implement stacktrace.js/stackframe#8\n                    line = line.replace(/eval code/g, 'eval').replace(/(\\(eval at [^()]*)|(\\),.*$)/g, '');\n                }\n                var sanitizedLine = line.replace(/^\\s+/, '').replace(/\\(eval code/g, '(');\n\n                // capture and preseve the parenthesized location \"(/foo/my bar.js:12:87)\" in\n                // case it has spaces in it, as the string is split on \\s+ later on\n                var location = sanitizedLine.match(/ (\\((.+):(\\d+):(\\d+)\\)$)/);\n\n                // remove the parenthesized location from the line, if it was matched\n                sanitizedLine = location ? sanitizedLine.replace(location[0], '') : sanitizedLine;\n\n                var tokens = sanitizedLine.split(/\\s+/).slice(1);\n                // if a location was matched, pass it to extractLocation() otherwise pop the last token\n                var locationParts = this.extractLocation(location ? location[1] : tokens.pop());\n                var functionName = tokens.join(' ') || undefined;\n                var fileName = ['eval', '<anonymous>'].indexOf(locationParts[0]) > -1 ? undefined : locationParts[0];\n\n                return new StackFrame({\n                    functionName: functionName,\n                    fileName: fileName,\n                    lineNumber: locationParts[1],\n                    columnNumber: locationParts[2],\n                    source: line\n                });\n            }, this);\n        },\n\n        parseFFOrSafari: function ErrorStackParser$$parseFFOrSafari(error) {\n            var filtered = error.stack.split('\\n').filter(function(line) {\n                return !line.match(SAFARI_NATIVE_CODE_REGEXP);\n            }, this);\n\n            return filtered.map(function(line) {\n                // Throw away eval information until we implement stacktrace.js/stackframe#8\n                if (line.indexOf(' > eval') > -1) {\n                    line = line.replace(/ line (\\d+)(?: > eval line \\d+)* > eval:\\d+:\\d+/g, ':$1');\n                }\n\n                if (line.indexOf('@') === -1 && line.indexOf(':') === -1) {\n                    // Safari eval frames only have function names and nothing else\n                    return new StackFrame({\n                        functionName: line\n                    });\n                } else {\n                    var functionNameRegex = /((.*\".+\"[^@]*)?[^@]*)(?:@)/;\n                    var matches = line.match(functionNameRegex);\n                    var functionName = matches && matches[1] ? matches[1] : undefined;\n                    var locationParts = this.extractLocation(line.replace(functionNameRegex, ''));\n\n                    return new StackFrame({\n                        functionName: functionName,\n                        fileName: locationParts[0],\n                        lineNumber: locationParts[1],\n                        columnNumber: locationParts[2],\n                        source: line\n                    });\n                }\n            }, this);\n        },\n\n        parseOpera: function ErrorStackParser$$parseOpera(e) {\n            if (!e.stacktrace || (e.message.indexOf('\\n') > -1 &&\n                e.message.split('\\n').length > e.stacktrace.split('\\n').length)) {\n                return this.parseOpera9(e);\n            } else if (!e.stack) {\n                return this.parseOpera10(e);\n            } else {\n                return this.parseOpera11(e);\n            }\n        },\n\n        parseOpera9: function ErrorStackParser$$parseOpera9(e) {\n            var lineRE = /Line (\\d+).*script (?:in )?(\\S+)/i;\n            var lines = e.message.split('\\n');\n            var result = [];\n\n            for (var i = 2, len = lines.length; i < len; i += 2) {\n                var match = lineRE.exec(lines[i]);\n                if (match) {\n                    result.push(new StackFrame({\n                        fileName: match[2],\n                        lineNumber: match[1],\n                        source: lines[i]\n                    }));\n                }\n            }\n\n            return result;\n        },\n\n        parseOpera10: function ErrorStackParser$$parseOpera10(e) {\n            var lineRE = /Line (\\d+).*script (?:in )?(\\S+)(?:: In function (\\S+))?$/i;\n            var lines = e.stacktrace.split('\\n');\n            var result = [];\n\n            for (var i = 0, len = lines.length; i < len; i += 2) {\n                var match = lineRE.exec(lines[i]);\n                if (match) {\n                    result.push(\n                        new StackFrame({\n                            functionName: match[3] || undefined,\n                            fileName: match[2],\n                            lineNumber: match[1],\n                            source: lines[i]\n                        })\n                    );\n                }\n            }\n\n            return result;\n        },\n\n        // Opera 10.65+ Error.stack very similar to FF/Safari\n        parseOpera11: function ErrorStackParser$$parseOpera11(error) {\n            var filtered = error.stack.split('\\n').filter(function(line) {\n                return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);\n            }, this);\n\n            return filtered.map(function(line) {\n                var tokens = line.split('@');\n                var locationParts = this.extractLocation(tokens.pop());\n                var functionCall = (tokens.shift() || '');\n                var functionName = functionCall\n                    .replace(/<anonymous function(: (\\w+))?>/, '$2')\n                    .replace(/\\([^)]*\\)/g, '') || undefined;\n                var argsRaw;\n                if (functionCall.match(/\\(([^)]*)\\)/)) {\n                    argsRaw = functionCall.replace(/^[^(]+\\(([^)]*)\\)$/, '$1');\n                }\n                var args = (argsRaw === undefined || argsRaw === '[arguments not available]') ?\n                    undefined : argsRaw.split(',');\n\n                return new StackFrame({\n                    functionName: functionName,\n                    args: args,\n                    fileName: locationParts[0],\n                    lineNumber: locationParts[1],\n                    columnNumber: locationParts[2],\n                    source: line\n                });\n            }, this);\n        }\n    };\n}));\n","(function(root, factory) {\n    'use strict';\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.\n\n    /* istanbul ignore next */\n    if (typeof define === 'function' && define.amd) {\n        define('stackframe', [], factory);\n    } else if (typeof exports === 'object') {\n        module.exports = factory();\n    } else {\n        root.StackFrame = factory();\n    }\n}(this, function() {\n    'use strict';\n    function _isNumber(n) {\n        return !isNaN(parseFloat(n)) && isFinite(n);\n    }\n\n    function _capitalize(str) {\n        return str.charAt(0).toUpperCase() + str.substring(1);\n    }\n\n    function _getter(p) {\n        return function() {\n            return this[p];\n        };\n    }\n\n    var booleanProps = ['isConstructor', 'isEval', 'isNative', 'isToplevel'];\n    var numericProps = ['columnNumber', 'lineNumber'];\n    var stringProps = ['fileName', 'functionName', 'source'];\n    var arrayProps = ['args'];\n\n    var props = booleanProps.concat(numericProps, stringProps, arrayProps);\n\n    function StackFrame(obj) {\n        if (!obj) return;\n        for (var i = 0; i < props.length; i++) {\n            if (obj[props[i]] !== undefined) {\n                this['set' + _capitalize(props[i])](obj[props[i]]);\n            }\n        }\n    }\n\n    StackFrame.prototype = {\n        getArgs: function() {\n            return this.args;\n        },\n        setArgs: function(v) {\n            if (Object.prototype.toString.call(v) !== '[object Array]') {\n                throw new TypeError('Args must be an Array');\n            }\n            this.args = v;\n        },\n\n        getEvalOrigin: function() {\n            return this.evalOrigin;\n        },\n        setEvalOrigin: function(v) {\n            if (v instanceof StackFrame) {\n                this.evalOrigin = v;\n            } else if (v instanceof Object) {\n                this.evalOrigin = new StackFrame(v);\n            } else {\n                throw new TypeError('Eval Origin must be an Object or StackFrame');\n            }\n        },\n\n        toString: function() {\n            var fileName = this.getFileName() || '';\n            var lineNumber = this.getLineNumber() || '';\n            var columnNumber = this.getColumnNumber() || '';\n            var functionName = this.getFunctionName() || '';\n            if (this.getIsEval()) {\n                if (fileName) {\n                    return '[eval] (' + fileName + ':' + lineNumber + ':' + columnNumber + ')';\n                }\n                return '[eval]:' + lineNumber + ':' + columnNumber;\n            }\n            if (functionName) {\n                return functionName + ' (' + fileName + ':' + lineNumber + ':' + columnNumber + ')';\n            }\n            return fileName + ':' + lineNumber + ':' + columnNumber;\n        }\n    };\n\n    StackFrame.fromString = function StackFrame$$fromString(str) {\n        var argsStartIndex = str.indexOf('(');\n        var argsEndIndex = str.lastIndexOf(')');\n\n        var functionName = str.substring(0, argsStartIndex);\n        var args = str.substring(argsStartIndex + 1, argsEndIndex).split(',');\n        var locationString = str.substring(argsEndIndex + 1);\n\n        if (locationString.indexOf('@') === 0) {\n            var parts = /@(.+?)(?::(\\d+))?(?::(\\d+))?$/.exec(locationString, '');\n            var fileName = parts[1];\n            var lineNumber = parts[2];\n            var columnNumber = parts[3];\n        }\n\n        return new StackFrame({\n            functionName: functionName,\n            args: args || undefined,\n            fileName: fileName,\n            lineNumber: lineNumber || undefined,\n            columnNumber: columnNumber || undefined\n        });\n    };\n\n    for (var i = 0; i < booleanProps.length; i++) {\n        StackFrame.prototype['get' + _capitalize(booleanProps[i])] = _getter(booleanProps[i]);\n        StackFrame.prototype['set' + _capitalize(booleanProps[i])] = (function(p) {\n            return function(v) {\n                this[p] = Boolean(v);\n            };\n        })(booleanProps[i]);\n    }\n\n    for (var j = 0; j < numericProps.length; j++) {\n        StackFrame.prototype['get' + _capitalize(numericProps[j])] = _getter(numericProps[j]);\n        StackFrame.prototype['set' + _capitalize(numericProps[j])] = (function(p) {\n            return function(v) {\n                if (!_isNumber(v)) {\n                    throw new TypeError(p + ' must be a Number');\n                }\n                this[p] = Number(v);\n            };\n        })(numericProps[j]);\n    }\n\n    for (var k = 0; k < stringProps.length; k++) {\n        StackFrame.prototype['get' + _capitalize(stringProps[k])] = _getter(stringProps[k]);\n        StackFrame.prototype['set' + _capitalize(stringProps[k])] = (function(p) {\n            return function(v) {\n                this[p] = String(v);\n            };\n        })(stringProps[k]);\n    }\n\n    return StackFrame;\n}));\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","/** @license React v0.0.0-experimental-9b8060041\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var l=require(\"object-assign\"),m=60103,p=60106;exports.Fragment=60107;exports.StrictMode=60108;exports.Profiler=60114;var q=60109,r=60110,t=60112;exports.Suspense=60113;exports.unstable_SuspenseList=60120;var u=60115,v=60116;exports.unstable_DebugTracingMode=60129;exports.unstable_LegacyHidden=60131;\nif(\"function\"===typeof Symbol&&Symbol.for){var w=Symbol.for;m=w(\"react.element\");p=w(\"react.portal\");exports.Fragment=w(\"react.fragment\");exports.StrictMode=w(\"react.strict_mode\");exports.Profiler=w(\"react.profiler\");q=w(\"react.provider\");r=w(\"react.context\");t=w(\"react.forward_ref\");exports.Suspense=w(\"react.suspense\");exports.unstable_SuspenseList=w(\"react.suspense_list\");u=w(\"react.memo\");v=w(\"react.lazy\");exports.unstable_DebugTracingMode=w(\"react.debug_trace_mode\");exports.unstable_LegacyHidden=\nw(\"react.legacy_hidden\")}var x=\"function\"===typeof Symbol&&Symbol.iterator;function y(a){if(null===a||\"object\"!==typeof a)return null;a=x&&a[x]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}\nfunction z(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}var A={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},B={};\nfunction C(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A}C.prototype.isReactComponent={};C.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(z(85));this.updater.enqueueSetState(this,a,b,\"setState\")};C.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};function D(){}D.prototype=C.prototype;function E(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A}var F=E.prototype=new D;\nF.constructor=E;l(F,C.prototype);F.isPureReactComponent=!0;var G={current:null},H=Object.prototype.hasOwnProperty,I={key:!0,ref:!0,__self:!0,__source:!0};\nfunction J(a,b,c){var e,d={},k=null,h=null;if(null!=b)for(e in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=\"\"+b.key),b)H.call(b,e)&&!I.hasOwnProperty(e)&&(d[e]=b[e]);var g=arguments.length-2;if(1===g)d.children=c;else if(1<g){for(var f=Array(g),n=0;n<g;n++)f[n]=arguments[n+2];d.children=f}if(a&&a.defaultProps)for(e in g=a.defaultProps,g)void 0===d[e]&&(d[e]=g[e]);return{$$typeof:m,type:a,key:k,ref:h,props:d,_owner:G.current}}\nfunction K(a,b){return{$$typeof:m,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function L(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===m}function escape(a){var b={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+a.replace(/[=:]/g,function(a){return b[a]})}var M=/\\/+/g;function N(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(\"\"+a.key):b.toString(36)}\nfunction O(a,b,c,e,d){var k=typeof a;if(\"undefined\"===k||\"boolean\"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case \"string\":case \"number\":h=!0;break;case \"object\":switch(a.$$typeof){case m:case p:h=!0}}if(h)return h=a,d=d(h),a=\"\"===e?\".\"+N(h,0):e,Array.isArray(d)?(c=\"\",null!=a&&(c=a.replace(M,\"$&/\")+\"/\"),O(d,b,c,\"\",function(a){return a})):null!=d&&(L(d)&&(d=K(d,c+(!d.key||h&&h.key===d.key?\"\":(\"\"+d.key).replace(M,\"$&/\")+\"/\")+a)),b.push(d)),1;h=0;e=\"\"===e?\".\":e+\":\";if(Array.isArray(a))for(var g=\n0;g<a.length;g++){k=a[g];var f=e+N(k,g);h+=O(k,b,c,f,d)}else if(f=y(a),\"function\"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=e+N(k,g++),h+=O(k,b,c,f,d);else if(\"object\"===k)throw b=\"\"+a,Error(z(31,\"[object Object]\"===b?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":b));return h}function P(a,b,c){if(null==a)return a;var e=[],d=0;O(a,e,\"\",\"\",function(a){return b.call(c,a,d++)});return e}\nfunction Q(a){if(-1===a._status){var b=a._result;b=b();a._status=0;a._result=b;b.then(function(b){0===a._status&&(b=b.default,a._status=1,a._result=b)},function(b){0===a._status&&(a._status=2,a._result=b)})}if(1===a._status)return a._result;throw a._result;}var R={current:null};function S(){var a=R.current;if(null===a)throw Error(z(321));return a}var T={transition:0},U={ReactCurrentDispatcher:R,ReactCurrentBatchConfig:T,ReactCurrentOwner:G,IsSomeRendererActing:{current:!1},assign:l};\nexports.Children={map:P,forEach:function(a,b,c){P(a,function(){b.apply(this,arguments)},c)},count:function(a){var b=0;P(a,function(){b++});return b},toArray:function(a){return P(a,function(a){return a})||[]},only:function(a){if(!L(a))throw Error(z(143));return a}};exports.Component=C;exports.PureComponent=E;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=U;\nexports.cloneElement=function(a,b,c){if(null===a||void 0===a)throw Error(z(267,a));var e=l({},a.props),d=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=G.current);void 0!==b.key&&(d=\"\"+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)H.call(b,f)&&!I.hasOwnProperty(f)&&(e[f]=void 0===b[f]&&void 0!==g?g[f]:b[f])}var f=arguments.length-2;if(1===f)e.children=c;else if(1<f){g=Array(f);for(var n=0;n<f;n++)g[n]=arguments[n+2];e.children=g}return{$$typeof:m,type:a.type,\nkey:d,ref:k,props:e,_owner:h}};exports.createContext=function(a,b){void 0===b&&(b=null);a={$$typeof:r,_calculateChangedBits:b,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null};a.Provider={$$typeof:q,_context:a};return a.Consumer=a};exports.createElement=J;exports.createFactory=function(a){var b=J.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};exports.forwardRef=function(a){return{$$typeof:t,render:a}};exports.isValidElement=L;\nexports.lazy=function(a){return{$$typeof:v,_payload:{_status:-1,_result:a},_init:Q}};exports.memo=function(a,b){return{$$typeof:u,type:a,compare:void 0===b?null:b}};exports.unstable_createMutableSource=function(a,b){return{_getVersion:b,_source:a,_workInProgressVersionPrimary:null,_workInProgressVersionSecondary:null}};exports.unstable_getCacheForType=function(a){return S().getCacheForType(a)};\nexports.unstable_startTransition=function(a){var b=T.transition;T.transition=1;try{a()}finally{T.transition=b}};exports.unstable_useDeferredValue=function(a){return S().useDeferredValue(a)};exports.unstable_useMutableSource=function(a,b,c){return S().useMutableSource(a,b,c)};exports.unstable_useOpaqueIdentifier=function(){return S().useOpaqueIdentifier()};exports.unstable_useTransition=function(){return S().useTransition()};exports.useCallback=function(a,b){return S().useCallback(a,b)};\nexports.useContext=function(a,b){return S().useContext(a,b)};exports.useDebugValue=function(){};exports.useEffect=function(a,b){return S().useEffect(a,b)};exports.useImperativeHandle=function(a,b,c){return S().useImperativeHandle(a,b,c)};exports.useLayoutEffect=function(a,b){return S().useLayoutEffect(a,b)};exports.useMemo=function(a,b){return S().useMemo(a,b)};exports.useReducer=function(a,b,c){return S().useReducer(a,b,c)};exports.useRef=function(a){return S().useRef(a)};exports.useState=function(a){return S().useState(a)};\nexports.version=\"17.0.2-experimental-9b8060041\";\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nexport default class EventEmitter<Events: Object> {\n  listenersMap: Map<string, Array<Function>> = new Map();\n\n  addListener<Event: $Keys<Events>>(\n    event: Event,\n    listener: (...$ElementType<Events, Event>) => any,\n  ): void {\n    const listeners = this.listenersMap.get(event);\n    if (listeners === undefined) {\n      this.listenersMap.set(event, [listener]);\n    } else {\n      const index = listeners.indexOf(listener);\n      if (index < 0) {\n        listeners.push(listener);\n      }\n    }\n  }\n\n  emit<Event: $Keys<Events>>(\n    event: Event,\n    ...args: $ElementType<Events, Event>\n  ): void {\n    const listeners = this.listenersMap.get(event);\n    if (listeners !== undefined) {\n      if (listeners.length === 1) {\n        // No need to clone or try/catch\n        const listener = listeners[0];\n        listener.apply(null, args);\n      } else {\n        let didThrow = false;\n        let caughtError = null;\n\n        const clonedListeners = Array.from(listeners);\n        for (let i = 0; i < clonedListeners.length; i++) {\n          const listener = clonedListeners[i];\n          try {\n            listener.apply(null, args);\n          } catch (error) {\n            if (caughtError === null) {\n              didThrow = true;\n              caughtError = error;\n            }\n          }\n        }\n\n        if (didThrow) {\n          throw caughtError;\n        }\n      }\n    }\n  }\n\n  removeAllListeners(): void {\n    this.listenersMap.clear();\n  }\n\n  removeListener(event: $Keys<Events>, listener: Function): void {\n    const listeners = this.listenersMap.get(event);\n    if (listeners !== undefined) {\n      const index = listeners.indexOf(listener);\n      if (index >= 0) {\n        listeners.splice(index, 1);\n      }\n    }\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\n// Flip this flag to true to enable verbose console debug logging.\nexport const __DEBUG__ = false;\n\nexport const TREE_OPERATION_ADD = 1;\nexport const TREE_OPERATION_REMOVE = 2;\nexport const TREE_OPERATION_REORDER_CHILDREN = 3;\nexport const TREE_OPERATION_UPDATE_TREE_BASE_DURATION = 4;\n\nexport const LOCAL_STORAGE_FILTER_PREFERENCES_KEY =\n  'React::DevTools::componentFilters';\n\nexport const SESSION_STORAGE_LAST_SELECTION_KEY =\n  'React::DevTools::lastSelection';\n\nexport const SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY =\n  'React::DevTools::recordChangeDescriptions';\n\nexport const SESSION_STORAGE_RELOAD_AND_PROFILE_KEY =\n  'React::DevTools::reloadAndProfile';\n\nexport const LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS =\n  'React::DevTools::breakOnConsoleErrors';\n\nexport const LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY =\n  'React::DevTools::appendComponentStack';\n\nexport const LOCAL_STORAGE_TRACE_UPDATES_ENABLED_KEY =\n  'React::DevTools::traceUpdatesEnabled';\n\nexport const PROFILER_EXPORT_VERSION = 4;\n\nexport const CHANGE_LOG_URL =\n  'https://github.com/facebook/react/blob/master/packages/react-devtools/CHANGELOG.md';\n\nexport const UNSUPPORTED_VERSION_URL =\n  'https://reactjs.org/blog/2019/08/15/new-react-devtools.html#how-do-i-get-the-old-version-back';\n\n// HACK\n//\n// Extracting during build time avoids a temporarily invalid state for the inline target.\n// Sometimes the inline target is rendered before root styles are applied,\n// which would result in e.g. NaN itemSize being passed to react-window list.\n//\nlet COMFORTABLE_LINE_HEIGHT;\nlet COMPACT_LINE_HEIGHT;\n\ntry {\n  // $FlowFixMe\n  const rawStyleString = require('!!raw-loader!react-devtools-shared/src/devtools/views/root.css')\n    .default;\n\n  const extractVar = varName => {\n    const regExp = new RegExp(`${varName}: ([0-9]+)`);\n    const match = rawStyleString.match(regExp);\n    return parseInt(match[1], 10);\n  };\n\n  COMFORTABLE_LINE_HEIGHT = extractVar('comfortable-line-height-data');\n  COMPACT_LINE_HEIGHT = extractVar('compact-line-height-data');\n} catch (error) {\n  // We can't use the Webpack loader syntax in the context of Jest,\n  // so tests need some reasonably meaningful fallback value.\n  COMFORTABLE_LINE_HEIGHT = 15;\n  COMPACT_LINE_HEIGHT = 10;\n}\n\nexport {COMFORTABLE_LINE_HEIGHT, COMPACT_LINE_HEIGHT};\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nexport function localStorageGetItem(key: string): any {\n  try {\n    return localStorage.getItem(key);\n  } catch (error) {\n    return null;\n  }\n}\n\nexport function localStorageRemoveItem(key: string): void {\n  try {\n    localStorage.removeItem(key);\n  } catch (error) {}\n}\n\nexport function localStorageSetItem(key: string, value: any): void {\n  try {\n    return localStorage.setItem(key, value);\n  } catch (error) {}\n}\n\nexport function sessionStorageGetItem(key: string): any {\n  try {\n    return sessionStorage.getItem(key);\n  } catch (error) {\n    return null;\n  }\n}\n\nexport function sessionStorageRemoveItem(key: string): void {\n  try {\n    sessionStorage.removeItem(key);\n  } catch (error) {}\n}\n\nexport function sessionStorageSetItem(key: string, value: any): void {\n  try {\n    return sessionStorage.setItem(key, value);\n  } catch (error) {}\n}\n","\n\nvar simpleIsEqual = function simpleIsEqual(a, b) {\n  return a === b;\n};\n\nexport default function (resultFn) {\n  var isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : simpleIsEqual;\n\n  var lastThis = void 0;\n  var lastArgs = [];\n  var lastResult = void 0;\n  var calledOnce = false;\n\n  var isNewArgEqualToLast = function isNewArgEqualToLast(newArg, index) {\n    return isEqual(newArg, lastArgs[index]);\n  };\n\n  var result = function result() {\n    for (var _len = arguments.length, newArgs = Array(_len), _key = 0; _key < _len; _key++) {\n      newArgs[_key] = arguments[_key];\n    }\n\n    if (calledOnce && lastThis === this && newArgs.length === lastArgs.length && newArgs.every(isNewArgEqualToLast)) {\n      return lastResult;\n    }\n\n    calledOnce = true;\n    lastThis = this;\n    lastArgs = newArgs;\n    lastResult = resultFn.apply(this, newArgs);\n    return lastResult;\n  };\n\n  return result;\n}","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nexport type Rect = {\n  bottom: number,\n  height: number,\n  left: number,\n  right: number,\n  top: number,\n  width: number,\n  ...\n};\n\n// Get the window object for the document that a node belongs to,\n// or return null if it cannot be found (node not attached to DOM,\n// etc).\nexport function getOwnerWindow(node: HTMLElement): typeof window | null {\n  if (!node.ownerDocument) {\n    return null;\n  }\n  return node.ownerDocument.defaultView;\n}\n\n// Get the iframe containing a node, or return null if it cannot\n// be found (node not within iframe, etc).\nexport function getOwnerIframe(node: HTMLElement): HTMLElement | null {\n  const nodeWindow = getOwnerWindow(node);\n  if (nodeWindow) {\n    return nodeWindow.frameElement;\n  }\n  return null;\n}\n\n// Get a bounding client rect for a node, with an\n// offset added to compensate for its border.\nexport function getBoundingClientRectWithBorderOffset(node: HTMLElement) {\n  const dimensions = getElementDimensions(node);\n  return mergeRectOffsets([\n    node.getBoundingClientRect(),\n    {\n      top: dimensions.borderTop,\n      left: dimensions.borderLeft,\n      bottom: dimensions.borderBottom,\n      right: dimensions.borderRight,\n      // This width and height won't get used by mergeRectOffsets (since this\n      // is not the first rect in the array), but we set them so that this\n      // object typechecks as a ClientRect.\n      width: 0,\n      height: 0,\n    },\n  ]);\n}\n\n// Add together the top, left, bottom, and right properties of\n// each ClientRect, but keep the width and height of the first one.\nexport function mergeRectOffsets(rects: Array<Rect>): Rect {\n  return rects.reduce((previousRect, rect) => {\n    if (previousRect == null) {\n      return rect;\n    }\n\n    return {\n      top: previousRect.top + rect.top,\n      left: previousRect.left + rect.left,\n      width: previousRect.width,\n      height: previousRect.height,\n      bottom: previousRect.bottom + rect.bottom,\n      right: previousRect.right + rect.right,\n    };\n  });\n}\n\n// Calculate a boundingClientRect for a node relative to boundaryWindow,\n// taking into account any offsets caused by intermediate iframes.\nexport function getNestedBoundingClientRect(\n  node: HTMLElement,\n  boundaryWindow: typeof window,\n): Rect {\n  const ownerIframe = getOwnerIframe(node);\n  if (ownerIframe && ownerIframe !== boundaryWindow) {\n    const rects = [node.getBoundingClientRect()];\n    let currentIframe = ownerIframe;\n    let onlyOneMore = false;\n    while (currentIframe) {\n      const rect = getBoundingClientRectWithBorderOffset(currentIframe);\n      rects.push(rect);\n      currentIframe = getOwnerIframe(currentIframe);\n\n      if (onlyOneMore) {\n        break;\n      }\n      // We don't want to calculate iframe offsets upwards beyond\n      // the iframe containing the boundaryWindow, but we\n      // need to calculate the offset relative to the boundaryWindow.\n      if (currentIframe && getOwnerWindow(currentIframe) === boundaryWindow) {\n        onlyOneMore = true;\n      }\n    }\n\n    return mergeRectOffsets(rects);\n  } else {\n    return node.getBoundingClientRect();\n  }\n}\n\nexport function getElementDimensions(domElement: Element) {\n  const calculatedStyle = window.getComputedStyle(domElement);\n  return {\n    borderLeft: parseInt(calculatedStyle.borderLeftWidth, 10),\n    borderRight: parseInt(calculatedStyle.borderRightWidth, 10),\n    borderTop: parseInt(calculatedStyle.borderTopWidth, 10),\n    borderBottom: parseInt(calculatedStyle.borderBottomWidth, 10),\n    marginLeft: parseInt(calculatedStyle.marginLeft, 10),\n    marginRight: parseInt(calculatedStyle.marginRight, 10),\n    marginTop: parseInt(calculatedStyle.marginTop, 10),\n    marginBottom: parseInt(calculatedStyle.marginBottom, 10),\n    paddingLeft: parseInt(calculatedStyle.paddingLeft, 10),\n    paddingRight: parseInt(calculatedStyle.paddingRight, 10),\n    paddingTop: parseInt(calculatedStyle.paddingTop, 10),\n    paddingBottom: parseInt(calculatedStyle.paddingBottom, 10),\n  };\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport assign from 'object-assign';\nimport {getElementDimensions, getNestedBoundingClientRect} from '../utils';\n\nimport type {DevToolsHook} from 'react-devtools-shared/src/backend/types';\nimport type {Rect} from '../utils';\n\ntype Box = {|top: number, left: number, width: number, height: number|};\n\n// Note that the Overlay components are not affected by the active Theme,\n// because they highlight elements in the main Chrome window (outside of devtools).\n// The colors below were chosen to roughly match those used by Chrome devtools.\n\nclass OverlayRect {\n  node: HTMLElement;\n  border: HTMLElement;\n  padding: HTMLElement;\n  content: HTMLElement;\n\n  constructor(doc: Document, container: HTMLElement) {\n    this.node = doc.createElement('div');\n    this.border = doc.createElement('div');\n    this.padding = doc.createElement('div');\n    this.content = doc.createElement('div');\n\n    this.border.style.borderColor = overlayStyles.border;\n    this.padding.style.borderColor = overlayStyles.padding;\n    this.content.style.backgroundColor = overlayStyles.background;\n\n    assign(this.node.style, {\n      borderColor: overlayStyles.margin,\n      pointerEvents: 'none',\n      position: 'fixed',\n    });\n\n    this.node.style.zIndex = '10000000';\n\n    this.node.appendChild(this.border);\n    this.border.appendChild(this.padding);\n    this.padding.appendChild(this.content);\n    container.appendChild(this.node);\n  }\n\n  remove() {\n    if (this.node.parentNode) {\n      this.node.parentNode.removeChild(this.node);\n    }\n  }\n\n  update(box: Rect, dims: any) {\n    boxWrap(dims, 'margin', this.node);\n    boxWrap(dims, 'border', this.border);\n    boxWrap(dims, 'padding', this.padding);\n\n    assign(this.content.style, {\n      height:\n        box.height -\n        dims.borderTop -\n        dims.borderBottom -\n        dims.paddingTop -\n        dims.paddingBottom +\n        'px',\n      width:\n        box.width -\n        dims.borderLeft -\n        dims.borderRight -\n        dims.paddingLeft -\n        dims.paddingRight +\n        'px',\n    });\n\n    assign(this.node.style, {\n      top: box.top - dims.marginTop + 'px',\n      left: box.left - dims.marginLeft + 'px',\n    });\n  }\n}\n\nclass OverlayTip {\n  tip: HTMLElement;\n  nameSpan: HTMLElement;\n  dimSpan: HTMLElement;\n\n  constructor(doc: Document, container: HTMLElement) {\n    this.tip = doc.createElement('div');\n    assign(this.tip.style, {\n      display: 'flex',\n      flexFlow: 'row nowrap',\n      backgroundColor: '#333740',\n      borderRadius: '2px',\n      fontFamily:\n        '\"SFMono-Regular\", Consolas, \"Liberation Mono\", Menlo, Courier, monospace',\n      fontWeight: 'bold',\n      padding: '3px 5px',\n      pointerEvents: 'none',\n      position: 'fixed',\n      fontSize: '12px',\n      whiteSpace: 'nowrap',\n    });\n\n    this.nameSpan = doc.createElement('span');\n    this.tip.appendChild(this.nameSpan);\n    assign(this.nameSpan.style, {\n      color: '#ee78e6',\n      borderRight: '1px solid #aaaaaa',\n      paddingRight: '0.5rem',\n      marginRight: '0.5rem',\n    });\n    this.dimSpan = doc.createElement('span');\n    this.tip.appendChild(this.dimSpan);\n    assign(this.dimSpan.style, {\n      color: '#d7d7d7',\n    });\n\n    this.tip.style.zIndex = '10000000';\n    container.appendChild(this.tip);\n  }\n\n  remove() {\n    if (this.tip.parentNode) {\n      this.tip.parentNode.removeChild(this.tip);\n    }\n  }\n\n  updateText(name: string, width: number, height: number) {\n    this.nameSpan.textContent = name;\n    this.dimSpan.textContent =\n      Math.round(width) + 'px × ' + Math.round(height) + 'px';\n  }\n\n  updatePosition(dims: Box, bounds: Box) {\n    const tipRect = this.tip.getBoundingClientRect();\n    const tipPos = findTipPos(dims, bounds, {\n      width: tipRect.width,\n      height: tipRect.height,\n    });\n    assign(this.tip.style, tipPos.style);\n  }\n}\n\nexport default class Overlay {\n  window: window;\n  tipBoundsWindow: window;\n  container: HTMLElement;\n  tip: OverlayTip;\n  rects: Array<OverlayRect>;\n\n  constructor() {\n    // Find the root window, because overlays are positioned relative to it.\n    const currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;\n    this.window = currentWindow;\n\n    // When opened in shells/dev, the tooltip should be bound by the app iframe, not by the topmost window.\n    const tipBoundsWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;\n    this.tipBoundsWindow = tipBoundsWindow;\n\n    const doc = currentWindow.document;\n    this.container = doc.createElement('div');\n    this.container.style.zIndex = '10000000';\n\n    this.tip = new OverlayTip(doc, this.container);\n    this.rects = [];\n\n    doc.body.appendChild(this.container);\n  }\n\n  remove() {\n    this.tip.remove();\n    this.rects.forEach(rect => {\n      rect.remove();\n    });\n    this.rects.length = 0;\n    if (this.container.parentNode) {\n      this.container.parentNode.removeChild(this.container);\n    }\n  }\n\n  inspect(nodes: Array<HTMLElement>, name?: ?string) {\n    // We can't get the size of text nodes or comment nodes. React as of v15\n    // heavily uses comment nodes to delimit text.\n    const elements = nodes.filter(node => node.nodeType === Node.ELEMENT_NODE);\n\n    while (this.rects.length > elements.length) {\n      const rect = this.rects.pop();\n      rect.remove();\n    }\n    if (elements.length === 0) {\n      return;\n    }\n\n    while (this.rects.length < elements.length) {\n      this.rects.push(new OverlayRect(this.window.document, this.container));\n    }\n\n    const outerBox = {\n      top: Number.POSITIVE_INFINITY,\n      right: Number.NEGATIVE_INFINITY,\n      bottom: Number.NEGATIVE_INFINITY,\n      left: Number.POSITIVE_INFINITY,\n    };\n    elements.forEach((element, index) => {\n      const box = getNestedBoundingClientRect(element, this.window);\n      const dims = getElementDimensions(element);\n\n      outerBox.top = Math.min(outerBox.top, box.top - dims.marginTop);\n      outerBox.right = Math.max(\n        outerBox.right,\n        box.left + box.width + dims.marginRight,\n      );\n      outerBox.bottom = Math.max(\n        outerBox.bottom,\n        box.top + box.height + dims.marginBottom,\n      );\n      outerBox.left = Math.min(outerBox.left, box.left - dims.marginLeft);\n\n      const rect = this.rects[index];\n      rect.update(box, dims);\n    });\n\n    if (!name) {\n      name = elements[0].nodeName.toLowerCase();\n\n      const node = elements[0];\n      const hook: DevToolsHook =\n        node.ownerDocument.defaultView.__REACT_DEVTOOLS_GLOBAL_HOOK__;\n      if (hook != null && hook.rendererInterfaces != null) {\n        let ownerName = null;\n        // eslint-disable-next-line no-for-of-loops/no-for-of-loops\n        for (const rendererInterface of hook.rendererInterfaces.values()) {\n          const id = rendererInterface.getFiberIDForNative(node, true);\n          if (id !== null) {\n            ownerName = rendererInterface.getDisplayNameForFiberID(id, true);\n            break;\n          }\n        }\n\n        if (ownerName) {\n          name += ' (in ' + ownerName + ')';\n        }\n      }\n    }\n\n    this.tip.updateText(\n      name,\n      outerBox.right - outerBox.left,\n      outerBox.bottom - outerBox.top,\n    );\n    const tipBounds = getNestedBoundingClientRect(\n      this.tipBoundsWindow.document.documentElement,\n      this.window,\n    );\n\n    this.tip.updatePosition(\n      {\n        top: outerBox.top,\n        left: outerBox.left,\n        height: outerBox.bottom - outerBox.top,\n        width: outerBox.right - outerBox.left,\n      },\n      {\n        top: tipBounds.top + this.tipBoundsWindow.scrollY,\n        left: tipBounds.left + this.tipBoundsWindow.scrollX,\n        height: this.tipBoundsWindow.innerHeight,\n        width: this.tipBoundsWindow.innerWidth,\n      },\n    );\n  }\n}\n\nfunction findTipPos(dims, bounds, tipSize) {\n  const tipHeight = Math.max(tipSize.height, 20);\n  const tipWidth = Math.max(tipSize.width, 60);\n  const margin = 5;\n\n  let top;\n  if (dims.top + dims.height + tipHeight <= bounds.top + bounds.height) {\n    if (dims.top + dims.height < bounds.top + 0) {\n      top = bounds.top + margin;\n    } else {\n      top = dims.top + dims.height + margin;\n    }\n  } else if (dims.top - tipHeight <= bounds.top + bounds.height) {\n    if (dims.top - tipHeight - margin < bounds.top + margin) {\n      top = bounds.top + margin;\n    } else {\n      top = dims.top - tipHeight - margin;\n    }\n  } else {\n    top = bounds.top + bounds.height - tipHeight - margin;\n  }\n\n  let left = dims.left + margin;\n  if (dims.left < bounds.left) {\n    left = bounds.left + margin;\n  }\n  if (dims.left + tipWidth > bounds.left + bounds.width) {\n    left = bounds.left + bounds.width - tipWidth - margin;\n  }\n\n  top += 'px';\n  left += 'px';\n  return {\n    style: {top, left},\n  };\n}\n\nfunction boxWrap(dims, what, node) {\n  assign(node.style, {\n    borderTopWidth: dims[what + 'Top'] + 'px',\n    borderLeftWidth: dims[what + 'Left'] + 'px',\n    borderRightWidth: dims[what + 'Right'] + 'px',\n    borderBottomWidth: dims[what + 'Bottom'] + 'px',\n    borderStyle: 'solid',\n  });\n}\n\nconst overlayStyles = {\n  background: 'rgba(120, 170, 210, 0.7)',\n  padding: 'rgba(77, 200, 0, 0.3)',\n  margin: 'rgba(255, 155, 0, 0.3)',\n  border: 'rgba(255, 200, 50, 0.3)',\n};\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport Overlay from './Overlay';\n\nconst SHOW_DURATION = 2000;\n\nlet timeoutID: TimeoutID | null = null;\nlet overlay: Overlay | null = null;\n\nexport function hideOverlay() {\n  timeoutID = null;\n\n  if (overlay !== null) {\n    overlay.remove();\n    overlay = null;\n  }\n}\n\nexport function showOverlay(\n  elements: Array<HTMLElement> | null,\n  componentName: string | null,\n  hideAfterTimeout: boolean,\n) {\n  // TODO (npm-packages) Detect RN and support it somehow\n  if (window.document == null) {\n    return;\n  }\n\n  if (timeoutID !== null) {\n    clearTimeout(timeoutID);\n  }\n\n  if (elements == null) {\n    return;\n  }\n\n  if (overlay === null) {\n    overlay = new Overlay();\n  }\n\n  overlay.inspect(elements, componentName);\n\n  if (hideAfterTimeout) {\n    timeoutID = setTimeout(hideOverlay, SHOW_DURATION);\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport memoize from 'memoize-one';\nimport throttle from 'lodash.throttle';\nimport Agent from 'react-devtools-shared/src/backend/agent';\nimport {hideOverlay, showOverlay} from './Highlighter';\n\nimport type {BackendBridge} from 'react-devtools-shared/src/bridge';\n\n// This plug-in provides in-page highlighting of the selected element.\n// It is used by the browser extension nad the standalone DevTools shell (when connected to a browser).\n// It is not currently the mechanism used to highlight React Native views.\n// That is done by the React Native Inspector component.\n\nlet iframesListeningTo: Set<HTMLIFrameElement> = new Set();\n\nexport default function setupHighlighter(\n  bridge: BackendBridge,\n  agent: Agent,\n): void {\n  bridge.addListener(\n    'clearNativeElementHighlight',\n    clearNativeElementHighlight,\n  );\n  bridge.addListener('highlightNativeElement', highlightNativeElement);\n  bridge.addListener('shutdown', stopInspectingNative);\n  bridge.addListener('startInspectingNative', startInspectingNative);\n  bridge.addListener('stopInspectingNative', stopInspectingNative);\n\n  function startInspectingNative() {\n    registerListenersOnWindow(window);\n  }\n\n  function registerListenersOnWindow(window) {\n    // This plug-in may run in non-DOM environments (e.g. React Native).\n    if (window && typeof window.addEventListener === 'function') {\n      window.addEventListener('click', onClick, true);\n      window.addEventListener('mousedown', onMouseEvent, true);\n      window.addEventListener('mouseover', onMouseEvent, true);\n      window.addEventListener('mouseup', onMouseEvent, true);\n      window.addEventListener('pointerdown', onPointerDown, true);\n      window.addEventListener('pointerover', onPointerOver, true);\n      window.addEventListener('pointerup', onPointerUp, true);\n    }\n  }\n\n  function stopInspectingNative() {\n    hideOverlay();\n    removeListenersOnWindow(window);\n    iframesListeningTo.forEach(function(frame) {\n      try {\n        removeListenersOnWindow(frame.contentWindow);\n      } catch (error) {\n        // This can error when the iframe is on a cross-origin.\n      }\n    });\n    iframesListeningTo = new Set();\n  }\n\n  function removeListenersOnWindow(window) {\n    // This plug-in may run in non-DOM environments (e.g. React Native).\n    if (window && typeof window.removeEventListener === 'function') {\n      window.removeEventListener('click', onClick, true);\n      window.removeEventListener('mousedown', onMouseEvent, true);\n      window.removeEventListener('mouseover', onMouseEvent, true);\n      window.removeEventListener('mouseup', onMouseEvent, true);\n      window.removeEventListener('pointerdown', onPointerDown, true);\n      window.removeEventListener('pointerover', onPointerOver, true);\n      window.removeEventListener('pointerup', onPointerUp, true);\n    }\n  }\n\n  function clearNativeElementHighlight() {\n    hideOverlay();\n  }\n\n  function highlightNativeElement({\n    displayName,\n    hideAfterTimeout,\n    id,\n    openNativeElementsPanel,\n    rendererID,\n    scrollIntoView,\n  }: {\n    displayName: string | null,\n    hideAfterTimeout: boolean,\n    id: number,\n    openNativeElementsPanel: boolean,\n    rendererID: number,\n    scrollIntoView: boolean,\n    ...\n  }) {\n    const renderer = agent.rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    }\n\n    let nodes: ?Array<HTMLElement> = null;\n    if (renderer != null) {\n      nodes = ((renderer.findNativeNodesForFiberID(\n        id,\n      ): any): ?Array<HTMLElement>);\n    }\n\n    if (nodes != null && nodes[0] != null) {\n      const node = nodes[0];\n      if (scrollIntoView && typeof node.scrollIntoView === 'function') {\n        // If the node isn't visible show it before highlighting it.\n        // We may want to reconsider this; it might be a little disruptive.\n        // $FlowFixMe Flow only knows about 'start' | 'end'\n        node.scrollIntoView({block: 'nearest', inline: 'nearest'});\n      }\n\n      showOverlay(nodes, displayName, hideAfterTimeout);\n\n      if (openNativeElementsPanel) {\n        window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0 = node;\n        bridge.send('syncSelectionToNativeElementsPanel');\n      }\n    } else {\n      hideOverlay();\n    }\n  }\n\n  function onClick(event: MouseEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n\n    stopInspectingNative();\n\n    bridge.send('stopInspectingNative', true);\n  }\n\n  function onMouseEvent(event: MouseEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n  }\n\n  function onPointerDown(event: MouseEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n\n    selectFiberForNode(((event.target: any): HTMLElement));\n  }\n\n  function onPointerOver(event: MouseEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n\n    const target = ((event.target: any): HTMLElement);\n\n    if (target.tagName === 'IFRAME') {\n      const iframe: HTMLIFrameElement = (target: any);\n      try {\n        if (!iframesListeningTo.has(iframe)) {\n          const window = iframe.contentWindow;\n          registerListenersOnWindow(window);\n          iframesListeningTo.add(iframe);\n        }\n      } catch (error) {\n        // This can error when the iframe is on a cross-origin.\n      }\n    }\n\n    // Don't pass the name explicitly.\n    // It will be inferred from DOM tag and Fiber owner.\n    showOverlay([target], null, false);\n\n    selectFiberForNode(target);\n  }\n\n  function onPointerUp(event: MouseEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n  }\n\n  const selectFiberForNode = throttle(\n    memoize((node: HTMLElement) => {\n      const id = agent.getIDForNode(node);\n      if (id !== null) {\n        bridge.send('selectFiber', id);\n      }\n    }),\n    200,\n    // Don't change the selection in the very first 200ms\n    // because those are usually unintentional as you lift the cursor.\n    {leading: false},\n  );\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport type {Data} from './index';\nimport type {Rect} from '../utils';\nimport type {NativeType} from '../../types';\n\nconst OUTLINE_COLOR = '#f0f0f0';\n\n// Note these colors are in sync with DevTools Profiler chart colors.\nconst COLORS = [\n  '#37afa9',\n  '#63b19e',\n  '#80b393',\n  '#97b488',\n  '#abb67d',\n  '#beb771',\n  '#cfb965',\n  '#dfba57',\n  '#efbb49',\n  '#febc38',\n];\n\nlet canvas: HTMLCanvasElement | null = null;\n\nexport function draw(nodeToData: Map<NativeType, Data>): void {\n  if (canvas === null) {\n    initialize();\n  }\n\n  const canvasFlow: HTMLCanvasElement = ((canvas: any): HTMLCanvasElement);\n  canvasFlow.width = window.innerWidth;\n  canvasFlow.height = window.innerHeight;\n\n  const context = canvasFlow.getContext('2d');\n  context.clearRect(0, 0, canvasFlow.width, canvasFlow.height);\n\n  nodeToData.forEach(({count, rect}) => {\n    if (rect !== null) {\n      const colorIndex = Math.min(COLORS.length - 1, count - 1);\n      const color = COLORS[colorIndex];\n\n      drawBorder(context, rect, color);\n    }\n  });\n}\n\nfunction drawBorder(\n  context: CanvasRenderingContext2D,\n  rect: Rect,\n  color: string,\n): void {\n  const {height, left, top, width} = rect;\n\n  // outline\n  context.lineWidth = 1;\n  context.strokeStyle = OUTLINE_COLOR;\n\n  context.strokeRect(left - 1, top - 1, width + 2, height + 2);\n\n  // inset\n  context.lineWidth = 1;\n  context.strokeStyle = OUTLINE_COLOR;\n  context.strokeRect(left + 1, top + 1, width - 1, height - 1);\n  context.strokeStyle = color;\n\n  context.setLineDash([0]);\n\n  // border\n  context.lineWidth = 1;\n  context.strokeRect(left, top, width - 1, height - 1);\n\n  context.setLineDash([0]);\n}\n\nexport function destroy(): void {\n  if (canvas !== null) {\n    if (canvas.parentNode != null) {\n      canvas.parentNode.removeChild(canvas);\n    }\n    canvas = null;\n  }\n}\n\nfunction initialize(): void {\n  canvas = window.document.createElement('canvas');\n  canvas.style.cssText = `\n    xx-background-color: red;\n    xx-opacity: 0.5;\n    bottom: 0;\n    left: 0;\n    pointer-events: none;\n    position: fixed;\n    right: 0;\n    top: 0;\n    z-index: 1000000000;\n  `;\n\n  const root = window.document.documentElement;\n  root.insertBefore(canvas, root.firstChild);\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport Agent from 'react-devtools-shared/src/backend/agent';\nimport {destroy as destroyCanvas, draw} from './canvas';\nimport {getNestedBoundingClientRect} from '../utils';\n\nimport type {NativeType} from '../../types';\nimport type {Rect} from '../utils';\n\n// How long the rect should be shown for?\nconst DISPLAY_DURATION = 250;\n\n// What's the longest we are willing to show the overlay for?\n// This can be important if we're getting a flurry of events (e.g. scroll update).\nconst MAX_DISPLAY_DURATION = 3000;\n\n// How long should a rect be considered valid for?\nconst REMEASUREMENT_AFTER_DURATION = 250;\n\n// Some environments (e.g. React Native / Hermes) don't support the performance API yet.\nconst getCurrentTime =\n  typeof performance === 'object' && typeof performance.now === 'function'\n    ? () => performance.now()\n    : () => Date.now();\n\nexport type Data = {|\n  count: number,\n  expirationTime: number,\n  lastMeasuredAt: number,\n  rect: Rect | null,\n|};\n\nconst nodeToData: Map<NativeType, Data> = new Map();\n\nlet agent: Agent = ((null: any): Agent);\nlet drawAnimationFrameID: AnimationFrameID | null = null;\nlet isEnabled: boolean = false;\nlet redrawTimeoutID: TimeoutID | null = null;\n\nexport function initialize(injectedAgent: Agent): void {\n  agent = injectedAgent;\n  agent.addListener('traceUpdates', traceUpdates);\n}\n\nexport function toggleEnabled(value: boolean): void {\n  isEnabled = value;\n\n  if (!isEnabled) {\n    nodeToData.clear();\n\n    if (drawAnimationFrameID !== null) {\n      cancelAnimationFrame(drawAnimationFrameID);\n      drawAnimationFrameID = null;\n    }\n\n    if (redrawTimeoutID !== null) {\n      clearTimeout(redrawTimeoutID);\n      redrawTimeoutID = null;\n    }\n\n    destroyCanvas();\n  }\n}\n\nfunction traceUpdates(nodes: Set<NativeType>): void {\n  if (!isEnabled) {\n    return;\n  }\n\n  nodes.forEach(node => {\n    const data = nodeToData.get(node);\n    const now = getCurrentTime();\n\n    let lastMeasuredAt = data != null ? data.lastMeasuredAt : 0;\n    let rect = data != null ? data.rect : null;\n    if (rect === null || lastMeasuredAt + REMEASUREMENT_AFTER_DURATION < now) {\n      lastMeasuredAt = now;\n      rect = measureNode(node);\n    }\n\n    nodeToData.set(node, {\n      count: data != null ? data.count + 1 : 1,\n      expirationTime:\n        data != null\n          ? Math.min(\n              now + MAX_DISPLAY_DURATION,\n              data.expirationTime + DISPLAY_DURATION,\n            )\n          : now + DISPLAY_DURATION,\n      lastMeasuredAt,\n      rect,\n    });\n  });\n\n  if (redrawTimeoutID !== null) {\n    clearTimeout(redrawTimeoutID);\n    redrawTimeoutID = null;\n  }\n\n  if (drawAnimationFrameID === null) {\n    drawAnimationFrameID = requestAnimationFrame(prepareToDraw);\n  }\n}\n\nfunction prepareToDraw(): void {\n  drawAnimationFrameID = null;\n  redrawTimeoutID = null;\n\n  const now = getCurrentTime();\n  let earliestExpiration = Number.MAX_VALUE;\n\n  // Remove any items that have already expired.\n  nodeToData.forEach((data, node) => {\n    if (data.expirationTime < now) {\n      nodeToData.delete(node);\n    } else {\n      earliestExpiration = Math.min(earliestExpiration, data.expirationTime);\n    }\n  });\n\n  draw(nodeToData);\n\n  if (earliestExpiration !== Number.MAX_VALUE) {\n    redrawTimeoutID = setTimeout(prepareToDraw, earliestExpiration - now);\n  }\n}\n\nfunction measureNode(node: Object): Rect | null {\n  if (!node || typeof node.getBoundingClientRect !== 'function') {\n    return null;\n  }\n\n  const currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;\n\n  return getNestedBoundingClientRect(node, currentWindow);\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\n// ATTENTION\n// When adding new symbols to this file,\n// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'\n\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\n// nor polyfill, then a plain number is used for performance.\nexport let REACT_ELEMENT_TYPE = 0xeac7;\nexport let REACT_PORTAL_TYPE = 0xeaca;\nexport let REACT_FRAGMENT_TYPE = 0xeacb;\nexport let REACT_STRICT_MODE_TYPE = 0xeacc;\nexport let REACT_PROFILER_TYPE = 0xead2;\nexport let REACT_PROVIDER_TYPE = 0xeacd;\nexport let REACT_CONTEXT_TYPE = 0xeace;\nexport let REACT_FORWARD_REF_TYPE = 0xead0;\nexport let REACT_SUSPENSE_TYPE = 0xead1;\nexport let REACT_SUSPENSE_LIST_TYPE = 0xead8;\nexport let REACT_MEMO_TYPE = 0xead3;\nexport let REACT_LAZY_TYPE = 0xead4;\nexport let REACT_FUNDAMENTAL_TYPE = 0xead5;\nexport let REACT_SCOPE_TYPE = 0xead7;\nexport let REACT_OPAQUE_ID_TYPE = 0xeae0;\nexport let REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;\nexport let REACT_OFFSCREEN_TYPE = 0xeae2;\nexport let REACT_LEGACY_HIDDEN_TYPE = 0xeae3;\n\nif (typeof Symbol === 'function' && Symbol.for) {\n  const symbolFor = Symbol.for;\n  REACT_ELEMENT_TYPE = symbolFor('react.element');\n  REACT_PORTAL_TYPE = symbolFor('react.portal');\n  REACT_FRAGMENT_TYPE = symbolFor('react.fragment');\n  REACT_STRICT_MODE_TYPE = symbolFor('react.strict_mode');\n  REACT_PROFILER_TYPE = symbolFor('react.profiler');\n  REACT_PROVIDER_TYPE = symbolFor('react.provider');\n  REACT_CONTEXT_TYPE = symbolFor('react.context');\n  REACT_FORWARD_REF_TYPE = symbolFor('react.forward_ref');\n  REACT_SUSPENSE_TYPE = symbolFor('react.suspense');\n  REACT_SUSPENSE_LIST_TYPE = symbolFor('react.suspense_list');\n  REACT_MEMO_TYPE = symbolFor('react.memo');\n  REACT_LAZY_TYPE = symbolFor('react.lazy');\n  REACT_FUNDAMENTAL_TYPE = symbolFor('react.fundamental');\n  REACT_SCOPE_TYPE = symbolFor('react.scope');\n  REACT_OPAQUE_ID_TYPE = symbolFor('react.opaque.id');\n  REACT_DEBUG_TRACING_MODE_TYPE = symbolFor('react.debug_trace_mode');\n  REACT_OFFSCREEN_TYPE = symbolFor('react.offscreen');\n  REACT_LEGACY_HIDDEN_TYPE = symbolFor('react.legacy_hidden');\n}\n\nconst MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\nconst FAUX_ITERATOR_SYMBOL = '@@iterator';\n\nexport function getIteratorFn(maybeIterable: ?any): ?() => ?Iterator<*> {\n  if (maybeIterable === null || typeof maybeIterable !== 'object') {\n    return null;\n  }\n  const maybeIterator =\n    (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||\n    maybeIterable[FAUX_ITERATOR_SYMBOL];\n  if (typeof maybeIterator === 'function') {\n    return maybeIterator;\n  }\n  return null;\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport {\n  getDataType,\n  getDisplayNameForReactElement,\n  getAllEnumerableKeys,\n  getInObject,\n  formatDataForPreview,\n  setInObject,\n} from './utils';\n\nimport type {DehydratedData} from 'react-devtools-shared/src/devtools/views/Components/types';\n\nexport const meta = {\n  inspectable: Symbol('inspectable'),\n  inspected: Symbol('inspected'),\n  name: Symbol('name'),\n  preview_long: Symbol('preview_long'),\n  preview_short: Symbol('preview_short'),\n  readonly: Symbol('readonly'),\n  size: Symbol('size'),\n  type: Symbol('type'),\n  unserializable: Symbol('unserializable'),\n};\n\nexport type Dehydrated = {|\n  inspectable: boolean,\n  name: string | null,\n  preview_long: string | null,\n  preview_short: string | null,\n  readonly?: boolean,\n  size?: number,\n  type: string,\n|};\n\n// Typed arrays and other complex iteratable objects (e.g. Map, Set, ImmutableJS) need special handling.\n// These objects can't be serialized without losing type information,\n// so a \"Unserializable\" type wrapper is used (with meta-data keys) to send nested values-\n// while preserving the original type and name.\nexport type Unserializable = {\n  name: string | null,\n  preview_long: string | null,\n  preview_short: string | null,\n  readonly?: boolean,\n  size?: number,\n  type: string,\n  unserializable: boolean,\n  ...\n};\n\n// This threshold determines the depth at which the bridge \"dehydrates\" nested data.\n// Dehydration means that we don't serialize the data for e.g. postMessage or stringify,\n// unless the frontend explicitly requests it (e.g. a user clicks to expand a props object).\n//\n// Reducing this threshold will improve the speed of initial component inspection,\n// but may decrease the responsiveness of expanding objects/arrays to inspect further.\nconst LEVEL_THRESHOLD = 2;\n\n/**\n * Generate the dehydrated metadata for complex object instances\n */\nfunction createDehydrated(\n  type: string,\n  inspectable: boolean,\n  data: Object,\n  cleaned: Array<Array<string | number>>,\n  path: Array<string | number>,\n): Dehydrated {\n  cleaned.push(path);\n\n  const dehydrated: Dehydrated = {\n    inspectable,\n    type,\n    preview_long: formatDataForPreview(data, true),\n    preview_short: formatDataForPreview(data, false),\n    name:\n      !data.constructor || data.constructor.name === 'Object'\n        ? ''\n        : data.constructor.name,\n  };\n\n  if (type === 'array' || type === 'typed_array') {\n    dehydrated.size = data.length;\n  } else if (type === 'object') {\n    dehydrated.size = Object.keys(data).length;\n  }\n\n  if (type === 'iterator' || type === 'typed_array') {\n    dehydrated.readonly = true;\n  }\n\n  return dehydrated;\n}\n\n/**\n * Strip out complex data (instances, functions, and data nested > LEVEL_THRESHOLD levels deep).\n * The paths of the stripped out objects are appended to the `cleaned` list.\n * On the other side of the barrier, the cleaned list is used to \"re-hydrate\" the cleaned representation into\n * an object with symbols as attributes, so that a sanitized object can be distinguished from a normal object.\n *\n * Input: {\"some\": {\"attr\": fn()}, \"other\": AnInstance}\n * Output: {\n *   \"some\": {\n *     \"attr\": {\"name\": the fn.name, type: \"function\"}\n *   },\n *   \"other\": {\n *     \"name\": \"AnInstance\",\n *     \"type\": \"object\",\n *   },\n * }\n * and cleaned = [[\"some\", \"attr\"], [\"other\"]]\n */\nexport function dehydrate(\n  data: Object,\n  cleaned: Array<Array<string | number>>,\n  unserializable: Array<Array<string | number>>,\n  path: Array<string | number>,\n  isPathAllowed: (path: Array<string | number>) => boolean,\n  level?: number = 0,\n):\n  | string\n  | Dehydrated\n  | Unserializable\n  | Array<Dehydrated>\n  | Array<Unserializable>\n  | {[key: string]: string | Dehydrated | Unserializable, ...} {\n  const type = getDataType(data);\n\n  let isPathAllowedCheck;\n\n  switch (type) {\n    case 'html_element':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: data.tagName,\n        type,\n      };\n\n    case 'function':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name:\n          typeof data.name === 'function' || !data.name\n            ? 'function'\n            : data.name,\n        type,\n      };\n\n    case 'string':\n      return data.length <= 500 ? data : data.slice(0, 500) + '...';\n\n    case 'bigint':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: data.toString(),\n        type,\n      };\n\n    case 'symbol':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: data.toString(),\n        type,\n      };\n\n    // React Elements aren't very inspector-friendly,\n    // and often contain private fields or circular references.\n    case 'react_element':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: getDisplayNameForReactElement(data) || 'Unknown',\n        type,\n      };\n\n    // ArrayBuffers error if you try to inspect them.\n    case 'array_buffer':\n    case 'data_view':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: type === 'data_view' ? 'DataView' : 'ArrayBuffer',\n        size: data.byteLength,\n        type,\n      };\n\n    case 'array':\n      isPathAllowedCheck = isPathAllowed(path);\n      if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {\n        return createDehydrated(type, true, data, cleaned, path);\n      }\n      return data.map((item, i) =>\n        dehydrate(\n          item,\n          cleaned,\n          unserializable,\n          path.concat([i]),\n          isPathAllowed,\n          isPathAllowedCheck ? 1 : level + 1,\n        ),\n      );\n\n    case 'html_all_collection':\n    case 'typed_array':\n    case 'iterator':\n      isPathAllowedCheck = isPathAllowed(path);\n      if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {\n        return createDehydrated(type, true, data, cleaned, path);\n      } else {\n        const unserializableValue: Unserializable = {\n          unserializable: true,\n          type: type,\n          readonly: true,\n          size: type === 'typed_array' ? data.length : undefined,\n          preview_short: formatDataForPreview(data, false),\n          preview_long: formatDataForPreview(data, true),\n          name:\n            !data.constructor || data.constructor.name === 'Object'\n              ? ''\n              : data.constructor.name,\n        };\n\n        if (typeof data[Symbol.iterator]) {\n          // TRICKY\n          // Don't use [...spread] syntax for this purpose.\n          // This project uses @babel/plugin-transform-spread in \"loose\" mode which only works with Array values.\n          // Other types (e.g. typed arrays, Sets) will not spread correctly.\n          Array.from(data).forEach(\n            (item, i) =>\n              (unserializableValue[i] = dehydrate(\n                item,\n                cleaned,\n                unserializable,\n                path.concat([i]),\n                isPathAllowed,\n                isPathAllowedCheck ? 1 : level + 1,\n              )),\n          );\n        }\n\n        unserializable.push(path);\n\n        return unserializableValue;\n      }\n\n    case 'opaque_iterator':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: data[Symbol.toStringTag],\n        type,\n      };\n\n    case 'date':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: data.toString(),\n        type,\n      };\n\n    case 'regexp':\n      cleaned.push(path);\n      return {\n        inspectable: false,\n        preview_short: formatDataForPreview(data, false),\n        preview_long: formatDataForPreview(data, true),\n        name: data.toString(),\n        type,\n      };\n\n    case 'object':\n      isPathAllowedCheck = isPathAllowed(path);\n      if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {\n        return createDehydrated(type, true, data, cleaned, path);\n      } else {\n        const object = {};\n        getAllEnumerableKeys(data).forEach(key => {\n          const name = key.toString();\n          object[name] = dehydrate(\n            data[key],\n            cleaned,\n            unserializable,\n            path.concat([name]),\n            isPathAllowed,\n            isPathAllowedCheck ? 1 : level + 1,\n          );\n        });\n        return object;\n      }\n\n    case 'infinity':\n    case 'nan':\n    case 'undefined':\n      // Some values are lossy when sent through a WebSocket.\n      // We dehydrate+rehydrate them to preserve their type.\n      cleaned.push(path);\n      return {\n        type,\n      };\n\n    default:\n      return data;\n  }\n}\n\nexport function fillInPath(\n  object: Object,\n  data: DehydratedData,\n  path: Array<string | number>,\n  value: any,\n) {\n  const target = getInObject(object, path);\n  if (target != null) {\n    if (!target[meta.unserializable]) {\n      delete target[meta.inspectable];\n      delete target[meta.inspected];\n      delete target[meta.name];\n      delete target[meta.preview_long];\n      delete target[meta.preview_short];\n      delete target[meta.readonly];\n      delete target[meta.size];\n      delete target[meta.type];\n    }\n  }\n\n  if (value !== null && data.unserializable.length > 0) {\n    const unserializablePath = data.unserializable[0];\n    let isMatch = unserializablePath.length === path.length;\n    for (let i = 0; i < path.length; i++) {\n      if (path[i] !== unserializablePath[i]) {\n        isMatch = false;\n        break;\n      }\n    }\n    if (isMatch) {\n      upgradeUnserializable(value, value);\n    }\n  }\n\n  setInObject(object, path, value);\n}\n\nexport function hydrate(\n  object: any,\n  cleaned: Array<Array<string | number>>,\n  unserializable: Array<Array<string | number>>,\n): Object {\n  cleaned.forEach((path: Array<string | number>) => {\n    const length = path.length;\n    const last = path[length - 1];\n    const parent = getInObject(object, path.slice(0, length - 1));\n    if (!parent || !parent.hasOwnProperty(last)) {\n      return;\n    }\n\n    const value = parent[last];\n\n    if (value.type === 'infinity') {\n      parent[last] = Infinity;\n    } else if (value.type === 'nan') {\n      parent[last] = NaN;\n    } else if (value.type === 'undefined') {\n      parent[last] = undefined;\n    } else {\n      // Replace the string keys with Symbols so they're non-enumerable.\n      const replaced: {[key: Symbol]: boolean | string, ...} = {};\n      replaced[meta.inspectable] = !!value.inspectable;\n      replaced[meta.inspected] = false;\n      replaced[meta.name] = value.name;\n      replaced[meta.preview_long] = value.preview_long;\n      replaced[meta.preview_short] = value.preview_short;\n      replaced[meta.size] = value.size;\n      replaced[meta.readonly] = !!value.readonly;\n      replaced[meta.type] = value.type;\n\n      parent[last] = replaced;\n    }\n  });\n  unserializable.forEach((path: Array<string | number>) => {\n    const length = path.length;\n    const last = path[length - 1];\n    const parent = getInObject(object, path.slice(0, length - 1));\n    if (!parent || !parent.hasOwnProperty(last)) {\n      return;\n    }\n\n    const node = parent[last];\n\n    const replacement = {\n      ...node,\n    };\n\n    upgradeUnserializable(replacement, node);\n\n    parent[last] = replacement;\n  });\n  return object;\n}\n\nfunction upgradeUnserializable(destination: Object, source: Object) {\n  Object.defineProperties(destination, {\n    [meta.inspected]: {\n      configurable: true,\n      enumerable: false,\n      value: !!source.inspected,\n    },\n    [meta.name]: {\n      configurable: true,\n      enumerable: false,\n      value: source.name,\n    },\n    [meta.preview_long]: {\n      configurable: true,\n      enumerable: false,\n      value: source.preview_long,\n    },\n    [meta.preview_short]: {\n      configurable: true,\n      enumerable: false,\n      value: source.preview_short,\n    },\n    [meta.size]: {\n      configurable: true,\n      enumerable: false,\n      value: source.size,\n    },\n    [meta.readonly]: {\n      configurable: true,\n      enumerable: false,\n      value: !!source.readonly,\n    },\n    [meta.type]: {\n      configurable: true,\n      enumerable: false,\n      value: source.type,\n    },\n    [meta.unserializable]: {\n      configurable: true,\n      enumerable: false,\n      value: !!source.unserializable,\n    },\n  });\n\n  delete destination.inspected;\n  delete destination.name;\n  delete destination.preview_long;\n  delete destination.preview_short;\n  delete destination.size;\n  delete destination.readonly;\n  delete destination.type;\n  delete destination.unserializable;\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport LRU from 'lru-cache';\nimport {\n  isElement,\n  typeOf,\n  ContextConsumer,\n  ContextProvider,\n  ForwardRef,\n  Fragment,\n  Lazy,\n  Memo,\n  Portal,\n  Profiler,\n  StrictMode,\n  Suspense,\n} from 'react-is';\nimport {REACT_SUSPENSE_LIST_TYPE as SuspenseList} from 'shared/ReactSymbols';\nimport {\n  TREE_OPERATION_ADD,\n  TREE_OPERATION_REMOVE,\n  TREE_OPERATION_REORDER_CHILDREN,\n  TREE_OPERATION_UPDATE_TREE_BASE_DURATION,\n} from './constants';\nimport {ElementTypeRoot} from 'react-devtools-shared/src/types';\nimport {\n  LOCAL_STORAGE_FILTER_PREFERENCES_KEY,\n  LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS,\n  LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY,\n} from './constants';\nimport {ComponentFilterElementType, ElementTypeHostComponent} from './types';\nimport {\n  ElementTypeClass,\n  ElementTypeForwardRef,\n  ElementTypeFunction,\n  ElementTypeMemo,\n} from 'react-devtools-shared/src/types';\nimport {localStorageGetItem, localStorageSetItem} from './storage';\nimport {meta} from './hydration';\nimport type {ComponentFilter, ElementType} from './types';\n\nconst cachedDisplayNames: WeakMap<Function, string> = new WeakMap();\n\n// On large trees, encoding takes significant time.\n// Try to reuse the already encoded strings.\nconst encodedStringCache = new LRU({max: 1000});\n\nexport function alphaSortKeys(\n  a: string | number | Symbol,\n  b: string | number | Symbol,\n): number {\n  if (a.toString() > b.toString()) {\n    return 1;\n  } else if (b.toString() > a.toString()) {\n    return -1;\n  } else {\n    return 0;\n  }\n}\n\nexport function getAllEnumerableKeys(\n  obj: Object,\n): Array<string | number | Symbol> {\n  const keys = [];\n  let current = obj;\n  while (current != null) {\n    const currentKeys = [\n      ...Object.keys(current),\n      ...Object.getOwnPropertySymbols(current),\n    ];\n    const descriptors = Object.getOwnPropertyDescriptors(current);\n    currentKeys.forEach(key => {\n      // $FlowFixMe: key can be a Symbol https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor\n      if (descriptors[key].enumerable) {\n        keys.push(key);\n      }\n    });\n    current = Object.getPrototypeOf(current);\n  }\n  return keys;\n}\n\nexport function getDisplayName(\n  type: Function,\n  fallbackName: string = 'Anonymous',\n): string {\n  const nameFromCache = cachedDisplayNames.get(type);\n  if (nameFromCache != null) {\n    return nameFromCache;\n  }\n\n  let displayName = fallbackName;\n\n  // The displayName property is not guaranteed to be a string.\n  // It's only safe to use for our purposes if it's a string.\n  // github.com/facebook/react-devtools/issues/803\n  if (typeof type.displayName === 'string') {\n    displayName = type.displayName;\n  } else if (typeof type.name === 'string' && type.name !== '') {\n    displayName = type.name;\n  }\n\n  cachedDisplayNames.set(type, displayName);\n  return displayName;\n}\n\nlet uidCounter: number = 0;\n\nexport function getUID(): number {\n  return ++uidCounter;\n}\n\nexport function utfDecodeString(array: Array<number>): string {\n  return String.fromCodePoint(...array);\n}\n\nexport function utfEncodeString(string: string): Array<number> {\n  const cached = encodedStringCache.get(string);\n  if (cached !== undefined) {\n    return cached;\n  }\n\n  const encoded = new Array(string.length);\n  for (let i = 0; i < string.length; i++) {\n    encoded[i] = string.codePointAt(i);\n  }\n  encodedStringCache.set(string, encoded);\n  return encoded;\n}\n\nexport function printOperationsArray(operations: Array<number>) {\n  // The first two values are always rendererID and rootID\n  const rendererID = operations[0];\n  const rootID = operations[1];\n\n  const logs = [`operations for renderer:${rendererID} and root:${rootID}`];\n\n  let i = 2;\n\n  // Reassemble the string table.\n  const stringTable = [\n    null, // ID = 0 corresponds to the null string.\n  ];\n  const stringTableSize = operations[i++];\n  const stringTableEnd = i + stringTableSize;\n  while (i < stringTableEnd) {\n    const nextLength = operations[i++];\n    const nextString = utfDecodeString(\n      (operations.slice(i, i + nextLength): any),\n    );\n    stringTable.push(nextString);\n    i += nextLength;\n  }\n\n  while (i < operations.length) {\n    const operation = operations[i];\n\n    switch (operation) {\n      case TREE_OPERATION_ADD: {\n        const id = ((operations[i + 1]: any): number);\n        const type = ((operations[i + 2]: any): ElementType);\n\n        i += 3;\n\n        if (type === ElementTypeRoot) {\n          logs.push(`Add new root node ${id}`);\n\n          i++; // supportsProfiling\n          i++; // hasOwnerMetadata\n        } else {\n          const parentID = ((operations[i]: any): number);\n          i++;\n\n          i++; // ownerID\n\n          const displayNameStringID = operations[i];\n          const displayName = stringTable[displayNameStringID];\n          i++;\n\n          i++; // key\n\n          logs.push(\n            `Add node ${id} (${displayName || 'null'}) as child of ${parentID}`,\n          );\n        }\n        break;\n      }\n      case TREE_OPERATION_REMOVE: {\n        const removeLength = ((operations[i + 1]: any): number);\n        i += 2;\n\n        for (let removeIndex = 0; removeIndex < removeLength; removeIndex++) {\n          const id = ((operations[i]: any): number);\n          i += 1;\n\n          logs.push(`Remove node ${id}`);\n        }\n        break;\n      }\n      case TREE_OPERATION_REORDER_CHILDREN: {\n        const id = ((operations[i + 1]: any): number);\n        const numChildren = ((operations[i + 2]: any): number);\n        i += 3;\n        const children = operations.slice(i, i + numChildren);\n        i += numChildren;\n\n        logs.push(`Re-order node ${id} children ${children.join(',')}`);\n        break;\n      }\n      case TREE_OPERATION_UPDATE_TREE_BASE_DURATION:\n        // Base duration updates are only sent while profiling is in progress.\n        // We can ignore them at this point.\n        // The profiler UI uses them lazily in order to generate the tree.\n        i += 3;\n        break;\n      default:\n        throw Error(`Unsupported Bridge operation ${operation}`);\n    }\n  }\n\n  console.log(logs.join('\\n  '));\n}\n\nexport function getDefaultComponentFilters(): Array<ComponentFilter> {\n  return [\n    {\n      type: ComponentFilterElementType,\n      value: ElementTypeHostComponent,\n      isEnabled: true,\n    },\n  ];\n}\n\nexport function getSavedComponentFilters(): Array<ComponentFilter> {\n  try {\n    const raw = localStorageGetItem(LOCAL_STORAGE_FILTER_PREFERENCES_KEY);\n    if (raw != null) {\n      return JSON.parse(raw);\n    }\n  } catch (error) {}\n  return getDefaultComponentFilters();\n}\n\nexport function saveComponentFilters(\n  componentFilters: Array<ComponentFilter>,\n): void {\n  localStorageSetItem(\n    LOCAL_STORAGE_FILTER_PREFERENCES_KEY,\n    JSON.stringify(componentFilters),\n  );\n}\n\nexport function getAppendComponentStack(): boolean {\n  try {\n    const raw = localStorageGetItem(LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY);\n    if (raw != null) {\n      return JSON.parse(raw);\n    }\n  } catch (error) {}\n  return true;\n}\n\nexport function setAppendComponentStack(value: boolean): void {\n  localStorageSetItem(\n    LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY,\n    JSON.stringify(value),\n  );\n}\n\nexport function getBreakOnConsoleErrors(): boolean {\n  try {\n    const raw = localStorageGetItem(\n      LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS,\n    );\n    if (raw != null) {\n      return JSON.parse(raw);\n    }\n  } catch (error) {}\n  return false;\n}\n\nexport function setBreakOnConsoleErrors(value: boolean): void {\n  localStorageSetItem(\n    LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS,\n    JSON.stringify(value),\n  );\n}\n\nexport function separateDisplayNameAndHOCs(\n  displayName: string | null,\n  type: ElementType,\n): [string | null, Array<string> | null] {\n  if (displayName === null) {\n    return [null, null];\n  }\n\n  let hocDisplayNames = null;\n\n  switch (type) {\n    case ElementTypeClass:\n    case ElementTypeForwardRef:\n    case ElementTypeFunction:\n    case ElementTypeMemo:\n      if (displayName.indexOf('(') >= 0) {\n        const matches = displayName.match(/[^()]+/g);\n        if (matches != null) {\n          displayName = matches.pop();\n          hocDisplayNames = matches;\n        }\n      }\n      break;\n    default:\n      break;\n  }\n\n  if (type === ElementTypeMemo) {\n    if (hocDisplayNames === null) {\n      hocDisplayNames = ['Memo'];\n    } else {\n      hocDisplayNames.unshift('Memo');\n    }\n  } else if (type === ElementTypeForwardRef) {\n    if (hocDisplayNames === null) {\n      hocDisplayNames = ['ForwardRef'];\n    } else {\n      hocDisplayNames.unshift('ForwardRef');\n    }\n  }\n\n  return [displayName, hocDisplayNames];\n}\n\n// Pulled from react-compat\n// https://github.com/developit/preact-compat/blob/7c5de00e7c85e2ffd011bf3af02899b63f699d3a/src/index.js#L349\nexport function shallowDiffers(prev: Object, next: Object): boolean {\n  for (const attribute in prev) {\n    if (!(attribute in next)) {\n      return true;\n    }\n  }\n  for (const attribute in next) {\n    if (prev[attribute] !== next[attribute]) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function getInObject(object: Object, path: Array<string | number>): any {\n  return path.reduce((reduced: Object, attr: any): any => {\n    if (reduced) {\n      if (hasOwnProperty.call(reduced, attr)) {\n        return reduced[attr];\n      }\n      if (typeof reduced[Symbol.iterator] === 'function') {\n        // Convert iterable to array and return array[index]\n        //\n        // TRICKY\n        // Don't use [...spread] syntax for this purpose.\n        // This project uses @babel/plugin-transform-spread in \"loose\" mode which only works with Array values.\n        // Other types (e.g. typed arrays, Sets) will not spread correctly.\n        return Array.from(reduced)[attr];\n      }\n    }\n\n    return null;\n  }, object);\n}\n\nexport function deletePathInObject(\n  object: Object,\n  path: Array<string | number>,\n) {\n  const length = path.length;\n  const last = path[length - 1];\n  if (object != null) {\n    const parent = getInObject(object, path.slice(0, length - 1));\n    if (parent) {\n      if (Array.isArray(parent)) {\n        parent.splice(((last: any): number), 1);\n      } else {\n        delete parent[last];\n      }\n    }\n  }\n}\n\nexport function renamePathInObject(\n  object: Object,\n  oldPath: Array<string | number>,\n  newPath: Array<string | number>,\n) {\n  const length = oldPath.length;\n  if (object != null) {\n    const parent = getInObject(object, oldPath.slice(0, length - 1));\n    if (parent) {\n      const lastOld = oldPath[length - 1];\n      const lastNew = newPath[length - 1];\n      parent[lastNew] = parent[lastOld];\n      if (Array.isArray(parent)) {\n        parent.splice(((lastOld: any): number), 1);\n      } else {\n        delete parent[lastOld];\n      }\n    }\n  }\n}\n\nexport function setInObject(\n  object: Object,\n  path: Array<string | number>,\n  value: any,\n) {\n  const length = path.length;\n  const last = path[length - 1];\n  if (object != null) {\n    const parent = getInObject(object, path.slice(0, length - 1));\n    if (parent) {\n      parent[last] = value;\n    }\n  }\n}\n\nexport type DataType =\n  | 'array'\n  | 'array_buffer'\n  | 'bigint'\n  | 'boolean'\n  | 'data_view'\n  | 'date'\n  | 'function'\n  | 'html_all_collection'\n  | 'html_element'\n  | 'infinity'\n  | 'iterator'\n  | 'opaque_iterator'\n  | 'nan'\n  | 'null'\n  | 'number'\n  | 'object'\n  | 'react_element'\n  | 'regexp'\n  | 'string'\n  | 'symbol'\n  | 'typed_array'\n  | 'undefined'\n  | 'unknown';\n\n/**\n * Get a enhanced/artificial type string based on the object instance\n */\nexport function getDataType(data: Object): DataType {\n  if (data === null) {\n    return 'null';\n  } else if (data === undefined) {\n    return 'undefined';\n  }\n\n  if (isElement(data)) {\n    return 'react_element';\n  }\n\n  if (typeof HTMLElement !== 'undefined' && data instanceof HTMLElement) {\n    return 'html_element';\n  }\n\n  const type = typeof data;\n  switch (type) {\n    case 'bigint':\n      return 'bigint';\n    case 'boolean':\n      return 'boolean';\n    case 'function':\n      return 'function';\n    case 'number':\n      if (Number.isNaN(data)) {\n        return 'nan';\n      } else if (!Number.isFinite(data)) {\n        return 'infinity';\n      } else {\n        return 'number';\n      }\n    case 'object':\n      if (Array.isArray(data)) {\n        return 'array';\n      } else if (ArrayBuffer.isView(data)) {\n        return hasOwnProperty.call(data.constructor, 'BYTES_PER_ELEMENT')\n          ? 'typed_array'\n          : 'data_view';\n      } else if (data.constructor && data.constructor.name === 'ArrayBuffer') {\n        // HACK This ArrayBuffer check is gross; is there a better way?\n        // We could try to create a new DataView with the value.\n        // If it doesn't error, we know it's an ArrayBuffer,\n        // but this seems kind of awkward and expensive.\n        return 'array_buffer';\n      } else if (typeof data[Symbol.iterator] === 'function') {\n        return data[Symbol.iterator]() === data\n          ? 'opaque_iterator'\n          : 'iterator';\n      } else if (data.constructor && data.constructor.name === 'RegExp') {\n        return 'regexp';\n      } else {\n        const toStringValue = Object.prototype.toString.call(data);\n        if (toStringValue === '[object Date]') {\n          return 'date';\n        } else if (toStringValue === '[object HTMLAllCollection]') {\n          return 'html_all_collection';\n        }\n      }\n      return 'object';\n    case 'string':\n      return 'string';\n    case 'symbol':\n      return 'symbol';\n    case 'undefined':\n      if (\n        Object.prototype.toString.call(data) === '[object HTMLAllCollection]'\n      ) {\n        return 'html_all_collection';\n      }\n      return 'undefined';\n    default:\n      return 'unknown';\n  }\n}\n\nexport function getDisplayNameForReactElement(\n  element: React$Element<any>,\n): string | null {\n  const elementType = typeOf(element);\n  switch (elementType) {\n    case ContextConsumer:\n      return 'ContextConsumer';\n    case ContextProvider:\n      return 'ContextProvider';\n    case ForwardRef:\n      return 'ForwardRef';\n    case Fragment:\n      return 'Fragment';\n    case Lazy:\n      return 'Lazy';\n    case Memo:\n      return 'Memo';\n    case Portal:\n      return 'Portal';\n    case Profiler:\n      return 'Profiler';\n    case StrictMode:\n      return 'StrictMode';\n    case Suspense:\n      return 'Suspense';\n    case SuspenseList:\n      return 'SuspenseList';\n    default:\n      const {type} = element;\n      if (typeof type === 'string') {\n        return type;\n      } else if (typeof type === 'function') {\n        return getDisplayName(type, 'Anonymous');\n      } else if (type != null) {\n        return 'NotImplementedInDevtools';\n      } else {\n        return 'Element';\n      }\n  }\n}\n\nconst MAX_PREVIEW_STRING_LENGTH = 50;\n\nfunction truncateForDisplay(\n  string: string,\n  length: number = MAX_PREVIEW_STRING_LENGTH,\n) {\n  if (string.length > length) {\n    return string.substr(0, length) + '…';\n  } else {\n    return string;\n  }\n}\n\n// Attempts to mimic Chrome's inline preview for values.\n// For example, the following value...\n//   {\n//      foo: 123,\n//      bar: \"abc\",\n//      baz: [true, false],\n//      qux: { ab: 1, cd: 2 }\n//   };\n//\n// Would show a preview of...\n//   {foo: 123, bar: \"abc\", baz: Array(2), qux: {…}}\n//\n// And the following value...\n//   [\n//     123,\n//     \"abc\",\n//     [true, false],\n//     { foo: 123, bar: \"abc\" }\n//   ];\n//\n// Would show a preview of...\n//   [123, \"abc\", Array(2), {…}]\nexport function formatDataForPreview(\n  data: any,\n  showFormattedValue: boolean,\n): string {\n  if (data != null && hasOwnProperty.call(data, meta.type)) {\n    return showFormattedValue\n      ? data[meta.preview_long]\n      : data[meta.preview_short];\n  }\n\n  const type = getDataType(data);\n\n  switch (type) {\n    case 'html_element':\n      return `<${truncateForDisplay(data.tagName.toLowerCase())} />`;\n    case 'function':\n      return truncateForDisplay(\n        `ƒ ${typeof data.name === 'function' ? '' : data.name}() {}`,\n      );\n    case 'string':\n      return `\"${data}\"`;\n    case 'bigint':\n      return truncateForDisplay(data.toString() + 'n');\n    case 'regexp':\n      return truncateForDisplay(data.toString());\n    case 'symbol':\n      return truncateForDisplay(data.toString());\n    case 'react_element':\n      return `<${truncateForDisplay(\n        getDisplayNameForReactElement(data) || 'Unknown',\n      )} />`;\n    case 'array_buffer':\n      return `ArrayBuffer(${data.byteLength})`;\n    case 'data_view':\n      return `DataView(${data.buffer.byteLength})`;\n    case 'array':\n      if (showFormattedValue) {\n        let formatted = '';\n        for (let i = 0; i < data.length; i++) {\n          if (i > 0) {\n            formatted += ', ';\n          }\n          formatted += formatDataForPreview(data[i], false);\n          if (formatted.length > MAX_PREVIEW_STRING_LENGTH) {\n            // Prevent doing a lot of unnecessary iteration...\n            break;\n          }\n        }\n        return `[${truncateForDisplay(formatted)}]`;\n      } else {\n        const length = hasOwnProperty.call(data, meta.size)\n          ? data[meta.size]\n          : data.length;\n        return `Array(${length})`;\n      }\n    case 'typed_array':\n      const shortName = `${data.constructor.name}(${data.length})`;\n      if (showFormattedValue) {\n        let formatted = '';\n        for (let i = 0; i < data.length; i++) {\n          if (i > 0) {\n            formatted += ', ';\n          }\n          formatted += data[i];\n          if (formatted.length > MAX_PREVIEW_STRING_LENGTH) {\n            // Prevent doing a lot of unnecessary iteration...\n            break;\n          }\n        }\n        return `${shortName} [${truncateForDisplay(formatted)}]`;\n      } else {\n        return shortName;\n      }\n    case 'iterator':\n      const name = data.constructor.name;\n\n      if (showFormattedValue) {\n        // TRICKY\n        // Don't use [...spread] syntax for this purpose.\n        // This project uses @babel/plugin-transform-spread in \"loose\" mode which only works with Array values.\n        // Other types (e.g. typed arrays, Sets) will not spread correctly.\n        const array = Array.from(data);\n\n        let formatted = '';\n        for (let i = 0; i < array.length; i++) {\n          const entryOrEntries = array[i];\n\n          if (i > 0) {\n            formatted += ', ';\n          }\n\n          // TRICKY\n          // Browsers display Maps and Sets differently.\n          // To mimic their behavior, detect if we've been given an entries tuple.\n          //   Map(2) {\"abc\" => 123, \"def\" => 123}\n          //   Set(2) {\"abc\", 123}\n          if (Array.isArray(entryOrEntries)) {\n            const key = formatDataForPreview(entryOrEntries[0], true);\n            const value = formatDataForPreview(entryOrEntries[1], false);\n            formatted += `${key} => ${value}`;\n          } else {\n            formatted += formatDataForPreview(entryOrEntries, false);\n          }\n\n          if (formatted.length > MAX_PREVIEW_STRING_LENGTH) {\n            // Prevent doing a lot of unnecessary iteration...\n            break;\n          }\n        }\n\n        return `${name}(${data.size}) {${truncateForDisplay(formatted)}}`;\n      } else {\n        return `${name}(${data.size})`;\n      }\n    case 'opaque_iterator': {\n      return data[Symbol.toStringTag];\n    }\n    case 'date':\n      return data.toString();\n    case 'object':\n      if (showFormattedValue) {\n        const keys = getAllEnumerableKeys(data).sort(alphaSortKeys);\n\n        let formatted = '';\n        for (let i = 0; i < keys.length; i++) {\n          const key = keys[i];\n          if (i > 0) {\n            formatted += ', ';\n          }\n          formatted += `${key.toString()}: ${formatDataForPreview(\n            data[key],\n            false,\n          )}`;\n          if (formatted.length > MAX_PREVIEW_STRING_LENGTH) {\n            // Prevent doing a lot of unnecessary iteration...\n            break;\n          }\n        }\n        return `{${truncateForDisplay(formatted)}}`;\n      } else {\n        return '{…}';\n      }\n    case 'boolean':\n    case 'number':\n    case 'infinity':\n    case 'nan':\n    case 'null':\n    case 'undefined':\n      return data;\n    default:\n      try {\n        return truncateForDisplay('' + data);\n      } catch (error) {\n        return 'unserializable';\n      }\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport {copy} from 'clipboard-js';\nimport {dehydrate} from '../hydration';\n\nimport type {DehydratedData} from 'react-devtools-shared/src/devtools/views/Components/types';\n\nexport function cleanForBridge(\n  data: Object | null,\n  isPathAllowed: (path: Array<string | number>) => boolean,\n  path?: Array<string | number> = [],\n): DehydratedData | null {\n  if (data !== null) {\n    const cleanedPaths = [];\n    const unserializablePaths = [];\n    const cleanedData = dehydrate(\n      data,\n      cleanedPaths,\n      unserializablePaths,\n      path,\n      isPathAllowed,\n    );\n\n    return {\n      data: cleanedData,\n      cleaned: cleanedPaths,\n      unserializable: unserializablePaths,\n    };\n  } else {\n    return null;\n  }\n}\n\nexport function copyToClipboard(value: any): void {\n  const safeToCopy = serializeToString(value);\n  const text = safeToCopy === undefined ? 'undefined' : safeToCopy;\n  const {clipboardCopyText} = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;\n\n  // On Firefox navigator.clipboard.writeText has to be called from\n  // the content script js code (because it requires the clipboardWrite\n  // permission to be allowed out of a \"user handling\" callback),\n  // clipboardCopyText is an helper injected into the page from.\n  // injectGlobalHook.\n  if (typeof clipboardCopyText === 'function') {\n    clipboardCopyText(text).catch(err => {});\n  } else {\n    copy(text);\n  }\n}\n\nexport function copyWithDelete(\n  obj: Object | Array<any>,\n  path: Array<string | number>,\n  index: number = 0,\n): Object | Array<any> {\n  const key = path[index];\n  const updated = Array.isArray(obj) ? obj.slice() : {...obj};\n  if (index + 1 === path.length) {\n    if (Array.isArray(updated)) {\n      updated.splice(((key: any): number), 1);\n    } else {\n      delete updated[key];\n    }\n  } else {\n    // $FlowFixMe number or string is fine here\n    updated[key] = copyWithDelete(obj[key], path, index + 1);\n  }\n  return updated;\n}\n\n// This function expects paths to be the same except for the final value.\n// e.g. ['path', 'to', 'foo'] and ['path', 'to', 'bar']\nexport function copyWithRename(\n  obj: Object | Array<any>,\n  oldPath: Array<string | number>,\n  newPath: Array<string | number>,\n  index: number = 0,\n): Object | Array<any> {\n  const oldKey = oldPath[index];\n  const updated = Array.isArray(obj) ? obj.slice() : {...obj};\n  if (index + 1 === oldPath.length) {\n    const newKey = newPath[index];\n    // $FlowFixMe number or string is fine here\n    updated[newKey] = updated[oldKey];\n    if (Array.isArray(updated)) {\n      updated.splice(((oldKey: any): number), 1);\n    } else {\n      delete updated[oldKey];\n    }\n  } else {\n    // $FlowFixMe number or string is fine here\n    updated[oldKey] = copyWithRename(obj[oldKey], oldPath, newPath, index + 1);\n  }\n  return updated;\n}\n\nexport function copyWithSet(\n  obj: Object | Array<any>,\n  path: Array<string | number>,\n  value: any,\n  index: number = 0,\n): Object | Array<any> {\n  if (index >= path.length) {\n    return value;\n  }\n  const key = path[index];\n  const updated = Array.isArray(obj) ? obj.slice() : {...obj};\n  // $FlowFixMe number or string is fine here\n  updated[key] = copyWithSet(obj[key], path, value, index + 1);\n  return updated;\n}\n\nexport function serializeToString(data: any): string {\n  const cache = new Set();\n  // Use a custom replacer function to protect against circular references.\n  return JSON.stringify(data, (key, value) => {\n    if (typeof value === 'object' && value !== null) {\n      if (cache.has(value)) {\n        return;\n      }\n      cache.add(value);\n    }\n    // $FlowFixMe\n    if (typeof value === 'bigint') {\n      return value.toString() + 'n';\n    }\n    return value;\n  });\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport {gt, gte} from 'semver';\nimport {\n  ComponentFilterDisplayName,\n  ComponentFilterElementType,\n  ComponentFilterHOC,\n  ComponentFilterLocation,\n  ElementTypeClass,\n  ElementTypeContext,\n  ElementTypeFunction,\n  ElementTypeForwardRef,\n  ElementTypeHostComponent,\n  ElementTypeMemo,\n  ElementTypeOtherOrUnknown,\n  ElementTypeProfiler,\n  ElementTypeRoot,\n  ElementTypeSuspense,\n  ElementTypeSuspenseList,\n} from 'react-devtools-shared/src/types';\nimport {\n  deletePathInObject,\n  getDisplayName,\n  getDefaultComponentFilters,\n  getInObject,\n  getUID,\n  renamePathInObject,\n  setInObject,\n  utfEncodeString,\n} from 'react-devtools-shared/src/utils';\nimport {sessionStorageGetItem} from 'react-devtools-shared/src/storage';\nimport {\n  cleanForBridge,\n  copyToClipboard,\n  copyWithDelete,\n  copyWithRename,\n  copyWithSet,\n} from './utils';\nimport {\n  __DEBUG__,\n  SESSION_STORAGE_RELOAD_AND_PROFILE_KEY,\n  SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY,\n  TREE_OPERATION_ADD,\n  TREE_OPERATION_REMOVE,\n  TREE_OPERATION_REORDER_CHILDREN,\n  TREE_OPERATION_UPDATE_TREE_BASE_DURATION,\n} from '../constants';\nimport {inspectHooksOfFiber} from 'react-debug-tools';\nimport {\n  patch as patchConsole,\n  registerRenderer as registerRendererWithConsole,\n} from './console';\nimport {\n  CONCURRENT_MODE_NUMBER,\n  CONCURRENT_MODE_SYMBOL_STRING,\n  DEPRECATED_ASYNC_MODE_SYMBOL_STRING,\n  PROVIDER_NUMBER,\n  PROVIDER_SYMBOL_STRING,\n  CONTEXT_NUMBER,\n  CONTEXT_SYMBOL_STRING,\n  STRICT_MODE_NUMBER,\n  STRICT_MODE_SYMBOL_STRING,\n  PROFILER_NUMBER,\n  PROFILER_SYMBOL_STRING,\n  SCOPE_NUMBER,\n  SCOPE_SYMBOL_STRING,\n  FORWARD_REF_NUMBER,\n  FORWARD_REF_SYMBOL_STRING,\n  MEMO_NUMBER,\n  MEMO_SYMBOL_STRING,\n} from './ReactSymbols';\n\nimport type {Fiber} from 'react-reconciler/src/ReactInternalTypes';\nimport type {\n  ChangeDescription,\n  CommitDataBackend,\n  DevToolsHook,\n  InspectedElement,\n  InspectedElementPayload,\n  InstanceAndStyle,\n  NativeType,\n  Owner,\n  PathFrame,\n  PathMatch,\n  ProfilingDataBackend,\n  ProfilingDataForRootBackend,\n  ReactRenderer,\n  RendererInterface,\n  WorkTagMap,\n} from './types';\nimport type {Interaction} from 'react-devtools-shared/src/devtools/views/Profiler/types';\nimport type {\n  ComponentFilter,\n  ElementType,\n} from 'react-devtools-shared/src/types';\n\ntype getDisplayNameForFiberType = (fiber: Fiber) => string | null;\ntype getTypeSymbolType = (type: any) => Symbol | number;\n\ntype ReactPriorityLevelsType = {|\n  ImmediatePriority: number,\n  UserBlockingPriority: number,\n  NormalPriority: number,\n  LowPriority: number,\n  IdlePriority: number,\n  NoPriority: number,\n|};\n\ntype ReactTypeOfSideEffectType = {|\n  NoFlags: number,\n  PerformedWork: number,\n  Placement: number,\n|};\n\nfunction getFiberFlags(fiber: Fiber): number {\n  // The name of this field changed from \"effectTag\" to \"flags\"\n  return fiber.flags !== undefined ? fiber.flags : (fiber: any).effectTag;\n}\n\n// Some environments (e.g. React Native / Hermes) don't support the performance API yet.\nconst getCurrentTime =\n  typeof performance === 'object' && typeof performance.now === 'function'\n    ? () => performance.now()\n    : () => Date.now();\n\nexport function getInternalReactConstants(\n  version: string,\n): {|\n  getDisplayNameForFiber: getDisplayNameForFiberType,\n  getTypeSymbol: getTypeSymbolType,\n  ReactPriorityLevels: ReactPriorityLevelsType,\n  ReactTypeOfSideEffect: ReactTypeOfSideEffectType,\n  ReactTypeOfWork: WorkTagMap,\n|} {\n  const ReactTypeOfSideEffect: ReactTypeOfSideEffectType = {\n    NoFlags: 0b00,\n    PerformedWork: 0b01,\n    Placement: 0b10,\n  };\n\n  // **********************************************************\n  // The section below is copied from files in React repo.\n  // Keep it in sync, and add version guards if it changes.\n  //\n  // Technically these priority levels are invalid for versions before 16.9,\n  // but 16.9 is the first version to report priority level to DevTools,\n  // so we can avoid checking for earlier versions and support pre-16.9 canary releases in the process.\n  const ReactPriorityLevels: ReactPriorityLevelsType = {\n    ImmediatePriority: 99,\n    UserBlockingPriority: 98,\n    NormalPriority: 97,\n    LowPriority: 96,\n    IdlePriority: 95,\n    NoPriority: 90,\n  };\n\n  let ReactTypeOfWork: WorkTagMap = ((null: any): WorkTagMap);\n\n  // **********************************************************\n  // The section below is copied from files in React repo.\n  // Keep it in sync, and add version guards if it changes.\n  //\n  // TODO Update the gt() check below to be gte() whichever the next version number is.\n  // Currently the version in Git is 17.0.2 (but that version has not been/may not end up being released).\n  if (gt(version, '17.0.1')) {\n    ReactTypeOfWork = {\n      ClassComponent: 1,\n      ContextConsumer: 9,\n      ContextProvider: 10,\n      CoroutineComponent: -1, // Removed\n      CoroutineHandlerPhase: -1, // Removed\n      DehydratedSuspenseComponent: 18, // Behind a flag\n      ForwardRef: 11,\n      Fragment: 7,\n      FunctionComponent: 0,\n      HostComponent: 5,\n      HostPortal: 4,\n      HostRoot: 3,\n      HostText: 6,\n      IncompleteClassComponent: 17,\n      IndeterminateComponent: 2,\n      LazyComponent: 16,\n      LegacyHiddenComponent: 23,\n      MemoComponent: 14,\n      Mode: 8,\n      OffscreenComponent: 22, // Experimental\n      Profiler: 12,\n      ScopeComponent: 21, // Experimental\n      SimpleMemoComponent: 15,\n      SuspenseComponent: 13,\n      SuspenseListComponent: 19, // Experimental\n      YieldComponent: -1, // Removed\n    };\n  } else if (gte(version, '17.0.0-alpha')) {\n    ReactTypeOfWork = {\n      ClassComponent: 1,\n      ContextConsumer: 9,\n      ContextProvider: 10,\n      CoroutineComponent: -1, // Removed\n      CoroutineHandlerPhase: -1, // Removed\n      DehydratedSuspenseComponent: 18, // Behind a flag\n      ForwardRef: 11,\n      Fragment: 7,\n      FunctionComponent: 0,\n      HostComponent: 5,\n      HostPortal: 4,\n      HostRoot: 3,\n      HostText: 6,\n      IncompleteClassComponent: 17,\n      IndeterminateComponent: 2,\n      LazyComponent: 16,\n      LegacyHiddenComponent: 24,\n      MemoComponent: 14,\n      Mode: 8,\n      OffscreenComponent: 23, // Experimental\n      Profiler: 12,\n      ScopeComponent: 21, // Experimental\n      SimpleMemoComponent: 15,\n      SuspenseComponent: 13,\n      SuspenseListComponent: 19, // Experimental\n      YieldComponent: -1, // Removed\n    };\n  } else if (gte(version, '16.6.0-beta.0')) {\n    ReactTypeOfWork = {\n      ClassComponent: 1,\n      ContextConsumer: 9,\n      ContextProvider: 10,\n      CoroutineComponent: -1, // Removed\n      CoroutineHandlerPhase: -1, // Removed\n      DehydratedSuspenseComponent: 18, // Behind a flag\n      ForwardRef: 11,\n      Fragment: 7,\n      FunctionComponent: 0,\n      HostComponent: 5,\n      HostPortal: 4,\n      HostRoot: 3,\n      HostText: 6,\n      IncompleteClassComponent: 17,\n      IndeterminateComponent: 2,\n      LazyComponent: 16,\n      LegacyHiddenComponent: -1,\n      MemoComponent: 14,\n      Mode: 8,\n      OffscreenComponent: -1, // Experimental\n      Profiler: 12,\n      ScopeComponent: -1, // Experimental\n      SimpleMemoComponent: 15,\n      SuspenseComponent: 13,\n      SuspenseListComponent: 19, // Experimental\n      YieldComponent: -1, // Removed\n    };\n  } else if (gte(version, '16.4.3-alpha')) {\n    ReactTypeOfWork = {\n      ClassComponent: 2,\n      ContextConsumer: 11,\n      ContextProvider: 12,\n      CoroutineComponent: -1, // Removed\n      CoroutineHandlerPhase: -1, // Removed\n      DehydratedSuspenseComponent: -1, // Doesn't exist yet\n      ForwardRef: 13,\n      Fragment: 9,\n      FunctionComponent: 0,\n      HostComponent: 7,\n      HostPortal: 6,\n      HostRoot: 5,\n      HostText: 8,\n      IncompleteClassComponent: -1, // Doesn't exist yet\n      IndeterminateComponent: 4,\n      LazyComponent: -1, // Doesn't exist yet\n      LegacyHiddenComponent: -1,\n      MemoComponent: -1, // Doesn't exist yet\n      Mode: 10,\n      OffscreenComponent: -1, // Experimental\n      Profiler: 15,\n      ScopeComponent: -1, // Experimental\n      SimpleMemoComponent: -1, // Doesn't exist yet\n      SuspenseComponent: 16,\n      SuspenseListComponent: -1, // Doesn't exist yet\n      YieldComponent: -1, // Removed\n    };\n  } else {\n    ReactTypeOfWork = {\n      ClassComponent: 2,\n      ContextConsumer: 12,\n      ContextProvider: 13,\n      CoroutineComponent: 7,\n      CoroutineHandlerPhase: 8,\n      DehydratedSuspenseComponent: -1, // Doesn't exist yet\n      ForwardRef: 14,\n      Fragment: 10,\n      FunctionComponent: 1,\n      HostComponent: 5,\n      HostPortal: 4,\n      HostRoot: 3,\n      HostText: 6,\n      IncompleteClassComponent: -1, // Doesn't exist yet\n      IndeterminateComponent: 0,\n      LazyComponent: -1, // Doesn't exist yet\n      LegacyHiddenComponent: -1,\n      MemoComponent: -1, // Doesn't exist yet\n      Mode: 11,\n      OffscreenComponent: -1, // Experimental\n      Profiler: 15,\n      ScopeComponent: -1, // Experimental\n      SimpleMemoComponent: -1, // Doesn't exist yet\n      SuspenseComponent: 16,\n      SuspenseListComponent: -1, // Doesn't exist yet\n      YieldComponent: 9,\n    };\n  }\n  // **********************************************************\n  // End of copied code.\n  // **********************************************************\n\n  function getTypeSymbol(type: any): Symbol | number {\n    const symbolOrNumber =\n      typeof type === 'object' && type !== null ? type.$$typeof : type;\n\n    // $FlowFixMe Flow doesn't know about typeof \"symbol\"\n    return typeof symbolOrNumber === 'symbol'\n      ? symbolOrNumber.toString()\n      : symbolOrNumber;\n  }\n\n  const {\n    ClassComponent,\n    IncompleteClassComponent,\n    FunctionComponent,\n    IndeterminateComponent,\n    ForwardRef,\n    HostRoot,\n    HostComponent,\n    HostPortal,\n    HostText,\n    Fragment,\n    LazyComponent,\n    LegacyHiddenComponent,\n    MemoComponent,\n    OffscreenComponent,\n    ScopeComponent,\n    SimpleMemoComponent,\n    SuspenseComponent,\n    SuspenseListComponent,\n  } = ReactTypeOfWork;\n\n  function resolveFiberType(type: any) {\n    const typeSymbol = getTypeSymbol(type);\n    switch (typeSymbol) {\n      case MEMO_NUMBER:\n      case MEMO_SYMBOL_STRING:\n        // recursively resolving memo type in case of memo(forwardRef(Component))\n        return resolveFiberType(type.type);\n      case FORWARD_REF_NUMBER:\n      case FORWARD_REF_SYMBOL_STRING:\n        return type.render;\n      default:\n        return type;\n    }\n  }\n\n  // NOTICE Keep in sync with shouldFilterFiber() and other get*ForFiber methods\n  function getDisplayNameForFiber(fiber: Fiber): string | null {\n    const {type, tag} = fiber;\n\n    let resolvedType = type;\n    if (typeof type === 'object' && type !== null) {\n      resolvedType = resolveFiberType(type);\n    }\n\n    let resolvedContext: any = null;\n\n    switch (tag) {\n      case ClassComponent:\n      case IncompleteClassComponent:\n        return getDisplayName(resolvedType);\n      case FunctionComponent:\n      case IndeterminateComponent:\n        return getDisplayName(resolvedType);\n      case ForwardRef:\n        // Mirror https://github.com/facebook/react/blob/7c21bf72ace77094fd1910cc350a548287ef8350/packages/shared/getComponentName.js#L27-L37\n        return (\n          (type && type.displayName) ||\n          getDisplayName(resolvedType, 'Anonymous')\n        );\n      case HostRoot:\n        return null;\n      case HostComponent:\n        return type;\n      case HostPortal:\n      case HostText:\n      case Fragment:\n        return null;\n      case LazyComponent:\n        // This display name will not be user visible.\n        // Once a Lazy component loads its inner component, React replaces the tag and type.\n        // This display name will only show up in console logs when DevTools DEBUG mode is on.\n        return 'Lazy';\n      case MemoComponent:\n      case SimpleMemoComponent:\n        return getDisplayName(resolvedType, 'Anonymous');\n      case SuspenseComponent:\n        return 'Suspense';\n      case LegacyHiddenComponent:\n        return 'LegacyHidden';\n      case OffscreenComponent:\n        return 'Offscreen';\n      case ScopeComponent:\n        return 'Scope';\n      case SuspenseListComponent:\n        return 'SuspenseList';\n      default:\n        const typeSymbol = getTypeSymbol(type);\n\n        switch (typeSymbol) {\n          case CONCURRENT_MODE_NUMBER:\n          case CONCURRENT_MODE_SYMBOL_STRING:\n          case DEPRECATED_ASYNC_MODE_SYMBOL_STRING:\n            return null;\n          case PROVIDER_NUMBER:\n          case PROVIDER_SYMBOL_STRING:\n            // 16.3.0 exposed the context object as \"context\"\n            // PR #12501 changed it to \"_context\" for 16.3.1+\n            // NOTE Keep in sync with inspectElementRaw()\n            resolvedContext = fiber.type._context || fiber.type.context;\n            return `${resolvedContext.displayName || 'Context'}.Provider`;\n          case CONTEXT_NUMBER:\n          case CONTEXT_SYMBOL_STRING:\n            // 16.3-16.5 read from \"type\" because the Consumer is the actual context object.\n            // 16.6+ should read from \"type._context\" because Consumer can be different (in DEV).\n            // NOTE Keep in sync with inspectElementRaw()\n            resolvedContext = fiber.type._context || fiber.type;\n\n            // NOTE: TraceUpdatesBackendManager depends on the name ending in '.Consumer'\n            // If you change the name, figure out a more resilient way to detect it.\n            return `${resolvedContext.displayName || 'Context'}.Consumer`;\n          case STRICT_MODE_NUMBER:\n          case STRICT_MODE_SYMBOL_STRING:\n            return null;\n          case PROFILER_NUMBER:\n          case PROFILER_SYMBOL_STRING:\n            return `Profiler(${fiber.memoizedProps.id})`;\n          case SCOPE_NUMBER:\n          case SCOPE_SYMBOL_STRING:\n            return 'Scope';\n          default:\n            // Unknown element type.\n            // This may mean a new element type that has not yet been added to DevTools.\n            return null;\n        }\n    }\n  }\n\n  return {\n    getDisplayNameForFiber,\n    getTypeSymbol,\n    ReactPriorityLevels,\n    ReactTypeOfWork,\n    ReactTypeOfSideEffect,\n  };\n}\n\nexport function attach(\n  hook: DevToolsHook,\n  rendererID: number,\n  renderer: ReactRenderer,\n  global: Object,\n): RendererInterface {\n  const {\n    getDisplayNameForFiber,\n    getTypeSymbol,\n    ReactPriorityLevels,\n    ReactTypeOfWork,\n    ReactTypeOfSideEffect,\n  } = getInternalReactConstants(renderer.version);\n  const {NoFlags, PerformedWork, Placement} = ReactTypeOfSideEffect;\n  const {\n    FunctionComponent,\n    ClassComponent,\n    ContextConsumer,\n    DehydratedSuspenseComponent,\n    Fragment,\n    ForwardRef,\n    HostRoot,\n    HostPortal,\n    HostComponent,\n    HostText,\n    IncompleteClassComponent,\n    IndeterminateComponent,\n    MemoComponent,\n    OffscreenComponent,\n    SimpleMemoComponent,\n    SuspenseComponent,\n    SuspenseListComponent,\n  } = ReactTypeOfWork;\n  const {\n    ImmediatePriority,\n    UserBlockingPriority,\n    NormalPriority,\n    LowPriority,\n    IdlePriority,\n    NoPriority,\n  } = ReactPriorityLevels;\n\n  const {\n    overrideHookState,\n    overrideHookStateDeletePath,\n    overrideHookStateRenamePath,\n    overrideProps,\n    overridePropsDeletePath,\n    overridePropsRenamePath,\n    setSuspenseHandler,\n    scheduleUpdate,\n  } = renderer;\n  const supportsTogglingSuspense =\n    typeof setSuspenseHandler === 'function' &&\n    typeof scheduleUpdate === 'function';\n\n  // Patching the console enables DevTools to do a few useful things:\n  // * Append component stacks to warnings and error messages\n  // * Disable logging during re-renders to inspect hooks (see inspectHooksOfFiber)\n  //\n  // Don't patch in test environments because we don't want to interfere with Jest's own console overrides.\n  if (process.env.NODE_ENV !== 'test') {\n    registerRendererWithConsole(renderer);\n\n    // The renderer interface can't read these preferences directly,\n    // because it is stored in localStorage within the context of the extension.\n    // It relies on the extension to pass the preference through via the global.\n    const appendComponentStack =\n      window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__ !== false;\n    const breakOnConsoleErrors =\n      window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__ === true;\n    if (appendComponentStack || breakOnConsoleErrors) {\n      patchConsole({\n        appendComponentStack,\n        breakOnConsoleErrors,\n      });\n    }\n  }\n\n  const debug = (name: string, fiber: Fiber, parentFiber: ?Fiber): void => {\n    if (__DEBUG__) {\n      const displayName =\n        fiber.tag + ':' + (getDisplayNameForFiber(fiber) || 'null');\n      const id = getFiberID(fiber);\n      const parentDisplayName = parentFiber\n        ? parentFiber.tag +\n          ':' +\n          (getDisplayNameForFiber(parentFiber) || 'null')\n        : '';\n      const parentID = parentFiber ? getFiberID(parentFiber) : '';\n      // NOTE: calling getFiberID or getPrimaryFiber is unsafe here\n      // because it will put them in the map. For now, we'll omit them.\n      // TODO: better debugging story for this.\n      console.log(\n        `[renderer] %c${name} %c${displayName} (${id}) %c${\n          parentFiber ? `${parentDisplayName} (${parentID})` : ''\n        }`,\n        'color: red; font-weight: bold;',\n        'color: blue;',\n        'color: purple;',\n      );\n    }\n  };\n\n  // Configurable Components tree filters.\n  const hideElementsWithDisplayNames: Set<RegExp> = new Set();\n  const hideElementsWithPaths: Set<RegExp> = new Set();\n  const hideElementsWithTypes: Set<ElementType> = new Set();\n\n  // Highlight updates\n  let traceUpdatesEnabled: boolean = false;\n  const traceUpdatesForNodes: Set<NativeType> = new Set();\n\n  function applyComponentFilters(componentFilters: Array<ComponentFilter>) {\n    hideElementsWithTypes.clear();\n    hideElementsWithDisplayNames.clear();\n    hideElementsWithPaths.clear();\n\n    componentFilters.forEach(componentFilter => {\n      if (!componentFilter.isEnabled) {\n        return;\n      }\n\n      switch (componentFilter.type) {\n        case ComponentFilterDisplayName:\n          if (componentFilter.isValid && componentFilter.value !== '') {\n            hideElementsWithDisplayNames.add(\n              new RegExp(componentFilter.value, 'i'),\n            );\n          }\n          break;\n        case ComponentFilterElementType:\n          hideElementsWithTypes.add(componentFilter.value);\n          break;\n        case ComponentFilterLocation:\n          if (componentFilter.isValid && componentFilter.value !== '') {\n            hideElementsWithPaths.add(new RegExp(componentFilter.value, 'i'));\n          }\n          break;\n        case ComponentFilterHOC:\n          hideElementsWithDisplayNames.add(new RegExp('\\\\('));\n          break;\n        default:\n          console.warn(\n            `Invalid component filter type \"${componentFilter.type}\"`,\n          );\n          break;\n      }\n    });\n  }\n\n  // The renderer interface can't read saved component filters directly,\n  // because they are stored in localStorage within the context of the extension.\n  // Instead it relies on the extension to pass filters through.\n  if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ != null) {\n    applyComponentFilters(window.__REACT_DEVTOOLS_COMPONENT_FILTERS__);\n  } else {\n    // Unfortunately this feature is not expected to work for React Native for now.\n    // It would be annoying for us to spam YellowBox warnings with unactionable stuff,\n    // so for now just skip this message...\n    //console.warn('⚛️ DevTools: Could not locate saved component filters');\n\n    // Fallback to assuming the default filters in this case.\n    applyComponentFilters(getDefaultComponentFilters());\n  }\n\n  // If necessary, we can revisit optimizing this operation.\n  // For example, we could add a new recursive unmount tree operation.\n  // The unmount operations are already significantly smaller than mount operations though.\n  // This is something to keep in mind for later.\n  function updateComponentFilters(componentFilters: Array<ComponentFilter>) {\n    if (isProfiling) {\n      // Re-mounting a tree while profiling is in progress might break a lot of assumptions.\n      // If necessary, we could support this- but it doesn't seem like a necessary use case.\n      throw Error('Cannot modify filter preferences while profiling');\n    }\n\n    // Recursively unmount all roots.\n    hook.getFiberRoots(rendererID).forEach(root => {\n      currentRootID = getFiberID(getPrimaryFiber(root.current));\n      unmountFiberChildrenRecursively(root.current);\n      recordUnmount(root.current, false);\n      currentRootID = -1;\n    });\n\n    applyComponentFilters(componentFilters);\n\n    // Reset pseudo counters so that new path selections will be persisted.\n    rootDisplayNameCounter.clear();\n\n    // Recursively re-mount all roots with new filter criteria applied.\n    hook.getFiberRoots(rendererID).forEach(root => {\n      currentRootID = getFiberID(getPrimaryFiber(root.current));\n      setRootPseudoKey(currentRootID, root.current);\n      mountFiberRecursively(root.current, null, false, false);\n      flushPendingEvents(root);\n      currentRootID = -1;\n    });\n  }\n\n  // NOTICE Keep in sync with get*ForFiber methods\n  function shouldFilterFiber(fiber: Fiber): boolean {\n    const {_debugSource, tag, type} = fiber;\n\n    switch (tag) {\n      case DehydratedSuspenseComponent:\n        // TODO: ideally we would show dehydrated Suspense immediately.\n        // However, it has some special behavior (like disconnecting\n        // an alternate and turning into real Suspense) which breaks DevTools.\n        // For now, ignore it, and only show it once it gets hydrated.\n        // https://github.com/bvaughn/react-devtools-experimental/issues/197\n        return true;\n      case HostPortal:\n      case HostText:\n      case Fragment:\n      case OffscreenComponent:\n        return true;\n      case HostRoot:\n        // It is never valid to filter the root element.\n        return false;\n      default:\n        const typeSymbol = getTypeSymbol(type);\n\n        switch (typeSymbol) {\n          case CONCURRENT_MODE_NUMBER:\n          case CONCURRENT_MODE_SYMBOL_STRING:\n          case DEPRECATED_ASYNC_MODE_SYMBOL_STRING:\n          case STRICT_MODE_NUMBER:\n          case STRICT_MODE_SYMBOL_STRING:\n            return true;\n          default:\n            break;\n        }\n    }\n\n    const elementType = getElementTypeForFiber(fiber);\n    if (hideElementsWithTypes.has(elementType)) {\n      return true;\n    }\n\n    if (hideElementsWithDisplayNames.size > 0) {\n      const displayName = getDisplayNameForFiber(fiber);\n      if (displayName != null) {\n        // eslint-disable-next-line no-for-of-loops/no-for-of-loops\n        for (const displayNameRegExp of hideElementsWithDisplayNames) {\n          if (displayNameRegExp.test(displayName)) {\n            return true;\n          }\n        }\n      }\n    }\n\n    if (_debugSource != null && hideElementsWithPaths.size > 0) {\n      const {fileName} = _debugSource;\n      // eslint-disable-next-line no-for-of-loops/no-for-of-loops\n      for (const pathRegExp of hideElementsWithPaths) {\n        if (pathRegExp.test(fileName)) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n  // NOTICE Keep in sync with shouldFilterFiber() and other get*ForFiber methods\n  function getElementTypeForFiber(fiber: Fiber): ElementType {\n    const {type, tag} = fiber;\n\n    switch (tag) {\n      case ClassComponent:\n      case IncompleteClassComponent:\n        return ElementTypeClass;\n      case FunctionComponent:\n      case IndeterminateComponent:\n        return ElementTypeFunction;\n      case ForwardRef:\n        return ElementTypeForwardRef;\n      case HostRoot:\n        return ElementTypeRoot;\n      case HostComponent:\n        return ElementTypeHostComponent;\n      case HostPortal:\n      case HostText:\n      case Fragment:\n        return ElementTypeOtherOrUnknown;\n      case MemoComponent:\n      case SimpleMemoComponent:\n        return ElementTypeMemo;\n      case SuspenseComponent:\n        return ElementTypeSuspense;\n      case SuspenseListComponent:\n        return ElementTypeSuspenseList;\n      default:\n        const typeSymbol = getTypeSymbol(type);\n\n        switch (typeSymbol) {\n          case CONCURRENT_MODE_NUMBER:\n          case CONCURRENT_MODE_SYMBOL_STRING:\n          case DEPRECATED_ASYNC_MODE_SYMBOL_STRING:\n            return ElementTypeOtherOrUnknown;\n          case PROVIDER_NUMBER:\n          case PROVIDER_SYMBOL_STRING:\n            return ElementTypeContext;\n          case CONTEXT_NUMBER:\n          case CONTEXT_SYMBOL_STRING:\n            return ElementTypeContext;\n          case STRICT_MODE_NUMBER:\n          case STRICT_MODE_SYMBOL_STRING:\n            return ElementTypeOtherOrUnknown;\n          case PROFILER_NUMBER:\n          case PROFILER_SYMBOL_STRING:\n            return ElementTypeProfiler;\n          default:\n            return ElementTypeOtherOrUnknown;\n        }\n    }\n  }\n\n  // This is a slightly annoying indirection.\n  // It is currently necessary because DevTools wants to use unique objects as keys for instances.\n  // However fibers have two versions.\n  // We use this set to remember first encountered fiber for each conceptual instance.\n  function getPrimaryFiber(fiber: Fiber): Fiber {\n    if (primaryFibers.has(fiber)) {\n      return fiber;\n    }\n    const {alternate} = fiber;\n    if (alternate != null && primaryFibers.has(alternate)) {\n      return alternate;\n    }\n    primaryFibers.add(fiber);\n    return fiber;\n  }\n\n  const fiberToIDMap: Map<Fiber, number> = new Map();\n  const idToFiberMap: Map<number, Fiber> = new Map();\n  const primaryFibers: Set<Fiber> = new Set();\n\n  // When profiling is supported, we store the latest tree base durations for each Fiber.\n  // This is so that we can quickly capture a snapshot of those values if profiling starts.\n  // If we didn't store these values, we'd have to crawl the tree when profiling started,\n  // and use a slow path to find each of the current Fibers.\n  const idToTreeBaseDurationMap: Map<number, number> = new Map();\n\n  // When profiling is supported, we store the latest tree base durations for each Fiber.\n  // This map enables us to filter these times by root when sending them to the frontend.\n  const idToRootMap: Map<number, number> = new Map();\n\n  // When a mount or update is in progress, this value tracks the root that is being operated on.\n  let currentRootID: number = -1;\n\n  function getFiberID(primaryFiber: Fiber): number {\n    if (!fiberToIDMap.has(primaryFiber)) {\n      const id = getUID();\n      fiberToIDMap.set(primaryFiber, id);\n      idToFiberMap.set(id, primaryFiber);\n    }\n    return ((fiberToIDMap.get(primaryFiber): any): number);\n  }\n\n  function getChangeDescription(\n    prevFiber: Fiber | null,\n    nextFiber: Fiber,\n  ): ChangeDescription | null {\n    switch (getElementTypeForFiber(nextFiber)) {\n      case ElementTypeClass:\n      case ElementTypeFunction:\n      case ElementTypeMemo:\n      case ElementTypeForwardRef:\n        if (prevFiber === null) {\n          return {\n            context: null,\n            didHooksChange: false,\n            isFirstMount: true,\n            props: null,\n            state: null,\n          };\n        } else {\n          return {\n            context: getContextChangedKeys(nextFiber),\n            didHooksChange: didHooksChange(\n              prevFiber.memoizedState,\n              nextFiber.memoizedState,\n            ),\n            isFirstMount: false,\n            props: getChangedKeys(\n              prevFiber.memoizedProps,\n              nextFiber.memoizedProps,\n            ),\n            state: getChangedKeys(\n              prevFiber.memoizedState,\n              nextFiber.memoizedState,\n            ),\n          };\n        }\n      default:\n        return null;\n    }\n  }\n\n  function updateContextsForFiber(fiber: Fiber) {\n    switch (getElementTypeForFiber(fiber)) {\n      case ElementTypeClass:\n        if (idToContextsMap !== null) {\n          const id = getFiberID(getPrimaryFiber(fiber));\n          const contexts = getContextsForFiber(fiber);\n          if (contexts !== null) {\n            idToContextsMap.set(id, contexts);\n          }\n        }\n        break;\n      default:\n        break;\n    }\n  }\n\n  // Differentiates between a null context value and no context.\n  const NO_CONTEXT = {};\n\n  function getContextsForFiber(fiber: Fiber): [Object, any] | null {\n    switch (getElementTypeForFiber(fiber)) {\n      case ElementTypeClass:\n        const instance = fiber.stateNode;\n        let legacyContext = NO_CONTEXT;\n        let modernContext = NO_CONTEXT;\n        if (instance != null) {\n          if (\n            instance.constructor &&\n            instance.constructor.contextType != null\n          ) {\n            modernContext = instance.context;\n          } else {\n            legacyContext = instance.context;\n            if (legacyContext && Object.keys(legacyContext).length === 0) {\n              legacyContext = NO_CONTEXT;\n            }\n          }\n        }\n        return [legacyContext, modernContext];\n      default:\n        return null;\n    }\n  }\n\n  // Record all contexts at the time profiling is started.\n  // Fibers only store the current context value,\n  // so we need to track them separately in order to determine changed keys.\n  function crawlToInitializeContextsMap(fiber: Fiber) {\n    updateContextsForFiber(fiber);\n    let current = fiber.child;\n    while (current !== null) {\n      crawlToInitializeContextsMap(current);\n      current = current.sibling;\n    }\n  }\n\n  function getContextChangedKeys(fiber: Fiber): null | boolean | Array<string> {\n    switch (getElementTypeForFiber(fiber)) {\n      case ElementTypeClass:\n        if (idToContextsMap !== null) {\n          const id = getFiberID(getPrimaryFiber(fiber));\n          const prevContexts = idToContextsMap.has(id)\n            ? idToContextsMap.get(id)\n            : null;\n          const nextContexts = getContextsForFiber(fiber);\n\n          if (prevContexts == null || nextContexts == null) {\n            return null;\n          }\n\n          const [prevLegacyContext, prevModernContext] = prevContexts;\n          const [nextLegacyContext, nextModernContext] = nextContexts;\n\n          if (nextLegacyContext !== NO_CONTEXT) {\n            return getChangedKeys(prevLegacyContext, nextLegacyContext);\n          } else if (nextModernContext !== NO_CONTEXT) {\n            return prevModernContext !== nextModernContext;\n          }\n        }\n        break;\n      default:\n        break;\n    }\n    return null;\n  }\n\n  function didHooksChange(prev: any, next: any): boolean {\n    if (prev == null || next == null) {\n      return false;\n    }\n\n    // We can't report anything meaningful for hooks changes.\n    if (\n      next.hasOwnProperty('baseState') &&\n      next.hasOwnProperty('memoizedState') &&\n      next.hasOwnProperty('next') &&\n      next.hasOwnProperty('queue')\n    ) {\n      while (next !== null) {\n        if (next.memoizedState !== prev.memoizedState) {\n          return true;\n        } else {\n          next = next.next;\n          prev = prev.next;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  function getChangedKeys(prev: any, next: any): null | Array<string> {\n    if (prev == null || next == null) {\n      return null;\n    }\n\n    // We can't report anything meaningful for hooks changes.\n    if (\n      next.hasOwnProperty('baseState') &&\n      next.hasOwnProperty('memoizedState') &&\n      next.hasOwnProperty('next') &&\n      next.hasOwnProperty('queue')\n    ) {\n      return null;\n    }\n\n    const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);\n    const changedKeys = [];\n    // eslint-disable-next-line no-for-of-loops/no-for-of-loops\n    for (const key of keys) {\n      if (prev[key] !== next[key]) {\n        changedKeys.push(key);\n      }\n    }\n\n    return changedKeys;\n  }\n\n  // eslint-disable-next-line no-unused-vars\n  function didFiberRender(prevFiber: Fiber, nextFiber: Fiber): boolean {\n    switch (nextFiber.tag) {\n      case ClassComponent:\n      case FunctionComponent:\n      case ContextConsumer:\n      case MemoComponent:\n      case SimpleMemoComponent:\n        // For types that execute user code, we check PerformedWork effect.\n        // We don't reflect bailouts (either referential or sCU) in DevTools.\n        // eslint-disable-next-line no-bitwise\n        return (getFiberFlags(nextFiber) & PerformedWork) === PerformedWork;\n      // Note: ContextConsumer only gets PerformedWork effect in 16.3.3+\n      // so it won't get highlighted with React 16.3.0 to 16.3.2.\n      default:\n        // For host components and other types, we compare inputs\n        // to determine whether something is an update.\n        return (\n          prevFiber.memoizedProps !== nextFiber.memoizedProps ||\n          prevFiber.memoizedState !== nextFiber.memoizedState ||\n          prevFiber.ref !== nextFiber.ref\n        );\n    }\n  }\n\n  const pendingOperations: Array<number> = [];\n  const pendingRealUnmountedIDs: Array<number> = [];\n  const pendingSimulatedUnmountedIDs: Array<number> = [];\n  let pendingOperationsQueue: Array<Array<number>> | null = [];\n  const pendingStringTable: Map<string, number> = new Map();\n  let pendingStringTableLength: number = 0;\n  let pendingUnmountedRootID: number | null = null;\n\n  function pushOperation(op: number): void {\n    if (__DEV__) {\n      if (!Number.isInteger(op)) {\n        console.error(\n          'pushOperation() was called but the value is not an integer.',\n          op,\n        );\n      }\n    }\n    pendingOperations.push(op);\n  }\n\n  function flushPendingEvents(root: Object): void {\n    if (\n      pendingOperations.length === 0 &&\n      pendingRealUnmountedIDs.length === 0 &&\n      pendingSimulatedUnmountedIDs.length === 0 &&\n      pendingUnmountedRootID === null\n    ) {\n      // If we aren't profiling, we can just bail out here.\n      // No use sending an empty update over the bridge.\n      //\n      // The Profiler stores metadata for each commit and reconstructs the app tree per commit using:\n      // (1) an initial tree snapshot and\n      // (2) the operations array for each commit\n      // Because of this, it's important that the operations and metadata arrays align,\n      // So it's important not to omit even empty operations while profiling is active.\n      if (!isProfiling) {\n        return;\n      }\n    }\n\n    const numUnmountIDs =\n      pendingRealUnmountedIDs.length +\n      pendingSimulatedUnmountedIDs.length +\n      (pendingUnmountedRootID === null ? 0 : 1);\n\n    const operations = new Array(\n      // Identify which renderer this update is coming from.\n      2 + // [rendererID, rootFiberID]\n      // How big is the string table?\n      1 + // [stringTableLength]\n        // Then goes the actual string table.\n        pendingStringTableLength +\n        // All unmounts are batched in a single message.\n        // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]\n        (numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) +\n        // Regular operations\n        pendingOperations.length,\n    );\n\n    // Identify which renderer this update is coming from.\n    // This enables roots to be mapped to renderers,\n    // Which in turn enables fiber props, states, and hooks to be inspected.\n    let i = 0;\n    operations[i++] = rendererID;\n    operations[i++] = currentRootID; // Use this ID in case the root was unmounted!\n\n    // Now fill in the string table.\n    // [stringTableLength, str1Length, ...str1, str2Length, ...str2, ...]\n    operations[i++] = pendingStringTableLength;\n    pendingStringTable.forEach((value, key) => {\n      operations[i++] = key.length;\n      const encodedKey = utfEncodeString(key);\n      for (let j = 0; j < encodedKey.length; j++) {\n        operations[i + j] = encodedKey[j];\n      }\n      i += key.length;\n    });\n\n    if (numUnmountIDs > 0) {\n      // All unmounts except roots are batched in a single message.\n      operations[i++] = TREE_OPERATION_REMOVE;\n      // The first number is how many unmounted IDs we're gonna send.\n      operations[i++] = numUnmountIDs;\n      // Fill in the real unmounts in the reverse order.\n      // They were inserted parents-first by React, but we want children-first.\n      // So we traverse our array backwards.\n      for (let j = pendingRealUnmountedIDs.length - 1; j >= 0; j--) {\n        operations[i++] = pendingRealUnmountedIDs[j];\n      }\n      // Fill in the simulated unmounts (hidden Suspense subtrees) in their order.\n      // (We want children to go before parents.)\n      // They go *after* the real unmounts because we know for sure they won't be\n      // children of already pushed \"real\" IDs. If they were, we wouldn't be able\n      // to discover them during the traversal, as they would have been deleted.\n      for (let j = 0; j < pendingSimulatedUnmountedIDs.length; j++) {\n        operations[i + j] = pendingSimulatedUnmountedIDs[j];\n      }\n      i += pendingSimulatedUnmountedIDs.length;\n      // The root ID should always be unmounted last.\n      if (pendingUnmountedRootID !== null) {\n        operations[i] = pendingUnmountedRootID;\n        i++;\n      }\n    }\n    // Fill in the rest of the operations.\n    for (let j = 0; j < pendingOperations.length; j++) {\n      operations[i + j] = pendingOperations[j];\n    }\n    i += pendingOperations.length;\n\n    // Let the frontend know about tree operations.\n    // The first value in this array will identify which root it corresponds to,\n    // so we do no longer need to dispatch a separate root-committed event.\n    if (pendingOperationsQueue !== null) {\n      // Until the frontend has been connected, store the tree operations.\n      // This will let us avoid walking the tree later when the frontend connects,\n      // and it enables the Profiler's reload-and-profile functionality to work as well.\n      pendingOperationsQueue.push(operations);\n    } else {\n      // If we've already connected to the frontend, just pass the operations through.\n      hook.emit('operations', operations);\n    }\n\n    pendingOperations.length = 0;\n    pendingRealUnmountedIDs.length = 0;\n    pendingSimulatedUnmountedIDs.length = 0;\n    pendingUnmountedRootID = null;\n    pendingStringTable.clear();\n    pendingStringTableLength = 0;\n  }\n\n  function getStringID(str: string | null): number {\n    if (str === null) {\n      return 0;\n    }\n    const existingID = pendingStringTable.get(str);\n    if (existingID !== undefined) {\n      return existingID;\n    }\n    const stringID = pendingStringTable.size + 1;\n    pendingStringTable.set(str, stringID);\n    // The string table total length needs to account\n    // both for the string length, and for the array item\n    // that contains the length itself. Hence + 1.\n    pendingStringTableLength += str.length + 1;\n    return stringID;\n  }\n\n  function recordMount(fiber: Fiber, parentFiber: Fiber | null) {\n    if (__DEBUG__) {\n      debug('recordMount()', fiber, parentFiber);\n    }\n\n    const isRoot = fiber.tag === HostRoot;\n    const id = getFiberID(getPrimaryFiber(fiber));\n\n    const hasOwnerMetadata = fiber.hasOwnProperty('_debugOwner');\n    const isProfilingSupported = fiber.hasOwnProperty('treeBaseDuration');\n\n    if (isRoot) {\n      pushOperation(TREE_OPERATION_ADD);\n      pushOperation(id);\n      pushOperation(ElementTypeRoot);\n      pushOperation(isProfilingSupported ? 1 : 0);\n      pushOperation(hasOwnerMetadata ? 1 : 0);\n\n      if (isProfiling) {\n        if (displayNamesByRootID !== null) {\n          displayNamesByRootID.set(id, getDisplayNameForRoot(fiber));\n        }\n      }\n    } else {\n      const {key} = fiber;\n      const displayName = getDisplayNameForFiber(fiber);\n      const elementType = getElementTypeForFiber(fiber);\n      const {_debugOwner} = fiber;\n\n      const ownerID =\n        _debugOwner != null ? getFiberID(getPrimaryFiber(_debugOwner)) : 0;\n      const parentID = parentFiber\n        ? getFiberID(getPrimaryFiber(parentFiber))\n        : 0;\n\n      const displayNameStringID = getStringID(displayName);\n\n      // This check is a guard to handle a React element that has been modified\n      // in such a way as to bypass the default stringification of the \"key\" property.\n      const keyString = key === null ? null : '' + key;\n      const keyStringID = getStringID(keyString);\n\n      pushOperation(TREE_OPERATION_ADD);\n      pushOperation(id);\n      pushOperation(elementType);\n      pushOperation(parentID);\n      pushOperation(ownerID);\n      pushOperation(displayNameStringID);\n      pushOperation(keyStringID);\n    }\n\n    if (isProfilingSupported) {\n      idToRootMap.set(id, currentRootID);\n\n      recordProfilingDurations(fiber);\n    }\n  }\n\n  function recordUnmount(fiber: Fiber, isSimulated: boolean) {\n    if (__DEBUG__) {\n      debug('recordUnmount()', fiber);\n    }\n\n    if (trackedPathMatchFiber !== null) {\n      // We're in the process of trying to restore previous selection.\n      // If this fiber matched but is being unmounted, there's no use trying.\n      // Reset the state so we don't keep holding onto it.\n      if (\n        fiber === trackedPathMatchFiber ||\n        fiber === trackedPathMatchFiber.alternate\n      ) {\n        setTrackedPath(null);\n      }\n    }\n\n    const isRoot = fiber.tag === HostRoot;\n    const primaryFiber = getPrimaryFiber(fiber);\n    if (!fiberToIDMap.has(primaryFiber)) {\n      // If we've never seen this Fiber, it might be because\n      // it is inside a non-current Suspense fragment tree,\n      // and so the store is not even aware of it.\n      // In that case we can just ignore it, or otherwise\n      // there will be errors later on.\n      primaryFibers.delete(primaryFiber);\n      // TODO: this is fragile and can obscure actual bugs.\n      return;\n    }\n    const id = getFiberID(primaryFiber);\n\n    if (isRoot) {\n      // Roots must be removed only after all children (pending and simulated) have been removed.\n      // So we track it separately.\n      pendingUnmountedRootID = id;\n    } else if (!shouldFilterFiber(fiber)) {\n      // To maintain child-first ordering,\n      // we'll push it into one of these queues,\n      // and later arrange them in the correct order.\n      if (isSimulated) {\n        pendingSimulatedUnmountedIDs.push(id);\n      } else {\n        pendingRealUnmountedIDs.push(id);\n      }\n    }\n    fiberToIDMap.delete(primaryFiber);\n    idToFiberMap.delete(id);\n    primaryFibers.delete(primaryFiber);\n\n    const isProfilingSupported = fiber.hasOwnProperty('treeBaseDuration');\n    if (isProfilingSupported) {\n      idToRootMap.delete(id);\n      idToTreeBaseDurationMap.delete(id);\n    }\n  }\n\n  function mountFiberRecursively(\n    fiber: Fiber,\n    parentFiber: Fiber | null,\n    traverseSiblings: boolean,\n    traceNearestHostComponentUpdate: boolean,\n  ) {\n    if (__DEBUG__) {\n      debug('mountFiberRecursively()', fiber, parentFiber);\n    }\n\n    // If we have the tree selection from previous reload, try to match this Fiber.\n    // Also remember whether to do the same for siblings.\n    const mightSiblingsBeOnTrackedPath = updateTrackedPathStateBeforeMount(\n      fiber,\n    );\n\n    const shouldIncludeInTree = !shouldFilterFiber(fiber);\n    if (shouldIncludeInTree) {\n      recordMount(fiber, parentFiber);\n    }\n\n    if (traceUpdatesEnabled) {\n      if (traceNearestHostComponentUpdate) {\n        const elementType = getElementTypeForFiber(fiber);\n        // If an ancestor updated, we should mark the nearest host nodes for highlighting.\n        if (elementType === ElementTypeHostComponent) {\n          traceUpdatesForNodes.add(fiber.stateNode);\n          traceNearestHostComponentUpdate = false;\n        }\n      }\n\n      // We intentionally do not re-enable the traceNearestHostComponentUpdate flag in this branch,\n      // because we don't want to highlight every host node inside of a newly mounted subtree.\n    }\n\n    const isSuspense = fiber.tag === ReactTypeOfWork.SuspenseComponent;\n    if (isSuspense) {\n      const isTimedOut = fiber.memoizedState !== null;\n      if (isTimedOut) {\n        // Special case: if Suspense mounts in a timed-out state,\n        // get the fallback child from the inner fragment and mount\n        // it as if it was our own child. Updates handle this too.\n        const primaryChildFragment = fiber.child;\n        const fallbackChildFragment = primaryChildFragment\n          ? primaryChildFragment.sibling\n          : null;\n        const fallbackChild = fallbackChildFragment\n          ? fallbackChildFragment.child\n          : null;\n        if (fallbackChild !== null) {\n          mountFiberRecursively(\n            fallbackChild,\n            shouldIncludeInTree ? fiber : parentFiber,\n            true,\n            traceNearestHostComponentUpdate,\n          );\n        }\n      } else {\n        let primaryChild: Fiber | null = null;\n        const areSuspenseChildrenConditionallyWrapped =\n          OffscreenComponent === -1;\n        if (areSuspenseChildrenConditionallyWrapped) {\n          primaryChild = fiber.child;\n        } else if (fiber.child !== null) {\n          primaryChild = fiber.child.child;\n        }\n        if (primaryChild !== null) {\n          mountFiberRecursively(\n            primaryChild,\n            shouldIncludeInTree ? fiber : parentFiber,\n            true,\n            traceNearestHostComponentUpdate,\n          );\n        }\n      }\n    } else {\n      if (fiber.child !== null) {\n        mountFiberRecursively(\n          fiber.child,\n          shouldIncludeInTree ? fiber : parentFiber,\n          true,\n          traceNearestHostComponentUpdate,\n        );\n      }\n    }\n\n    // We're exiting this Fiber now, and entering its siblings.\n    // If we have selection to restore, we might need to re-activate tracking.\n    updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath);\n\n    if (traverseSiblings && fiber.sibling !== null) {\n      mountFiberRecursively(\n        fiber.sibling,\n        parentFiber,\n        true,\n        traceNearestHostComponentUpdate,\n      );\n    }\n  }\n\n  // We use this to simulate unmounting for Suspense trees\n  // when we switch from primary to fallback.\n  function unmountFiberChildrenRecursively(fiber: Fiber) {\n    if (__DEBUG__) {\n      debug('unmountFiberChildrenRecursively()', fiber);\n    }\n\n    // We might meet a nested Suspense on our way.\n    const isTimedOutSuspense =\n      fiber.tag === ReactTypeOfWork.SuspenseComponent &&\n      fiber.memoizedState !== null;\n\n    let child = fiber.child;\n    if (isTimedOutSuspense) {\n      // If it's showing fallback tree, let's traverse it instead.\n      const primaryChildFragment = fiber.child;\n      const fallbackChildFragment = primaryChildFragment\n        ? primaryChildFragment.sibling\n        : null;\n      // Skip over to the real Fiber child.\n      child = fallbackChildFragment ? fallbackChildFragment.child : null;\n    }\n\n    while (child !== null) {\n      // Record simulated unmounts children-first.\n      // We skip nodes without return because those are real unmounts.\n      if (child.return !== null) {\n        unmountFiberChildrenRecursively(child);\n        recordUnmount(child, true);\n      }\n      child = child.sibling;\n    }\n  }\n\n  function recordProfilingDurations(fiber: Fiber) {\n    const id = getFiberID(getPrimaryFiber(fiber));\n    const {actualDuration, treeBaseDuration} = fiber;\n\n    idToTreeBaseDurationMap.set(id, treeBaseDuration || 0);\n\n    if (isProfiling) {\n      const {alternate} = fiber;\n\n      // It's important to update treeBaseDuration even if the current Fiber did not render,\n      // because it's possible that one of its descendants did.\n      if (\n        alternate == null ||\n        treeBaseDuration !== alternate.treeBaseDuration\n      ) {\n        // Tree base duration updates are included in the operations typed array.\n        // So we have to convert them from milliseconds to microseconds so we can send them as ints.\n        const convertedTreeBaseDuration = Math.floor(\n          (treeBaseDuration || 0) * 1000,\n        );\n        pushOperation(TREE_OPERATION_UPDATE_TREE_BASE_DURATION);\n        pushOperation(id);\n        pushOperation(convertedTreeBaseDuration);\n      }\n\n      if (alternate == null || didFiberRender(alternate, fiber)) {\n        if (actualDuration != null) {\n          // The actual duration reported by React includes time spent working on children.\n          // This is useful information, but it's also useful to be able to exclude child durations.\n          // The frontend can't compute this, since the immediate children may have been filtered out.\n          // So we need to do this on the backend.\n          // Note that this calculated self duration is not the same thing as the base duration.\n          // The two are calculated differently (tree duration does not accumulate).\n          let selfDuration = actualDuration;\n          let child = fiber.child;\n          while (child !== null) {\n            selfDuration -= child.actualDuration || 0;\n            child = child.sibling;\n          }\n\n          // If profiling is active, store durations for elements that were rendered during the commit.\n          // Note that we should do this for any fiber we performed work on, regardless of its actualDuration value.\n          // In some cases actualDuration might be 0 for fibers we worked on (particularly if we're using Date.now)\n          // In other cases (e.g. Memo) actualDuration might be greater than 0 even if we \"bailed out\".\n          const metadata = ((currentCommitProfilingMetadata: any): CommitProfilingData);\n          metadata.durations.push(id, actualDuration, selfDuration);\n          metadata.maxActualDuration = Math.max(\n            metadata.maxActualDuration,\n            actualDuration,\n          );\n\n          if (recordChangeDescriptions) {\n            const changeDescription = getChangeDescription(alternate, fiber);\n            if (changeDescription !== null) {\n              if (metadata.changeDescriptions !== null) {\n                metadata.changeDescriptions.set(id, changeDescription);\n              }\n            }\n\n            updateContextsForFiber(fiber);\n          }\n        }\n      }\n    }\n  }\n\n  function recordResetChildren(fiber: Fiber, childSet: Fiber) {\n    if (__DEBUG__) {\n      debug('recordResetChildren()', childSet, fiber);\n    }\n    // The frontend only really cares about the displayName, key, and children.\n    // The first two don't really change, so we are only concerned with the order of children here.\n    // This is trickier than a simple comparison though, since certain types of fibers are filtered.\n    const nextChildren: Array<number> = [];\n\n    // This is a naive implementation that shallowly recourses children.\n    // We might want to revisit this if it proves to be too inefficient.\n    let child = childSet;\n    while (child !== null) {\n      findReorderedChildrenRecursively(child, nextChildren);\n      child = child.sibling;\n    }\n\n    const numChildren = nextChildren.length;\n    if (numChildren < 2) {\n      // No need to reorder.\n      return;\n    }\n    pushOperation(TREE_OPERATION_REORDER_CHILDREN);\n    pushOperation(getFiberID(getPrimaryFiber(fiber)));\n    pushOperation(numChildren);\n    for (let i = 0; i < nextChildren.length; i++) {\n      pushOperation(nextChildren[i]);\n    }\n  }\n\n  function findReorderedChildrenRecursively(\n    fiber: Fiber,\n    nextChildren: Array<number>,\n  ) {\n    if (!shouldFilterFiber(fiber)) {\n      nextChildren.push(getFiberID(getPrimaryFiber(fiber)));\n    } else {\n      let child = fiber.child;\n      const isTimedOutSuspense =\n        fiber.tag === SuspenseComponent && fiber.memoizedState !== null;\n      if (isTimedOutSuspense) {\n        // Special case: if Suspense mounts in a timed-out state,\n        // get the fallback child from the inner fragment,\n        // and skip over the primary child.\n        const primaryChildFragment = fiber.child;\n        const fallbackChildFragment = primaryChildFragment\n          ? primaryChildFragment.sibling\n          : null;\n        const fallbackChild = fallbackChildFragment\n          ? fallbackChildFragment.child\n          : null;\n        if (fallbackChild !== null) {\n          child = fallbackChild;\n        }\n      }\n      while (child !== null) {\n        findReorderedChildrenRecursively(child, nextChildren);\n        child = child.sibling;\n      }\n    }\n  }\n\n  // Returns whether closest unfiltered fiber parent needs to reset its child list.\n  function updateFiberRecursively(\n    nextFiber: Fiber,\n    prevFiber: Fiber,\n    parentFiber: Fiber | null,\n    traceNearestHostComponentUpdate: boolean,\n  ): boolean {\n    if (__DEBUG__) {\n      debug('updateFiberRecursively()', nextFiber, parentFiber);\n    }\n\n    if (traceUpdatesEnabled) {\n      const elementType = getElementTypeForFiber(nextFiber);\n      if (traceNearestHostComponentUpdate) {\n        // If an ancestor updated, we should mark the nearest host nodes for highlighting.\n        if (elementType === ElementTypeHostComponent) {\n          traceUpdatesForNodes.add(nextFiber.stateNode);\n          traceNearestHostComponentUpdate = false;\n        }\n      } else {\n        if (\n          elementType === ElementTypeFunction ||\n          elementType === ElementTypeClass ||\n          elementType === ElementTypeContext\n        ) {\n          // Otherwise if this is a traced ancestor, flag for the nearest host descendant(s).\n          traceNearestHostComponentUpdate = didFiberRender(\n            prevFiber,\n            nextFiber,\n          );\n        }\n      }\n    }\n\n    if (\n      mostRecentlyInspectedElement !== null &&\n      mostRecentlyInspectedElement.id ===\n        getFiberID(getPrimaryFiber(nextFiber)) &&\n      didFiberRender(prevFiber, nextFiber)\n    ) {\n      // If this Fiber has updated, clear cached inspected data.\n      // If it is inspected again, it may need to be re-run to obtain updated hooks values.\n      hasElementUpdatedSinceLastInspected = true;\n    }\n\n    const shouldIncludeInTree = !shouldFilterFiber(nextFiber);\n    const isSuspense = nextFiber.tag === SuspenseComponent;\n    let shouldResetChildren = false;\n    // The behavior of timed-out Suspense trees is unique.\n    // Rather than unmount the timed out content (and possibly lose important state),\n    // React re-parents this content within a hidden Fragment while the fallback is showing.\n    // This behavior doesn't need to be observable in the DevTools though.\n    // It might even result in a bad user experience for e.g. node selection in the Elements panel.\n    // The easiest fix is to strip out the intermediate Fragment fibers,\n    // so the Elements panel and Profiler don't need to special case them.\n    // Suspense components only have a non-null memoizedState if they're timed-out.\n    const prevDidTimeout = isSuspense && prevFiber.memoizedState !== null;\n    const nextDidTimeOut = isSuspense && nextFiber.memoizedState !== null;\n    // The logic below is inspired by the code paths in updateSuspenseComponent()\n    // inside ReactFiberBeginWork in the React source code.\n    if (prevDidTimeout && nextDidTimeOut) {\n      // Fallback -> Fallback:\n      // 1. Reconcile fallback set.\n      const nextFiberChild = nextFiber.child;\n      const nextFallbackChildSet = nextFiberChild\n        ? nextFiberChild.sibling\n        : null;\n      // Note: We can't use nextFiber.child.sibling.alternate\n      // because the set is special and alternate may not exist.\n      const prevFiberChild = prevFiber.child;\n      const prevFallbackChildSet = prevFiberChild\n        ? prevFiberChild.sibling\n        : null;\n      if (\n        nextFallbackChildSet != null &&\n        prevFallbackChildSet != null &&\n        updateFiberRecursively(\n          nextFallbackChildSet,\n          prevFallbackChildSet,\n          nextFiber,\n          traceNearestHostComponentUpdate,\n        )\n      ) {\n        shouldResetChildren = true;\n      }\n    } else if (prevDidTimeout && !nextDidTimeOut) {\n      // Fallback -> Primary:\n      // 1. Unmount fallback set\n      // Note: don't emulate fallback unmount because React actually did it.\n      // 2. Mount primary set\n      const nextPrimaryChildSet = nextFiber.child;\n      if (nextPrimaryChildSet !== null) {\n        mountFiberRecursively(\n          nextPrimaryChildSet,\n          shouldIncludeInTree ? nextFiber : parentFiber,\n          true,\n          traceNearestHostComponentUpdate,\n        );\n      }\n      shouldResetChildren = true;\n    } else if (!prevDidTimeout && nextDidTimeOut) {\n      // Primary -> Fallback:\n      // 1. Hide primary set\n      // This is not a real unmount, so it won't get reported by React.\n      // We need to manually walk the previous tree and record unmounts.\n      unmountFiberChildrenRecursively(prevFiber);\n      // 2. Mount fallback set\n      const nextFiberChild = nextFiber.child;\n      const nextFallbackChildSet = nextFiberChild\n        ? nextFiberChild.sibling\n        : null;\n      if (nextFallbackChildSet != null) {\n        mountFiberRecursively(\n          nextFallbackChildSet,\n          shouldIncludeInTree ? nextFiber : parentFiber,\n          true,\n          traceNearestHostComponentUpdate,\n        );\n        shouldResetChildren = true;\n      }\n    } else {\n      // Common case: Primary -> Primary.\n      // This is the same code path as for non-Suspense fibers.\n      if (nextFiber.child !== prevFiber.child) {\n        // If the first child is different, we need to traverse them.\n        // Each next child will be either a new child (mount) or an alternate (update).\n        let nextChild = nextFiber.child;\n        let prevChildAtSameIndex = prevFiber.child;\n        while (nextChild) {\n          // We already know children will be referentially different because\n          // they are either new mounts or alternates of previous children.\n          // Schedule updates and mounts depending on whether alternates exist.\n          // We don't track deletions here because they are reported separately.\n          if (nextChild.alternate) {\n            const prevChild = nextChild.alternate;\n            if (\n              updateFiberRecursively(\n                nextChild,\n                prevChild,\n                shouldIncludeInTree ? nextFiber : parentFiber,\n                traceNearestHostComponentUpdate,\n              )\n            ) {\n              // If a nested tree child order changed but it can't handle its own\n              // child order invalidation (e.g. because it's filtered out like host nodes),\n              // propagate the need to reset child order upwards to this Fiber.\n              shouldResetChildren = true;\n            }\n            // However we also keep track if the order of the children matches\n            // the previous order. They are always different referentially, but\n            // if the instances line up conceptually we'll want to know that.\n            if (prevChild !== prevChildAtSameIndex) {\n              shouldResetChildren = true;\n            }\n          } else {\n            mountFiberRecursively(\n              nextChild,\n              shouldIncludeInTree ? nextFiber : parentFiber,\n              false,\n              traceNearestHostComponentUpdate,\n            );\n            shouldResetChildren = true;\n          }\n          // Try the next child.\n          nextChild = nextChild.sibling;\n          // Advance the pointer in the previous list so that we can\n          // keep comparing if they line up.\n          if (!shouldResetChildren && prevChildAtSameIndex !== null) {\n            prevChildAtSameIndex = prevChildAtSameIndex.sibling;\n          }\n        }\n        // If we have no more children, but used to, they don't line up.\n        if (prevChildAtSameIndex !== null) {\n          shouldResetChildren = true;\n        }\n      } else {\n        if (traceUpdatesEnabled) {\n          // If we're tracing updates and we've bailed out before reaching a host node,\n          // we should fall back to recursively marking the nearest host descendants for highlight.\n          if (traceNearestHostComponentUpdate) {\n            const hostFibers = findAllCurrentHostFibers(\n              getFiberID(getPrimaryFiber(nextFiber)),\n            );\n            hostFibers.forEach(hostFiber => {\n              traceUpdatesForNodes.add(hostFiber.stateNode);\n            });\n          }\n        }\n      }\n    }\n\n    if (shouldIncludeInTree) {\n      const isProfilingSupported = nextFiber.hasOwnProperty('treeBaseDuration');\n      if (isProfilingSupported) {\n        recordProfilingDurations(nextFiber);\n      }\n    }\n    if (shouldResetChildren) {\n      // We need to crawl the subtree for closest non-filtered Fibers\n      // so that we can display them in a flat children set.\n      if (shouldIncludeInTree) {\n        // Normally, search for children from the rendered child.\n        let nextChildSet = nextFiber.child;\n        if (nextDidTimeOut) {\n          // Special case: timed-out Suspense renders the fallback set.\n          const nextFiberChild = nextFiber.child;\n          nextChildSet = nextFiberChild ? nextFiberChild.sibling : null;\n        }\n        if (nextChildSet != null) {\n          recordResetChildren(nextFiber, nextChildSet);\n        }\n        // We've handled the child order change for this Fiber.\n        // Since it's included, there's no need to invalidate parent child order.\n        return false;\n      } else {\n        // Let the closest unfiltered parent Fiber reset its child order instead.\n        return true;\n      }\n    } else {\n      return false;\n    }\n  }\n\n  function cleanup() {\n    // We don't patch any methods so there is no cleanup.\n  }\n\n  function flushInitialOperations() {\n    const localPendingOperationsQueue = pendingOperationsQueue;\n\n    pendingOperationsQueue = null;\n\n    if (\n      localPendingOperationsQueue !== null &&\n      localPendingOperationsQueue.length > 0\n    ) {\n      // We may have already queued up some operations before the frontend connected\n      // If so, let the frontend know about them.\n      localPendingOperationsQueue.forEach(operations => {\n        hook.emit('operations', operations);\n      });\n    } else {\n      // Before the traversals, remember to start tracking\n      // our path in case we have selection to restore.\n      if (trackedPath !== null) {\n        mightBeOnTrackedPath = true;\n      }\n      // If we have not been profiling, then we can just walk the tree and build up its current state as-is.\n      hook.getFiberRoots(rendererID).forEach(root => {\n        currentRootID = getFiberID(getPrimaryFiber(root.current));\n        setRootPseudoKey(currentRootID, root.current);\n\n        // Checking root.memoizedInteractions handles multi-renderer edge-case-\n        // where some v16 renderers support profiling and others don't.\n        if (isProfiling && root.memoizedInteractions != null) {\n          // If profiling is active, store commit time and duration, and the current interactions.\n          // The frontend may request this information after profiling has stopped.\n          currentCommitProfilingMetadata = {\n            changeDescriptions: recordChangeDescriptions ? new Map() : null,\n            durations: [],\n            commitTime: getCurrentTime() - profilingStartTime,\n            interactions: Array.from(root.memoizedInteractions).map(\n              (interaction: Interaction) => ({\n                ...interaction,\n                timestamp: interaction.timestamp - profilingStartTime,\n              }),\n            ),\n            maxActualDuration: 0,\n            priorityLevel: null,\n          };\n        }\n\n        mountFiberRecursively(root.current, null, false, false);\n        flushPendingEvents(root);\n        currentRootID = -1;\n      });\n    }\n  }\n\n  function handleCommitFiberUnmount(fiber) {\n    // This is not recursive.\n    // We can't traverse fibers after unmounting so instead\n    // we rely on React telling us about each unmount.\n    recordUnmount(fiber, false);\n  }\n\n  function handleCommitFiberRoot(root, priorityLevel) {\n    const current = root.current;\n    const alternate = current.alternate;\n\n    currentRootID = getFiberID(getPrimaryFiber(current));\n\n    // Before the traversals, remember to start tracking\n    // our path in case we have selection to restore.\n    if (trackedPath !== null) {\n      mightBeOnTrackedPath = true;\n    }\n\n    if (traceUpdatesEnabled) {\n      traceUpdatesForNodes.clear();\n    }\n\n    // Checking root.memoizedInteractions handles multi-renderer edge-case-\n    // where some v16 renderers support profiling and others don't.\n    const isProfilingSupported = root.memoizedInteractions != null;\n\n    if (isProfiling && isProfilingSupported) {\n      // If profiling is active, store commit time and duration, and the current interactions.\n      // The frontend may request this information after profiling has stopped.\n      currentCommitProfilingMetadata = {\n        changeDescriptions: recordChangeDescriptions ? new Map() : null,\n        durations: [],\n        commitTime: getCurrentTime() - profilingStartTime,\n        interactions: Array.from(root.memoizedInteractions).map(\n          (interaction: Interaction) => ({\n            ...interaction,\n            timestamp: interaction.timestamp - profilingStartTime,\n          }),\n        ),\n        maxActualDuration: 0,\n        priorityLevel:\n          priorityLevel == null ? null : formatPriorityLevel(priorityLevel),\n      };\n    }\n\n    if (alternate) {\n      // TODO: relying on this seems a bit fishy.\n      const wasMounted =\n        alternate.memoizedState != null &&\n        alternate.memoizedState.element != null;\n      const isMounted =\n        current.memoizedState != null && current.memoizedState.element != null;\n      if (!wasMounted && isMounted) {\n        // Mount a new root.\n        setRootPseudoKey(currentRootID, current);\n        mountFiberRecursively(current, null, false, false);\n      } else if (wasMounted && isMounted) {\n        // Update an existing root.\n        updateFiberRecursively(current, alternate, null, false);\n      } else if (wasMounted && !isMounted) {\n        // Unmount an existing root.\n        removeRootPseudoKey(currentRootID);\n        recordUnmount(current, false);\n      }\n    } else {\n      // Mount a new root.\n      setRootPseudoKey(currentRootID, current);\n      mountFiberRecursively(current, null, false, false);\n    }\n\n    if (isProfiling && isProfilingSupported) {\n      const commitProfilingMetadata = ((rootToCommitProfilingMetadataMap: any): CommitProfilingMetadataMap).get(\n        currentRootID,\n      );\n      if (commitProfilingMetadata != null) {\n        commitProfilingMetadata.push(\n          ((currentCommitProfilingMetadata: any): CommitProfilingData),\n        );\n      } else {\n        ((rootToCommitProfilingMetadataMap: any): CommitProfilingMetadataMap).set(\n          currentRootID,\n          [((currentCommitProfilingMetadata: any): CommitProfilingData)],\n        );\n      }\n    }\n\n    // We're done here.\n    flushPendingEvents(root);\n\n    if (traceUpdatesEnabled) {\n      hook.emit('traceUpdates', traceUpdatesForNodes);\n    }\n\n    currentRootID = -1;\n  }\n\n  function findAllCurrentHostFibers(id: number): $ReadOnlyArray<Fiber> {\n    const fibers = [];\n    const fiber = findCurrentFiberUsingSlowPathById(id);\n    if (!fiber) {\n      return fibers;\n    }\n\n    // Next we'll drill down this component to find all HostComponent/Text.\n    let node: Fiber = fiber;\n    while (true) {\n      if (node.tag === HostComponent || node.tag === HostText) {\n        fibers.push(node);\n      } else if (node.child) {\n        node.child.return = node;\n        node = node.child;\n        continue;\n      }\n      if (node === fiber) {\n        return fibers;\n      }\n      while (!node.sibling) {\n        if (!node.return || node.return === fiber) {\n          return fibers;\n        }\n        node = node.return;\n      }\n      node.sibling.return = node.return;\n      node = node.sibling;\n    }\n    // Flow needs the return here, but ESLint complains about it.\n    // eslint-disable-next-line no-unreachable\n    return fibers;\n  }\n\n  function findNativeNodesForFiberID(id: number) {\n    try {\n      let fiber = findCurrentFiberUsingSlowPathById(id);\n      if (fiber === null) {\n        return null;\n      }\n      // Special case for a timed-out Suspense.\n      const isTimedOutSuspense =\n        fiber.tag === SuspenseComponent && fiber.memoizedState !== null;\n      if (isTimedOutSuspense) {\n        // A timed-out Suspense's findDOMNode is useless.\n        // Try our best to find the fallback directly.\n        const maybeFallbackFiber = fiber.child && fiber.child.sibling;\n        if (maybeFallbackFiber != null) {\n          fiber = maybeFallbackFiber;\n        }\n      }\n      const hostFibers = findAllCurrentHostFibers(id);\n      return hostFibers.map(hostFiber => hostFiber.stateNode).filter(Boolean);\n    } catch (err) {\n      // The fiber might have unmounted by now.\n      return null;\n    }\n  }\n\n  function getDisplayNameForFiberID(id) {\n    const fiber = idToFiberMap.get(id);\n    return fiber != null ? getDisplayNameForFiber(((fiber: any): Fiber)) : null;\n  }\n\n  function getFiberIDForNative(\n    hostInstance,\n    findNearestUnfilteredAncestor = false,\n  ) {\n    let fiber = renderer.findFiberByHostInstance(hostInstance);\n    if (fiber != null) {\n      if (findNearestUnfilteredAncestor) {\n        while (fiber !== null && shouldFilterFiber(fiber)) {\n          fiber = fiber.return;\n        }\n      }\n      return getFiberID(getPrimaryFiber(((fiber: any): Fiber)));\n    }\n    return null;\n  }\n\n  const MOUNTING = 1;\n  const MOUNTED = 2;\n  const UNMOUNTED = 3;\n\n  // This function is copied from React and should be kept in sync:\n  // https://github.com/facebook/react/blob/master/packages/react-reconciler/src/ReactFiberTreeReflection.js\n  function isFiberMountedImpl(fiber: Fiber): number {\n    let node = fiber;\n    if (!fiber.alternate) {\n      // If there is no alternate, this might be a new tree that isn't inserted\n      // yet. If it is, then it will have a pending insertion effect on it.\n      if ((getFiberFlags(node) & Placement) !== NoFlags) {\n        return MOUNTING;\n      }\n      while (node.return) {\n        node = node.return;\n        if ((getFiberFlags(node) & Placement) !== NoFlags) {\n          return MOUNTING;\n        }\n      }\n    } else {\n      while (node.return) {\n        node = node.return;\n      }\n    }\n    if (node.tag === HostRoot) {\n      // TODO: Check if this was a nested HostRoot when used with\n      // renderContainerIntoSubtree.\n      return MOUNTED;\n    }\n    // If we didn't hit the root, that means that we're in an disconnected tree\n    // that has been unmounted.\n    return UNMOUNTED;\n  }\n\n  // This function is copied from React and should be kept in sync:\n  // https://github.com/facebook/react/blob/master/packages/react-reconciler/src/ReactFiberTreeReflection.js\n  // It would be nice if we updated React to inject this function directly (vs just indirectly via findDOMNode).\n  // BEGIN copied code\n  function findCurrentFiberUsingSlowPathById(id: number): Fiber | null {\n    const fiber = idToFiberMap.get(id);\n    if (fiber == null) {\n      console.warn(`Could not find Fiber with id \"${id}\"`);\n      return null;\n    }\n\n    const alternate = fiber.alternate;\n    if (!alternate) {\n      // If there is no alternate, then we only need to check if it is mounted.\n      const state = isFiberMountedImpl(fiber);\n      if (state === UNMOUNTED) {\n        throw Error('Unable to find node on an unmounted component.');\n      }\n      if (state === MOUNTING) {\n        return null;\n      }\n      return fiber;\n    }\n    // If we have two possible branches, we'll walk backwards up to the root\n    // to see what path the root points to. On the way we may hit one of the\n    // special cases and we'll deal with them.\n    let a: Fiber = fiber;\n    let b: Fiber = alternate;\n    while (true) {\n      const parentA = a.return;\n      if (parentA === null) {\n        // We're at the root.\n        break;\n      }\n      const parentB = parentA.alternate;\n      if (parentB === null) {\n        // There is no alternate. This is an unusual case. Currently, it only\n        // happens when a Suspense component is hidden. An extra fragment fiber\n        // is inserted in between the Suspense fiber and its children. Skip\n        // over this extra fragment fiber and proceed to the next parent.\n        const nextParent = parentA.return;\n        if (nextParent !== null) {\n          a = b = nextParent;\n          continue;\n        }\n        // If there's no parent, we're at the root.\n        break;\n      }\n\n      // If both copies of the parent fiber point to the same child, we can\n      // assume that the child is current. This happens when we bailout on low\n      // priority: the bailed out fiber's child reuses the current child.\n      if (parentA.child === parentB.child) {\n        let child = parentA.child;\n        while (child) {\n          if (child === a) {\n            // We've determined that A is the current branch.\n            if (isFiberMountedImpl(parentA) !== MOUNTED) {\n              throw Error('Unable to find node on an unmounted component.');\n            }\n            return fiber;\n          }\n          if (child === b) {\n            // We've determined that B is the current branch.\n            if (isFiberMountedImpl(parentA) !== MOUNTED) {\n              throw Error('Unable to find node on an unmounted component.');\n            }\n            return alternate;\n          }\n          child = child.sibling;\n        }\n        // We should never have an alternate for any mounting node. So the only\n        // way this could possibly happen is if this was unmounted, if at all.\n        throw Error('Unable to find node on an unmounted component.');\n      }\n\n      if (a.return !== b.return) {\n        // The return pointer of A and the return pointer of B point to different\n        // fibers. We assume that return pointers never criss-cross, so A must\n        // belong to the child set of A.return, and B must belong to the child\n        // set of B.return.\n        a = parentA;\n        b = parentB;\n      } else {\n        // The return pointers point to the same fiber. We'll have to use the\n        // default, slow path: scan the child sets of each parent alternate to see\n        // which child belongs to which set.\n        //\n        // Search parent A's child set\n        let didFindChild = false;\n        let child = parentA.child;\n        while (child) {\n          if (child === a) {\n            didFindChild = true;\n            a = parentA;\n            b = parentB;\n            break;\n          }\n          if (child === b) {\n            didFindChild = true;\n            b = parentA;\n            a = parentB;\n            break;\n          }\n          child = child.sibling;\n        }\n        if (!didFindChild) {\n          // Search parent B's child set\n          child = parentB.child;\n          while (child) {\n            if (child === a) {\n              didFindChild = true;\n              a = parentB;\n              b = parentA;\n              break;\n            }\n            if (child === b) {\n              didFindChild = true;\n              b = parentB;\n              a = parentA;\n              break;\n            }\n            child = child.sibling;\n          }\n          if (!didFindChild) {\n            throw Error(\n              'Child was not found in either parent set. This indicates a bug ' +\n                'in React related to the return pointer. Please file an issue.',\n            );\n          }\n        }\n      }\n\n      if (a.alternate !== b) {\n        throw Error(\n          \"Return fibers should always be each others' alternates. \" +\n            'This error is likely caused by a bug in React. Please file an issue.',\n        );\n      }\n    }\n    // If the root is not a host container, we're in a disconnected tree. I.e.\n    // unmounted.\n    if (a.tag !== HostRoot) {\n      throw Error('Unable to find node on an unmounted component.');\n    }\n    if (a.stateNode.current === a) {\n      // We've determined that A is the current branch.\n      return fiber;\n    }\n    // Otherwise B has to be current branch.\n    return alternate;\n  }\n  // END copied code\n\n  function prepareViewAttributeSource(\n    id: number,\n    path: Array<string | number>,\n  ): void {\n    const isCurrent = isMostRecentlyInspectedElementCurrent(id);\n    if (isCurrent) {\n      window.$attribute = getInObject(\n        ((mostRecentlyInspectedElement: any): InspectedElement),\n        path,\n      );\n    }\n  }\n\n  function prepareViewElementSource(id: number): void {\n    const fiber = idToFiberMap.get(id);\n    if (fiber == null) {\n      console.warn(`Could not find Fiber with id \"${id}\"`);\n      return;\n    }\n\n    const {elementType, tag, type} = fiber;\n\n    switch (tag) {\n      case ClassComponent:\n      case IncompleteClassComponent:\n      case IndeterminateComponent:\n      case FunctionComponent:\n        global.$type = type;\n        break;\n      case ForwardRef:\n        global.$type = type.render;\n        break;\n      case MemoComponent:\n      case SimpleMemoComponent:\n        global.$type =\n          elementType != null && elementType.type != null\n            ? elementType.type\n            : type;\n        break;\n      default:\n        global.$type = null;\n        break;\n    }\n  }\n\n  function getOwnersList(id: number): Array<Owner> | null {\n    const fiber = findCurrentFiberUsingSlowPathById(id);\n    if (fiber == null) {\n      return null;\n    }\n\n    const {_debugOwner} = fiber;\n\n    const owners = [\n      {\n        displayName: getDisplayNameForFiber(fiber) || 'Anonymous',\n        id,\n        type: getElementTypeForFiber(fiber),\n      },\n    ];\n\n    if (_debugOwner) {\n      let owner = _debugOwner;\n      while (owner !== null) {\n        owners.unshift({\n          displayName: getDisplayNameForFiber(owner) || 'Anonymous',\n          id: getFiberID(getPrimaryFiber(owner)),\n          type: getElementTypeForFiber(owner),\n        });\n        owner = owner._debugOwner || null;\n      }\n    }\n\n    return owners;\n  }\n\n  // Fast path props lookup for React Native style editor.\n  // Could use inspectElementRaw() but that would require shallow rendering hooks components,\n  // and could also mess with memoization.\n  function getInstanceAndStyle(id: number): InstanceAndStyle {\n    let instance = null;\n    let style = null;\n\n    const fiber = findCurrentFiberUsingSlowPathById(id);\n    if (fiber !== null) {\n      instance = fiber.stateNode;\n\n      if (fiber.memoizedProps !== null) {\n        style = fiber.memoizedProps.style;\n      }\n    }\n\n    return {instance, style};\n  }\n\n  function inspectElementRaw(id: number): InspectedElement | null {\n    const fiber = findCurrentFiberUsingSlowPathById(id);\n    if (fiber == null) {\n      return null;\n    }\n\n    const {\n      _debugOwner,\n      _debugSource,\n      stateNode,\n      key,\n      memoizedProps,\n      memoizedState,\n      dependencies,\n      tag,\n      type,\n    } = fiber;\n\n    const elementType = getElementTypeForFiber(fiber);\n\n    const usesHooks =\n      (tag === FunctionComponent ||\n        tag === SimpleMemoComponent ||\n        tag === ForwardRef) &&\n      (!!memoizedState || !!dependencies);\n\n    const typeSymbol = getTypeSymbol(type);\n\n    let canViewSource = false;\n    let context = null;\n    if (\n      tag === ClassComponent ||\n      tag === FunctionComponent ||\n      tag === IncompleteClassComponent ||\n      tag === IndeterminateComponent ||\n      tag === MemoComponent ||\n      tag === ForwardRef ||\n      tag === SimpleMemoComponent\n    ) {\n      canViewSource = true;\n      if (stateNode && stateNode.context != null) {\n        // Don't show an empty context object for class components that don't use the context API.\n        const shouldHideContext =\n          elementType === ElementTypeClass &&\n          !(type.contextTypes || type.contextType);\n\n        if (!shouldHideContext) {\n          context = stateNode.context;\n        }\n      }\n    } else if (\n      typeSymbol === CONTEXT_NUMBER ||\n      typeSymbol === CONTEXT_SYMBOL_STRING\n    ) {\n      // 16.3-16.5 read from \"type\" because the Consumer is the actual context object.\n      // 16.6+ should read from \"type._context\" because Consumer can be different (in DEV).\n      // NOTE Keep in sync with getDisplayNameForFiber()\n      const consumerResolvedContext = type._context || type;\n\n      // Global context value.\n      context = consumerResolvedContext._currentValue || null;\n\n      // Look for overridden value.\n      let current = ((fiber: any): Fiber).return;\n      while (current !== null) {\n        const currentType = current.type;\n        const currentTypeSymbol = getTypeSymbol(currentType);\n        if (\n          currentTypeSymbol === PROVIDER_NUMBER ||\n          currentTypeSymbol === PROVIDER_SYMBOL_STRING\n        ) {\n          // 16.3.0 exposed the context object as \"context\"\n          // PR #12501 changed it to \"_context\" for 16.3.1+\n          // NOTE Keep in sync with getDisplayNameForFiber()\n          const providerResolvedContext =\n            currentType._context || currentType.context;\n          if (providerResolvedContext === consumerResolvedContext) {\n            context = current.memoizedProps.value;\n            break;\n          }\n        }\n\n        current = current.return;\n      }\n    }\n\n    let hasLegacyContext = false;\n    if (context !== null) {\n      hasLegacyContext = !!type.contextTypes;\n\n      // To simplify hydration and display logic for context, wrap in a value object.\n      // Otherwise simple values (e.g. strings, booleans) become harder to handle.\n      context = {value: context};\n    }\n\n    let owners = null;\n    if (_debugOwner) {\n      owners = [];\n      let owner = _debugOwner;\n      while (owner !== null) {\n        owners.push({\n          displayName: getDisplayNameForFiber(owner) || 'Anonymous',\n          id: getFiberID(getPrimaryFiber(owner)),\n          type: getElementTypeForFiber(owner),\n        });\n        owner = owner._debugOwner || null;\n      }\n    }\n\n    const isTimedOutSuspense =\n      tag === SuspenseComponent && memoizedState !== null;\n\n    let hooks = null;\n    if (usesHooks) {\n      const originalConsoleMethods = {};\n\n      // Temporarily disable all console logging before re-running the hook.\n      for (const method in console) {\n        try {\n          originalConsoleMethods[method] = console[method];\n          // $FlowFixMe property error|warn is not writable.\n          console[method] = () => {};\n        } catch (error) {}\n      }\n\n      try {\n        hooks = inspectHooksOfFiber(\n          fiber,\n          (renderer.currentDispatcherRef: any),\n        );\n      } finally {\n        // Restore original console functionality.\n        for (const method in originalConsoleMethods) {\n          try {\n            // $FlowFixMe property error|warn is not writable.\n            console[method] = originalConsoleMethods[method];\n          } catch (error) {}\n        }\n      }\n    }\n\n    let rootType = null;\n    let current = fiber;\n    while (current.return !== null) {\n      current = current.return;\n    }\n    const fiberRoot = current.stateNode;\n    if (fiberRoot != null && fiberRoot._debugRootType !== null) {\n      rootType = fiberRoot._debugRootType;\n    }\n\n    return {\n      id,\n\n      // Does the current renderer support editable hooks and function props?\n      canEditHooks: typeof overrideHookState === 'function',\n      canEditFunctionProps: typeof overrideProps === 'function',\n\n      // Does the current renderer support advanced editing interface?\n      canEditHooksAndDeletePaths:\n        typeof overrideHookStateDeletePath === 'function',\n      canEditHooksAndRenamePaths:\n        typeof overrideHookStateRenamePath === 'function',\n      canEditFunctionPropsDeletePaths:\n        typeof overridePropsDeletePath === 'function',\n      canEditFunctionPropsRenamePaths:\n        typeof overridePropsRenamePath === 'function',\n\n      canToggleSuspense:\n        supportsTogglingSuspense &&\n        // If it's showing the real content, we can always flip fallback.\n        (!isTimedOutSuspense ||\n          // If it's showing fallback because we previously forced it to,\n          // allow toggling it back to remove the fallback override.\n          forceFallbackForSuspenseIDs.has(id)),\n\n      // Can view component source location.\n      canViewSource,\n\n      // Does the component have legacy context attached to it.\n      hasLegacyContext,\n\n      key: key != null ? key : null,\n\n      displayName: getDisplayNameForFiber(fiber),\n      type: elementType,\n\n      // Inspectable properties.\n      // TODO Review sanitization approach for the below inspectable values.\n      context,\n      hooks,\n      props: memoizedProps,\n      state: usesHooks ? null : memoizedState,\n\n      // List of owners\n      owners,\n\n      // Location of component in source code.\n      source: _debugSource || null,\n\n      rootType,\n      rendererPackageName: renderer.rendererPackageName,\n      rendererVersion: renderer.version,\n    };\n  }\n\n  let mostRecentlyInspectedElement: InspectedElement | null = null;\n  let hasElementUpdatedSinceLastInspected: boolean = false;\n  let currentlyInspectedPaths: Object = {};\n\n  function isMostRecentlyInspectedElementCurrent(id: number): boolean {\n    return (\n      mostRecentlyInspectedElement !== null &&\n      mostRecentlyInspectedElement.id === id &&\n      !hasElementUpdatedSinceLastInspected\n    );\n  }\n\n  // Track the intersection of currently inspected paths,\n  // so that we can send their data along if the element is re-rendered.\n  function mergeInspectedPaths(path: Array<string | number>) {\n    let current = currentlyInspectedPaths;\n    path.forEach(key => {\n      if (!current[key]) {\n        current[key] = {};\n      }\n      current = current[key];\n    });\n  }\n\n  function createIsPathAllowed(\n    key: string | null,\n    secondaryCategory: 'hooks' | null,\n  ) {\n    // This function helps prevent previously-inspected paths from being dehydrated in updates.\n    // This is important to avoid a bad user experience where expanded toggles collapse on update.\n    return function isPathAllowed(path: Array<string | number>): boolean {\n      switch (secondaryCategory) {\n        case 'hooks':\n          if (path.length === 1) {\n            // Never dehydrate the \"hooks\" object at the top levels.\n            return true;\n          }\n          if (\n            path[path.length - 1] === 'subHooks' ||\n            path[path.length - 2] === 'subHooks'\n          ) {\n            // Dehydrating the 'subHooks' property makes the HooksTree UI a lot more complicated,\n            // so it's easiest for now if we just don't break on this boundary.\n            // We can always dehydrate a level deeper (in the value object).\n            return true;\n          }\n          break;\n        default:\n          break;\n      }\n\n      let current =\n        key === null ? currentlyInspectedPaths : currentlyInspectedPaths[key];\n      if (!current) {\n        return false;\n      }\n      for (let i = 0; i < path.length; i++) {\n        current = current[path[i]];\n        if (!current) {\n          return false;\n        }\n      }\n      return true;\n    };\n  }\n\n  function updateSelectedElement(inspectedElement: InspectedElement): void {\n    const {hooks, id, props} = inspectedElement;\n\n    const fiber = idToFiberMap.get(id);\n    if (fiber == null) {\n      console.warn(`Could not find Fiber with id \"${id}\"`);\n      return;\n    }\n\n    const {elementType, stateNode, tag, type} = fiber;\n\n    switch (tag) {\n      case ClassComponent:\n      case IncompleteClassComponent:\n      case IndeterminateComponent:\n        global.$r = stateNode;\n        break;\n      case FunctionComponent:\n        global.$r = {\n          hooks,\n          props,\n          type,\n        };\n        break;\n      case ForwardRef:\n        global.$r = {\n          props,\n          type: type.render,\n        };\n        break;\n      case MemoComponent:\n      case SimpleMemoComponent:\n        global.$r = {\n          props,\n          type:\n            elementType != null && elementType.type != null\n              ? elementType.type\n              : type,\n        };\n        break;\n      default:\n        global.$r = null;\n        break;\n    }\n  }\n\n  function storeAsGlobal(\n    id: number,\n    path: Array<string | number>,\n    count: number,\n  ): void {\n    const isCurrent = isMostRecentlyInspectedElementCurrent(id);\n\n    if (isCurrent) {\n      const value = getInObject(\n        ((mostRecentlyInspectedElement: any): InspectedElement),\n        path,\n      );\n      const key = `$reactTemp${count}`;\n\n      window[key] = value;\n\n      console.log(key);\n      console.log(value);\n    }\n  }\n\n  function copyElementPath(id: number, path: Array<string | number>): void {\n    const isCurrent = isMostRecentlyInspectedElementCurrent(id);\n\n    if (isCurrent) {\n      copyToClipboard(\n        getInObject(\n          ((mostRecentlyInspectedElement: any): InspectedElement),\n          path,\n        ),\n      );\n    }\n  }\n\n  function inspectElement(\n    id: number,\n    path?: Array<string | number>,\n  ): InspectedElementPayload {\n    const isCurrent = isMostRecentlyInspectedElementCurrent(id);\n\n    if (isCurrent) {\n      if (path != null) {\n        mergeInspectedPaths(path);\n\n        let secondaryCategory = null;\n        if (path[0] === 'hooks') {\n          secondaryCategory = 'hooks';\n        }\n\n        // If this element has not been updated since it was last inspected,\n        // we can just return the subset of data in the newly-inspected path.\n        return {\n          id,\n          type: 'hydrated-path',\n          path,\n          value: cleanForBridge(\n            getInObject(\n              ((mostRecentlyInspectedElement: any): InspectedElement),\n              path,\n            ),\n            createIsPathAllowed(null, secondaryCategory),\n            path,\n          ),\n        };\n      } else {\n        // If this element has not been updated since it was last inspected, we don't need to re-run it.\n        // Instead we can just return the ID to indicate that it has not changed.\n        return {\n          id,\n          type: 'no-change',\n        };\n      }\n    } else {\n      hasElementUpdatedSinceLastInspected = false;\n\n      if (\n        mostRecentlyInspectedElement === null ||\n        mostRecentlyInspectedElement.id !== id\n      ) {\n        currentlyInspectedPaths = {};\n      }\n\n      mostRecentlyInspectedElement = inspectElementRaw(id);\n      if (mostRecentlyInspectedElement === null) {\n        return {\n          id,\n          type: 'not-found',\n        };\n      }\n\n      if (path != null) {\n        mergeInspectedPaths(path);\n      }\n\n      // Any time an inspected element has an update,\n      // we should update the selected $r value as wel.\n      // Do this before dehydration (cleanForBridge).\n      updateSelectedElement(mostRecentlyInspectedElement);\n\n      // Clone before cleaning so that we preserve the full data.\n      // This will enable us to send patches without re-inspecting if hydrated paths are requested.\n      // (Reducing how often we shallow-render is a better DX for function components that use hooks.)\n      const cleanedInspectedElement = {...mostRecentlyInspectedElement};\n      cleanedInspectedElement.context = cleanForBridge(\n        cleanedInspectedElement.context,\n        createIsPathAllowed('context', null),\n      );\n      cleanedInspectedElement.hooks = cleanForBridge(\n        cleanedInspectedElement.hooks,\n        createIsPathAllowed('hooks', 'hooks'),\n      );\n      cleanedInspectedElement.props = cleanForBridge(\n        cleanedInspectedElement.props,\n        createIsPathAllowed('props', null),\n      );\n      cleanedInspectedElement.state = cleanForBridge(\n        cleanedInspectedElement.state,\n        createIsPathAllowed('state', null),\n      );\n\n      return {\n        id,\n        type: 'full-data',\n        value: cleanedInspectedElement,\n      };\n    }\n  }\n\n  function logElementToConsole(id) {\n    const result = isMostRecentlyInspectedElementCurrent(id)\n      ? mostRecentlyInspectedElement\n      : inspectElementRaw(id);\n    if (result === null) {\n      console.warn(`Could not find Fiber with id \"${id}\"`);\n      return;\n    }\n\n    const supportsGroup = typeof console.groupCollapsed === 'function';\n    if (supportsGroup) {\n      console.groupCollapsed(\n        `[Click to expand] %c<${result.displayName || 'Component'} />`,\n        // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.\n        'color: var(--dom-tag-name-color); font-weight: normal;',\n      );\n    }\n    if (result.props !== null) {\n      console.log('Props:', result.props);\n    }\n    if (result.state !== null) {\n      console.log('State:', result.state);\n    }\n    if (result.hooks !== null) {\n      console.log('Hooks:', result.hooks);\n    }\n    const nativeNodes = findNativeNodesForFiberID(id);\n    if (nativeNodes !== null) {\n      console.log('Nodes:', nativeNodes);\n    }\n    if (result.source !== null) {\n      console.log('Location:', result.source);\n    }\n    if (window.chrome || /firefox/i.test(navigator.userAgent)) {\n      console.log(\n        'Right-click any value to save it as a global variable for further inspection.',\n      );\n    }\n    if (supportsGroup) {\n      console.groupEnd();\n    }\n  }\n\n  function deletePath(\n    type: 'context' | 'hooks' | 'props' | 'state',\n    id: number,\n    hookID: ?number,\n    path: Array<string | number>,\n  ): void {\n    const fiber = findCurrentFiberUsingSlowPathById(id);\n    if (fiber !== null) {\n      const instance = fiber.stateNode;\n\n      switch (type) {\n        case 'context':\n          // To simplify hydration and display of primitive context values (e.g. number, string)\n          // the inspectElement() method wraps context in a {value: ...} object.\n          // We need to remove the first part of the path (the \"value\") before continuing.\n          path = path.slice(1);\n\n          switch (fiber.tag) {\n            case ClassComponent:\n              if (path.length === 0) {\n                // Simple context value (noop)\n              } else {\n                deletePathInObject(instance.context, path);\n              }\n              instance.forceUpdate();\n              break;\n            case FunctionComponent:\n              // Function components using legacy context are not editable\n              // because there's no instance on which to create a cloned, mutated context.\n              break;\n          }\n          break;\n        case 'hooks':\n          if (typeof overrideHookStateDeletePath === 'function') {\n            overrideHookStateDeletePath(fiber, ((hookID: any): number), path);\n          }\n          break;\n        case 'props':\n          if (instance === null) {\n            if (typeof overridePropsDeletePath === 'function') {\n              overridePropsDeletePath(fiber, path);\n            }\n          } else {\n            fiber.pendingProps = copyWithDelete(instance.props, path);\n            instance.forceUpdate();\n          }\n          break;\n        case 'state':\n          deletePathInObject(instance.state, path);\n          instance.forceUpdate();\n          break;\n      }\n    }\n  }\n\n  function renamePath(\n    type: 'context' | 'hooks' | 'props' | 'state',\n    id: number,\n    hookID: ?number,\n    oldPath: Array<string | number>,\n    newPath: Array<string | number>,\n  ): void {\n    const fiber = findCurrentFiberUsingSlowPathById(id);\n    if (fiber !== null) {\n      const instance = fiber.stateNode;\n\n      switch (type) {\n        case 'context':\n          // To simplify hydration and display of primitive context values (e.g. number, string)\n          // the inspectElement() method wraps context in a {value: ...} object.\n          // We need to remove the first part of the path (the \"value\") before continuing.\n          oldPath = oldPath.slice(1);\n          newPath = newPath.slice(1);\n\n          switch (fiber.tag) {\n            case ClassComponent:\n              if (oldPath.length === 0) {\n                // Simple context value (noop)\n              } else {\n                renamePathInObject(instance.context, oldPath, newPath);\n              }\n              instance.forceUpdate();\n              break;\n            case FunctionComponent:\n              // Function components using legacy context are not editable\n              // because there's no instance on which to create a cloned, mutated context.\n              break;\n          }\n          break;\n        case 'hooks':\n          if (typeof overrideHookStateRenamePath === 'function') {\n            overrideHookStateRenamePath(\n              fiber,\n              ((hookID: any): number),\n              oldPath,\n              newPath,\n            );\n          }\n          break;\n        case 'props':\n          if (instance === null) {\n            if (typeof overridePropsRenamePath === 'function') {\n              overridePropsRenamePath(fiber, oldPath, newPath);\n            }\n          } else {\n            fiber.pendingProps = copyWithRename(\n              instance.props,\n              oldPath,\n              newPath,\n            );\n            instance.forceUpdate();\n          }\n          break;\n        case 'state':\n          renamePathInObject(instance.state, oldPath, newPath);\n          instance.forceUpdate();\n          break;\n      }\n    }\n  }\n\n  function overrideValueAtPath(\n    type: 'context' | 'hooks' | 'props' | 'state',\n    id: number,\n    hookID: ?number,\n    path: Array<string | number>,\n    value: any,\n  ): void {\n    const fiber = findCurrentFiberUsingSlowPathById(id);\n    if (fiber !== null) {\n      const instance = fiber.stateNode;\n\n      switch (type) {\n        case 'context':\n          // To simplify hydration and display of primitive context values (e.g. number, string)\n          // the inspectElement() method wraps context in a {value: ...} object.\n          // We need to remove the first part of the path (the \"value\") before continuing.\n          path = path.slice(1);\n\n          switch (fiber.tag) {\n            case ClassComponent:\n              if (path.length === 0) {\n                // Simple context value\n                instance.context = value;\n              } else {\n                setInObject(instance.context, path, value);\n              }\n              instance.forceUpdate();\n              break;\n            case FunctionComponent:\n              // Function components using legacy context are not editable\n              // because there's no instance on which to create a cloned, mutated context.\n              break;\n          }\n          break;\n        case 'hooks':\n          if (typeof overrideHookState === 'function') {\n            overrideHookState(fiber, ((hookID: any): number), path, value);\n          }\n          break;\n        case 'props':\n          switch (fiber.tag) {\n            case ClassComponent:\n              fiber.pendingProps = copyWithSet(instance.props, path, value);\n              instance.forceUpdate();\n              break;\n            default:\n              if (typeof overrideProps === 'function') {\n                overrideProps(fiber, path, value);\n              }\n              break;\n          }\n          break;\n        case 'state':\n          switch (fiber.tag) {\n            case ClassComponent:\n              setInObject(instance.state, path, value);\n              instance.forceUpdate();\n              break;\n          }\n          break;\n      }\n    }\n  }\n\n  type CommitProfilingData = {|\n    changeDescriptions: Map<number, ChangeDescription> | null,\n    commitTime: number,\n    durations: Array<number>,\n    interactions: Array<Interaction>,\n    maxActualDuration: number,\n    priorityLevel: string | null,\n  |};\n\n  type CommitProfilingMetadataMap = Map<number, Array<CommitProfilingData>>;\n  type DisplayNamesByRootID = Map<number, string>;\n\n  let currentCommitProfilingMetadata: CommitProfilingData | null = null;\n  let displayNamesByRootID: DisplayNamesByRootID | null = null;\n  let idToContextsMap: Map<number, any> | null = null;\n  let initialTreeBaseDurationsMap: Map<number, number> | null = null;\n  let initialIDToRootMap: Map<number, number> | null = null;\n  let isProfiling: boolean = false;\n  let profilingStartTime: number = 0;\n  let recordChangeDescriptions: boolean = false;\n  let rootToCommitProfilingMetadataMap: CommitProfilingMetadataMap | null = null;\n\n  function getProfilingData(): ProfilingDataBackend {\n    const dataForRoots: Array<ProfilingDataForRootBackend> = [];\n\n    if (rootToCommitProfilingMetadataMap === null) {\n      throw Error(\n        'getProfilingData() called before any profiling data was recorded',\n      );\n    }\n\n    rootToCommitProfilingMetadataMap.forEach(\n      (commitProfilingMetadata, rootID) => {\n        const commitData: Array<CommitDataBackend> = [];\n        const initialTreeBaseDurations: Array<[number, number]> = [];\n        const allInteractions: Map<number, Interaction> = new Map();\n        const interactionCommits: Map<number, Array<number>> = new Map();\n\n        const displayName =\n          (displayNamesByRootID !== null && displayNamesByRootID.get(rootID)) ||\n          'Unknown';\n\n        if (initialTreeBaseDurationsMap != null) {\n          initialTreeBaseDurationsMap.forEach((treeBaseDuration, id) => {\n            if (\n              initialIDToRootMap != null &&\n              initialIDToRootMap.get(id) === rootID\n            ) {\n              // We don't need to convert milliseconds to microseconds in this case,\n              // because the profiling summary is JSON serialized.\n              initialTreeBaseDurations.push([id, treeBaseDuration]);\n            }\n          });\n        }\n\n        commitProfilingMetadata.forEach((commitProfilingData, commitIndex) => {\n          const {\n            changeDescriptions,\n            durations,\n            interactions,\n            maxActualDuration,\n            priorityLevel,\n            commitTime,\n          } = commitProfilingData;\n\n          const interactionIDs: Array<number> = [];\n\n          interactions.forEach(interaction => {\n            if (!allInteractions.has(interaction.id)) {\n              allInteractions.set(interaction.id, interaction);\n            }\n\n            interactionIDs.push(interaction.id);\n\n            const commitIndices = interactionCommits.get(interaction.id);\n            if (commitIndices != null) {\n              commitIndices.push(commitIndex);\n            } else {\n              interactionCommits.set(interaction.id, [commitIndex]);\n            }\n          });\n\n          const fiberActualDurations: Array<[number, number]> = [];\n          const fiberSelfDurations: Array<[number, number]> = [];\n          for (let i = 0; i < durations.length; i += 3) {\n            const fiberID = durations[i];\n            fiberActualDurations.push([fiberID, durations[i + 1]]);\n            fiberSelfDurations.push([fiberID, durations[i + 2]]);\n          }\n\n          commitData.push({\n            changeDescriptions:\n              changeDescriptions !== null\n                ? Array.from(changeDescriptions.entries())\n                : null,\n            duration: maxActualDuration,\n            fiberActualDurations,\n            fiberSelfDurations,\n            interactionIDs,\n            priorityLevel,\n            timestamp: commitTime,\n          });\n        });\n\n        dataForRoots.push({\n          commitData,\n          displayName,\n          initialTreeBaseDurations,\n          interactionCommits: Array.from(interactionCommits.entries()),\n          interactions: Array.from(allInteractions.entries()),\n          rootID,\n        });\n      },\n    );\n\n    return {\n      dataForRoots,\n      rendererID,\n    };\n  }\n\n  function startProfiling(shouldRecordChangeDescriptions: boolean) {\n    if (isProfiling) {\n      return;\n    }\n\n    recordChangeDescriptions = shouldRecordChangeDescriptions;\n\n    // Capture initial values as of the time profiling starts.\n    // It's important we snapshot both the durations and the id-to-root map,\n    // since either of these may change during the profiling session\n    // (e.g. when a fiber is re-rendered or when a fiber gets removed).\n    displayNamesByRootID = new Map();\n    initialTreeBaseDurationsMap = new Map(idToTreeBaseDurationMap);\n    initialIDToRootMap = new Map(idToRootMap);\n    idToContextsMap = new Map();\n\n    hook.getFiberRoots(rendererID).forEach(root => {\n      const rootID = getFiberID(getPrimaryFiber(root.current));\n      ((displayNamesByRootID: any): DisplayNamesByRootID).set(\n        rootID,\n        getDisplayNameForRoot(root.current),\n      );\n\n      if (shouldRecordChangeDescriptions) {\n        // Record all contexts at the time profiling is started.\n        // Fibers only store the current context value,\n        // so we need to track them separately in order to determine changed keys.\n        crawlToInitializeContextsMap(root.current);\n      }\n    });\n\n    isProfiling = true;\n    profilingStartTime = getCurrentTime();\n    rootToCommitProfilingMetadataMap = new Map();\n  }\n\n  function stopProfiling() {\n    isProfiling = false;\n    recordChangeDescriptions = false;\n  }\n\n  // Automatically start profiling so that we don't miss timing info from initial \"mount\".\n  if (\n    sessionStorageGetItem(SESSION_STORAGE_RELOAD_AND_PROFILE_KEY) === 'true'\n  ) {\n    startProfiling(\n      sessionStorageGetItem(SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY) ===\n        'true',\n    );\n  }\n\n  // React will switch between these implementations depending on whether\n  // we have any manually suspended Fibers or not.\n\n  function shouldSuspendFiberAlwaysFalse() {\n    return false;\n  }\n\n  const forceFallbackForSuspenseIDs = new Set();\n  function shouldSuspendFiberAccordingToSet(fiber) {\n    const id = getFiberID(getPrimaryFiber(((fiber: any): Fiber)));\n    return forceFallbackForSuspenseIDs.has(id);\n  }\n\n  function overrideSuspense(id, forceFallback) {\n    if (\n      typeof setSuspenseHandler !== 'function' ||\n      typeof scheduleUpdate !== 'function'\n    ) {\n      throw new Error(\n        'Expected overrideSuspense() to not get called for earlier React versions.',\n      );\n    }\n    if (forceFallback) {\n      forceFallbackForSuspenseIDs.add(id);\n      if (forceFallbackForSuspenseIDs.size === 1) {\n        // First override is added. Switch React to slower path.\n        setSuspenseHandler(shouldSuspendFiberAccordingToSet);\n      }\n    } else {\n      forceFallbackForSuspenseIDs.delete(id);\n      if (forceFallbackForSuspenseIDs.size === 0) {\n        // Last override is gone. Switch React back to fast path.\n        setSuspenseHandler(shouldSuspendFiberAlwaysFalse);\n      }\n    }\n    const fiber = idToFiberMap.get(id);\n    if (fiber != null) {\n      scheduleUpdate(fiber);\n    }\n  }\n\n  // Remember if we're trying to restore the selection after reload.\n  // In that case, we'll do some extra checks for matching mounts.\n  let trackedPath: Array<PathFrame> | null = null;\n  let trackedPathMatchFiber: Fiber | null = null;\n  let trackedPathMatchDepth = -1;\n  let mightBeOnTrackedPath = false;\n\n  function setTrackedPath(path: Array<PathFrame> | null) {\n    if (path === null) {\n      trackedPathMatchFiber = null;\n      trackedPathMatchDepth = -1;\n      mightBeOnTrackedPath = false;\n    }\n    trackedPath = path;\n  }\n\n  // We call this before traversing a new mount.\n  // It remembers whether this Fiber is the next best match for tracked path.\n  // The return value signals whether we should keep matching siblings or not.\n  function updateTrackedPathStateBeforeMount(fiber: Fiber): boolean {\n    if (trackedPath === null || !mightBeOnTrackedPath) {\n      // Fast path: there's nothing to track so do nothing and ignore siblings.\n      return false;\n    }\n    const returnFiber = fiber.return;\n    const returnAlternate = returnFiber !== null ? returnFiber.alternate : null;\n    // By now we know there's some selection to restore, and this is a new Fiber.\n    // Is this newly mounted Fiber a direct child of the current best match?\n    // (This will also be true for new roots if we haven't matched anything yet.)\n    if (\n      trackedPathMatchFiber === returnFiber ||\n      (trackedPathMatchFiber === returnAlternate && returnAlternate !== null)\n    ) {\n      // Is this the next Fiber we should select? Let's compare the frames.\n      const actualFrame = getPathFrame(fiber);\n      const expectedFrame = trackedPath[trackedPathMatchDepth + 1];\n      if (expectedFrame === undefined) {\n        throw new Error('Expected to see a frame at the next depth.');\n      }\n      if (\n        actualFrame.index === expectedFrame.index &&\n        actualFrame.key === expectedFrame.key &&\n        actualFrame.displayName === expectedFrame.displayName\n      ) {\n        // We have our next match.\n        trackedPathMatchFiber = fiber;\n        trackedPathMatchDepth++;\n        // Are we out of frames to match?\n        if (trackedPathMatchDepth === trackedPath.length - 1) {\n          // There's nothing that can possibly match afterwards.\n          // Don't check the children.\n          mightBeOnTrackedPath = false;\n        } else {\n          // Check the children, as they might reveal the next match.\n          mightBeOnTrackedPath = true;\n        }\n        // In either case, since we have a match, we don't need\n        // to check the siblings. They'll never match.\n        return false;\n      }\n    }\n    // This Fiber's parent is on the path, but this Fiber itself isn't.\n    // There's no need to check its children--they won't be on the path either.\n    mightBeOnTrackedPath = false;\n    // However, one of its siblings may be on the path so keep searching.\n    return true;\n  }\n\n  function updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath) {\n    // updateTrackedPathStateBeforeMount() told us whether to match siblings.\n    // Now that we're entering siblings, let's use that information.\n    mightBeOnTrackedPath = mightSiblingsBeOnTrackedPath;\n  }\n\n  // Roots don't have a real persistent identity.\n  // A root's \"pseudo key\" is \"childDisplayName:indexWithThatName\".\n  // For example, \"App:0\" or, in case of similar roots, \"Story:0\", \"Story:1\", etc.\n  // We will use this to try to disambiguate roots when restoring selection between reloads.\n  const rootPseudoKeys: Map<number, string> = new Map();\n  const rootDisplayNameCounter: Map<string, number> = new Map();\n\n  function setRootPseudoKey(id: number, fiber: Fiber) {\n    const name = getDisplayNameForRoot(fiber);\n    const counter = rootDisplayNameCounter.get(name) || 0;\n    rootDisplayNameCounter.set(name, counter + 1);\n    const pseudoKey = `${name}:${counter}`;\n    rootPseudoKeys.set(id, pseudoKey);\n  }\n\n  function removeRootPseudoKey(id: number) {\n    const pseudoKey = rootPseudoKeys.get(id);\n    if (pseudoKey === undefined) {\n      throw new Error('Expected root pseudo key to be known.');\n    }\n    const name = pseudoKey.substring(0, pseudoKey.lastIndexOf(':'));\n    const counter = rootDisplayNameCounter.get(name);\n    if (counter === undefined) {\n      throw new Error('Expected counter to be known.');\n    }\n    if (counter > 1) {\n      rootDisplayNameCounter.set(name, counter - 1);\n    } else {\n      rootDisplayNameCounter.delete(name);\n    }\n    rootPseudoKeys.delete(id);\n  }\n\n  function getDisplayNameForRoot(fiber: Fiber): string {\n    let preferredDisplayName = null;\n    let fallbackDisplayName = null;\n    let child = fiber.child;\n    // Go at most three levels deep into direct children\n    // while searching for a child that has a displayName.\n    for (let i = 0; i < 3; i++) {\n      if (child === null) {\n        break;\n      }\n      const displayName = getDisplayNameForFiber(child);\n      if (displayName !== null) {\n        // Prefer display names that we get from user-defined components.\n        // We want to avoid using e.g. 'Suspense' unless we find nothing else.\n        if (typeof child.type === 'function') {\n          // There's a few user-defined tags, but we'll prefer the ones\n          // that are usually explicitly named (function or class components).\n          preferredDisplayName = displayName;\n        } else if (fallbackDisplayName === null) {\n          fallbackDisplayName = displayName;\n        }\n      }\n      if (preferredDisplayName !== null) {\n        break;\n      }\n      child = child.child;\n    }\n    return preferredDisplayName || fallbackDisplayName || 'Anonymous';\n  }\n\n  function getPathFrame(fiber: Fiber): PathFrame {\n    const {key} = fiber;\n    let displayName = getDisplayNameForFiber(fiber);\n    const index = fiber.index;\n    switch (fiber.tag) {\n      case HostRoot:\n        // Roots don't have a real displayName, index, or key.\n        // Instead, we'll use the pseudo key (childDisplayName:indexWithThatName).\n        const id = getFiberID(getPrimaryFiber(fiber));\n        const pseudoKey = rootPseudoKeys.get(id);\n        if (pseudoKey === undefined) {\n          throw new Error('Expected mounted root to have known pseudo key.');\n        }\n        displayName = pseudoKey;\n        break;\n      case HostComponent:\n        displayName = fiber.type;\n        break;\n      default:\n        break;\n    }\n    return {\n      displayName,\n      key,\n      index,\n    };\n  }\n\n  // Produces a serializable representation that does a best effort\n  // of identifying a particular Fiber between page reloads.\n  // The return path will contain Fibers that are \"invisible\" to the store\n  // because their keys and indexes are important to restoring the selection.\n  function getPathForElement(id: number): Array<PathFrame> | null {\n    let fiber = idToFiberMap.get(id);\n    if (fiber == null) {\n      return null;\n    }\n    const keyPath = [];\n    while (fiber !== null) {\n      keyPath.push(getPathFrame(fiber));\n      fiber = fiber.return;\n    }\n    keyPath.reverse();\n    return keyPath;\n  }\n\n  function getBestMatchForTrackedPath(): PathMatch | null {\n    if (trackedPath === null) {\n      // Nothing to match.\n      return null;\n    }\n    if (trackedPathMatchFiber === null) {\n      // We didn't find anything.\n      return null;\n    }\n    // Find the closest Fiber store is aware of.\n    let fiber = trackedPathMatchFiber;\n    while (fiber !== null && shouldFilterFiber(fiber)) {\n      fiber = fiber.return;\n    }\n    if (fiber === null) {\n      return null;\n    }\n    return {\n      id: getFiberID(getPrimaryFiber(fiber)),\n      isFullMatch: trackedPathMatchDepth === trackedPath.length - 1,\n    };\n  }\n\n  const formatPriorityLevel = (priorityLevel: ?number) => {\n    if (priorityLevel == null) {\n      return 'Unknown';\n    }\n\n    switch (priorityLevel) {\n      case ImmediatePriority:\n        return 'Immediate';\n      case UserBlockingPriority:\n        return 'User-Blocking';\n      case NormalPriority:\n        return 'Normal';\n      case LowPriority:\n        return 'Low';\n      case IdlePriority:\n        return 'Idle';\n      case NoPriority:\n      default:\n        return 'Unknown';\n    }\n  };\n\n  function setTraceUpdatesEnabled(isEnabled: boolean): void {\n    traceUpdatesEnabled = isEnabled;\n  }\n\n  return {\n    cleanup,\n    copyElementPath,\n    deletePath,\n    findNativeNodesForFiberID,\n    flushInitialOperations,\n    getBestMatchForTrackedPath,\n    getDisplayNameForFiberID,\n    getFiberIDForNative,\n    getInstanceAndStyle,\n    getOwnersList,\n    getPathForElement,\n    getProfilingData,\n    handleCommitFiberRoot,\n    handleCommitFiberUnmount,\n    inspectElement,\n    logElementToConsole,\n    prepareViewAttributeSource,\n    prepareViewElementSource,\n    overrideSuspense,\n    overrideValueAtPath,\n    renamePath,\n    renderer,\n    setTraceUpdatesEnabled,\n    setTrackedPath,\n    startProfiling,\n    stopProfiling,\n    storeAsGlobal,\n    updateComponentFilters,\n  };\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\n// This list should be kept updated to reflect additions to 'shared/ReactSymbols'.\n// DevTools can't import symbols from 'shared/ReactSymbols' directly for two reasons:\n// 1. DevTools requires symbols which may have been deleted in more recent versions (e.g. concurrent mode)\n// 2. DevTools must support both Symbol and numeric forms of each symbol;\n//    Since e.g. standalone DevTools runs in a separate process, it can't rely on its own ES capabilities.\n\nexport const CONCURRENT_MODE_NUMBER = 0xeacf;\nexport const CONCURRENT_MODE_SYMBOL_STRING = 'Symbol(react.concurrent_mode)';\n\nexport const CONTEXT_NUMBER = 0xeace;\nexport const CONTEXT_SYMBOL_STRING = 'Symbol(react.context)';\n\nexport const DEPRECATED_ASYNC_MODE_SYMBOL_STRING = 'Symbol(react.async_mode)';\n\nexport const ELEMENT_NUMBER = 0xeac7;\nexport const ELEMENT_SYMBOL_STRING = 'Symbol(react.element)';\n\nexport const DEBUG_TRACING_MODE_NUMBER = 0xeae1;\nexport const DEBUG_TRACING_MODE_SYMBOL_STRING =\n  'Symbol(react.debug_trace_mode)';\n\nexport const FORWARD_REF_NUMBER = 0xead0;\nexport const FORWARD_REF_SYMBOL_STRING = 'Symbol(react.forward_ref)';\n\nexport const FRAGMENT_NUMBER = 0xeacb;\nexport const FRAGMENT_SYMBOL_STRING = 'Symbol(react.fragment)';\n\nexport const FUNDAMENTAL_NUMBER = 0xead5;\nexport const FUNDAMENTAL_SYMBOL_STRING = 'Symbol(react.fundamental)';\n\nexport const LAZY_NUMBER = 0xead4;\nexport const LAZY_SYMBOL_STRING = 'Symbol(react.lazy)';\n\nexport const MEMO_NUMBER = 0xead3;\nexport const MEMO_SYMBOL_STRING = 'Symbol(react.memo)';\n\nexport const OPAQUE_ID_NUMBER = 0xeae0;\nexport const OPAQUE_ID_SYMBOL_STRING = 'Symbol(react.opaque.id)';\n\nexport const PORTAL_NUMBER = 0xeaca;\nexport const PORTAL_SYMBOL_STRING = 'Symbol(react.portal)';\n\nexport const PROFILER_NUMBER = 0xead2;\nexport const PROFILER_SYMBOL_STRING = 'Symbol(react.profiler)';\n\nexport const PROVIDER_NUMBER = 0xeacd;\nexport const PROVIDER_SYMBOL_STRING = 'Symbol(react.provider)';\n\nexport const SCOPE_NUMBER = 0xead7;\nexport const SCOPE_SYMBOL_STRING = 'Symbol(react.scope)';\n\nexport const STRICT_MODE_NUMBER = 0xeacc;\nexport const STRICT_MODE_SYMBOL_STRING = 'Symbol(react.strict_mode)';\n\nexport const SUSPENSE_NUMBER = 0xead1;\nexport const SUSPENSE_SYMBOL_STRING = 'Symbol(react.suspense)';\n\nexport const SUSPENSE_LIST_NUMBER = 0xead8;\nexport const SUSPENSE_LIST_SYMBOL_STRING = 'Symbol(react.suspense_list)';\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nexport type Wall = {|\n  // `listen` returns the \"unlisten\" function.\n  listen: (fn: Function) => Function,\n  send: (event: string, payload: any, transferable?: Array<any>) => void,\n|};\n\n// WARNING\n// The values below are referenced by ComponentFilters (which are saved via localStorage).\n// Do not change them or it will break previously saved user customizations.\n// If new element types are added, use new numbers rather than re-ordering existing ones.\n//\n// Changing these types is also a backwards breaking change for the standalone shell,\n// since the frontend and backend must share the same values-\n// and the backend is embedded in certain environments (like React Native).\nexport const ElementTypeClass = 1;\nexport const ElementTypeContext = 2;\nexport const ElementTypeFunction = 5;\nexport const ElementTypeForwardRef = 6;\nexport const ElementTypeHostComponent = 7;\nexport const ElementTypeMemo = 8;\nexport const ElementTypeOtherOrUnknown = 9;\nexport const ElementTypeProfiler = 10;\nexport const ElementTypeRoot = 11;\nexport const ElementTypeSuspense = 12;\nexport const ElementTypeSuspenseList = 13;\n\n// Different types of elements displayed in the Elements tree.\n// These types may be used to visually distinguish types,\n// or to enable/disable certain functionality.\nexport type ElementType = 1 | 2 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13;\n\n// WARNING\n// The values below are referenced by ComponentFilters (which are saved via localStorage).\n// Do not change them or it will break previously saved user customizations.\n// If new filter types are added, use new numbers rather than re-ordering existing ones.\nexport const ComponentFilterElementType = 1;\nexport const ComponentFilterDisplayName = 2;\nexport const ComponentFilterLocation = 3;\nexport const ComponentFilterHOC = 4;\n\nexport type ComponentFilterType = 1 | 2 | 3 | 4;\n\n// Hide all elements of types in this Set.\n// We hide host components only by default.\nexport type ElementTypeComponentFilter = {|\n  isEnabled: boolean,\n  type: 1,\n  value: ElementType,\n|};\n\n// Hide all elements with displayNames or paths matching one or more of the RegExps in this Set.\n// Path filters are only used when elements include debug source location.\nexport type RegExpComponentFilter = {|\n  isEnabled: boolean,\n  isValid: boolean,\n  type: 2 | 3,\n  value: string,\n|};\n\nexport type BooleanComponentFilter = {|\n  isEnabled: boolean,\n  isValid: boolean,\n  type: 4,\n|};\n\nexport type ComponentFilter =\n  | BooleanComponentFilter\n  | ElementTypeComponentFilter\n  | RegExpComponentFilter;\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\n// Helpers to patch console.logs to avoid logging during side-effect free\n// replaying on render function. This currently only patches the object\n// lazily which won't cover if the log function was extracted eagerly.\n// We could also eagerly patch the method.\n\nlet disabledDepth = 0;\nlet prevLog;\nlet prevInfo;\nlet prevWarn;\nlet prevError;\nlet prevGroup;\nlet prevGroupCollapsed;\nlet prevGroupEnd;\n\nfunction disabledLog() {}\ndisabledLog.__reactDisabledLog = true;\n\nexport function disableLogs(): void {\n  if (__DEV__) {\n    if (disabledDepth === 0) {\n      /* eslint-disable react-internal/no-production-logging */\n      prevLog = console.log;\n      prevInfo = console.info;\n      prevWarn = console.warn;\n      prevError = console.error;\n      prevGroup = console.group;\n      prevGroupCollapsed = console.groupCollapsed;\n      prevGroupEnd = console.groupEnd;\n      // https://github.com/facebook/react/issues/19099\n      const props = {\n        configurable: true,\n        enumerable: true,\n        value: disabledLog,\n        writable: true,\n      };\n      // $FlowFixMe Flow thinks console is immutable.\n      Object.defineProperties(console, {\n        info: props,\n        log: props,\n        warn: props,\n        error: props,\n        group: props,\n        groupCollapsed: props,\n        groupEnd: props,\n      });\n      /* eslint-enable react-internal/no-production-logging */\n    }\n    disabledDepth++;\n  }\n}\n\nexport function reenableLogs(): void {\n  if (__DEV__) {\n    disabledDepth--;\n    if (disabledDepth === 0) {\n      /* eslint-disable react-internal/no-production-logging */\n      const props = {\n        configurable: true,\n        enumerable: true,\n        writable: true,\n      };\n      // $FlowFixMe Flow thinks console is immutable.\n      Object.defineProperties(console, {\n        log: {...props, value: prevLog},\n        info: {...props, value: prevInfo},\n        warn: {...props, value: prevWarn},\n        error: {...props, value: prevError},\n        group: {...props, value: prevGroup},\n        groupCollapsed: {...props, value: prevGroupCollapsed},\n        groupEnd: {...props, value: prevGroupEnd},\n      });\n      /* eslint-enable react-internal/no-production-logging */\n    }\n    if (disabledDepth < 0) {\n      console.error(\n        'disabledDepth fell below zero. ' +\n          'This is a bug in React. Please file an issue.',\n      );\n    }\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\n// This is a DevTools fork of ReactComponentStackFrame.\n// This fork enables DevTools to use the same \"native\" component stack format,\n// while still maintaining support for multiple renderer versions\n// (which use different values for ReactTypeOfWork).\n\nimport type {Source} from 'shared/ReactElementType';\nimport type {LazyComponent} from 'react/src/ReactLazy';\nimport type {CurrentDispatcherRef} from './types';\n\nimport {\n  FORWARD_REF_NUMBER,\n  FORWARD_REF_SYMBOL_STRING,\n  LAZY_NUMBER,\n  LAZY_SYMBOL_STRING,\n  MEMO_NUMBER,\n  MEMO_SYMBOL_STRING,\n  SUSPENSE_NUMBER,\n  SUSPENSE_SYMBOL_STRING,\n  SUSPENSE_LIST_NUMBER,\n  SUSPENSE_LIST_SYMBOL_STRING,\n} from './ReactSymbols';\n\n// These methods are safe to import from shared;\n// there is no React-specific logic here.\nimport {disableLogs, reenableLogs} from 'shared/ConsolePatchingDev';\n\nlet prefix;\nexport function describeBuiltInComponentFrame(\n  name: string,\n  source: void | null | Source,\n  ownerFn: void | null | Function,\n): string {\n  if (prefix === undefined) {\n    // Extract the VM specific prefix used by each line.\n    try {\n      throw Error();\n    } catch (x) {\n      const match = x.stack.trim().match(/\\n( *(at )?)/);\n      prefix = (match && match[1]) || '';\n    }\n  }\n  // We use the prefix to ensure our stacks line up with native stack frames.\n  return '\\n' + prefix + name;\n}\n\nlet reentry = false;\nlet componentFrameCache;\nif (__DEV__) {\n  const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;\n  componentFrameCache = new PossiblyWeakMap();\n}\n\nexport function describeNativeComponentFrame(\n  fn: Function,\n  construct: boolean,\n  currentDispatcherRef: CurrentDispatcherRef,\n): string {\n  // If something asked for a stack inside a fake render, it should get ignored.\n  if (!fn || reentry) {\n    return '';\n  }\n\n  if (__DEV__) {\n    const frame = componentFrameCache.get(fn);\n    if (frame !== undefined) {\n      return frame;\n    }\n  }\n\n  let control;\n\n  const previousPrepareStackTrace = Error.prepareStackTrace;\n  // $FlowFixMe It does accept undefined.\n  Error.prepareStackTrace = undefined;\n\n  reentry = true;\n\n  // Override the dispatcher so effects scheduled by this shallow render are thrown away.\n  //\n  // Note that unlike the code this was forked from (in ReactComponentStackFrame)\n  // DevTools should override the dispatcher even when DevTools is compiled in production mode,\n  // because the app itself may be in development mode and log errors/warnings.\n  const previousDispatcher = currentDispatcherRef.current;\n  currentDispatcherRef.current = null;\n  disableLogs();\n\n  try {\n    // This should throw.\n    if (construct) {\n      // Something should be setting the props in the constructor.\n      const Fake = function() {\n        throw Error();\n      };\n      // $FlowFixMe\n      Object.defineProperty(Fake.prototype, 'props', {\n        set: function() {\n          // We use a throwing setter instead of frozen or non-writable props\n          // because that won't throw in a non-strict mode function.\n          throw Error();\n        },\n      });\n      if (typeof Reflect === 'object' && Reflect.construct) {\n        // We construct a different control for this case to include any extra\n        // frames added by the construct call.\n        try {\n          Reflect.construct(Fake, []);\n        } catch (x) {\n          control = x;\n        }\n        Reflect.construct(fn, [], Fake);\n      } else {\n        try {\n          Fake.call();\n        } catch (x) {\n          control = x;\n        }\n        fn.call(Fake.prototype);\n      }\n    } else {\n      try {\n        throw Error();\n      } catch (x) {\n        control = x;\n      }\n      fn();\n    }\n  } catch (sample) {\n    // This is inlined manually because closure doesn't do it for us.\n    if (sample && control && typeof sample.stack === 'string') {\n      // This extracts the first frame from the sample that isn't also in the control.\n      // Skipping one frame that we assume is the frame that calls the two.\n      const sampleLines = sample.stack.split('\\n');\n      const controlLines = control.stack.split('\\n');\n      let s = sampleLines.length - 1;\n      let c = controlLines.length - 1;\n      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {\n        // We expect at least one stack frame to be shared.\n        // Typically this will be the root most one. However, stack frames may be\n        // cut off due to maximum stack limits. In this case, one maybe cut off\n        // earlier than the other. We assume that the sample is longer or the same\n        // and there for cut off earlier. So we should find the root most frame in\n        // the sample somewhere in the control.\n        c--;\n      }\n      for (; s >= 1 && c >= 0; s--, c--) {\n        // Next we find the first one that isn't the same which should be the\n        // frame that called our sample function and the control.\n        if (sampleLines[s] !== controlLines[c]) {\n          // In V8, the first line is describing the message but other VMs don't.\n          // If we're about to return the first line, and the control is also on the same\n          // line, that's a pretty good indicator that our sample threw at same line as\n          // the control. I.e. before we entered the sample frame. So we ignore this result.\n          // This can happen if you passed a class to function component, or non-function.\n          if (s !== 1 || c !== 1) {\n            do {\n              s--;\n              c--;\n              // We may still have similar intermediate frames from the construct call.\n              // The next one that isn't the same should be our match though.\n              if (c < 0 || sampleLines[s] !== controlLines[c]) {\n                // V8 adds a \"new\" prefix for native classes. Let's remove it to make it prettier.\n                const frame = '\\n' + sampleLines[s].replace(' at new ', ' at ');\n                if (__DEV__) {\n                  if (typeof fn === 'function') {\n                    componentFrameCache.set(fn, frame);\n                  }\n                }\n                // Return the line we found.\n                return frame;\n              }\n            } while (s >= 1 && c >= 0);\n          }\n          break;\n        }\n      }\n    }\n  } finally {\n    reentry = false;\n\n    Error.prepareStackTrace = previousPrepareStackTrace;\n\n    currentDispatcherRef.current = previousDispatcher;\n    reenableLogs();\n  }\n  // Fallback to just using the name if we couldn't make it throw.\n  const name = fn ? fn.displayName || fn.name : '';\n  const syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';\n  if (__DEV__) {\n    if (typeof fn === 'function') {\n      componentFrameCache.set(fn, syntheticFrame);\n    }\n  }\n  return syntheticFrame;\n}\n\nexport function describeClassComponentFrame(\n  ctor: Function,\n  source: void | null | Source,\n  ownerFn: void | null | Function,\n  currentDispatcherRef: CurrentDispatcherRef,\n): string {\n  return describeNativeComponentFrame(ctor, true, currentDispatcherRef);\n}\n\nexport function describeFunctionComponentFrame(\n  fn: Function,\n  source: void | null | Source,\n  ownerFn: void | null | Function,\n  currentDispatcherRef: CurrentDispatcherRef,\n): string {\n  return describeNativeComponentFrame(fn, false, currentDispatcherRef);\n}\n\nfunction shouldConstruct(Component: Function) {\n  const prototype = Component.prototype;\n  return !!(prototype && prototype.isReactComponent);\n}\n\nexport function describeUnknownElementTypeFrameInDEV(\n  type: any,\n  source: void | null | Source,\n  ownerFn: void | null | Function,\n  currentDispatcherRef: CurrentDispatcherRef,\n): string {\n  if (!__DEV__) {\n    return '';\n  }\n  if (type == null) {\n    return '';\n  }\n  if (typeof type === 'function') {\n    return describeNativeComponentFrame(\n      type,\n      shouldConstruct(type),\n      currentDispatcherRef,\n    );\n  }\n  if (typeof type === 'string') {\n    return describeBuiltInComponentFrame(type, source, ownerFn);\n  }\n  switch (type) {\n    case SUSPENSE_NUMBER:\n    case SUSPENSE_SYMBOL_STRING:\n      return describeBuiltInComponentFrame('Suspense', source, ownerFn);\n    case SUSPENSE_LIST_NUMBER:\n    case SUSPENSE_LIST_SYMBOL_STRING:\n      return describeBuiltInComponentFrame('SuspenseList', source, ownerFn);\n  }\n  if (typeof type === 'object') {\n    switch (type.$$typeof) {\n      case FORWARD_REF_NUMBER:\n      case FORWARD_REF_SYMBOL_STRING:\n        return describeFunctionComponentFrame(\n          type.render,\n          source,\n          ownerFn,\n          currentDispatcherRef,\n        );\n      case MEMO_NUMBER:\n      case MEMO_SYMBOL_STRING:\n        // Memo may contain any component type so we recursively resolve it.\n        return describeUnknownElementTypeFrameInDEV(\n          type.type,\n          source,\n          ownerFn,\n          currentDispatcherRef,\n        );\n      case LAZY_NUMBER:\n      case LAZY_SYMBOL_STRING: {\n        const lazyComponent: LazyComponent<any, any> = (type: any);\n        const payload = lazyComponent._payload;\n        const init = lazyComponent._init;\n        try {\n          // Lazy may contain any component type so we recursively resolve it.\n          return describeUnknownElementTypeFrameInDEV(\n            init(payload),\n            source,\n            ownerFn,\n            currentDispatcherRef,\n          );\n        } catch (x) {}\n      }\n    }\n  }\n  return '';\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\n// This is a DevTools fork of ReactFiberComponentStack.\n// This fork enables DevTools to use the same \"native\" component stack format,\n// while still maintaining support for multiple renderer versions\n// (which use different values for ReactTypeOfWork).\n\nimport type {Fiber} from 'react-reconciler/src/ReactInternalTypes';\nimport type {CurrentDispatcherRef, WorkTagMap} from './types';\n\nimport {\n  describeBuiltInComponentFrame,\n  describeFunctionComponentFrame,\n  describeClassComponentFrame,\n} from './DevToolsComponentStackFrame';\n\nfunction describeFiber(\n  workTagMap: WorkTagMap,\n  workInProgress: Fiber,\n  currentDispatcherRef: CurrentDispatcherRef,\n): string {\n  const {\n    HostComponent,\n    LazyComponent,\n    SuspenseComponent,\n    SuspenseListComponent,\n    FunctionComponent,\n    IndeterminateComponent,\n    SimpleMemoComponent,\n    ForwardRef,\n    ClassComponent,\n  } = workTagMap;\n\n  const owner: null | Function = __DEV__\n    ? workInProgress._debugOwner\n      ? workInProgress._debugOwner.type\n      : null\n    : null;\n  const source = __DEV__ ? workInProgress._debugSource : null;\n  switch (workInProgress.tag) {\n    case HostComponent:\n      return describeBuiltInComponentFrame(workInProgress.type, source, owner);\n    case LazyComponent:\n      return describeBuiltInComponentFrame('Lazy', source, owner);\n    case SuspenseComponent:\n      return describeBuiltInComponentFrame('Suspense', source, owner);\n    case SuspenseListComponent:\n      return describeBuiltInComponentFrame('SuspenseList', source, owner);\n    case FunctionComponent:\n    case IndeterminateComponent:\n    case SimpleMemoComponent:\n      return describeFunctionComponentFrame(\n        workInProgress.type,\n        source,\n        owner,\n        currentDispatcherRef,\n      );\n    case ForwardRef:\n      return describeFunctionComponentFrame(\n        workInProgress.type.render,\n        source,\n        owner,\n        currentDispatcherRef,\n      );\n    case ClassComponent:\n      return describeClassComponentFrame(\n        workInProgress.type,\n        source,\n        owner,\n        currentDispatcherRef,\n      );\n    default:\n      return '';\n  }\n}\n\nexport function getStackByFiberInDevAndProd(\n  workTagMap: WorkTagMap,\n  workInProgress: Fiber,\n  currentDispatcherRef: CurrentDispatcherRef,\n): string {\n  try {\n    let info = '';\n    let node = workInProgress;\n    do {\n      info += describeFiber(workTagMap, node, currentDispatcherRef);\n      node = node.return;\n    } while (node);\n    return info;\n  } catch (x) {\n    return '\\nError generating stack: ' + x.message + '\\n' + x.stack;\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport type {Fiber} from 'react-reconciler/src/ReactInternalTypes';\nimport type {CurrentDispatcherRef, ReactRenderer, WorkTagMap} from './types';\n\nimport {getInternalReactConstants} from './renderer';\nimport {getStackByFiberInDevAndProd} from './DevToolsFiberComponentStack';\n\nconst APPEND_STACK_TO_METHODS = ['error', 'trace', 'warn'];\n\n// React's custom built component stack strings match \"\\s{4}in\"\n// Chrome's prefix matches \"\\s{4}at\"\nconst PREFIX_REGEX = /\\s{4}(in|at)\\s{1}/;\n// Firefox and Safari have no prefix (\"\")\n// but we can fallback to looking for location info (e.g. \"foo.js:12:345\")\nconst ROW_COLUMN_NUMBER_REGEX = /:\\d+:\\d+(\\n|$)/;\n\nconst injectedRenderers: Map<\n  ReactRenderer,\n  {|\n    currentDispatcherRef: CurrentDispatcherRef,\n    getCurrentFiber: () => Fiber | null,\n    workTagMap: WorkTagMap,\n  |},\n> = new Map();\n\nlet targetConsole: Object = console;\nlet targetConsoleMethods = {};\nfor (const method in console) {\n  targetConsoleMethods[method] = console[method];\n}\n\nlet unpatchFn: null | (() => void) = null;\n\n// Enables e.g. Jest tests to inject a mock console object.\nexport function dangerous_setTargetConsoleForTesting(\n  targetConsoleForTesting: Object,\n): void {\n  targetConsole = targetConsoleForTesting;\n\n  targetConsoleMethods = {};\n  for (const method in targetConsole) {\n    targetConsoleMethods[method] = console[method];\n  }\n}\n\n// v16 renderers should use this method to inject internals necessary to generate a component stack.\n// These internals will be used if the console is patched.\n// Injecting them separately allows the console to easily be patched or un-patched later (at runtime).\nexport function registerRenderer(renderer: ReactRenderer): void {\n  const {\n    currentDispatcherRef,\n    getCurrentFiber,\n    findFiberByHostInstance,\n    version,\n  } = renderer;\n\n  // Ignore React v15 and older because they don't expose a component stack anyway.\n  if (typeof findFiberByHostInstance !== 'function') {\n    return;\n  }\n\n  // currentDispatcherRef gets injected for v16.8+ to support hooks inspection.\n  // getCurrentFiber gets injected for v16.9+.\n  if (currentDispatcherRef != null && typeof getCurrentFiber === 'function') {\n    const {ReactTypeOfWork} = getInternalReactConstants(version);\n\n    injectedRenderers.set(renderer, {\n      currentDispatcherRef,\n      getCurrentFiber,\n      workTagMap: ReactTypeOfWork,\n    });\n  }\n}\n\nconst consoleSettingsRef = {\n  appendComponentStack: false,\n  breakOnConsoleErrors: false,\n};\n\n// Patches console methods to append component stack for the current fiber.\n// Call unpatch() to remove the injected behavior.\nexport function patch({\n  appendComponentStack,\n  breakOnConsoleErrors,\n}: {\n  appendComponentStack: boolean,\n  breakOnConsoleErrors: boolean,\n}): void {\n  // Settings may change after we've patched the console.\n  // Using a shared ref allows the patch function to read the latest values.\n  consoleSettingsRef.appendComponentStack = appendComponentStack;\n  consoleSettingsRef.breakOnConsoleErrors = breakOnConsoleErrors;\n\n  if (unpatchFn !== null) {\n    // Don't patch twice.\n    return;\n  }\n\n  const originalConsoleMethods = {};\n\n  unpatchFn = () => {\n    for (const method in originalConsoleMethods) {\n      try {\n        // $FlowFixMe property error|warn is not writable.\n        targetConsole[method] = originalConsoleMethods[method];\n      } catch (error) {}\n    }\n  };\n\n  APPEND_STACK_TO_METHODS.forEach(method => {\n    try {\n      const originalMethod = (originalConsoleMethods[method] =\n        targetConsole[method]);\n\n      const overrideMethod = (...args) => {\n        const latestAppendComponentStack =\n          consoleSettingsRef.appendComponentStack;\n        const latestBreakOnConsoleErrors =\n          consoleSettingsRef.breakOnConsoleErrors;\n\n        if (latestAppendComponentStack) {\n          try {\n            // If we are ever called with a string that already has a component stack, e.g. a React error/warning,\n            // don't append a second stack.\n            const lastArg = args.length > 0 ? args[args.length - 1] : null;\n            const alreadyHasComponentStack =\n              lastArg !== null &&\n              (PREFIX_REGEX.test(lastArg) ||\n                ROW_COLUMN_NUMBER_REGEX.test(lastArg));\n\n            if (!alreadyHasComponentStack) {\n              // If there's a component stack for at least one of the injected renderers, append it.\n              // We don't handle the edge case of stacks for more than one (e.g. interleaved renderers?)\n              // eslint-disable-next-line no-for-of-loops/no-for-of-loops\n              for (const {\n                currentDispatcherRef,\n                getCurrentFiber,\n                workTagMap,\n              } of injectedRenderers.values()) {\n                const current: ?Fiber = getCurrentFiber();\n                if (current != null) {\n                  const componentStack = getStackByFiberInDevAndProd(\n                    workTagMap,\n                    current,\n                    currentDispatcherRef,\n                  );\n                  if (componentStack !== '') {\n                    args.push(componentStack);\n                  }\n                  break;\n                }\n              }\n            }\n          } catch (error) {\n            // Don't let a DevTools or React internal error interfere with logging.\n          }\n        }\n\n        if (latestBreakOnConsoleErrors) {\n          // --- Welcome to debugging with React DevTools ---\n          // This debugger statement means that you've enabled the \"break on warnings\" feature.\n          // Use the browser's Call Stack panel to step out of this override function-\n          // to where the original warning or error was logged.\n          // eslint-disable-next-line no-debugger\n          debugger;\n        }\n\n        originalMethod(...args);\n      };\n\n      overrideMethod.__REACT_DEVTOOLS_ORIGINAL_METHOD__ = originalMethod;\n\n      // $FlowFixMe property error|warn is not writable.\n      targetConsole[method] = overrideMethod;\n    } catch (error) {}\n  });\n}\n\n// Removed component stack patch from console methods.\nexport function unpatch(): void {\n  if (unpatchFn !== null) {\n    unpatchFn();\n    unpatchFn = null;\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport EventEmitter from '../events';\nimport throttle from 'lodash.throttle';\nimport {\n  SESSION_STORAGE_LAST_SELECTION_KEY,\n  SESSION_STORAGE_RELOAD_AND_PROFILE_KEY,\n  SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY,\n  __DEBUG__,\n} from '../constants';\nimport {\n  sessionStorageGetItem,\n  sessionStorageRemoveItem,\n  sessionStorageSetItem,\n} from 'react-devtools-shared/src/storage';\nimport setupHighlighter from './views/Highlighter';\nimport {\n  initialize as setupTraceUpdates,\n  toggleEnabled as setTraceUpdatesEnabled,\n} from './views/TraceUpdates';\nimport {patch as patchConsole, unpatch as unpatchConsole} from './console';\n\nimport type {BackendBridge} from 'react-devtools-shared/src/bridge';\nimport type {\n  InstanceAndStyle,\n  NativeType,\n  OwnersList,\n  PathFrame,\n  PathMatch,\n  RendererID,\n  RendererInterface,\n} from './types';\nimport type {ComponentFilter} from '../types';\n\nconst debug = (methodName, ...args) => {\n  if (__DEBUG__) {\n    console.log(\n      `%cAgent %c${methodName}`,\n      'color: purple; font-weight: bold;',\n      'font-weight: bold;',\n      ...args,\n    );\n  }\n};\n\ntype ElementAndRendererID = {|\n  id: number,\n  rendererID: number,\n|};\n\ntype StoreAsGlobalParams = {|\n  count: number,\n  id: number,\n  path: Array<string | number>,\n  rendererID: number,\n|};\n\ntype CopyElementParams = {|\n  id: number,\n  path: Array<string | number>,\n  rendererID: number,\n|};\n\ntype InspectElementParams = {|\n  id: number,\n  path?: Array<string | number>,\n  rendererID: number,\n|};\n\ntype OverrideHookParams = {|\n  id: number,\n  hookID: number,\n  path: Array<string | number>,\n  rendererID: number,\n  wasForwarded?: boolean,\n  value: any,\n|};\n\ntype SetInParams = {|\n  id: number,\n  path: Array<string | number>,\n  rendererID: number,\n  wasForwarded?: boolean,\n  value: any,\n|};\n\ntype PathType = 'props' | 'hooks' | 'state' | 'context';\n\ntype DeletePathParams = {|\n  type: PathType,\n  hookID?: ?number,\n  id: number,\n  path: Array<string | number>,\n  rendererID: number,\n|};\n\ntype RenamePathParams = {|\n  type: PathType,\n  hookID?: ?number,\n  id: number,\n  oldPath: Array<string | number>,\n  newPath: Array<string | number>,\n  rendererID: number,\n|};\n\ntype OverrideValueAtPathParams = {|\n  type: PathType,\n  hookID?: ?number,\n  id: number,\n  path: Array<string | number>,\n  rendererID: number,\n  value: any,\n|};\n\ntype OverrideSuspenseParams = {|\n  id: number,\n  rendererID: number,\n  forceFallback: boolean,\n|};\n\ntype PersistedSelection = {|\n  rendererID: number,\n  path: Array<PathFrame>,\n|};\n\nexport default class Agent extends EventEmitter<{|\n  hideNativeHighlight: [],\n  showNativeHighlight: [NativeType],\n  shutdown: [],\n  traceUpdates: [Set<NativeType>],\n|}> {\n  _bridge: BackendBridge;\n  _isProfiling: boolean = false;\n  _recordChangeDescriptions: boolean = false;\n  _rendererInterfaces: {[key: RendererID]: RendererInterface, ...} = {};\n  _persistedSelection: PersistedSelection | null = null;\n  _persistedSelectionMatch: PathMatch | null = null;\n  _traceUpdatesEnabled: boolean = false;\n\n  constructor(bridge: BackendBridge) {\n    super();\n\n    if (\n      sessionStorageGetItem(SESSION_STORAGE_RELOAD_AND_PROFILE_KEY) === 'true'\n    ) {\n      this._recordChangeDescriptions =\n        sessionStorageGetItem(\n          SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY,\n        ) === 'true';\n      this._isProfiling = true;\n\n      sessionStorageRemoveItem(SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY);\n      sessionStorageRemoveItem(SESSION_STORAGE_RELOAD_AND_PROFILE_KEY);\n    }\n\n    const persistedSelectionString = sessionStorageGetItem(\n      SESSION_STORAGE_LAST_SELECTION_KEY,\n    );\n    if (persistedSelectionString != null) {\n      this._persistedSelection = JSON.parse(persistedSelectionString);\n    }\n\n    this._bridge = bridge;\n\n    bridge.addListener('copyElementPath', this.copyElementPath);\n    bridge.addListener('deletePath', this.deletePath);\n    bridge.addListener('getProfilingData', this.getProfilingData);\n    bridge.addListener('getProfilingStatus', this.getProfilingStatus);\n    bridge.addListener('getOwnersList', this.getOwnersList);\n    bridge.addListener('inspectElement', this.inspectElement);\n    bridge.addListener('logElementToConsole', this.logElementToConsole);\n    bridge.addListener('overrideSuspense', this.overrideSuspense);\n    bridge.addListener('overrideValueAtPath', this.overrideValueAtPath);\n    bridge.addListener('reloadAndProfile', this.reloadAndProfile);\n    bridge.addListener('renamePath', this.renamePath);\n    bridge.addListener('setTraceUpdatesEnabled', this.setTraceUpdatesEnabled);\n    bridge.addListener('startProfiling', this.startProfiling);\n    bridge.addListener('stopProfiling', this.stopProfiling);\n    bridge.addListener('storeAsGlobal', this.storeAsGlobal);\n    bridge.addListener(\n      'syncSelectionFromNativeElementsPanel',\n      this.syncSelectionFromNativeElementsPanel,\n    );\n    bridge.addListener('shutdown', this.shutdown);\n    bridge.addListener(\n      'updateConsolePatchSettings',\n      this.updateConsolePatchSettings,\n    );\n    bridge.addListener('updateComponentFilters', this.updateComponentFilters);\n    bridge.addListener('viewAttributeSource', this.viewAttributeSource);\n    bridge.addListener('viewElementSource', this.viewElementSource);\n\n    // Temporarily support older standalone front-ends sending commands to newer embedded backends.\n    // We do this because React Native embeds the React DevTools backend,\n    // but cannot control which version of the frontend users use.\n    bridge.addListener('overrideContext', this.overrideContext);\n    bridge.addListener('overrideHookState', this.overrideHookState);\n    bridge.addListener('overrideProps', this.overrideProps);\n    bridge.addListener('overrideState', this.overrideState);\n\n    if (this._isProfiling) {\n      bridge.send('profilingStatus', true);\n    }\n\n    // Notify the frontend if the backend supports the Storage API (e.g. localStorage).\n    // If not, features like reload-and-profile will not work correctly and must be disabled.\n    let isBackendStorageAPISupported = false;\n    try {\n      localStorage.getItem('test');\n      isBackendStorageAPISupported = true;\n    } catch (error) {}\n    bridge.send('isBackendStorageAPISupported', isBackendStorageAPISupported);\n\n    setupHighlighter(bridge, this);\n    setupTraceUpdates(this);\n  }\n\n  get rendererInterfaces(): {[key: RendererID]: RendererInterface, ...} {\n    return this._rendererInterfaces;\n  }\n\n  copyElementPath = ({id, path, rendererID}: CopyElementParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.copyElementPath(id, path);\n    }\n  };\n\n  deletePath = ({hookID, id, path, rendererID, type}: DeletePathParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.deletePath(type, id, hookID, path);\n    }\n  };\n\n  getInstanceAndStyle({\n    id,\n    rendererID,\n  }: ElementAndRendererID): InstanceAndStyle | null {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\"`);\n      return null;\n    }\n    return renderer.getInstanceAndStyle(id);\n  }\n\n  getIDForNode(node: Object): number | null {\n    for (const rendererID in this._rendererInterfaces) {\n      const renderer = ((this._rendererInterfaces[\n        (rendererID: any)\n      ]: any): RendererInterface);\n\n      try {\n        const id = renderer.getFiberIDForNative(node, true);\n        if (id !== null) {\n          return id;\n        }\n      } catch (error) {\n        // Some old React versions might throw if they can't find a match.\n        // If so we should ignore it...\n      }\n    }\n    return null;\n  }\n\n  getProfilingData = ({rendererID}: {|rendererID: RendererID|}) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\"`);\n    }\n\n    this._bridge.send('profilingData', renderer.getProfilingData());\n  };\n\n  getProfilingStatus = () => {\n    this._bridge.send('profilingStatus', this._isProfiling);\n  };\n\n  getOwnersList = ({id, rendererID}: ElementAndRendererID) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      const owners = renderer.getOwnersList(id);\n      this._bridge.send('ownersList', ({id, owners}: OwnersList));\n    }\n  };\n\n  inspectElement = ({id, path, rendererID}: InspectElementParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      this._bridge.send('inspectedElement', renderer.inspectElement(id, path));\n\n      // When user selects an element, stop trying to restore the selection,\n      // and instead remember the current selection for the next reload.\n      if (\n        this._persistedSelectionMatch === null ||\n        this._persistedSelectionMatch.id !== id\n      ) {\n        this._persistedSelection = null;\n        this._persistedSelectionMatch = null;\n        renderer.setTrackedPath(null);\n        this._throttledPersistSelection(rendererID, id);\n      }\n\n      // TODO: If there was a way to change the selected DOM element\n      // in native Elements tab without forcing a switch to it, we'd do it here.\n      // For now, it doesn't seem like there is a way to do that:\n      // https://github.com/bvaughn/react-devtools-experimental/issues/102\n      // (Setting $0 doesn't work, and calling inspect() switches the tab.)\n    }\n  };\n\n  logElementToConsole = ({id, rendererID}: ElementAndRendererID) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.logElementToConsole(id);\n    }\n  };\n\n  overrideSuspense = ({\n    id,\n    rendererID,\n    forceFallback,\n  }: OverrideSuspenseParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.overrideSuspense(id, forceFallback);\n    }\n  };\n\n  overrideValueAtPath = ({\n    hookID,\n    id,\n    path,\n    rendererID,\n    type,\n    value,\n  }: OverrideValueAtPathParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.overrideValueAtPath(type, id, hookID, path, value);\n    }\n  };\n\n  // Temporarily support older standalone front-ends by forwarding the older message types\n  // to the new \"overrideValueAtPath\" command the backend is now listening to.\n  overrideContext = ({\n    id,\n    path,\n    rendererID,\n    wasForwarded,\n    value,\n  }: SetInParams) => {\n    // Don't forward a message that's already been forwarded by the front-end Bridge.\n    // We only need to process the override command once!\n    if (!wasForwarded) {\n      this.overrideValueAtPath({\n        id,\n        path,\n        rendererID,\n        type: 'context',\n        value,\n      });\n    }\n  };\n\n  // Temporarily support older standalone front-ends by forwarding the older message types\n  // to the new \"overrideValueAtPath\" command the backend is now listening to.\n  overrideHookState = ({\n    id,\n    hookID,\n    path,\n    rendererID,\n    wasForwarded,\n    value,\n  }: OverrideHookParams) => {\n    // Don't forward a message that's already been forwarded by the front-end Bridge.\n    // We only need to process the override command once!\n    if (!wasForwarded) {\n      this.overrideValueAtPath({\n        id,\n        path,\n        rendererID,\n        type: 'hooks',\n        value,\n      });\n    }\n  };\n\n  // Temporarily support older standalone front-ends by forwarding the older message types\n  // to the new \"overrideValueAtPath\" command the backend is now listening to.\n  overrideProps = ({\n    id,\n    path,\n    rendererID,\n    wasForwarded,\n    value,\n  }: SetInParams) => {\n    // Don't forward a message that's already been forwarded by the front-end Bridge.\n    // We only need to process the override command once!\n    if (!wasForwarded) {\n      this.overrideValueAtPath({\n        id,\n        path,\n        rendererID,\n        type: 'props',\n        value,\n      });\n    }\n  };\n\n  // Temporarily support older standalone front-ends by forwarding the older message types\n  // to the new \"overrideValueAtPath\" command the backend is now listening to.\n  overrideState = ({\n    id,\n    path,\n    rendererID,\n    wasForwarded,\n    value,\n  }: SetInParams) => {\n    // Don't forward a message that's already been forwarded by the front-end Bridge.\n    // We only need to process the override command once!\n    if (!wasForwarded) {\n      this.overrideValueAtPath({\n        id,\n        path,\n        rendererID,\n        type: 'state',\n        value,\n      });\n    }\n  };\n\n  reloadAndProfile = (recordChangeDescriptions: boolean) => {\n    sessionStorageSetItem(SESSION_STORAGE_RELOAD_AND_PROFILE_KEY, 'true');\n    sessionStorageSetItem(\n      SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY,\n      recordChangeDescriptions ? 'true' : 'false',\n    );\n\n    // This code path should only be hit if the shell has explicitly told the Store that it supports profiling.\n    // In that case, the shell must also listen for this specific message to know when it needs to reload the app.\n    // The agent can't do this in a way that is renderer agnostic.\n    this._bridge.send('reloadAppForProfiling');\n  };\n\n  renamePath = ({\n    hookID,\n    id,\n    newPath,\n    oldPath,\n    rendererID,\n    type,\n  }: RenamePathParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.renamePath(type, id, hookID, oldPath, newPath);\n    }\n  };\n\n  selectNode(target: Object): void {\n    const id = this.getIDForNode(target);\n    if (id !== null) {\n      this._bridge.send('selectFiber', id);\n    }\n  }\n\n  setRendererInterface(\n    rendererID: RendererID,\n    rendererInterface: RendererInterface,\n  ) {\n    this._rendererInterfaces[rendererID] = rendererInterface;\n\n    if (this._isProfiling) {\n      rendererInterface.startProfiling(this._recordChangeDescriptions);\n    }\n\n    rendererInterface.setTraceUpdatesEnabled(this._traceUpdatesEnabled);\n\n    // When the renderer is attached, we need to tell it whether\n    // we remember the previous selection that we'd like to restore.\n    // It'll start tracking mounts for matches to the last selection path.\n    const selection = this._persistedSelection;\n    if (selection !== null && selection.rendererID === rendererID) {\n      rendererInterface.setTrackedPath(selection.path);\n    }\n  }\n\n  setTraceUpdatesEnabled = (traceUpdatesEnabled: boolean) => {\n    this._traceUpdatesEnabled = traceUpdatesEnabled;\n\n    setTraceUpdatesEnabled(traceUpdatesEnabled);\n\n    for (const rendererID in this._rendererInterfaces) {\n      const renderer = ((this._rendererInterfaces[\n        (rendererID: any)\n      ]: any): RendererInterface);\n      renderer.setTraceUpdatesEnabled(traceUpdatesEnabled);\n    }\n  };\n\n  syncSelectionFromNativeElementsPanel = () => {\n    const target = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;\n    if (target == null) {\n      return;\n    }\n    this.selectNode(target);\n  };\n\n  shutdown = () => {\n    // Clean up the overlay if visible, and associated events.\n    this.emit('shutdown');\n  };\n\n  startProfiling = (recordChangeDescriptions: boolean) => {\n    this._recordChangeDescriptions = recordChangeDescriptions;\n    this._isProfiling = true;\n    for (const rendererID in this._rendererInterfaces) {\n      const renderer = ((this._rendererInterfaces[\n        (rendererID: any)\n      ]: any): RendererInterface);\n      renderer.startProfiling(recordChangeDescriptions);\n    }\n    this._bridge.send('profilingStatus', this._isProfiling);\n  };\n\n  stopProfiling = () => {\n    this._isProfiling = false;\n    this._recordChangeDescriptions = false;\n    for (const rendererID in this._rendererInterfaces) {\n      const renderer = ((this._rendererInterfaces[\n        (rendererID: any)\n      ]: any): RendererInterface);\n      renderer.stopProfiling();\n    }\n    this._bridge.send('profilingStatus', this._isProfiling);\n  };\n\n  storeAsGlobal = ({count, id, path, rendererID}: StoreAsGlobalParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.storeAsGlobal(id, path, count);\n    }\n  };\n\n  updateConsolePatchSettings = ({\n    appendComponentStack,\n    breakOnConsoleErrors,\n  }: {|\n    appendComponentStack: boolean,\n    breakOnConsoleErrors: boolean,\n  |}) => {\n    // If the frontend preference has change,\n    // or in the case of React Native- if the backend is just finding out the preference-\n    // then install or uninstall the console overrides.\n    // It's safe to call these methods multiple times, so we don't need to worry about that.\n    if (appendComponentStack || breakOnConsoleErrors) {\n      patchConsole({appendComponentStack, breakOnConsoleErrors});\n    } else {\n      unpatchConsole();\n    }\n  };\n\n  updateComponentFilters = (componentFilters: Array<ComponentFilter>) => {\n    for (const rendererID in this._rendererInterfaces) {\n      const renderer = ((this._rendererInterfaces[\n        (rendererID: any)\n      ]: any): RendererInterface);\n      renderer.updateComponentFilters(componentFilters);\n    }\n  };\n\n  viewAttributeSource = ({id, path, rendererID}: CopyElementParams) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.prepareViewAttributeSource(id, path);\n    }\n  };\n\n  viewElementSource = ({id, rendererID}: ElementAndRendererID) => {\n    const renderer = this._rendererInterfaces[rendererID];\n    if (renderer == null) {\n      console.warn(`Invalid renderer id \"${rendererID}\" for element \"${id}\"`);\n    } else {\n      renderer.prepareViewElementSource(id);\n    }\n  };\n\n  onTraceUpdates = (nodes: Set<NativeType>) => {\n    this.emit('traceUpdates', nodes);\n  };\n\n  onHookOperations = (operations: Array<number>) => {\n    if (__DEBUG__) {\n      debug('onHookOperations', operations);\n    }\n\n    // TODO:\n    // The chrome.runtime does not currently support transferables; it forces JSON serialization.\n    // See bug https://bugs.chromium.org/p/chromium/issues/detail?id=927134\n    //\n    // Regarding transferables, the postMessage doc states:\n    // If the ownership of an object is transferred, it becomes unusable (neutered)\n    // in the context it was sent from and becomes available only to the worker it was sent to.\n    //\n    // Even though Chrome is eventually JSON serializing the array buffer,\n    // using the transferable approach also sometimes causes it to throw:\n    //   DOMException: Failed to execute 'postMessage' on 'Window': ArrayBuffer at index 0 is already neutered.\n    //\n    // See bug https://github.com/bvaughn/react-devtools-experimental/issues/25\n    //\n    // The Store has a fallback in place that parses the message as JSON if the type isn't an array.\n    // For now the simplest fix seems to be to not transfer the array.\n    // This will negatively impact performance on Firefox so it's unfortunate,\n    // but until we're able to fix the Chrome error mentioned above, it seems necessary.\n    //\n    // this._bridge.send('operations', operations, [operations.buffer]);\n    this._bridge.send('operations', operations);\n\n    if (this._persistedSelection !== null) {\n      const rendererID = operations[0];\n      if (this._persistedSelection.rendererID === rendererID) {\n        // Check if we can select a deeper match for the persisted selection.\n        const renderer = this._rendererInterfaces[rendererID];\n        if (renderer == null) {\n          console.warn(`Invalid renderer id \"${rendererID}\"`);\n        } else {\n          const prevMatch = this._persistedSelectionMatch;\n          const nextMatch = renderer.getBestMatchForTrackedPath();\n          this._persistedSelectionMatch = nextMatch;\n          const prevMatchID = prevMatch !== null ? prevMatch.id : null;\n          const nextMatchID = nextMatch !== null ? nextMatch.id : null;\n          if (prevMatchID !== nextMatchID) {\n            if (nextMatchID !== null) {\n              // We moved forward, unlocking a deeper node.\n              this._bridge.send('selectFiber', nextMatchID);\n            }\n          }\n          if (nextMatch !== null && nextMatch.isFullMatch) {\n            // We've just unlocked the innermost selected node.\n            // There's no point tracking it further.\n            this._persistedSelection = null;\n            this._persistedSelectionMatch = null;\n            renderer.setTrackedPath(null);\n          }\n        }\n      }\n    }\n  };\n\n  onUnsupportedRenderer(rendererID: number) {\n    this._bridge.send('unsupportedRendererVersion', rendererID);\n  }\n\n  _throttledPersistSelection = throttle((rendererID: number, id: number) => {\n    // This is throttled, so both renderer and selected ID\n    // might not be available by the time we read them.\n    // This is why we need the defensive checks here.\n    const renderer = this._rendererInterfaces[rendererID];\n    const path = renderer != null ? renderer.getPathForElement(id) : null;\n    if (path !== null) {\n      sessionStorageSetItem(\n        SESSION_STORAGE_LAST_SELECTION_KEY,\n        JSON.stringify(({rendererID, path}: PersistedSelection)),\n      );\n    } else {\n      sessionStorageRemoveItem(SESSION_STORAGE_LAST_SELECTION_KEY);\n    }\n  }, 1000);\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport EventEmitter from './events';\n\nimport type {ComponentFilter, Wall} from './types';\nimport type {\n  InspectedElementPayload,\n  OwnersList,\n  ProfilingDataBackend,\n  RendererID,\n} from 'react-devtools-shared/src/backend/types';\nimport type {StyleAndLayout as StyleAndLayoutPayload} from 'react-devtools-shared/src/backend/NativeStyleEditor/types';\n\nconst BATCH_DURATION = 100;\n\ntype ElementAndRendererID = {|id: number, rendererID: RendererID|};\n\ntype Message = {|\n  event: string,\n  payload: any,\n|};\n\ntype HighlightElementInDOM = {|\n  ...ElementAndRendererID,\n  displayName: string | null,\n  hideAfterTimeout: boolean,\n  openNativeElementsPanel: boolean,\n  scrollIntoView: boolean,\n|};\n\ntype OverrideValue = {|\n  ...ElementAndRendererID,\n  path: Array<string | number>,\n  wasForwarded?: boolean,\n  value: any,\n|};\n\ntype OverrideHookState = {|\n  ...OverrideValue,\n  hookID: number,\n|};\n\ntype PathType = 'props' | 'hooks' | 'state' | 'context';\n\ntype DeletePath = {|\n  ...ElementAndRendererID,\n  type: PathType,\n  hookID?: ?number,\n  path: Array<string | number>,\n|};\n\ntype RenamePath = {|\n  ...ElementAndRendererID,\n  type: PathType,\n  hookID?: ?number,\n  oldPath: Array<string | number>,\n  newPath: Array<string | number>,\n|};\n\ntype OverrideValueAtPath = {|\n  ...ElementAndRendererID,\n  type: PathType,\n  hookID?: ?number,\n  path: Array<string | number>,\n  value: any,\n|};\n\ntype OverrideSuspense = {|\n  ...ElementAndRendererID,\n  forceFallback: boolean,\n|};\n\ntype CopyElementPathParams = {|\n  ...ElementAndRendererID,\n  path: Array<string | number>,\n|};\n\ntype ViewAttributeSourceParams = {|\n  ...ElementAndRendererID,\n  path: Array<string | number>,\n|};\n\ntype InspectElementParams = {|\n  ...ElementAndRendererID,\n  path?: Array<string | number>,\n|};\n\ntype StoreAsGlobalParams = {|\n  ...ElementAndRendererID,\n  count: number,\n  path: Array<string | number>,\n|};\n\ntype NativeStyleEditor_RenameAttributeParams = {|\n  ...ElementAndRendererID,\n  oldName: string,\n  newName: string,\n  value: string,\n|};\n\ntype NativeStyleEditor_SetValueParams = {|\n  ...ElementAndRendererID,\n  name: string,\n  value: string,\n|};\n\ntype UpdateConsolePatchSettingsParams = {|\n  appendComponentStack: boolean,\n  breakOnConsoleErrors: boolean,\n|};\n\ntype BackendEvents = {|\n  extensionBackendInitialized: [],\n  inspectedElement: [InspectedElementPayload],\n  isBackendStorageAPISupported: [boolean],\n  operations: [Array<number>],\n  ownersList: [OwnersList],\n  overrideComponentFilters: [Array<ComponentFilter>],\n  profilingData: [ProfilingDataBackend],\n  profilingStatus: [boolean],\n  reloadAppForProfiling: [],\n  selectFiber: [number],\n  shutdown: [],\n  stopInspectingNative: [boolean],\n  syncSelectionFromNativeElementsPanel: [],\n  syncSelectionToNativeElementsPanel: [],\n  unsupportedRendererVersion: [RendererID],\n\n  // React Native style editor plug-in.\n  isNativeStyleEditorSupported: [\n    {|isSupported: boolean, validAttributes: ?$ReadOnlyArray<string>|},\n  ],\n  NativeStyleEditor_styleAndLayout: [StyleAndLayoutPayload],\n|};\n\ntype FrontendEvents = {|\n  clearNativeElementHighlight: [],\n  copyElementPath: [CopyElementPathParams],\n  deletePath: [DeletePath],\n  getOwnersList: [ElementAndRendererID],\n  getProfilingData: [{|rendererID: RendererID|}],\n  getProfilingStatus: [],\n  highlightNativeElement: [HighlightElementInDOM],\n  inspectElement: [InspectElementParams],\n  logElementToConsole: [ElementAndRendererID],\n  overrideSuspense: [OverrideSuspense],\n  overrideValueAtPath: [OverrideValueAtPath],\n  profilingData: [ProfilingDataBackend],\n  reloadAndProfile: [boolean],\n  renamePath: [RenamePath],\n  selectFiber: [number],\n  setTraceUpdatesEnabled: [boolean],\n  shutdown: [],\n  startInspectingNative: [],\n  startProfiling: [boolean],\n  stopInspectingNative: [boolean],\n  stopProfiling: [],\n  storeAsGlobal: [StoreAsGlobalParams],\n  updateComponentFilters: [Array<ComponentFilter>],\n  updateConsolePatchSettings: [UpdateConsolePatchSettingsParams],\n  viewAttributeSource: [ViewAttributeSourceParams],\n  viewElementSource: [ElementAndRendererID],\n\n  // React Native style editor plug-in.\n  NativeStyleEditor_measure: [ElementAndRendererID],\n  NativeStyleEditor_renameAttribute: [NativeStyleEditor_RenameAttributeParams],\n  NativeStyleEditor_setValue: [NativeStyleEditor_SetValueParams],\n\n  // Temporarily support newer standalone front-ends sending commands to older embedded backends.\n  // We do this because React Native embeds the React DevTools backend,\n  // but cannot control which version of the frontend users use.\n  //\n  // Note that nothing in the newer backend actually listens to these events,\n  // but the new frontend still dispatches them (in case older backends are listening to them instead).\n  //\n  // Note that this approach does no support the combination of a newer backend with an older frontend.\n  // It would be more work to suppot both approaches (and not run handlers twice)\n  // so I chose to support the more likely/common scenario (and the one more difficult for an end user to \"fix\").\n  overrideContext: [OverrideValue],\n  overrideHookState: [OverrideHookState],\n  overrideProps: [OverrideValue],\n  overrideState: [OverrideValue],\n|};\n\nclass Bridge<\n  OutgoingEvents: Object,\n  IncomingEvents: Object,\n> extends EventEmitter<{|\n  ...IncomingEvents,\n  ...OutgoingEvents,\n|}> {\n  _isShutdown: boolean = false;\n  _messageQueue: Array<any> = [];\n  _timeoutID: TimeoutID | null = null;\n  _wall: Wall;\n  _wallUnlisten: Function | null = null;\n\n  constructor(wall: Wall) {\n    super();\n\n    this._wall = wall;\n\n    this._wallUnlisten =\n      wall.listen((message: Message) => {\n        (this: any).emit(message.event, message.payload);\n      }) || null;\n\n    // Temporarily support older standalone front-ends sending commands to newer embedded backends.\n    // We do this because React Native embeds the React DevTools backend,\n    // but cannot control which version of the frontend users use.\n    this.addListener('overrideValueAtPath', this.overrideValueAtPath);\n  }\n\n  // Listening directly to the wall isn't advised.\n  // It can be used to listen for legacy (v3) messages (since they use a different format).\n  get wall(): Wall {\n    return this._wall;\n  }\n\n  send<EventName: $Keys<OutgoingEvents>>(\n    event: EventName,\n    ...payload: $ElementType<OutgoingEvents, EventName>\n  ) {\n    if (this._isShutdown) {\n      console.warn(\n        `Cannot send message \"${event}\" through a Bridge that has been shutdown.`,\n      );\n      return;\n    }\n\n    // When we receive a message:\n    // - we add it to our queue of messages to be sent\n    // - if there hasn't been a message recently, we set a timer for 0 ms in\n    //   the future, allowing all messages created in the same tick to be sent\n    //   together\n    // - if there *has* been a message flushed in the last BATCH_DURATION ms\n    //   (or we're waiting for our setTimeout-0 to fire), then _timeoutID will\n    //   be set, and we'll simply add to the queue and wait for that\n    this._messageQueue.push(event, payload);\n    if (!this._timeoutID) {\n      this._timeoutID = setTimeout(this._flush, 0);\n    }\n  }\n\n  shutdown() {\n    if (this._isShutdown) {\n      console.warn('Bridge was already shutdown.');\n      return;\n    }\n\n    // Queue the shutdown outgoing message for subscribers.\n    this.send('shutdown');\n\n    // Mark this bridge as destroyed, i.e. disable its public API.\n    this._isShutdown = true;\n\n    // Disable the API inherited from EventEmitter that can add more listeners and send more messages.\n    // $FlowFixMe This property is not writable.\n    this.addListener = function() {};\n    // $FlowFixMe This property is not writable.\n    this.emit = function() {};\n    // NOTE: There's also EventEmitter API like `on` and `prependListener` that we didn't add to our Flow type of EventEmitter.\n\n    // Unsubscribe this bridge incoming message listeners to be sure, and so they don't have to do that.\n    this.removeAllListeners();\n\n    // Stop accepting and emitting incoming messages from the wall.\n    const wallUnlisten = this._wallUnlisten;\n    if (wallUnlisten) {\n      wallUnlisten();\n    }\n\n    // Synchronously flush all queued outgoing messages.\n    // At this step the subscribers' code may run in this call stack.\n    do {\n      this._flush();\n    } while (this._messageQueue.length);\n\n    // Make sure once again that there is no dangling timer.\n    if (this._timeoutID !== null) {\n      clearTimeout(this._timeoutID);\n      this._timeoutID = null;\n    }\n  }\n\n  _flush = () => {\n    // This method is used after the bridge is marked as destroyed in shutdown sequence,\n    // so we do not bail out if the bridge marked as destroyed.\n    // It is a private method that the bridge ensures is only called at the right times.\n\n    if (this._timeoutID !== null) {\n      clearTimeout(this._timeoutID);\n      this._timeoutID = null;\n    }\n\n    if (this._messageQueue.length) {\n      for (let i = 0; i < this._messageQueue.length; i += 2) {\n        this._wall.send(this._messageQueue[i], ...this._messageQueue[i + 1]);\n      }\n      this._messageQueue.length = 0;\n\n      // Check again for queued messages in BATCH_DURATION ms. This will keep\n      // flushing in a loop as long as messages continue to be added. Once no\n      // more are, the timer expires.\n      this._timeoutID = setTimeout(this._flush, BATCH_DURATION);\n    }\n  };\n\n  // Temporarily support older standalone backends by forwarding \"overrideValueAtPath\" commands\n  // to the older message types they may be listening to.\n  overrideValueAtPath = ({\n    id,\n    path,\n    rendererID,\n    type,\n    value,\n  }: OverrideValueAtPath) => {\n    switch (type) {\n      case 'context':\n        this.send('overrideContext', {\n          id,\n          path,\n          rendererID,\n          wasForwarded: true,\n          value,\n        });\n        break;\n      case 'hooks':\n        this.send('overrideHookState', {\n          id,\n          path,\n          rendererID,\n          wasForwarded: true,\n          value,\n        });\n        break;\n      case 'props':\n        this.send('overrideProps', {\n          id,\n          path,\n          rendererID,\n          wasForwarded: true,\n          value,\n        });\n        break;\n      case 'state':\n        this.send('overrideState', {\n          id,\n          path,\n          rendererID,\n          wasForwarded: true,\n          value,\n        });\n        break;\n    }\n  };\n}\n\nexport type BackendBridge = Bridge<BackendEvents, FrontendEvents>;\nexport type FrontendBridge = Bridge<FrontendEvents, BackendEvents>;\n\nexport default Bridge;\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport type {InternalInstance} from './renderer';\n\nexport function decorate(object: Object, attr: string, fn: Function): Function {\n  const old = object[attr];\n  object[attr] = function(instance: InternalInstance) {\n    return fn.call(this, old, arguments);\n  };\n  return old;\n}\n\nexport function decorateMany(\n  source: Object,\n  fns: {[attr: string]: Function, ...},\n): Object {\n  const olds = {};\n  for (const name in fns) {\n    olds[name] = decorate(source, name, fns[name]);\n  }\n  return olds;\n}\n\nexport function restoreMany(source: Object, olds: Object): void {\n  for (const name in olds) {\n    source[name] = olds[name];\n  }\n}\n\nexport function forceUpdate(instance: InternalInstance): void {\n  if (typeof instance.forceUpdate === 'function') {\n    instance.forceUpdate();\n  } else if (\n    instance.updater != null &&\n    typeof instance.updater.enqueueForceUpdate === 'function'\n  ) {\n    instance.updater.enqueueForceUpdate(this, () => {}, 'forceUpdate');\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport {\n  ElementTypeClass,\n  ElementTypeFunction,\n  ElementTypeRoot,\n  ElementTypeHostComponent,\n  ElementTypeOtherOrUnknown,\n} from 'react-devtools-shared/src/types';\nimport {getUID, utfEncodeString, printOperationsArray} from '../../utils';\nimport {\n  cleanForBridge,\n  copyToClipboard,\n  copyWithDelete,\n  copyWithRename,\n  copyWithSet,\n} from '../utils';\nimport {\n  deletePathInObject,\n  getDisplayName,\n  getInObject,\n  renamePathInObject,\n  setInObject,\n} from 'react-devtools-shared/src/utils';\nimport {\n  __DEBUG__,\n  TREE_OPERATION_ADD,\n  TREE_OPERATION_REMOVE,\n  TREE_OPERATION_REORDER_CHILDREN,\n} from '../../constants';\nimport {decorateMany, forceUpdate, restoreMany} from './utils';\n\nimport type {\n  DevToolsHook,\n  GetFiberIDForNative,\n  InspectedElementPayload,\n  InstanceAndStyle,\n  NativeType,\n  PathFrame,\n  PathMatch,\n  RendererInterface,\n} from '../types';\nimport type {\n  ComponentFilter,\n  ElementType,\n} from 'react-devtools-shared/src/types';\nimport type {Owner, InspectedElement} from '../types';\n\nexport type InternalInstance = Object;\ntype LegacyRenderer = Object;\n\nfunction getData(internalInstance: InternalInstance) {\n  let displayName = null;\n  let key = null;\n\n  // != used deliberately here to catch undefined and null\n  if (internalInstance._currentElement != null) {\n    if (internalInstance._currentElement.key) {\n      key = '' + internalInstance._currentElement.key;\n    }\n\n    const elementType = internalInstance._currentElement.type;\n    if (typeof elementType === 'string') {\n      displayName = elementType;\n    } else if (typeof elementType === 'function') {\n      displayName = getDisplayName(elementType);\n    }\n  }\n\n  return {\n    displayName,\n    key,\n  };\n}\n\nfunction getElementType(internalInstance: InternalInstance): ElementType {\n  // != used deliberately here to catch undefined and null\n  if (internalInstance._currentElement != null) {\n    const elementType = internalInstance._currentElement.type;\n    if (typeof elementType === 'function') {\n      const publicInstance = internalInstance.getPublicInstance();\n      if (publicInstance !== null) {\n        return ElementTypeClass;\n      } else {\n        return ElementTypeFunction;\n      }\n    } else if (typeof elementType === 'string') {\n      return ElementTypeHostComponent;\n    }\n  }\n  return ElementTypeOtherOrUnknown;\n}\n\nfunction getChildren(internalInstance: Object): Array<any> {\n  const children = [];\n\n  // If the parent is a native node without rendered children, but with\n  // multiple string children, then the `element` that gets passed in here is\n  // a plain value -- a string or number.\n  if (typeof internalInstance !== 'object') {\n    // No children\n  } else if (\n    internalInstance._currentElement === null ||\n    internalInstance._currentElement === false\n  ) {\n    // No children\n  } else if (internalInstance._renderedComponent) {\n    const child = internalInstance._renderedComponent;\n    if (getElementType(child) !== ElementTypeOtherOrUnknown) {\n      children.push(child);\n    }\n  } else if (internalInstance._renderedChildren) {\n    const renderedChildren = internalInstance._renderedChildren;\n    for (const name in renderedChildren) {\n      const child = renderedChildren[name];\n      if (getElementType(child) !== ElementTypeOtherOrUnknown) {\n        children.push(child);\n      }\n    }\n  }\n  // Note: we skip the case where children are just strings or numbers\n  // because the new DevTools skips over host text nodes anyway.\n  return children;\n}\n\nexport function attach(\n  hook: DevToolsHook,\n  rendererID: number,\n  renderer: LegacyRenderer,\n  global: Object,\n): RendererInterface {\n  const idToInternalInstanceMap: Map<number, InternalInstance> = new Map();\n  const internalInstanceToIDMap: WeakMap<\n    InternalInstance,\n    number,\n  > = new WeakMap();\n  const internalInstanceToRootIDMap: WeakMap<\n    InternalInstance,\n    number,\n  > = new WeakMap();\n\n  let getInternalIDForNative: GetFiberIDForNative = ((null: any): GetFiberIDForNative);\n  let findNativeNodeForInternalID: (id: number) => ?NativeType;\n\n  if (renderer.ComponentTree) {\n    getInternalIDForNative = (node, findNearestUnfilteredAncestor) => {\n      const internalInstance = renderer.ComponentTree.getClosestInstanceFromNode(\n        node,\n      );\n      return internalInstanceToIDMap.get(internalInstance) || null;\n    };\n    findNativeNodeForInternalID = (id: number) => {\n      const internalInstance = idToInternalInstanceMap.get(id);\n      return renderer.ComponentTree.getNodeFromInstance(internalInstance);\n    };\n  } else if (renderer.Mount.getID && renderer.Mount.getNode) {\n    getInternalIDForNative = (node, findNearestUnfilteredAncestor) => {\n      // Not implemented.\n      return null;\n    };\n    findNativeNodeForInternalID = (id: number) => {\n      // Not implemented.\n      return null;\n    };\n  }\n\n  function getDisplayNameForFiberID(id: number): string | null {\n    const internalInstance = idToInternalInstanceMap.get(id);\n    return internalInstance ? getData(internalInstance).displayName : null;\n  }\n\n  function getID(internalInstance: InternalInstance): number {\n    if (typeof internalInstance !== 'object' || internalInstance === null) {\n      throw new Error('Invalid internal instance: ' + internalInstance);\n    }\n    if (!internalInstanceToIDMap.has(internalInstance)) {\n      const id = getUID();\n      internalInstanceToIDMap.set(internalInstance, id);\n      idToInternalInstanceMap.set(id, internalInstance);\n    }\n    return ((internalInstanceToIDMap.get(internalInstance): any): number);\n  }\n\n  function areEqualArrays(a, b) {\n    if (a.length !== b.length) {\n      return false;\n    }\n    for (let i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // This is shared mutable state that lets us keep track of where we are.\n  let parentIDStack = [];\n\n  let oldReconcilerMethods = null;\n  if (renderer.Reconciler) {\n    // React 15\n    oldReconcilerMethods = decorateMany(renderer.Reconciler, {\n      mountComponent(fn, args) {\n        const internalInstance = args[0];\n        const hostContainerInfo = args[3];\n        if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {\n          return fn.apply(this, args);\n        }\n        if (hostContainerInfo._topLevelWrapper === undefined) {\n          // SSR\n          return fn.apply(this, args);\n        }\n\n        const id = getID(internalInstance);\n        // Push the operation.\n        const parentID =\n          parentIDStack.length > 0\n            ? parentIDStack[parentIDStack.length - 1]\n            : 0;\n        recordMount(internalInstance, id, parentID);\n        parentIDStack.push(id);\n\n        // Remember the root.\n        internalInstanceToRootIDMap.set(\n          internalInstance,\n          getID(hostContainerInfo._topLevelWrapper),\n        );\n\n        try {\n          const result = fn.apply(this, args);\n          parentIDStack.pop();\n          return result;\n        } catch (err) {\n          parentIDStack = [];\n          throw err;\n        } finally {\n          if (parentIDStack.length === 0) {\n            const rootID = internalInstanceToRootIDMap.get(internalInstance);\n            if (rootID === undefined) {\n              throw new Error('Expected to find root ID.');\n            }\n            flushPendingEvents(rootID);\n          }\n        }\n      },\n      performUpdateIfNecessary(fn, args) {\n        const internalInstance = args[0];\n        if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {\n          return fn.apply(this, args);\n        }\n\n        const id = getID(internalInstance);\n        parentIDStack.push(id);\n\n        const prevChildren = getChildren(internalInstance);\n        try {\n          const result = fn.apply(this, args);\n\n          const nextChildren = getChildren(internalInstance);\n          if (!areEqualArrays(prevChildren, nextChildren)) {\n            // Push the operation\n            recordReorder(internalInstance, id, nextChildren);\n          }\n\n          parentIDStack.pop();\n          return result;\n        } catch (err) {\n          parentIDStack = [];\n          throw err;\n        } finally {\n          if (parentIDStack.length === 0) {\n            const rootID = internalInstanceToRootIDMap.get(internalInstance);\n            if (rootID === undefined) {\n              throw new Error('Expected to find root ID.');\n            }\n            flushPendingEvents(rootID);\n          }\n        }\n      },\n      receiveComponent(fn, args) {\n        const internalInstance = args[0];\n        if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {\n          return fn.apply(this, args);\n        }\n\n        const id = getID(internalInstance);\n        parentIDStack.push(id);\n\n        const prevChildren = getChildren(internalInstance);\n        try {\n          const result = fn.apply(this, args);\n\n          const nextChildren = getChildren(internalInstance);\n          if (!areEqualArrays(prevChildren, nextChildren)) {\n            // Push the operation\n            recordReorder(internalInstance, id, nextChildren);\n          }\n\n          parentIDStack.pop();\n          return result;\n        } catch (err) {\n          parentIDStack = [];\n          throw err;\n        } finally {\n          if (parentIDStack.length === 0) {\n            const rootID = internalInstanceToRootIDMap.get(internalInstance);\n            if (rootID === undefined) {\n              throw new Error('Expected to find root ID.');\n            }\n            flushPendingEvents(rootID);\n          }\n        }\n      },\n      unmountComponent(fn, args) {\n        const internalInstance = args[0];\n        if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {\n          return fn.apply(this, args);\n        }\n\n        const id = getID(internalInstance);\n        parentIDStack.push(id);\n        try {\n          const result = fn.apply(this, args);\n          parentIDStack.pop();\n\n          // Push the operation.\n          recordUnmount(internalInstance, id);\n\n          return result;\n        } catch (err) {\n          parentIDStack = [];\n          throw err;\n        } finally {\n          if (parentIDStack.length === 0) {\n            const rootID = internalInstanceToRootIDMap.get(internalInstance);\n            if (rootID === undefined) {\n              throw new Error('Expected to find root ID.');\n            }\n            flushPendingEvents(rootID);\n          }\n        }\n      },\n    });\n  }\n\n  function cleanup() {\n    if (oldReconcilerMethods !== null) {\n      if (renderer.Component) {\n        restoreMany(renderer.Component.Mixin, oldReconcilerMethods);\n      } else {\n        restoreMany(renderer.Reconciler, oldReconcilerMethods);\n      }\n    }\n    oldReconcilerMethods = null;\n  }\n\n  function recordMount(\n    internalInstance: InternalInstance,\n    id: number,\n    parentID: number,\n  ) {\n    const isRoot = parentID === 0;\n\n    if (__DEBUG__) {\n      console.log(\n        '%crecordMount()',\n        'color: green; font-weight: bold;',\n        id,\n        getData(internalInstance).displayName,\n      );\n    }\n\n    if (isRoot) {\n      // TODO Is this right? For all versions?\n      const hasOwnerMetadata =\n        internalInstance._currentElement != null &&\n        internalInstance._currentElement._owner != null;\n\n      pushOperation(TREE_OPERATION_ADD);\n      pushOperation(id);\n      pushOperation(ElementTypeRoot);\n      pushOperation(0); // isProfilingSupported?\n      pushOperation(hasOwnerMetadata ? 1 : 0);\n    } else {\n      const type = getElementType(internalInstance);\n      const {displayName, key} = getData(internalInstance);\n\n      const ownerID =\n        internalInstance._currentElement != null &&\n        internalInstance._currentElement._owner != null\n          ? getID(internalInstance._currentElement._owner)\n          : 0;\n\n      const displayNameStringID = getStringID(displayName);\n      const keyStringID = getStringID(key);\n      pushOperation(TREE_OPERATION_ADD);\n      pushOperation(id);\n      pushOperation(type);\n      pushOperation(parentID);\n      pushOperation(ownerID);\n      pushOperation(displayNameStringID);\n      pushOperation(keyStringID);\n    }\n  }\n\n  function recordReorder(\n    internalInstance: InternalInstance,\n    id: number,\n    nextChildren: Array<InternalInstance>,\n  ) {\n    pushOperation(TREE_OPERATION_REORDER_CHILDREN);\n    pushOperation(id);\n    const nextChildIDs = nextChildren.map(getID);\n    pushOperation(nextChildIDs.length);\n    for (let i = 0; i < nextChildIDs.length; i++) {\n      pushOperation(nextChildIDs[i]);\n    }\n  }\n\n  function recordUnmount(internalInstance: InternalInstance, id: number) {\n    pendingUnmountedIDs.push(id);\n    idToInternalInstanceMap.delete(id);\n  }\n\n  function crawlAndRecordInitialMounts(\n    id: number,\n    parentID: number,\n    rootID: number,\n  ) {\n    if (__DEBUG__) {\n      console.group('crawlAndRecordInitialMounts() id:', id);\n    }\n\n    const internalInstance = idToInternalInstanceMap.get(id);\n    if (internalInstance != null) {\n      internalInstanceToRootIDMap.set(internalInstance, rootID);\n      recordMount(internalInstance, id, parentID);\n      getChildren(internalInstance).forEach(child =>\n        crawlAndRecordInitialMounts(getID(child), id, rootID),\n      );\n    }\n\n    if (__DEBUG__) {\n      console.groupEnd();\n    }\n  }\n\n  function flushInitialOperations() {\n    // Crawl roots though and register any nodes that mounted before we were injected.\n\n    const roots =\n      renderer.Mount._instancesByReactRootID ||\n      renderer.Mount._instancesByContainerID;\n\n    for (const key in roots) {\n      const internalInstance = roots[key];\n      const id = getID(internalInstance);\n      crawlAndRecordInitialMounts(id, 0, id);\n      flushPendingEvents(id);\n    }\n  }\n\n  const pendingOperations: Array<number> = [];\n  const pendingStringTable: Map<string, number> = new Map();\n  let pendingUnmountedIDs: Array<number> = [];\n  let pendingStringTableLength: number = 0;\n  let pendingUnmountedRootID: number | null = null;\n\n  function flushPendingEvents(rootID: number) {\n    if (\n      pendingOperations.length === 0 &&\n      pendingUnmountedIDs.length === 0 &&\n      pendingUnmountedRootID === null\n    ) {\n      return;\n    }\n\n    const numUnmountIDs =\n      pendingUnmountedIDs.length + (pendingUnmountedRootID === null ? 0 : 1);\n\n    const operations = new Array(\n      // Identify which renderer this update is coming from.\n      2 + // [rendererID, rootFiberID]\n      // How big is the string table?\n      1 + // [stringTableLength]\n        // Then goes the actual string table.\n        pendingStringTableLength +\n        // All unmounts are batched in a single message.\n        // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]\n        (numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) +\n        // Mount operations\n        pendingOperations.length,\n    );\n\n    // Identify which renderer this update is coming from.\n    // This enables roots to be mapped to renderers,\n    // Which in turn enables fiber properations, states, and hooks to be inspected.\n    let i = 0;\n    operations[i++] = rendererID;\n    operations[i++] = rootID;\n\n    // Now fill in the string table.\n    // [stringTableLength, str1Length, ...str1, str2Length, ...str2, ...]\n    operations[i++] = pendingStringTableLength;\n    pendingStringTable.forEach((value, key) => {\n      operations[i++] = key.length;\n      const encodedKey = utfEncodeString(key);\n      for (let j = 0; j < encodedKey.length; j++) {\n        operations[i + j] = encodedKey[j];\n      }\n      i += key.length;\n    });\n\n    if (numUnmountIDs > 0) {\n      // All unmounts except roots are batched in a single message.\n      operations[i++] = TREE_OPERATION_REMOVE;\n      // The first number is how many unmounted IDs we're gonna send.\n      operations[i++] = numUnmountIDs;\n      // Fill in the unmounts\n      for (let j = 0; j < pendingUnmountedIDs.length; j++) {\n        operations[i++] = pendingUnmountedIDs[j];\n      }\n      // The root ID should always be unmounted last.\n      if (pendingUnmountedRootID !== null) {\n        operations[i] = pendingUnmountedRootID;\n        i++;\n      }\n    }\n\n    // Fill in the rest of the operations.\n    for (let j = 0; j < pendingOperations.length; j++) {\n      operations[i + j] = pendingOperations[j];\n    }\n    i += pendingOperations.length;\n\n    if (__DEBUG__) {\n      printOperationsArray(operations);\n    }\n\n    // If we've already connected to the frontend, just pass the operations through.\n    hook.emit('operations', operations);\n\n    pendingOperations.length = 0;\n    pendingUnmountedIDs = [];\n    pendingUnmountedRootID = null;\n    pendingStringTable.clear();\n    pendingStringTableLength = 0;\n  }\n\n  function pushOperation(op: number): void {\n    if (__DEV__) {\n      if (!Number.isInteger(op)) {\n        console.error(\n          'pushOperation() was called but the value is not an integer.',\n          op,\n        );\n      }\n    }\n    pendingOperations.push(op);\n  }\n\n  function getStringID(str: string | null): number {\n    if (str === null) {\n      return 0;\n    }\n    const existingID = pendingStringTable.get(str);\n    if (existingID !== undefined) {\n      return existingID;\n    }\n    const stringID = pendingStringTable.size + 1;\n    pendingStringTable.set(str, stringID);\n    // The string table total length needs to account\n    // both for the string length, and for the array item\n    // that contains the length itself. Hence + 1.\n    pendingStringTableLength += str.length + 1;\n    return stringID;\n  }\n\n  let currentlyInspectedElementID: number | null = null;\n  let currentlyInspectedPaths: Object = {};\n\n  // Track the intersection of currently inspected paths,\n  // so that we can send their data along if the element is re-rendered.\n  function mergeInspectedPaths(path: Array<string | number>) {\n    let current = currentlyInspectedPaths;\n    path.forEach(key => {\n      if (!current[key]) {\n        current[key] = {};\n      }\n      current = current[key];\n    });\n  }\n\n  function createIsPathAllowed(key: string) {\n    // This function helps prevent previously-inspected paths from being dehydrated in updates.\n    // This is important to avoid a bad user experience where expanded toggles collapse on update.\n    return function isPathAllowed(path: Array<string | number>): boolean {\n      let current = currentlyInspectedPaths[key];\n      if (!current) {\n        return false;\n      }\n      for (let i = 0; i < path.length; i++) {\n        current = current[path[i]];\n        if (!current) {\n          return false;\n        }\n      }\n      return true;\n    };\n  }\n\n  // Fast path props lookup for React Native style editor.\n  function getInstanceAndStyle(id: number): InstanceAndStyle {\n    let instance = null;\n    let style = null;\n\n    const internalInstance = idToInternalInstanceMap.get(id);\n    if (internalInstance != null) {\n      instance = internalInstance._instance || null;\n\n      const element = internalInstance._currentElement;\n      if (element != null && element.props != null) {\n        style = element.props.style || null;\n      }\n    }\n\n    return {\n      instance,\n      style,\n    };\n  }\n\n  function updateSelectedElement(id: number): void {\n    const internalInstance = idToInternalInstanceMap.get(id);\n    if (internalInstance == null) {\n      console.warn(`Could not find instance with id \"${id}\"`);\n      return;\n    }\n\n    switch (getElementType(internalInstance)) {\n      case ElementTypeClass:\n        global.$r = internalInstance._instance;\n        break;\n      case ElementTypeFunction:\n        const element = internalInstance._currentElement;\n        if (element == null) {\n          console.warn(`Could not find element with id \"${id}\"`);\n          return;\n        }\n\n        global.$r = {\n          props: element.props,\n          type: element.type,\n        };\n        break;\n      default:\n        global.$r = null;\n        break;\n    }\n  }\n\n  function storeAsGlobal(\n    id: number,\n    path: Array<string | number>,\n    count: number,\n  ): void {\n    const inspectedElement = inspectElementRaw(id);\n    if (inspectedElement !== null) {\n      const value = getInObject(inspectedElement, path);\n      const key = `$reactTemp${count}`;\n\n      window[key] = value;\n\n      console.log(key);\n      console.log(value);\n    }\n  }\n\n  function copyElementPath(id: number, path: Array<string | number>): void {\n    const inspectedElement = inspectElementRaw(id);\n    if (inspectedElement !== null) {\n      copyToClipboard(getInObject(inspectedElement, path));\n    }\n  }\n\n  function inspectElement(\n    id: number,\n    path?: Array<string | number>,\n  ): InspectedElementPayload {\n    if (currentlyInspectedElementID !== id) {\n      currentlyInspectedElementID = id;\n      currentlyInspectedPaths = {};\n    }\n\n    const inspectedElement = inspectElementRaw(id);\n    if (inspectedElement === null) {\n      return {\n        id,\n        type: 'not-found',\n      };\n    }\n\n    if (path != null) {\n      mergeInspectedPaths(path);\n    }\n\n    // Any time an inspected element has an update,\n    // we should update the selected $r value as wel.\n    // Do this before dehyration (cleanForBridge).\n    updateSelectedElement(id);\n\n    inspectedElement.context = cleanForBridge(\n      inspectedElement.context,\n      createIsPathAllowed('context'),\n    );\n    inspectedElement.props = cleanForBridge(\n      inspectedElement.props,\n      createIsPathAllowed('props'),\n    );\n    inspectedElement.state = cleanForBridge(\n      inspectedElement.state,\n      createIsPathAllowed('state'),\n    );\n\n    return {\n      id,\n      type: 'full-data',\n      value: inspectedElement,\n    };\n  }\n\n  function inspectElementRaw(id: number): InspectedElement | null {\n    const internalInstance = idToInternalInstanceMap.get(id);\n\n    if (internalInstance == null) {\n      return null;\n    }\n\n    const {displayName, key} = getData(internalInstance);\n    const type = getElementType(internalInstance);\n\n    let context = null;\n    let owners = null;\n    let props = null;\n    let state = null;\n    let source = null;\n\n    const element = internalInstance._currentElement;\n    if (element !== null) {\n      props = element.props;\n      source = element._source != null ? element._source : null;\n\n      let owner = element._owner;\n      if (owner) {\n        owners = [];\n        while (owner != null) {\n          owners.push({\n            displayName: getData(owner).displayName || 'Unknown',\n            id: getID(owner),\n            type: getElementType(owner),\n          });\n          if (owner._currentElement) {\n            owner = owner._currentElement._owner;\n          }\n        }\n      }\n    }\n\n    const publicInstance = internalInstance._instance;\n    if (publicInstance != null) {\n      context = publicInstance.context || null;\n      state = publicInstance.state || null;\n    }\n\n    return {\n      id,\n\n      // Does the current renderer support editable hooks and function props?\n      canEditHooks: false,\n      canEditFunctionProps: false,\n\n      // Does the current renderer support advanced editing interface?\n      canEditHooksAndDeletePaths: false,\n      canEditHooksAndRenamePaths: false,\n      canEditFunctionPropsDeletePaths: false,\n      canEditFunctionPropsRenamePaths: false,\n\n      // Suspense did not exist in legacy versions\n      canToggleSuspense: false,\n\n      // Can view component source location.\n      canViewSource: type === ElementTypeClass || type === ElementTypeFunction,\n\n      // Only legacy context exists in legacy versions.\n      hasLegacyContext: true,\n\n      displayName: displayName,\n\n      type: type,\n\n      key: key != null ? key : null,\n\n      // Inspectable properties.\n      context,\n      hooks: null,\n      props,\n      state,\n\n      // List of owners\n      owners,\n\n      // Location of component in source code.\n      source,\n\n      rootType: null,\n      rendererPackageName: null,\n      rendererVersion: null,\n    };\n  }\n\n  function logElementToConsole(id: number): void {\n    const result = inspectElementRaw(id);\n    if (result === null) {\n      console.warn(`Could not find element with id \"${id}\"`);\n      return;\n    }\n\n    const supportsGroup = typeof console.groupCollapsed === 'function';\n    if (supportsGroup) {\n      console.groupCollapsed(\n        `[Click to expand] %c<${result.displayName || 'Component'} />`,\n        // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.\n        'color: var(--dom-tag-name-color); font-weight: normal;',\n      );\n    }\n    if (result.props !== null) {\n      console.log('Props:', result.props);\n    }\n    if (result.state !== null) {\n      console.log('State:', result.state);\n    }\n    if (result.context !== null) {\n      console.log('Context:', result.context);\n    }\n    const nativeNode = findNativeNodeForInternalID(id);\n    if (nativeNode !== null) {\n      console.log('Node:', nativeNode);\n    }\n    if (window.chrome || /firefox/i.test(navigator.userAgent)) {\n      console.log(\n        'Right-click any value to save it as a global variable for further inspection.',\n      );\n    }\n    if (supportsGroup) {\n      console.groupEnd();\n    }\n  }\n\n  function prepareViewAttributeSource(\n    id: number,\n    path: Array<string | number>,\n  ): void {\n    const inspectedElement = inspectElementRaw(id);\n    if (inspectedElement !== null) {\n      window.$attribute = getInObject(inspectedElement, path);\n    }\n  }\n\n  function prepareViewElementSource(id: number): void {\n    const internalInstance = idToInternalInstanceMap.get(id);\n    if (internalInstance == null) {\n      console.warn(`Could not find instance with id \"${id}\"`);\n      return;\n    }\n\n    const element = internalInstance._currentElement;\n    if (element == null) {\n      console.warn(`Could not find element with id \"${id}\"`);\n      return;\n    }\n\n    global.$type = element.type;\n  }\n\n  function deletePath(\n    type: 'context' | 'hooks' | 'props' | 'state',\n    id: number,\n    hookID: ?number,\n    path: Array<string | number>,\n  ): void {\n    const internalInstance = idToInternalInstanceMap.get(id);\n    if (internalInstance != null) {\n      const publicInstance = internalInstance._instance;\n      if (publicInstance != null) {\n        switch (type) {\n          case 'context':\n            deletePathInObject(publicInstance.context, path);\n            forceUpdate(publicInstance);\n            break;\n          case 'hooks':\n            throw new Error('Hooks not supported by this renderer');\n          case 'props':\n            const element = internalInstance._currentElement;\n            internalInstance._currentElement = {\n              ...element,\n              props: copyWithDelete(element.props, path),\n            };\n            forceUpdate(publicInstance);\n            break;\n          case 'state':\n            deletePathInObject(publicInstance.state, path);\n            forceUpdate(publicInstance);\n            break;\n        }\n      }\n    }\n  }\n\n  function renamePath(\n    type: 'context' | 'hooks' | 'props' | 'state',\n    id: number,\n    hookID: ?number,\n    oldPath: Array<string | number>,\n    newPath: Array<string | number>,\n  ): void {\n    const internalInstance = idToInternalInstanceMap.get(id);\n    if (internalInstance != null) {\n      const publicInstance = internalInstance._instance;\n      if (publicInstance != null) {\n        switch (type) {\n          case 'context':\n            renamePathInObject(publicInstance.context, oldPath, newPath);\n            forceUpdate(publicInstance);\n            break;\n          case 'hooks':\n            throw new Error('Hooks not supported by this renderer');\n          case 'props':\n            const element = internalInstance._currentElement;\n            internalInstance._currentElement = {\n              ...element,\n              props: copyWithRename(element.props, oldPath, newPath),\n            };\n            forceUpdate(publicInstance);\n            break;\n          case 'state':\n            renamePathInObject(publicInstance.state, oldPath, newPath);\n            forceUpdate(publicInstance);\n            break;\n        }\n      }\n    }\n  }\n\n  function overrideValueAtPath(\n    type: 'context' | 'hooks' | 'props' | 'state',\n    id: number,\n    hookID: ?number,\n    path: Array<string | number>,\n    value: any,\n  ): void {\n    const internalInstance = idToInternalInstanceMap.get(id);\n    if (internalInstance != null) {\n      const publicInstance = internalInstance._instance;\n      if (publicInstance != null) {\n        switch (type) {\n          case 'context':\n            setInObject(publicInstance.context, path, value);\n            forceUpdate(publicInstance);\n            break;\n          case 'hooks':\n            throw new Error('Hooks not supported by this renderer');\n          case 'props':\n            const element = internalInstance._currentElement;\n            internalInstance._currentElement = {\n              ...element,\n              props: copyWithSet(element.props, path, value),\n            };\n            forceUpdate(publicInstance);\n            break;\n          case 'state':\n            setInObject(publicInstance.state, path, value);\n            forceUpdate(publicInstance);\n            break;\n        }\n      }\n    }\n  }\n\n  // v16+ only features\n  const getProfilingData = () => {\n    throw new Error('getProfilingData not supported by this renderer');\n  };\n  const handleCommitFiberRoot = () => {\n    throw new Error('handleCommitFiberRoot not supported by this renderer');\n  };\n  const handleCommitFiberUnmount = () => {\n    throw new Error('handleCommitFiberUnmount not supported by this renderer');\n  };\n  const overrideSuspense = () => {\n    throw new Error('overrideSuspense not supported by this renderer');\n  };\n  const startProfiling = () => {\n    // Do not throw, since this would break a multi-root scenario where v15 and v16 were both present.\n  };\n  const stopProfiling = () => {\n    // Do not throw, since this would break a multi-root scenario where v15 and v16 were both present.\n  };\n\n  function getBestMatchForTrackedPath(): PathMatch | null {\n    // Not implemented.\n    return null;\n  }\n\n  function getPathForElement(id: number): Array<PathFrame> | null {\n    // Not implemented.\n    return null;\n  }\n\n  function updateComponentFilters(componentFilters: Array<ComponentFilter>) {\n    // Not implemented.\n  }\n\n  function setTraceUpdatesEnabled(enabled: boolean) {\n    // Not implemented.\n  }\n\n  function setTrackedPath(path: Array<PathFrame> | null) {\n    // Not implemented.\n  }\n\n  function getOwnersList(id: number): Array<Owner> | null {\n    // Not implemented.\n    return null;\n  }\n\n  return {\n    cleanup,\n    copyElementPath,\n    deletePath,\n    flushInitialOperations,\n    getBestMatchForTrackedPath,\n    getDisplayNameForFiberID,\n    getFiberIDForNative: getInternalIDForNative,\n    getInstanceAndStyle,\n    findNativeNodesForFiberID: (id: number) => {\n      const nativeNode = findNativeNodeForInternalID(id);\n      return nativeNode == null ? null : [nativeNode];\n    },\n    getOwnersList,\n    getPathForElement,\n    getProfilingData,\n    handleCommitFiberRoot,\n    handleCommitFiberUnmount,\n    inspectElement,\n    logElementToConsole,\n    overrideSuspense,\n    overrideValueAtPath,\n    renamePath,\n    prepareViewAttributeSource,\n    prepareViewElementSource,\n    renderer,\n    setTraceUpdatesEnabled,\n    setTrackedPath,\n    startProfiling,\n    stopProfiling,\n    storeAsGlobal,\n    updateComponentFilters,\n  };\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport type {BoxStyle} from './types';\n\n/**\n * This mirrors react-native/Libraries/Inspector/resolveBoxStyle.js (but without RTL support).\n *\n * Resolve a style property into it's component parts, e.g.\n *\n * resolveBoxStyle('margin', {margin: 5, marginBottom: 10})\n * -> {top: 5, left: 5, right: 5, bottom: 10}\n */\nexport default function resolveBoxStyle(\n  prefix: string,\n  style: Object,\n): BoxStyle | null {\n  let hasParts = false;\n  const result = {\n    bottom: 0,\n    left: 0,\n    right: 0,\n    top: 0,\n  };\n\n  const styleForAll = style[prefix];\n  if (styleForAll != null) {\n    // eslint-disable-next-line no-for-of-loops/no-for-of-loops\n    for (const key of Object.keys(result)) {\n      result[key] = styleForAll;\n    }\n    hasParts = true;\n  }\n\n  const styleForHorizontal = style[prefix + 'Horizontal'];\n  if (styleForHorizontal != null) {\n    result.left = styleForHorizontal;\n    result.right = styleForHorizontal;\n    hasParts = true;\n  } else {\n    const styleForLeft = style[prefix + 'Left'];\n    if (styleForLeft != null) {\n      result.left = styleForLeft;\n      hasParts = true;\n    }\n\n    const styleForRight = style[prefix + 'Right'];\n    if (styleForRight != null) {\n      result.right = styleForRight;\n      hasParts = true;\n    }\n\n    const styleForEnd = style[prefix + 'End'];\n    if (styleForEnd != null) {\n      // TODO RTL support\n      result.right = styleForEnd;\n      hasParts = true;\n    }\n    const styleForStart = style[prefix + 'Start'];\n    if (styleForStart != null) {\n      // TODO RTL support\n      result.left = styleForStart;\n      hasParts = true;\n    }\n  }\n\n  const styleForVertical = style[prefix + 'Vertical'];\n  if (styleForVertical != null) {\n    result.bottom = styleForVertical;\n    result.top = styleForVertical;\n    hasParts = true;\n  } else {\n    const styleForBottom = style[prefix + 'Bottom'];\n    if (styleForBottom != null) {\n      result.bottom = styleForBottom;\n      hasParts = true;\n    }\n\n    const styleForTop = style[prefix + 'Top'];\n    if (styleForTop != null) {\n      result.top = styleForTop;\n      hasParts = true;\n    }\n  }\n\n  return hasParts ? result : null;\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport Agent from 'react-devtools-shared/src/backend/agent';\nimport resolveBoxStyle from './resolveBoxStyle';\n\nimport type {BackendBridge} from 'react-devtools-shared/src/bridge';\nimport type {RendererID} from '../types';\nimport type {StyleAndLayout} from './types';\n\nexport type ResolveNativeStyle = (stylesheetID: any) => ?Object;\n\nexport default function setupNativeStyleEditor(\n  bridge: BackendBridge,\n  agent: Agent,\n  resolveNativeStyle: ResolveNativeStyle,\n  validAttributes?: $ReadOnlyArray<string> | null,\n) {\n  bridge.addListener(\n    'NativeStyleEditor_measure',\n    ({id, rendererID}: {|id: number, rendererID: RendererID|}) => {\n      measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);\n    },\n  );\n\n  bridge.addListener(\n    'NativeStyleEditor_renameAttribute',\n    ({\n      id,\n      rendererID,\n      oldName,\n      newName,\n      value,\n    }: {|\n      id: number,\n      rendererID: RendererID,\n      oldName: string,\n      newName: string,\n      value: string,\n    |}) => {\n      renameStyle(agent, id, rendererID, oldName, newName, value);\n      setTimeout(() =>\n        measureStyle(agent, bridge, resolveNativeStyle, id, rendererID),\n      );\n    },\n  );\n\n  bridge.addListener(\n    'NativeStyleEditor_setValue',\n    ({\n      id,\n      rendererID,\n      name,\n      value,\n    }: {|\n      id: number,\n      rendererID: number,\n      name: string,\n      value: string,\n    |}) => {\n      setStyle(agent, id, rendererID, name, value);\n      setTimeout(() =>\n        measureStyle(agent, bridge, resolveNativeStyle, id, rendererID),\n      );\n    },\n  );\n\n  bridge.send('isNativeStyleEditorSupported', {\n    isSupported: true,\n    validAttributes,\n  });\n}\n\nconst EMPTY_BOX_STYLE = {\n  top: 0,\n  left: 0,\n  right: 0,\n  bottom: 0,\n};\n\nconst componentIDToStyleOverrides: Map<number, Object> = new Map();\n\nfunction measureStyle(\n  agent: Agent,\n  bridge: BackendBridge,\n  resolveNativeStyle: ResolveNativeStyle,\n  id: number,\n  rendererID: RendererID,\n) {\n  const data = agent.getInstanceAndStyle({id, rendererID});\n  if (!data || !data.style) {\n    bridge.send(\n      'NativeStyleEditor_styleAndLayout',\n      ({\n        id,\n        layout: null,\n        style: null,\n      }: StyleAndLayout),\n    );\n    return;\n  }\n\n  const {instance, style} = data;\n\n  let resolvedStyle = resolveNativeStyle(style);\n\n  // If it's a host component we edited before, amend styles.\n  const styleOverrides = componentIDToStyleOverrides.get(id);\n  if (styleOverrides != null) {\n    resolvedStyle = Object.assign({}, resolvedStyle, styleOverrides);\n  }\n\n  if (!instance || typeof instance.measure !== 'function') {\n    bridge.send(\n      'NativeStyleEditor_styleAndLayout',\n      ({\n        id,\n        layout: null,\n        style: resolvedStyle || null,\n      }: StyleAndLayout),\n    );\n    return;\n  }\n\n  // $FlowFixMe the parameter types of an unknown function are unknown\n  instance.measure((x, y, width, height, left, top) => {\n    // RN Android sometimes returns undefined here. Don't send measurements in this case.\n    // https://github.com/jhen0409/react-native-debugger/issues/84#issuecomment-304611817\n    if (typeof x !== 'number') {\n      bridge.send(\n        'NativeStyleEditor_styleAndLayout',\n        ({\n          id,\n          layout: null,\n          style: resolvedStyle || null,\n        }: StyleAndLayout),\n      );\n      return;\n    }\n    const margin =\n      (resolvedStyle != null && resolveBoxStyle('margin', resolvedStyle)) ||\n      EMPTY_BOX_STYLE;\n    const padding =\n      (resolvedStyle != null && resolveBoxStyle('padding', resolvedStyle)) ||\n      EMPTY_BOX_STYLE;\n    bridge.send(\n      'NativeStyleEditor_styleAndLayout',\n      ({\n        id,\n        layout: {\n          x,\n          y,\n          width,\n          height,\n          left,\n          top,\n          margin,\n          padding,\n        },\n        style: resolvedStyle || null,\n      }: StyleAndLayout),\n    );\n  });\n}\n\nfunction shallowClone(object: Object): Object {\n  const cloned = {};\n  for (const n in object) {\n    cloned[n] = object[n];\n  }\n  return cloned;\n}\n\nfunction renameStyle(\n  agent: Agent,\n  id: number,\n  rendererID: RendererID,\n  oldName: string,\n  newName: string,\n  value: string,\n): void {\n  const data = agent.getInstanceAndStyle({id, rendererID});\n  if (!data || !data.style) {\n    return;\n  }\n\n  const {instance, style} = data;\n\n  const newStyle = newName\n    ? {[oldName]: undefined, [newName]: value}\n    : {[oldName]: undefined};\n\n  let customStyle;\n\n  // TODO It would be nice if the renderer interface abstracted this away somehow.\n  if (instance !== null && typeof instance.setNativeProps === 'function') {\n    // In the case of a host component, we need to use setNativeProps().\n    // Remember to \"correct\" resolved styles when we read them next time.\n    const styleOverrides = componentIDToStyleOverrides.get(id);\n    if (!styleOverrides) {\n      componentIDToStyleOverrides.set(id, newStyle);\n    } else {\n      Object.assign(styleOverrides, newStyle);\n    }\n    // TODO Fabric does not support setNativeProps; chat with Sebastian or Eli\n    instance.setNativeProps({style: newStyle});\n  } else if (Array.isArray(style)) {\n    const lastIndex = style.length - 1;\n    if (\n      typeof style[lastIndex] === 'object' &&\n      !Array.isArray(style[lastIndex])\n    ) {\n      customStyle = shallowClone(style[lastIndex]);\n      delete customStyle[oldName];\n      if (newName) {\n        customStyle[newName] = value;\n      } else {\n        customStyle[oldName] = undefined;\n      }\n\n      agent.overrideValueAtPath({\n        type: 'props',\n        id,\n        rendererID,\n        path: ['style', lastIndex],\n        value: customStyle,\n      });\n    } else {\n      agent.overrideValueAtPath({\n        type: 'props',\n        id,\n        rendererID,\n        path: ['style'],\n        value: style.concat([newStyle]),\n      });\n    }\n  } else if (typeof style === 'object') {\n    customStyle = shallowClone(style);\n    delete customStyle[oldName];\n    if (newName) {\n      customStyle[newName] = value;\n    } else {\n      customStyle[oldName] = undefined;\n    }\n\n    agent.overrideValueAtPath({\n      type: 'props',\n      id,\n      rendererID,\n      path: ['style'],\n      value: customStyle,\n    });\n  } else {\n    agent.overrideValueAtPath({\n      type: 'props',\n      id,\n      rendererID,\n      path: ['style'],\n      value: [style, newStyle],\n    });\n  }\n\n  agent.emit('hideNativeHighlight');\n}\n\nfunction setStyle(\n  agent: Agent,\n  id: number,\n  rendererID: RendererID,\n  name: string,\n  value: string,\n) {\n  const data = agent.getInstanceAndStyle({id, rendererID});\n  if (!data || !data.style) {\n    return;\n  }\n\n  const {instance, style} = data;\n  const newStyle = {[name]: value};\n\n  // TODO It would be nice if the renderer interface abstracted this away somehow.\n  if (instance !== null && typeof instance.setNativeProps === 'function') {\n    // In the case of a host component, we need to use setNativeProps().\n    // Remember to \"correct\" resolved styles when we read them next time.\n    const styleOverrides = componentIDToStyleOverrides.get(id);\n    if (!styleOverrides) {\n      componentIDToStyleOverrides.set(id, newStyle);\n    } else {\n      Object.assign(styleOverrides, newStyle);\n    }\n    // TODO Fabric does not support setNativeProps; chat with Sebastian or Eli\n    instance.setNativeProps({style: newStyle});\n  } else if (Array.isArray(style)) {\n    const lastLength = style.length - 1;\n    if (\n      typeof style[lastLength] === 'object' &&\n      !Array.isArray(style[lastLength])\n    ) {\n      agent.overrideValueAtPath({\n        type: 'props',\n        id,\n        rendererID,\n        path: ['style', lastLength, name],\n        value,\n      });\n    } else {\n      agent.overrideValueAtPath({\n        type: 'props',\n        id,\n        rendererID,\n        path: ['style'],\n        value: style.concat([newStyle]),\n      });\n    }\n  } else {\n    agent.overrideValueAtPath({\n      type: 'props',\n      id,\n      rendererID,\n      path: ['style'],\n      value: [style, newStyle],\n    });\n  }\n\n  agent.emit('hideNativeHighlight');\n}\n","/**\n * Install the hook on window, which is an event emitter.\n * Note because Chrome content scripts cannot directly modify the window object,\n * we are evaling this function by inserting a script tag.\n * That's why we have to inline the whole event emitter implementation here.\n *\n * @flow\n */\n\nimport {\n  patch as patchConsole,\n  registerRenderer as registerRendererWithConsole,\n} from './backend/console';\n\nimport type {DevToolsHook} from 'react-devtools-shared/src/backend/types';\n\ndeclare var window: any;\n\nexport function installHook(target: any): DevToolsHook | null {\n  if (target.hasOwnProperty('__REACT_DEVTOOLS_GLOBAL_HOOK__')) {\n    return null;\n  }\n\n  function detectReactBuildType(renderer) {\n    try {\n      if (typeof renderer.version === 'string') {\n        // React DOM Fiber (16+)\n        if (renderer.bundleType > 0) {\n          // This is not a production build.\n          // We are currently only using 0 (PROD) and 1 (DEV)\n          // but might add 2 (PROFILE) in the future.\n          return 'development';\n        }\n\n        // React 16 uses flat bundles. If we report the bundle as production\n        // version, it means we also minified and envified it ourselves.\n        return 'production';\n        // Note: There is still a risk that the CommonJS entry point has not\n        // been envified or uglified. In this case the user would have *both*\n        // development and production bundle, but only the prod one would run.\n        // This would be really bad. We have a separate check for this because\n        // it happens *outside* of the renderer injection. See `checkDCE` below.\n      }\n\n      const toString = Function.prototype.toString;\n      if (renderer.Mount && renderer.Mount._renderNewRootComponent) {\n        // React DOM Stack\n        const renderRootCode = toString.call(\n          renderer.Mount._renderNewRootComponent,\n        );\n        // Filter out bad results (if that is even possible):\n        if (renderRootCode.indexOf('function') !== 0) {\n          // Hope for the best if we're not sure.\n          return 'production';\n        }\n        // Check for React DOM Stack < 15.1.0 in development.\n        // If it contains \"storedMeasure\" call, it's wrapped in ReactPerf (DEV only).\n        // This would be true even if it's minified, as method name still matches.\n        if (renderRootCode.indexOf('storedMeasure') !== -1) {\n          return 'development';\n        }\n        // For other versions (and configurations) it's not so easy.\n        // Let's quickly exclude proper production builds.\n        // If it contains a warning message, it's either a DEV build,\n        // or an PROD build without proper dead code elimination.\n        if (renderRootCode.indexOf('should be a pure function') !== -1) {\n          // Now how do we tell a DEV build from a bad PROD build?\n          // If we see NODE_ENV, we're going to assume this is a dev build\n          // because most likely it is referring to an empty shim.\n          if (renderRootCode.indexOf('NODE_ENV') !== -1) {\n            return 'development';\n          }\n          // If we see \"development\", we're dealing with an envified DEV build\n          // (such as the official React DEV UMD).\n          if (renderRootCode.indexOf('development') !== -1) {\n            return 'development';\n          }\n          // I've seen process.env.NODE_ENV !== 'production' being smartly\n          // replaced by `true` in DEV by Webpack. I don't know how that\n          // works but we can safely guard against it because `true` was\n          // never used in the function source since it was written.\n          if (renderRootCode.indexOf('true') !== -1) {\n            return 'development';\n          }\n          // By now either it is a production build that has not been minified,\n          // or (worse) this is a minified development build using non-standard\n          // environment (e.g. \"staging\"). We're going to look at whether\n          // the function argument name is mangled:\n          if (\n            // 0.13 to 15\n            renderRootCode.indexOf('nextElement') !== -1 ||\n            // 0.12\n            renderRootCode.indexOf('nextComponent') !== -1\n          ) {\n            // We can't be certain whether this is a development build or not,\n            // but it is definitely unminified.\n            return 'unminified';\n          } else {\n            // This is likely a minified development build.\n            return 'development';\n          }\n        }\n        // By now we know that it's envified and dead code elimination worked,\n        // but what if it's still not minified? (Is this even possible?)\n        // Let's check matches for the first argument name.\n        if (\n          // 0.13 to 15\n          renderRootCode.indexOf('nextElement') !== -1 ||\n          // 0.12\n          renderRootCode.indexOf('nextComponent') !== -1\n        ) {\n          return 'unminified';\n        }\n        // Seems like we're using the production version.\n        // However, the branch above is Stack-only so this is 15 or earlier.\n        return 'outdated';\n      }\n    } catch (err) {\n      // Weird environments may exist.\n      // This code needs a higher fault tolerance\n      // because it runs even with closed DevTools.\n      // TODO: should we catch errors in all injected code, and not just this part?\n    }\n    return 'production';\n  }\n\n  function checkDCE(fn: Function) {\n    // This runs for production versions of React.\n    // Needs to be super safe.\n    try {\n      const toString = Function.prototype.toString;\n      const code = toString.call(fn);\n\n      // This is a string embedded in the passed function under DEV-only\n      // condition. However the function executes only in PROD. Therefore,\n      // if we see it, dead code elimination did not work.\n      if (code.indexOf('^_^') > -1) {\n        // Remember to report during next injection.\n        hasDetectedBadDCE = true;\n\n        // Bonus: throw an exception hoping that it gets picked up by a reporting system.\n        // Not synchronously so that it doesn't break the calling code.\n        setTimeout(function() {\n          throw new Error(\n            'React is running in production mode, but dead code ' +\n              'elimination has not been applied. Read how to correctly ' +\n              'configure React for production: ' +\n              'https://reactjs.org/link/perf-use-production-build',\n          );\n        });\n      }\n    } catch (err) {}\n  }\n\n  let uidCounter = 0;\n\n  function inject(renderer) {\n    const id = ++uidCounter;\n    renderers.set(id, renderer);\n\n    const reactBuildType = hasDetectedBadDCE\n      ? 'deadcode'\n      : detectReactBuildType(renderer);\n\n    // Patching the console enables DevTools to do a few useful things:\n    // * Append component stacks to warnings and error messages\n    // * Disable logging during re-renders to inspect hooks (see inspectHooksOfFiber)\n    //\n    // For React Native, we intentionally patch early (during injection).\n    // This provides React Native developers with components stacks even if they don't run DevTools.\n    // This won't work for DOM though, since this entire file is eval'ed and inserted as a script tag.\n    // In that case, we'll patch later (when the frontend attaches).\n    //\n    // Don't patch in test environments because we don't want to interfere with Jest's own console overrides.\n    //\n    // Note that because this function is inlined, this conditional check must only use static booleans.\n    // Otherwise the extension will throw with an undefined error.\n    // (See comments in the try/catch below for more context on inlining.)\n    if (!__EXTENSION__ && !__TEST__) {\n      try {\n        const appendComponentStack =\n          window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__ !== false;\n        const breakOnConsoleErrors =\n          window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__ === true;\n\n        // The installHook() function is injected by being stringified in the browser,\n        // so imports outside of this function do not get included.\n        //\n        // Normally we could check \"typeof patchConsole === 'function'\",\n        // but Webpack wraps imports with an object (e.g. _backend_console__WEBPACK_IMPORTED_MODULE_0__)\n        // and the object itself will be undefined as well for the reasons mentioned above,\n        // so we use try/catch instead.\n        if (appendComponentStack || breakOnConsoleErrors) {\n          registerRendererWithConsole(renderer);\n          patchConsole({\n            appendComponentStack,\n            breakOnConsoleErrors,\n          });\n        }\n      } catch (error) {}\n    }\n\n    // If we have just reloaded to profile, we need to inject the renderer interface before the app loads.\n    // Otherwise the renderer won't yet exist and we can skip this step.\n    const attach = target.__REACT_DEVTOOLS_ATTACH__;\n    if (typeof attach === 'function') {\n      const rendererInterface = attach(hook, id, renderer, target);\n      hook.rendererInterfaces.set(id, rendererInterface);\n    }\n\n    hook.emit('renderer', {id, renderer, reactBuildType});\n\n    return id;\n  }\n\n  let hasDetectedBadDCE = false;\n\n  function sub(event, fn) {\n    hook.on(event, fn);\n    return () => hook.off(event, fn);\n  }\n\n  function on(event, fn) {\n    if (!listeners[event]) {\n      listeners[event] = [];\n    }\n    listeners[event].push(fn);\n  }\n\n  function off(event, fn) {\n    if (!listeners[event]) {\n      return;\n    }\n    const index = listeners[event].indexOf(fn);\n    if (index !== -1) {\n      listeners[event].splice(index, 1);\n    }\n    if (!listeners[event].length) {\n      delete listeners[event];\n    }\n  }\n\n  function emit(event, data) {\n    if (listeners[event]) {\n      listeners[event].map(fn => fn(data));\n    }\n  }\n\n  function getFiberRoots(rendererID) {\n    const roots = fiberRoots;\n    if (!roots[rendererID]) {\n      roots[rendererID] = new Set();\n    }\n    return roots[rendererID];\n  }\n\n  function onCommitFiberUnmount(rendererID, fiber) {\n    const rendererInterface = rendererInterfaces.get(rendererID);\n    if (rendererInterface != null) {\n      rendererInterface.handleCommitFiberUnmount(fiber);\n    }\n  }\n\n  function onCommitFiberRoot(rendererID, root, priorityLevel) {\n    const mountedRoots = hook.getFiberRoots(rendererID);\n    const current = root.current;\n    const isKnownRoot = mountedRoots.has(root);\n    const isUnmounting =\n      current.memoizedState == null || current.memoizedState.element == null;\n\n    // Keep track of mounted roots so we can hydrate when DevTools connect.\n    if (!isKnownRoot && !isUnmounting) {\n      mountedRoots.add(root);\n    } else if (isKnownRoot && isUnmounting) {\n      mountedRoots.delete(root);\n    }\n    const rendererInterface = rendererInterfaces.get(rendererID);\n    if (rendererInterface != null) {\n      rendererInterface.handleCommitFiberRoot(root, priorityLevel);\n    }\n  }\n\n  // TODO: More meaningful names for \"rendererInterfaces\" and \"renderers\".\n  const fiberRoots = {};\n  const rendererInterfaces = new Map();\n  const listeners = {};\n  const renderers = new Map();\n\n  const hook: DevToolsHook = {\n    rendererInterfaces,\n    listeners,\n\n    // Fast Refresh for web relies on this.\n    renderers,\n\n    emit,\n    getFiberRoots,\n    inject,\n    on,\n    off,\n    sub,\n\n    // This is a legacy flag.\n    // React v16 checks the hook for this to ensure DevTools is new enough.\n    supportsFiber: true,\n\n    // React calls these methods.\n    checkDCE,\n    onCommitFiberUnmount,\n    onCommitFiberRoot,\n  };\n\n  Object.defineProperty(\n    target,\n    '__REACT_DEVTOOLS_GLOBAL_HOOK__',\n    ({\n      // This property needs to be configurable for the test environment,\n      // else we won't be able to delete and recreate it beween tests.\n      configurable: __DEV__,\n      enumerable: false,\n      get() {\n        return hook;\n      },\n    }: Object),\n  );\n\n  return hook;\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport Agent from 'react-devtools-shared/src/backend/agent';\nimport Bridge from 'react-devtools-shared/src/bridge';\nimport {installHook} from 'react-devtools-shared/src/hook';\nimport {initBackend} from 'react-devtools-shared/src/backend';\nimport {__DEBUG__} from 'react-devtools-shared/src/constants';\nimport setupNativeStyleEditor from 'react-devtools-shared/src/backend/NativeStyleEditor/setupNativeStyleEditor';\nimport {getDefaultComponentFilters} from 'react-devtools-shared/src/utils';\n\nimport type {BackendBridge} from 'react-devtools-shared/src/bridge';\nimport type {ComponentFilter} from 'react-devtools-shared/src/types';\nimport type {DevToolsHook} from 'react-devtools-shared/src/backend/types';\nimport type {ResolveNativeStyle} from 'react-devtools-shared/src/backend/NativeStyleEditor/setupNativeStyleEditor';\n\ntype ConnectOptions = {\n  host?: string,\n  nativeStyleEditorValidAttributes?: $ReadOnlyArray<string>,\n  port?: number,\n  useHttps?: boolean,\n  resolveRNStyle?: ResolveNativeStyle,\n  retryConnectionDelay?: number,\n  isAppActive?: () => boolean,\n  websocket?: ?WebSocket,\n  ...\n};\n\ninstallHook(window);\n\nconst hook: ?DevToolsHook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;\n\nlet savedComponentFilters: Array<ComponentFilter> = getDefaultComponentFilters();\n\nfunction debug(methodName: string, ...args) {\n  if (__DEBUG__) {\n    console.log(\n      `%c[core/backend] %c${methodName}`,\n      'color: teal; font-weight: bold;',\n      'font-weight: bold;',\n      ...args,\n    );\n  }\n}\n\nexport function connectToDevTools(options: ?ConnectOptions) {\n  if (hook == null) {\n    // DevTools didn't get injected into this page (maybe b'c of the contentType).\n    return;\n  }\n  const {\n    host = 'localhost',\n    nativeStyleEditorValidAttributes,\n    useHttps = false,\n    port = 8097,\n    websocket,\n    resolveRNStyle = null,\n    retryConnectionDelay = 2000,\n    isAppActive = () => true,\n  } = options || {};\n\n  const protocol = useHttps ? 'wss' : 'ws';\n  let retryTimeoutID: TimeoutID | null = null;\n\n  function scheduleRetry() {\n    if (retryTimeoutID === null) {\n      // Two seconds because RN had issues with quick retries.\n      retryTimeoutID = setTimeout(\n        () => connectToDevTools(options),\n        retryConnectionDelay,\n      );\n    }\n  }\n\n  if (!isAppActive()) {\n    // If the app is in background, maybe retry later.\n    // Don't actually attempt to connect until we're in foreground.\n    scheduleRetry();\n    return;\n  }\n\n  let bridge: BackendBridge | null = null;\n\n  const messageListeners = [];\n  const uri = protocol + '://' + host + ':' + port;\n\n  // If existing websocket is passed, use it.\n  // This is necessary to support our custom integrations.\n  // See D6251744.\n  const ws = websocket ? websocket : new window.WebSocket(uri);\n  ws.onclose = handleClose;\n  ws.onerror = handleFailed;\n  ws.onmessage = handleMessage;\n  ws.onopen = function() {\n    bridge = new Bridge({\n      listen(fn) {\n        messageListeners.push(fn);\n        return () => {\n          const index = messageListeners.indexOf(fn);\n          if (index >= 0) {\n            messageListeners.splice(index, 1);\n          }\n        };\n      },\n      send(event: string, payload: any, transferable?: Array<any>) {\n        if (ws.readyState === ws.OPEN) {\n          if (__DEBUG__) {\n            debug('wall.send()', event, payload);\n          }\n\n          ws.send(JSON.stringify({event, payload}));\n        } else {\n          if (__DEBUG__) {\n            debug(\n              'wall.send()',\n              'Shutting down bridge because of closed WebSocket connection',\n            );\n          }\n\n          if (bridge !== null) {\n            bridge.shutdown();\n          }\n\n          scheduleRetry();\n        }\n      },\n    });\n    bridge.addListener(\n      'inspectElement',\n      ({id, rendererID}: {id: number, rendererID: number, ...}) => {\n        const renderer = agent.rendererInterfaces[rendererID];\n        if (renderer != null) {\n          // Send event for RN to highlight.\n          const nodes: ?Array<HTMLElement> = renderer.findNativeNodesForFiberID(\n            id,\n          );\n          if (nodes != null && nodes[0] != null) {\n            agent.emit('showNativeHighlight', nodes[0]);\n          }\n        }\n      },\n    );\n    bridge.addListener(\n      'updateComponentFilters',\n      (componentFilters: Array<ComponentFilter>) => {\n        // Save filter changes in memory, in case DevTools is reloaded.\n        // In that case, the renderer will already be using the updated values.\n        // We'll lose these in between backend reloads but that can't be helped.\n        savedComponentFilters = componentFilters;\n      },\n    );\n\n    // The renderer interface doesn't read saved component filters directly,\n    // because they are generally stored in localStorage within the context of the extension.\n    // Because of this it relies on the extension to pass filters.\n    // In the case of the standalone DevTools being used with a website,\n    // saved filters are injected along with the backend script tag so we shouldn't override them here.\n    // This injection strategy doesn't work for React Native though.\n    // Ideally the backend would save the filters itself, but RN doesn't provide a sync storage solution.\n    // So for now we just fall back to using the default filters...\n    if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ == null) {\n      bridge.send('overrideComponentFilters', savedComponentFilters);\n    }\n\n    // TODO (npm-packages) Warn if \"isBackendStorageAPISupported\"\n    const agent = new Agent(bridge);\n    agent.addListener('shutdown', () => {\n      // If we received 'shutdown' from `agent`, we assume the `bridge` is already shutting down,\n      // and that caused the 'shutdown' event on the `agent`, so we don't need to call `bridge.shutdown()` here.\n      hook.emit('shutdown');\n    });\n\n    initBackend(hook, agent, window);\n\n    // Setup React Native style editor if the environment supports it.\n    if (resolveRNStyle != null || hook.resolveRNStyle != null) {\n      setupNativeStyleEditor(\n        bridge,\n        agent,\n        ((resolveRNStyle || hook.resolveRNStyle: any): ResolveNativeStyle),\n        nativeStyleEditorValidAttributes ||\n          hook.nativeStyleEditorValidAttributes ||\n          null,\n      );\n    } else {\n      // Otherwise listen to detect if the environment later supports it.\n      // For example, Flipper does not eagerly inject these values.\n      // Instead it relies on the React Native Inspector to lazily inject them.\n      let lazyResolveRNStyle;\n      let lazyNativeStyleEditorValidAttributes;\n\n      const initAfterTick = () => {\n        if (bridge !== null) {\n          setupNativeStyleEditor(\n            bridge,\n            agent,\n            lazyResolveRNStyle,\n            lazyNativeStyleEditorValidAttributes,\n          );\n        }\n      };\n\n      if (!hook.hasOwnProperty('resolveRNStyle')) {\n        Object.defineProperty(\n          hook,\n          'resolveRNStyle',\n          ({\n            enumerable: false,\n            get() {\n              return lazyResolveRNStyle;\n            },\n            set(value) {\n              lazyResolveRNStyle = value;\n              initAfterTick();\n            },\n          }: Object),\n        );\n      }\n      if (!hook.hasOwnProperty('nativeStyleEditorValidAttributes')) {\n        Object.defineProperty(\n          hook,\n          'nativeStyleEditorValidAttributes',\n          ({\n            enumerable: false,\n            get() {\n              return lazyNativeStyleEditorValidAttributes;\n            },\n            set(value) {\n              lazyNativeStyleEditorValidAttributes = value;\n              initAfterTick();\n            },\n          }: Object),\n        );\n      }\n    }\n  };\n\n  function handleClose() {\n    if (__DEBUG__) {\n      debug('WebSocket.onclose');\n    }\n\n    if (bridge !== null) {\n      bridge.emit('shutdown');\n    }\n\n    scheduleRetry();\n  }\n\n  function handleFailed() {\n    if (__DEBUG__) {\n      debug('WebSocket.onerror');\n    }\n\n    scheduleRetry();\n  }\n\n  function handleMessage(event) {\n    let data;\n    try {\n      if (typeof event.data === 'string') {\n        data = JSON.parse(event.data);\n        if (__DEBUG__) {\n          debug('WebSocket.onmessage', data);\n        }\n      } else {\n        throw Error();\n      }\n    } catch (e) {\n      console.error(\n        '[React DevTools] Failed to parse JSON: ' + (event.data: any),\n      );\n      return;\n    }\n    messageListeners.forEach(fn => {\n      try {\n        fn(data);\n      } catch (error) {\n        // jsc doesn't play so well with tracebacks that go into eval'd code,\n        // so the stack trace here will stop at the `eval()` call. Getting the\n        // message that caused the error is the best we can do for now.\n        console.log('[React DevTools] Error calling listener', data);\n        console.log('error:', error);\n        throw error;\n      }\n    });\n  }\n}\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\n\nimport Agent from './agent';\n\nimport {attach} from './renderer';\nimport {attach as attachLegacy} from './legacy/renderer';\n\nimport type {DevToolsHook, ReactRenderer, RendererInterface} from './types';\n\nexport function initBackend(\n  hook: DevToolsHook,\n  agent: Agent,\n  global: Object,\n): () => void {\n  if (hook == null) {\n    // DevTools didn't get injected into this page (maybe b'c of the contentType).\n    return () => {};\n  }\n  const subs = [\n    hook.sub(\n      'renderer-attached',\n      ({\n        id,\n        renderer,\n        rendererInterface,\n      }: {\n        id: number,\n        renderer: ReactRenderer,\n        rendererInterface: RendererInterface,\n        ...\n      }) => {\n        agent.setRendererInterface(id, rendererInterface);\n\n        // Now that the Store and the renderer interface are connected,\n        // it's time to flush the pending operation codes to the frontend.\n        rendererInterface.flushInitialOperations();\n      },\n    ),\n\n    hook.sub('unsupported-renderer-version', (id: number) => {\n      agent.onUnsupportedRenderer(id);\n    }),\n\n    hook.sub('operations', agent.onHookOperations),\n    hook.sub('traceUpdates', agent.onTraceUpdates),\n\n    // TODO Add additional subscriptions required for profiling mode\n  ];\n\n  const attachRenderer = (id: number, renderer: ReactRenderer) => {\n    let rendererInterface = hook.rendererInterfaces.get(id);\n\n    // Inject any not-yet-injected renderers (if we didn't reload-and-profile)\n    if (rendererInterface == null) {\n      if (typeof renderer.findFiberByHostInstance === 'function') {\n        // react-reconciler v16+\n        rendererInterface = attach(hook, id, renderer, global);\n      } else if (renderer.ComponentTree) {\n        // react-dom v15\n        rendererInterface = attachLegacy(hook, id, renderer, global);\n      } else {\n        // Older react-dom or other unsupported renderer version\n      }\n\n      if (rendererInterface != null) {\n        hook.rendererInterfaces.set(id, rendererInterface);\n      }\n    }\n\n    // Notify the DevTools frontend about new renderers.\n    // This includes any that were attached early (via __REACT_DEVTOOLS_ATTACH__).\n    if (rendererInterface != null) {\n      hook.emit('renderer-attached', {\n        id,\n        renderer,\n        rendererInterface,\n      });\n    } else {\n      hook.emit('unsupported-renderer-version', id);\n    }\n  };\n\n  // Connect renderers that have already injected themselves.\n  hook.renderers.forEach((renderer, id) => {\n    attachRenderer(id, renderer);\n  });\n\n  // Connect any new renderers that injected themselves.\n  subs.push(\n    hook.sub(\n      'renderer',\n      ({id, renderer}: {id: number, renderer: ReactRenderer, ...}) => {\n        attachRenderer(id, renderer);\n      },\n    ),\n  );\n\n  hook.emit('react-devtools', agent);\n  hook.reactDevtoolsAgent = agent;\n  const onAgentShutdown = () => {\n    subs.forEach(fn => fn());\n    hook.rendererInterfaces.forEach(rendererInterface => {\n      rendererInterface.cleanup();\n    });\n    hook.reactDevtoolsAgent = null;\n  };\n  agent.addListener('shutdown', onAgentShutdown);\n  subs.push(() => {\n    agent.removeListener('shutdown', onAgentShutdown);\n  });\n\n  return () => {\n    subs.forEach(fn => fn());\n  };\n}\n"],"sourceRoot":""}