bippy 0.6.1-dev.fe75557 → 0.7.0-dev.07e6032

package/src/react-internals/generated/react-work-tags.ts

@@ -0,0 +1,318 @@
+import { compareSemver } from "../semver.js";
+
+export const ReactBuildType = {
+  Development: 1,
+  Production: 0,
+} as const;
+
+export const ReactFiberFlags = {
+  ChildDeletion: 16,
+  Cloned: 8,
+  ContentReset: 32,
+  Hydrating: 4096,
+  PerformedWork: 1,
+  Placement: 2,
+  Snapshot: 1024,
+  Update: 4,
+  Visibility: 8192,
+} as const;
+
+export const ReactSymbols = {
+  CONCURRENT_MODE_NUMBER: 60111,
+  CONCURRENT_MODE_SYMBOL_DESCRIPTION: "react.concurrent_mode",
+  CONCURRENT_MODE_SYMBOL_STRING: "Symbol(react.concurrent_mode)",
+  DEPRECATED_ASYNC_MODE_SYMBOL_DESCRIPTION: "react.async_mode",
+  DEPRECATED_ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)",
+  ELEMENT_SYMBOL_STRING: "Symbol(react.transitional.element)",
+  LEGACY_ELEMENT_SYMBOL_STRING: "Symbol(react.element)",
+} as const;
+
+export interface ReactWorkTagMap {
+  ActivityComponent: number;
+  CacheComponent: number;
+  ClassComponent: number;
+  ContextConsumer: number;
+  ContextProvider: number;
+  CoroutineComponent: number;
+  CoroutineHandlerPhase: number;
+  DehydratedSuspenseComponent: number;
+  ForwardRef: number;
+  Fragment: number;
+  FunctionComponent: number;
+  HostComponent: number;
+  HostHoistable: number;
+  HostPortal: number;
+  HostRoot: number;
+  HostSingleton: number;
+  HostText: number;
+  IncompleteClassComponent: number;
+  IncompleteFunctionComponent: number;
+  IndeterminateComponent: number;
+  LazyComponent: number;
+  LegacyHiddenComponent: number;
+  MemoComponent: number;
+  Mode: number;
+  OffscreenComponent: number;
+  Profiler: number;
+  ScopeComponent: number;
+  SimpleMemoComponent: number;
+  SuspenseComponent: number;
+  SuspenseListComponent: number;
+  Throw: number;
+  TracingMarkerComponent: number;
+  ViewTransitionComponent: number;
+  YieldComponent: number;
+}
+
+const defineReactWorkTags = <const VersionedWorkTags extends Record<string, ReactWorkTagMap>>(
+  workTags: VersionedWorkTags,
+): VersionedWorkTags => workTags;
+
+const reactWorkTagsByVersion = defineReactWorkTags({
+  "16.0.0": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 2,
+    ContextConsumer: 12,
+    ContextProvider: 13,
+    CoroutineComponent: 7,
+    CoroutineHandlerPhase: 8,
+    DehydratedSuspenseComponent: -1,
+    ForwardRef: 14,
+    Fragment: 10,
+    FunctionComponent: 1,
+    HostComponent: 5,
+    HostHoistable: -1,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: -1,
+    HostText: 6,
+    IncompleteClassComponent: -1,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 0,
+    LazyComponent: -1,
+    LegacyHiddenComponent: -1,
+    MemoComponent: -1,
+    Mode: 11,
+    OffscreenComponent: -1,
+    Profiler: 15,
+    ScopeComponent: -1,
+    SimpleMemoComponent: -1,
+    SuspenseComponent: 16,
+    SuspenseListComponent: -1,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: 9,
+  },
+  "16.4.3-alpha": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 2,
+    ContextConsumer: 11,
+    ContextProvider: 12,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: -1,
+    ForwardRef: 13,
+    Fragment: 9,
+    FunctionComponent: 0,
+    HostComponent: 7,
+    HostHoistable: -1,
+    HostPortal: 6,
+    HostRoot: 5,
+    HostSingleton: -1,
+    HostText: 8,
+    IncompleteClassComponent: -1,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 4,
+    LazyComponent: -1,
+    LegacyHiddenComponent: -1,
+    MemoComponent: -1,
+    Mode: 10,
+    OffscreenComponent: -1,
+    Profiler: 15,
+    ScopeComponent: -1,
+    SimpleMemoComponent: -1,
+    SuspenseComponent: 16,
+    SuspenseListComponent: -1,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: -1,
+  },
+  "16.6.0-beta.0": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 1,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: 18,
+    ForwardRef: 11,
+    Fragment: 7,
+    FunctionComponent: 0,
+    HostComponent: 5,
+    HostHoistable: -1,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: -1,
+    HostText: 6,
+    IncompleteClassComponent: 17,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 2,
+    LazyComponent: 16,
+    LegacyHiddenComponent: -1,
+    MemoComponent: 14,
+    Mode: 8,
+    OffscreenComponent: -1,
+    Profiler: 12,
+    ScopeComponent: -1,
+    SimpleMemoComponent: 15,
+    SuspenseComponent: 13,
+    SuspenseListComponent: 19,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: -1,
+  },
+  "17.0.0-alpha": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 1,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: 18,
+    ForwardRef: 11,
+    Fragment: 7,
+    FunctionComponent: 0,
+    HostComponent: 5,
+    HostHoistable: -1,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: -1,
+    HostText: 6,
+    IncompleteClassComponent: 17,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 2,
+    LazyComponent: 16,
+    LegacyHiddenComponent: 24,
+    MemoComponent: 14,
+    Mode: 8,
+    OffscreenComponent: 23,
+    Profiler: 12,
+    ScopeComponent: 21,
+    SimpleMemoComponent: 15,
+    SuspenseComponent: 13,
+    SuspenseListComponent: 19,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: -1,
+  },
+  "17.0.2": {
+    ActivityComponent: 31,
+    CacheComponent: 24,
+    ClassComponent: 1,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: 18,
+    ForwardRef: 11,
+    Fragment: 7,
+    FunctionComponent: 0,
+    HostComponent: 5,
+    HostHoistable: 26,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: 27,
+    HostText: 6,
+    IncompleteClassComponent: 17,
+    IncompleteFunctionComponent: 28,
+    IndeterminateComponent: 2,
+    LazyComponent: 16,
+    LegacyHiddenComponent: 23,
+    MemoComponent: 14,
+    Mode: 8,
+    OffscreenComponent: 22,
+    Profiler: 12,
+    ScopeComponent: 21,
+    SimpleMemoComponent: 15,
+    SuspenseComponent: 13,
+    SuspenseListComponent: 19,
+    Throw: 29,
+    TracingMarkerComponent: 25,
+    ViewTransitionComponent: 30,
+    YieldComponent: -1,
+  },
+});
+
+export type ReactWorkTagVersion = keyof typeof reactWorkTagsByVersion;
+
+export interface GetReactWorkTags {
+  (): Readonly<ReactWorkTagMap>;
+  <Version extends ReactWorkTagVersion>(
+    reactVersion: Version,
+  ): Readonly<(typeof reactWorkTagsByVersion)[Version]>;
+  (reactVersion: string): Readonly<ReactWorkTagMap>;
+}
+
+export type ReactWorkTag = Exclude<
+  (typeof reactWorkTagsByVersion)[ReactWorkTagVersion][keyof ReactWorkTagMap],
+  -1
+>;
+
+export type HostWorkTag = Exclude<
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostComponent"]
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostHoistable"]
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostSingleton"]
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostText"],
+  -1
+>;
+
+interface ReactWorkTagRange {
+  isMinimumExcluded: boolean;
+  minimumVersion: string;
+  workTags: Readonly<ReactWorkTagMap>;
+}
+
+const reactWorkTagRanges: ReactWorkTagRange[] = [
+  {
+    isMinimumExcluded: true,
+    minimumVersion: "17.0.1",
+    workTags: reactWorkTagsByVersion["17.0.2"],
+  },
+  {
+    isMinimumExcluded: false,
+    minimumVersion: "17.0.0-alpha",
+    workTags: reactWorkTagsByVersion["17.0.0-alpha"],
+  },
+  {
+    isMinimumExcluded: false,
+    minimumVersion: "16.6.0-beta.0",
+    workTags: reactWorkTagsByVersion["16.6.0-beta.0"],
+  },
+  {
+    isMinimumExcluded: false,
+    minimumVersion: "16.4.3-alpha",
+    workTags: reactWorkTagsByVersion["16.4.3-alpha"],
+  },
+];
+
+const defaultReactWorkTags = reactWorkTagsByVersion["17.0.2"];
+
+export const getReactWorkTags: GetReactWorkTags = (reactVersion?: string) => {
+  if (reactVersion === undefined) return defaultReactWorkTags;
+  for (const range of reactWorkTagRanges) {
+    const comparison = compareSemver(reactVersion, range.minimumVersion);
+    if (comparison === null) return defaultReactWorkTags;
+    if (comparison === 1 || (comparison === 0 && !range.isMinimumExcluded)) {
+      return range.workTags;
+    }
+  }
+  return reactWorkTagsByVersion["16.0.0"];
+};

package/src/react-internals/index.ts

@@ -0,0 +1,73 @@
+import { getReactWorkTags, ReactFiberFlags } from "./generated/react-work-tags.js";
+import type { ReactWorkTagMap } from "./generated/react-work-tags.js";
+import { isSemver } from "./semver.js";
+import type { Fiber, ReactRenderer } from "./types.js";
+
+export { compareSemver } from "./semver.js";
+export {
+  getReactWorkTags,
+  ReactBuildType,
+  ReactFiberFlags,
+  ReactSymbols,
+} from "./generated/react-work-tags.js";
+export type {
+  HostWorkTag,
+  ReactWorkTag,
+  ReactWorkTagMap,
+  ReactWorkTagVersion,
+} from "./generated/react-work-tags.js";
+export * from "./types.js";
+
+const defaultReactWorkTags = getReactWorkTags();
+const fiberReactWorkTags = new WeakMap<Fiber, Readonly<ReactWorkTagMap>>();
+
+// React's experimental channel historically reported "0.0.0-experimental-<sha>"
+// as the runtime version; those builds use modern work tags, not the 16.x rows
+// the version table would resolve "0.0.0" to.
+const getReactWorkTagsForVersion = (version: string): Readonly<ReactWorkTagMap> =>
+  version.startsWith("0.0.0-") ? defaultReactWorkTags : getReactWorkTags(version);
+
+export const getReactWorkTagsForRenderer = (
+  renderer?: ReactRenderer | null,
+): Readonly<ReactWorkTagMap> => {
+  const reconcilerVersion = renderer?.reconcilerVersion;
+  if (reconcilerVersion && isSemver(reconcilerVersion)) {
+    return getReactWorkTagsForVersion(reconcilerVersion);
+  }
+  return renderer?.version ? getReactWorkTagsForVersion(renderer.version) : defaultReactWorkTags;
+};
+
+export const setReactWorkTagsForFiber = (fiber: Fiber, renderer?: ReactRenderer): void => {
+  const workTags = getReactWorkTagsForRenderer(renderer);
+  fiberReactWorkTags.set(fiber, workTags);
+  if (fiber.alternate) fiberReactWorkTags.set(fiber.alternate, workTags);
+};
+
+export const getReactWorkTagsForFiber = (fiber: Fiber): Readonly<ReactWorkTagMap> => {
+  const cachedWorkTags = fiberReactWorkTags.get(fiber);
+  if (cachedWorkTags) return cachedWorkTags;
+
+  const traversedFibers: Fiber[] = [fiber];
+  let rootFiber = fiber;
+  while (rootFiber.return) {
+    rootFiber = rootFiber.return;
+    traversedFibers.push(rootFiber);
+  }
+  const workTags = fiberReactWorkTags.get(rootFiber) ?? defaultReactWorkTags;
+  for (const traversedFiber of traversedFibers) {
+    fiberReactWorkTags.set(traversedFiber, workTags);
+    if (traversedFiber.alternate) {
+      fiberReactWorkTags.set(traversedFiber.alternate, workTags);
+    }
+  }
+  return workTags;
+};
+
+export const MutationMask =
+  ReactFiberFlags.Placement |
+  ReactFiberFlags.Update |
+  ReactFiberFlags.ChildDeletion |
+  ReactFiberFlags.ContentReset |
+  ReactFiberFlags.Hydrating |
+  ReactFiberFlags.Visibility |
+  ReactFiberFlags.Snapshot;

package/src/react-internals/semver.ts

@@ -0,0 +1,80 @@
+interface SemanticVersion {
+  major: string;
+  minor: string;
+  patch: string;
+  prerelease: string[];
+}
+
+const SEMVER_PATTERN =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const NUMERIC_IDENTIFIER_PATTERN = /^\d+$/;
+
+export const isSemver = (version: string): boolean => parseSemver(version) !== null;
+
+const parseSemver = (version: string): SemanticVersion | null => {
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match) return null;
+  const prerelease = match[4]?.split(".") ?? [];
+  if (
+    prerelease.some(
+      (identifier) =>
+        NUMERIC_IDENTIFIER_PATTERN.test(identifier) &&
+        identifier.length > 1 &&
+        identifier.startsWith("0"),
+    )
+  ) {
+    return null;
+  }
+  return {
+    major: match[1],
+    minor: match[2],
+    patch: match[3],
+    prerelease,
+  };
+};
+
+const compareNumericIdentifiers = (left: string, right: string): -1 | 0 | 1 => {
+  if (left.length !== right.length) return left.length < right.length ? -1 : 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+};
+
+const comparePrereleaseIdentifiers = (left: string, right: string): -1 | 0 | 1 => {
+  const isLeftNumeric = NUMERIC_IDENTIFIER_PATTERN.test(left);
+  const isRightNumeric = NUMERIC_IDENTIFIER_PATTERN.test(right);
+  if (isLeftNumeric && isRightNumeric) return compareNumericIdentifiers(left, right);
+  if (isLeftNumeric !== isRightNumeric) return isLeftNumeric ? -1 : 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+};
+
+const comparePrerelease = (left: string[], right: string[]): -1 | 0 | 1 => {
+  if (left.length === 0 || right.length === 0) {
+    if (left.length === right.length) return 0;
+    return left.length === 0 ? 1 : -1;
+  }
+  const identifierCount = Math.max(left.length, right.length);
+  for (let identifierIndex = 0; identifierIndex < identifierCount; identifierIndex++) {
+    const leftIdentifier = left[identifierIndex];
+    const rightIdentifier = right[identifierIndex];
+    if (leftIdentifier === undefined || rightIdentifier === undefined) {
+      return leftIdentifier === undefined ? -1 : 1;
+    }
+    const comparison = comparePrereleaseIdentifiers(leftIdentifier, rightIdentifier);
+    if (comparison !== 0) return comparison;
+  }
+  return 0;
+};
+
+export const compareSemver = (leftVersion: string, rightVersion: string): -1 | 0 | 1 | null => {
+  const left = parseSemver(leftVersion);
+  const right = parseSemver(rightVersion);
+  if (!left || !right) return null;
+  const majorComparison = compareNumericIdentifiers(left.major, right.major);
+  if (majorComparison !== 0) return majorComparison;
+  const minorComparison = compareNumericIdentifiers(left.minor, right.minor);
+  if (minorComparison !== 0) return minorComparison;
+  const patchComparison = compareNumericIdentifiers(left.patch, right.patch);
+  if (patchComparison !== 0) return patchComparison;
+  return comparePrerelease(left.prerelease, right.prerelease);
+};

package/src/react-internals/types.ts

@@ -0,0 +1,186 @@
+import type { ReactNode } from "react";
+import type ReactReconciler from "react-reconciler";
+import type { HostWorkTag, ReactWorkTag } from "./generated/react-work-tags.js";
+
+export type WorkTag = ReactReconciler.WorkTag | ReactWorkTag;
+
+export interface Source extends ReactReconciler.Source {}
+
+export interface ReactContext<T> extends ReactReconciler.ReactContext<T> {}
+
+// HACK: React 17 exposes observedBits while React 18+ exposes memoizedValue on context dependencies.
+export interface ContextDependency<T> extends Omit<
+  ReactReconciler.ContextDependency<T>,
+  "observedBits"
+> {
+  memoizedValue?: T;
+  observedBits?: number;
+}
+
+export interface DebugThenableState {
+  thenables?: unknown[];
+}
+
+export interface Dependencies extends Omit<ReactReconciler.Dependencies, "firstContext"> {
+  _debugThenableState?: DebugThenableState | unknown[];
+  firstContext: ContextDependency<unknown> | null;
+}
+
+export interface ServerComponentInfo {
+  name?: string;
+  env?: string;
+  owner?: Fiber | ServerComponentInfo | null;
+  debugStack?: Error | null;
+}
+
+export interface ReactDebugInfo {
+  debugLocation?: unknown;
+  env?: string;
+  name?: string;
+}
+
+export interface ReactMemoCache {
+  data: unknown[][];
+  index: number;
+}
+
+export interface FiberDebugSource extends Source {
+  columnNumber?: number;
+}
+
+export interface FiberUpdateQueue {
+  [key: string]: unknown;
+  memoCache?: ReactMemoCache;
+}
+
+// HACK: @types/react-reconciler does not yet include React 19 debug fields or recursive server owners.
+export interface Fiber<T = unknown> extends Omit<
+  ReactReconciler.Fiber,
+  | "alternate"
+  | "_debugOwner"
+  | "_debugSource"
+  | "child"
+  | "deletions"
+  | "dependencies"
+  | "memoizedProps"
+  | "memoizedState"
+  | "pendingProps"
+  | "return"
+  | "sibling"
+  | "stateNode"
+  | "tag"
+  | "updateQueue"
+> {
+  _debugInfo?: ReactDebugInfo[];
+  _debugOwner?: Fiber | ServerComponentInfo | null;
+  _debugSource?: FiberDebugSource | null;
+  _debugStack?: Error & { stack: string };
+  alternate: Fiber | null;
+  child: Fiber | null;
+  deletions: Fiber[] | null;
+  dependencies: Dependencies | null;
+  effectTag?: number;
+  memoizedProps: Props;
+  memoizedState: MemoizedState | null;
+  pendingProps: Props;
+  return: Fiber | null;
+  sibling: Fiber | null;
+  stateNode: T;
+  tag: WorkTag;
+  updateQueue: FiberUpdateQueue | null;
+}
+
+export interface HostFiber<T = unknown> extends Fiber<T> {
+  tag: HostWorkTag;
+}
+
+export interface FiberRoot {
+  current: Fiber;
+}
+
+export interface MemoizedState {
+  [key: string]: unknown;
+  memoizedState: unknown;
+  next: MemoizedState | null;
+}
+
+export interface Props {
+  [key: string]: unknown;
+}
+
+export interface ReactDevToolsEventHandler {
+  (data: unknown): void;
+}
+
+export interface ReactDevToolsGlobalHook {
+  _instrumentationIsActive?: boolean;
+  _instrumentationSource?: string;
+  checkDCE: (fn: unknown) => void;
+  emit?: (event: string, data?: unknown) => void;
+  getFiberRoots?: (rendererID: number) => Set<FiberRoot>;
+  hasUnsupportedRendererAttached: boolean;
+  inject: (renderer: ReactRenderer) => number;
+  off?: (event: string, handler: ReactDevToolsEventHandler) => void;
+  on: (event: string, handler: ReactDevToolsEventHandler) => void;
+  onCommitFiberRoot: (
+    rendererID: number,
+    root: FiberRoot,
+    priority: number | void,
+    didError?: boolean,
+  ) => void;
+  onCommitFiberUnmount: (rendererID: number, fiber: Fiber) => void;
+  onPostCommitFiberRoot: (rendererID: number, root: FiberRoot) => void;
+  onScheduleFiberRoot?: (rendererID: number, root: FiberRoot, children: ReactNode) => void;
+  renderers: Map<number, ReactRenderer>;
+  sub?: (event: string, handler: ReactDevToolsEventHandler) => () => void;
+  supportsFiber: boolean;
+  supportsFlight: boolean;
+}
+
+export interface LegacyDispatcherRef {
+  current: unknown;
+}
+
+export interface CurrentDispatcherRef {
+  H: unknown;
+}
+
+export type RendererDispatcherRef = CurrentDispatcherRef | LegacyDispatcherRef;
+
+export interface ReactRenderer extends Omit<
+  ReactReconciler.DevToolsConfig<unknown, unknown, unknown>,
+  "findFiberByHostInstance"
+> {
+  currentDispatcherRef?: RendererDispatcherRef | null;
+  findFiberByHostInstance?: (hostInstance: unknown) => Fiber | null;
+  getCurrentFiber?: () => Fiber | null;
+  overrideContext?: (fiber: Fiber, contextType: unknown, path: string[], value: unknown) => void;
+
+  overrideHookState?: (fiber: Fiber, id: number, path: string[], value: unknown) => void;
+  overrideHookStateDeletePath?: (fiber: Fiber, id: number, path: Array<number | string>) => void;
+  overrideHookStateRenamePath?: (
+    fiber: Fiber,
+    id: number,
+    oldPath: Array<number | string>,
+    newPath: Array<number | string>,
+  ) => void;
+  overrideProps?: (fiber: Fiber, path: string[], value: unknown) => void;
+  overridePropsDeletePath?: (fiber: Fiber, path: Array<number | string>) => void;
+  overridePropsRenamePath?: (
+    fiber: Fiber,
+    oldPath: Array<number | string>,
+    newPath: Array<number | string>,
+  ) => void;
+  reconcilerVersion?: string;
+  scheduleRetry?: (fiber: Fiber) => void;
+  scheduleRoot?: (root: FiberRoot, element: React.ReactNode) => void;
+  scheduleUpdate?: (fiber: Fiber) => void;
+
+  setErrorHandler?: (newShouldErrorImpl: (fiber: Fiber) => boolean | null) => void;
+  setSuspenseHandler?: (newShouldSuspendImpl: (fiber: Fiber) => boolean) => void;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __REACT_DEVTOOLS_GLOBAL_HOOK__: ReactDevToolsGlobalHook | undefined;
+}